diff --git a/Cargo.lock b/Cargo.lock index 28be5d6b3..0c4466d9b 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -948,7 +948,6 @@ dependencies = [ "xous-api-names", "xous-api-ticktimer", "xous-ipc 0.10.2 (registry+https://github.com/rust-lang/crates.io-index)", - "xous-pio", "xous-pl230", "xous-swapper", ] @@ -972,7 +971,6 @@ dependencies = [ "xous-api-names", "xous-api-ticktimer", "xous-ipc 0.10.2 (registry+https://github.com/rust-lang/crates.io-index)", - "xous-pio", "xous-pl230", ] @@ -3018,7 +3016,6 @@ dependencies = [ "sha2-loader", "simple-fatfs", "utralib 0.1.25", - "xous-pio", "xous-pl230", "xous-riscv", ] @@ -6795,18 +6792,6 @@ dependencies = [ "xous-ipc 0.10.2 (registry+https://github.com/rust-lang/crates.io-index)", ] -[[package]] -name = "xous-pio" -version = "0.1.0" -dependencies = [ - "defmt", - "log", - "pio", - "pio-proc", - "utralib 0.1.25", - "xous 0.9.64 (registry+https://github.com/rust-lang/crates.io-index)", -] - [[package]] name = "xous-pl230" version = "0.1.0" @@ -6818,7 +6803,6 @@ dependencies = [ "pio-proc", "utralib 0.1.25", "xous 0.9.64 (registry+https://github.com/rust-lang/crates.io-index)", - "xous-pio", ] [[package]] diff --git a/Cargo.toml b/Cargo.toml index d8fcdb766..f6d2397a7 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -100,7 +100,7 @@ members = [ "libs/perflib", "libs/tls", "libs/userprefs", - "libs/xous-pio", + # "libs/xous-pio", "libs/xous-bio", "libs/xous-bio-bdma", "libs/xous-pl230", diff --git a/kernel/Cargo.toml b/kernel/Cargo.toml index 3605ad1cf..7ec1ed7d2 100644 --- a/kernel/Cargo.toml +++ b/kernel/Cargo.toml @@ -45,6 +45,7 @@ unexpected_cfgs = { level = "warn", check-cfg = ['cfg(ci)', 'cfg(baremetal)'] } [features] cramium-soc = ["utralib/cramium-soc", "cramium-hal", "rand_chacha", "raw-trng"] +verilator-only = ["cramium-hal/verilator-only"] cramium-fpga = ["utralib/cramium-fpga"] board-baosec = ["cramium-hal/board-baosec"] board-baosor = ["cramium-hal/board-baosor"] diff --git a/kernel/src/mem.rs b/kernel/src/mem.rs index 554cbcd0a..82e1ad9d8 100644 --- a/kernel/src/mem.rs +++ b/kernel/src/mem.rs @@ -290,6 +290,7 @@ impl MemoryManager { self.ram_size ); }; + #[cfg(feature = "swap")] for o in 0..self.ram_size / PAGE_SIZE { unsafe { println!( diff --git a/libs/cramium-hal/Cargo.toml b/libs/cramium-hal/Cargo.toml index 170a0f199..e34a58ea1 100644 --- a/libs/cramium-hal/Cargo.toml +++ b/libs/cramium-hal/Cargo.toml @@ -28,9 +28,17 @@ either = { version = "1.9.0", default-features = false } xous = { version = "0.9.64", features = ["v2p"] } [features] -board-baosec = [] # USB form factor token -board-baosor = [] # Precursor form factor -board-dabao = [] # Dev board form factor +camera-ov2640 = [] +display-sh1107 = [] +axp2101 = [] +board-baosec = [ + "camera-ov2640", + "display-sh1107", + "axp2101", +] # USB form factor token +board-baosor = ["camera-ov2640", "axp2101"] # Precursor form factor +board-dabao = [] # Dev board form factor +verilator-only = [] udma-stress-test = [ ] # For RTL simulation testing - aggravates a key corner case @@ -39,4 +47,4 @@ compress-entropy = [] magic-manual = [] std = ["log", "xous-api-names", "usb-device", "xous-api-ticktimer"] derive-rkyv = ["rkyv"] -default = ["board-baosec"] +default = [] diff --git a/libs/cramium-hal/src/board/dabao.rs b/libs/cramium-hal/src/board/dabao.rs new file mode 100644 index 000000000..687277c52 --- /dev/null +++ b/libs/cramium-hal/src/board/dabao.rs @@ -0,0 +1,69 @@ +// Constants that define pin locations, RAM offsets, etc. for the DaBao basic breakout board +use crate::iox::IoSetup; +use crate::iox::*; + +// console uart buffer +pub const UART_DMA_TX_BUF_PHYS: usize = utralib::HW_IFRAM0_MEM + utralib::HW_IFRAM0_MEM_LEN - 4096; + +// RAM needs two buffers of 1k + 16 bytes = 2048 + 16 = 2064 bytes; round up to one page +pub const SPIM_RAM_IFRAM_ADDR: usize = utralib::HW_IFRAM0_MEM + utralib::HW_IFRAM0_MEM_LEN - 2 * 4096; + +// app uart buffer +pub const APP_UART_IFRAM_ADDR: usize = utralib::HW_IFRAM0_MEM + utralib::HW_IFRAM0_MEM_LEN - 3 * 4096; + +// one page for the I2C driver +pub const I2C_IFRAM_ADDR: usize = utralib::HW_IFRAM0_MEM + utralib::HW_IFRAM0_MEM_LEN - 4 * 4096; + +// USB pages - USB subsystem is a hog, needs a lot of pages, note this is mutually exclusive with camera, +// can't use both at once +pub const CRG_IFRAM_PAGES: usize = 23; // +1 for extended application buffer by 4k +pub const CRG_UDC_MEMBASE: usize = + utralib::HW_IFRAM1_MEM + utralib::HW_IFRAM1_MEM_LEN - CRG_IFRAM_PAGES * 0x1000; + +// MANUALLY SYNCED TO ALLOCATIONS ABOVE +// inclusive numbering - we allocate pages from the top-down, so the last number should generally be 31 +pub const IFRAM0_RESERVED_PAGE_RANGE: [usize; 2] = [31 - 4, 31]; +pub const IFRAM1_RESERVED_PAGE_RANGE: [usize; 2] = [31 - 0, 31]; + +/// returns the USB SE0 port and pin number +const SE0_PIN: u8 = 14; +pub fn setup_usb_pins(iox: &T) -> (IoxPort, u8) { + iox.setup_pin( + IoxPort::PB, + SE0_PIN, + Some(IoxDir::Output), + Some(IoxFunction::Gpio), + None, + None, + Some(IoxEnable::Enable), + Some(IoxDriveStrength::Drive2mA), + ); + iox.set_gpio_pin_value(IoxPort::PB, SE0_PIN, IoxValue::Low); + (IoxPort::PB, SE0_PIN) +} + +pub fn setup_i2c_pins(iox: &dyn IoSetup) -> crate::udma::I2cChannel { + // I2C_SCL_B[0] + iox.setup_pin( + IoxPort::PB, + 11, + Some(IoxDir::Output), + Some(IoxFunction::AF1), + None, + None, + Some(IoxEnable::Enable), + Some(IoxDriveStrength::Drive2mA), + ); + // I2C_SDA_B[0] + iox.setup_pin( + IoxPort::PB, + 12, + Some(IoxDir::Output), + Some(IoxFunction::AF1), + Some(IoxEnable::Enable), + None, + Some(IoxEnable::Enable), + Some(IoxDriveStrength::Drive2mA), + ); + crate::udma::I2cChannel::Channel0 +} diff --git a/libs/cramium-hal/src/board/mod.rs b/libs/cramium-hal/src/board/mod.rs index f8d67d674..d4f813907 100644 --- a/libs/cramium-hal/src/board/mod.rs +++ b/libs/cramium-hal/src/board/mod.rs @@ -6,3 +6,7 @@ pub use baosec::*; pub mod baosor; #[cfg(feature = "board-baosor")] pub use baosor::*; +#[cfg(feature = "board-dabao")] +pub mod dabao; +#[cfg(feature = "board-dabao")] +pub use dabao::*; diff --git a/libs/cramium-hal/src/lib.rs b/libs/cramium-hal/src/lib.rs index 50b2d1252..f26c056ec 100644 --- a/libs/cramium-hal/src/lib.rs +++ b/libs/cramium-hal/src/lib.rs @@ -2,12 +2,15 @@ #[macro_use] pub mod debug; +#[cfg(feature = "axp2101")] pub mod axp2101; pub mod board; pub mod ifram; pub mod iox; +#[cfg(feature = "camera-ov2640")] pub mod ov2640; pub mod sce; +#[cfg(feature = "display-sh1107")] pub mod sh1107; pub mod shared_csr; pub mod udma; diff --git a/libs/cramium-hal/src/sce/trng.rs b/libs/cramium-hal/src/sce/trng.rs index 5d16e1a5a..b73c67044 100644 --- a/libs/cramium-hal/src/sce/trng.rs +++ b/libs/cramium-hal/src/sce/trng.rs @@ -84,6 +84,7 @@ const RAW_ENTRIES: usize = 16; /// for at least this many cycles before the next sample is taken, thus /// making it more difficult for any adversary to reason about the current /// state of the TRNG given the QC samples. +#[allow(dead_code)] const RAW_GUARDBAND: usize = 32; pub struct Trng { @@ -92,6 +93,9 @@ pub struct Trng { mode: Mode, /// Buffer some raw entropy inside the kernel, so we can "burst out" entropy /// for reseed operations without having to wait for the TRNG to regenerate data. + /// + /// This generates an unused warning when `verilator-only` is selected. We leave this + /// warning in place to remind ourselves that the TRNG is not real. raw: [Option; RAW_ENTRIES], #[cfg(feature = "compress-entropy")] rng_var: u8, @@ -110,6 +114,7 @@ impl Trng { } } + #[cfg(not(feature = "verilator-only"))] pub fn setup_raw_generation(&mut self, count: u16) { self._count = count; self.mode = Mode::Raw; @@ -137,6 +142,10 @@ impl Trng { self.csr.wo(utra::trng::SFR_OPT, 0); } + #[cfg(feature = "verilator-only")] + pub fn setup_raw_generation(&mut self, _count: u16) { self.mode = Mode::Raw; } + + #[cfg(not(feature = "verilator-only"))] pub fn get_raw(&mut self) -> u32 { // Pull from the buffered entropy pool, until it's empty. for d in self.raw.iter_mut() { @@ -217,6 +226,13 @@ impl Trng { self.raw[0].take().unwrap() } + #[cfg(feature = "verilator-only")] + pub fn get_raw(&mut self) -> u32 { + // guaranteed random by fair dice roll + // (in all seriousness, this is intentional in verilator because there is no TRNG in the RTL model) + 4 + } + pub fn get_u32(&mut self) -> Option { match self.mode { Mode::Uninit => None, diff --git a/libs/xous-pl230/Cargo.toml b/libs/xous-pl230/Cargo.toml index ff5c0c224..e7892de77 100644 --- a/libs/xous-pl230/Cargo.toml +++ b/libs/xous-pl230/Cargo.toml @@ -9,7 +9,7 @@ edition = "2021" log = "0.4.14" utralib = { version = "0.1.25", optional = true, default-features = false } bitfield = "0.13.2" -xous-pio = { path = "../xous-pio", optional = true, default-features = false } +# xous-pio = { path = "../xous-pio", optional = true, default-features = false } pio-proc = "0.2.2" pio = "0.2.1" cramium-hal = { path = "../cramium-hal", optional = true, default-features = false } @@ -23,10 +23,10 @@ cramium-fpga = ["utralib/cramium-fpga"] precursor = [] hosted = [] renode = [] -pio = ["xous-pio"] +pio = [] dma-mainram = [] baremetal = [] debug-print = [] -tests = ["pio", "cramium-hal"] -default = ["tests", "pio"] +tests = ["cramium-hal"] +default = ["tests"] diff --git a/loader/Cargo.toml b/loader/Cargo.toml index 26a27b24e..841a421d4 100644 --- a/loader/Cargo.toml +++ b/loader/Cargo.toml @@ -25,11 +25,11 @@ xous-pl230 = { path = "../libs/xous-pl230", optional = true, features = [ "baremetal", # "dma-mainram", # PL-230 option - this fails on MPW ] } -xous-pio = { path = "../libs/xous-pio", optional = true, features = [ - "tests", - "cramium-soc", - "baremetal", -] } +# xous-pio = { path = "../libs/xous-pio", optional = true, features = [ +# "tests", +# "cramium-soc", +# "baremetal", +# ] } aes-gcm-siv = { version = "0.11.1", default-features = false, features = [ "aes", ], optional = true } @@ -79,29 +79,25 @@ renode = [ cramium-soc = [ "utralib/cramium-soc", "debug-print", - "simulation-only", "cramium-hal", - "xous-pio", - "xous-pl230", "rand_chacha", "sram-margin", + # "boot-delay", +] +board-baosec = [ + "cramium-hal/board-baosec", + "updates", + "usb", "libm", "simple-fatfs", "linked_list_allocator", "ed25519-dalek", "sha2", "digest", - # "boot-delay", ] -board-baosec = ["cramium-hal/board-baosec"] board-baosor = ["cramium-hal/board-baosor"] board-dabao = ["cramium-hal/board-dabao"] -cramium-fpga = [ - "utralib/cramium-fpga", - "debug-print", - "simulation-only", - "cramium-hal", -] +cramium-fpga = ["utralib/cramium-fpga", "debug-print", "cramium-hal"] atsama5d27 = ["utralib/atsama5d27", "armv7", "dep:atsama5d27"] # precursor flags @@ -118,6 +114,7 @@ board-bringup = [] sram-margin = [] boot-delay = [] simulation-only = [] +verilator-only = [] quantum-timer-test = ["pio", "pio-proc"] spim-test = [] irq-test = [] @@ -129,10 +126,11 @@ clock-tests = [] reset-debug = [] usb = [] qr = ["nalgebra"] +updates = [] # general flags debug-print = [] earlyprintk = [] resume = [] # suspend/resume pathway code -default = ["board-bringup", "dump-trng", "usb"] +default = [] diff --git a/loader/src/asm.rs b/loader/src/asm.rs index 8cf5ddb7b..1d29727c6 100644 --- a/loader/src/asm.rs +++ b/loader/src/asm.rs @@ -16,7 +16,7 @@ pub extern "C" fn _start(_kernel_args: usize, loader_sig: usize) { // Stub for clearing IFRAM & RAM on Cramium target. This is required // to clear the parity check bits, which are randomly set on boot. System will // eventually hang if these bits aren't cleared. - #[cfg(any(feature = "cramium-soc", feature = "cramium-fpga"))] + #[cfg(all(any(feature = "cramium-soc", feature = "cramium-fpga"), not(feature = "simulation-only")))] unsafe { #[rustfmt::skip] asm! ( diff --git a/loader/src/bootconfig.rs b/loader/src/bootconfig.rs index 989e41764..024fc231e 100644 --- a/loader/src/bootconfig.rs +++ b/loader/src/bootconfig.rs @@ -130,10 +130,15 @@ impl BootConfig { (self.sram_size - self.init_size - self.extra_pages * PAGE_SIZE) / mem::size_of::(), ) }; - assert!((val as usize) >= (self.sram_start as usize)); + assert!( + (val as usize) >= (self.sram_start as usize), + "val {:x} ! >= sram_start {:x}", + val as usize, + self.sram_start as usize + ); assert!( (val as usize) < (self.sram_start as usize) + self.sram_size, - "top address {:08x} > (start + size) {:08x} + {:08x} = {:08x}", + "top address {:08x} ! < (start + size) {:08x} + {:08x} = {:08x}", val as usize, self.sram_start as usize, self.sram_size, diff --git a/loader/src/main.rs b/loader/src/main.rs index 27fbbd9ba..1e5af0d9f 100644 --- a/loader/src/main.rs +++ b/loader/src/main.rs @@ -83,19 +83,12 @@ pub enum IniType { /// This function is safe to call exactly once. #[export_name = "rust_entry"] pub unsafe extern "C" fn rust_entry(signed_buffer: *const usize, signature: u32) -> ! { - // - // YOU WILL FORGET THIS -- but I haven't figured out a good way to describe this scenario - // when cross-building a SoC image (for s32 sim) to run on the FPGA variant, - // you need to comment this out. or else, the simulation will hang. But really, the SoC - // should be the SoC, the FPGA should be the FPGA...the cross-sim is not really guaranteed to work - // but it is just a handy tool to use when it *does* work. - // - #[cfg(feature = "cramium-soc")] + #[cfg(all(feature = "cramium-soc", not(feature = "verilator-only")))] let perclk_freq = crate::platform::early_init(); // sets up PLLs so we're not running at 16MHz... - #[cfg(not(feature = "cramium-soc"))] + #[cfg(not(all(feature = "cramium-soc", not(feature = "verilator-only"))))] let perclk_freq = 0; - #[cfg(feature = "cramium-soc")] + #[cfg(all(feature = "cramium-soc", feature = "updates"))] crate::platform::process_update(perclk_freq); // initially validate the whole image on disk (including kernel args) @@ -148,7 +141,7 @@ fn boot_sequence(args: KernelArguments, _signature: u32, fs_prehash: [u8; 64], _ println!("No suspend marker found, doing a cold boot!"); #[cfg(feature = "simulation-only")] println!("Configured for simulation. Skipping RAM clear!"); - #[cfg(not(feature = "simulation-only"))] + #[cfg(not(feature = "cramium-soc"))] // cramium-soc target clears RAM with assembly routine on boot clear_ram(&mut cfg); phase_1(&mut cfg); phase_2(&mut cfg, &fs_prehash); @@ -506,7 +499,7 @@ fn check_resume(cfg: &mut BootConfig) -> (bool, bool, u32) { /// Clears all of RAM. This is a must for systems that have suspend-to-RAM for security. /// It is configured to be skipped in simulation only, to accelerate the simulation times /// since we can initialize the RAM to zero in simulation. -#[cfg(not(feature = "simulation-only"))] +#[cfg(all(not(feature = "simulation-only"), not(feature = "cramium-soc")))] fn clear_ram(cfg: &mut BootConfig) { // clear RAM on a cold boot. // RAM is persistent and battery-backed. This means secret material could potentially diff --git a/loader/src/minielf.rs b/loader/src/minielf.rs index 3a1e9ec31..e54607d4f 100644 --- a/loader/src/minielf.rs +++ b/loader/src/minielf.rs @@ -593,6 +593,7 @@ pub fn pt_walk(root: usize, va: usize) -> Option { } #[cfg(all(any(feature = "debug-print", feature = "swap"), not(feature = "atsama5d27")))] +#[allow(dead_code)] pub fn pt_walk_swap(root: usize, va: usize, swap_root: usize) -> Option { let l1_pt = unsafe { &mut (*((root << 12) as *mut PageTable)) }; let l1_entry_va = (l1_pt.entries[(va & 0xFFC0_0000) >> 22] >> 10) << 12; diff --git a/loader/src/platform/cramium.rs b/loader/src/platform/cramium.rs index b779cce32..7293d32c2 100644 --- a/loader/src/platform/cramium.rs +++ b/loader/src/platform/cramium.rs @@ -4,13 +4,19 @@ pub use cramium::*; pub mod swap; #[cfg(feature = "swap")] pub use swap::*; +#[cfg(any(feature = "board-baosec", feature = "board-baosor"))] mod bootlogo; +#[cfg(any(feature = "board-baosec", feature = "board-baosor"))] mod poweron_bt; +#[cfg(feature = "updates")] mod update; +#[cfg(feature = "updates")] pub use update::*; +#[cfg(feature = "updates")] mod verifier; +#[cfg(any(feature = "board-baosec", feature = "board-baosor"))] mod gfx; #[cfg(feature = "qr")] mod homography; @@ -19,4 +25,5 @@ mod qr; #[cfg(feature = "usb")] mod usb; +#[cfg(feature = "updates")] mod sha512_digest; diff --git a/loader/src/platform/cramium/cramium.rs b/loader/src/platform/cramium/cramium.rs index e63e051a9..843a9cb2e 100644 --- a/loader/src/platform/cramium/cramium.rs +++ b/loader/src/platform/cramium/cramium.rs @@ -1,7 +1,11 @@ +#[cfg(any(feature = "board-baosec", feature = "board-baosor"))] use cramium_hal::axp2101::Axp2101; +#[cfg(not(feature = "verilator-only"))] use cramium_hal::iox::{Iox, IoxDir, IoxEnable, IoxFunction, IoxPort}; use cramium_hal::udma; +#[cfg(any(feature = "board-baosec", feature = "board-baosor"))] use cramium_hal::udma::PeriphId; +#[cfg(any(feature = "board-baosec", feature = "board-baosor"))] use cramium_hal::udma::UdmaGlobalConfig; use utralib::generated::*; @@ -75,6 +79,7 @@ pub const FLASH_BASE: usize = utralib::generated::HW_RERAM_MEM; // exclusive of the signature block offset pub const KERNEL_OFFSET: usize = 0x6_0000; +#[allow(dead_code)] pub(crate) fn delay(quantum: usize) { use utralib::{CSR, utra}; // abuse the d11ctime timer to create some time-out like thing @@ -91,7 +96,7 @@ pub(crate) fn delay(quantum: usize) { } } -#[cfg(feature = "cramium-soc")] +#[cfg(all(feature = "cramium-soc", not(feature = "verilator-only")))] pub fn early_init() -> u32 { // Set up the initial clocks. This is done as a "poke array" into a table of addresses. // Why? because this is actually how it's done for the chip verification code. We can @@ -207,8 +212,10 @@ pub fn early_init() -> u32 { // Now setup the clocks for real // Safety: this can only be called in the early_init boot context + #[cfg(not(feature = "simulation-only"))] let perclk = unsafe { init_clock_asic(800_000_000) }; - // let perclk = unsafe { init_clock_asic_c(800_000_000, 0) }; + #[cfg(feature = "simulation-only")] + let perclk = 100_000_000; crate::println!("Perclk is {} Hz", perclk); // Configure the UDMA UART. This UART's settings will be used as the initial console UART. @@ -220,6 +227,7 @@ pub fn early_init() -> u32 { // UART_TX_A[0] = PA4 app // UART_RX_A[1] = PD13 console // UART_RX_A[1] = PD14 console + #[allow(unused_mut)] // some configs require mut let mut iox = Iox::new(utra::iox::HW_IOX_BASE as *mut u32); iox.set_alternate_function(IoxPort::PD, 13, IoxFunction::AF1); iox.set_alternate_function(IoxPort::PD, 14, IoxFunction::AF1); @@ -230,6 +238,7 @@ pub fn early_init() -> u32 { iox.set_gpio_dir(IoxPort::PD, 14, IoxDir::Output); // Set up the UDMA_UART block to the correct baud rate and enable status + #[allow(unused_mut)] // some configs require mut let mut udma_global = udma::GlobalConfig::new(utra::udma_ctrl::HW_UDMA_CTRL_BASE as *mut u32); udma_global.clock_on(udma::PeriphId::Uart1); udma_global.map_event( @@ -277,8 +286,11 @@ pub fn early_init() -> u32 { glbl_csr.wo(utra::sce_glbsfr::SFR_FFCLR, 0xff05); // configure LDO voltages that aren't correct by default. + #[cfg(any(feature = "board-baosec", feature = "board-baosor"))] let i2c_channel = cramium_hal::board::setup_i2c_pins(&iox); + #[cfg(any(feature = "board-baosec", feature = "board-baosor"))] udma_global.clock(PeriphId::from(i2c_channel), true); + #[cfg(any(feature = "board-baosec", feature = "board-baosor"))] let i2c_ifram = unsafe { cramium_hal::ifram::IframRange::from_raw_parts( cramium_hal::board::I2C_IFRAM_ADDR, @@ -286,75 +298,83 @@ pub fn early_init() -> u32 { 4096, ) }; + + #[cfg(any(feature = "board-baosec", feature = "board-baosor"))] let mut i2c = unsafe { cramium_hal::udma::I2c::new_with_ifram(i2c_channel, 400_000, perclk, i2c_ifram) }; // setup PMIC - let mut pmic: Option = None; + #[cfg(any(feature = "board-baosec", feature = "board-baosor"))] + { + let mut pmic: Option = None; - for _ in 0..3 { - match cramium_hal::axp2101::Axp2101::new(&mut i2c) { - Ok(p) => { - pmic = Some(p); - break; - } - Err(e) => { - crate::println!("Error initializing pmic: {:?}, retrying", e); + for _ in 0..3 { + match cramium_hal::axp2101::Axp2101::new(&mut i2c) { + Ok(p) => { + pmic = Some(p); + break; + } + Err(e) => { + crate::println!("Error initializing pmic: {:?}, retrying", e); - // we have to reboot it appears if the I2C is unstable - a "soft recovery" - // just leads to CPU lock-up on exit from the init routine? what is going on?? - // maybe some IFRAM instability? Maybe the I2C unit is locking up? - let mut rcurst = CSR::new(utra::sysctrl::HW_SYSCTRL_BASE as *mut u32); - rcurst.wo(utra::sysctrl::SFR_RCURST0, 0x55AA); - rcurst.wo(utra::sysctrl::SFR_RCURST1, 0x55AA); + // we have to reboot it appears if the I2C is unstable - a "soft recovery" + // just leads to CPU lock-up on exit from the init routine? what is going on?? + // maybe some IFRAM instability? Maybe the I2C unit is locking up? + let mut rcurst = CSR::new(utra::sysctrl::HW_SYSCTRL_BASE as *mut u32); + rcurst.wo(utra::sysctrl::SFR_RCURST0, 0x55AA); + rcurst.wo(utra::sysctrl::SFR_RCURST1, 0x55AA); - /* - unsafe { - let ifram0 = HW_IFRAM0_MEM as *mut u32; - for i in 0..HW_IFRAM0_MEM_LEN / size_of::() { - ifram0.add(i).write_volatile(0); - } - let ifram1 = HW_IFRAM1_MEM as *mut u32; - for i in 0..HW_IFRAM1_MEM_LEN / size_of::() { - ifram1.add(i).write_volatile(0); - } - }*/ + /* + unsafe { + let ifram0 = HW_IFRAM0_MEM as *mut u32; + for i in 0..HW_IFRAM0_MEM_LEN / size_of::() { + ifram0.add(i).write_volatile(0); + } + let ifram1 = HW_IFRAM1_MEM as *mut u32; + for i in 0..HW_IFRAM1_MEM_LEN / size_of::() { + ifram1.add(i).write_volatile(0); + } + }*/ - delay(500); - } - }; - } - if let Some(mut pmic) = pmic { - pmic.set_ldo(&mut i2c, Some(2.5), cramium_hal::axp2101::WhichLdo::Aldo2).unwrap(); - pmic.set_dcdc(&mut i2c, Some((1.2, false)), cramium_hal::axp2101::WhichDcDc::Dcdc4).unwrap(); - crate::println!("AXP2101 configure: {:?}", pmic); - - // Make this true to have the system shut down by disconnecting its own battery while on battery power - // Note this does nothing if you have USB power plugged in. - if false { - crate::println!("shutting down..."); - pmic.set_ldo(&mut i2c, Some(0.9), cramium_hal::axp2101::WhichLdo::Aldo3).ok(); - crate::println!("system should be off"); + delay(500); + } + }; + } + if let Some(mut pmic) = pmic { + pmic.set_ldo(&mut i2c, Some(2.5), cramium_hal::axp2101::WhichLdo::Aldo2).unwrap(); + pmic.set_dcdc(&mut i2c, Some((1.2, false)), cramium_hal::axp2101::WhichDcDc::Dcdc4).unwrap(); + crate::println!("AXP2101 configure: {:?}", pmic); + + // Make this true to have the system shut down by disconnecting its own battery while on battery + // power Note this does nothing if you have USB power plugged in. + if false { + crate::println!("shutting down..."); + pmic.set_ldo(&mut i2c, Some(0.9), cramium_hal::axp2101::WhichLdo::Aldo3).ok(); + crate::println!("system should be off"); + } + } else { + crate::println!("Couldn't init AXP2101, rebooting"); + let mut rcurst = CSR::new(utra::sysctrl::HW_SYSCTRL_BASE as *mut u32); + rcurst.wo(utra::sysctrl::SFR_RCURST0, 0x55AA); + rcurst.wo(utra::sysctrl::SFR_RCURST1, 0x55AA); + panic!("System should have reset"); } - } else { - crate::println!("Couldn't init AXP2101, rebooting"); - let mut rcurst = CSR::new(utra::sysctrl::HW_SYSCTRL_BASE as *mut u32); - rcurst.wo(utra::sysctrl::SFR_RCURST0, 0x55AA); - rcurst.wo(utra::sysctrl::SFR_RCURST1, 0x55AA); - panic!("System should have reset"); } // Turn off SE0 on USB - let _se0 = cramium_hal::board::baosec::setup_usb_pins(&iox); + let _se0 = cramium_hal::board::setup_usb_pins(&iox); #[cfg(feature = "board-bringup")] let iox_loop = iox.clone(); - // show the boot logo - use cramium_hal::minigfx::FrameBuffer; + #[cfg(any(feature = "board-baosec", feature = "board-baosor"))] + { + // show the boot logo + use cramium_hal::minigfx::FrameBuffer; - let mut sh1107 = cramium_hal::sh1107::Oled128x128::new(perclk, &mut iox, &mut udma_global); - sh1107.init(); - crate::platform::cramium::bootlogo::show_logo(&mut sh1107); - sh1107.buffer_swap(); - sh1107.draw(); + let mut sh1107 = cramium_hal::sh1107::Oled128x128::new(perclk, &mut iox, &mut udma_global); + sh1107.init(); + crate::platform::cramium::bootlogo::show_logo(&mut sh1107); + sh1107.buffer_swap(); + sh1107.draw(); + } // Board bring-up: send characters to confirm the UART is configured & ready to go for the logging crate! // The "boot gutter" also has a role to pause the system in "real mode" before VM is mapped in Xous @@ -1337,6 +1357,7 @@ fn test_duart() { pub fn platform_tests() { test_duart(); } // returns the actual per_clk +#[cfg(not(feature = "simulation-only"))] unsafe fn init_clock_asic(freq_hz: u32) -> u32 { use utra::sysctrl; let daric_cgu = sysctrl::HW_SYSCTRL_BASE as *mut u32; diff --git a/services/cram-console/Cargo.toml b/services/cram-console/Cargo.toml index 2965f8bb5..ee6c705b9 100644 --- a/services/cram-console/Cargo.toml +++ b/services/cram-console/Cargo.toml @@ -16,7 +16,7 @@ log = "0.4.14" num-derive = { version = "0.3.3", default-features = false } num-traits = { version = "0.2.14", default-features = false } -xous-pio = { path = "../../libs/xous-pio", optional = true } +# xous-pio = { path = "../../libs/xous-pio", optional = true } xous-pl230 = { path = "../../libs/xous-pl230", optional = true } # this is temporary, until we get GAM/modals pulled in graphics-server = { path = "../graphics-server" } @@ -38,7 +38,7 @@ xous-swapper = { path = "../xous-swapper" } "clifford-poll" = [] "tts" = [] "early-ball" = [] -"pio-test" = ["xous-pio"] +# "pio-test" = ["xous-pio"] "pl230-test" = ["xous-pl230"] "hwtest" = [] "pddb" = [] diff --git a/services/cram-hal-service/Cargo.toml b/services/cram-hal-service/Cargo.toml index 810958c01..030b0dde6 100644 --- a/services/cram-hal-service/Cargo.toml +++ b/services/cram-hal-service/Cargo.toml @@ -20,9 +20,9 @@ cramium-hal = { path = "../../libs/cramium-hal", features = [ "std", ] } xous-pl230 = { path = "../../libs/xous-pl230", features = ["cramium-soc"] } -xous-pio = { path = "../../libs/xous-pio", default-features = false, features = [ - "cramium-soc", -] } +# xous-pio = { path = "../../libs/xous-pio", default-features = false, features = [ +# "cramium-soc", +# ] } pio-proc = "0.2.2" pio = "0.2.1" rand_core = "0.6.4" @@ -43,5 +43,5 @@ rawserial = [] pinger = [] swap = [] # add this feature to enable pre-emption -quantum-timer = ["utralib"] -default = ["quantum-timer", "app-uart"] +quantum-timer = ["utralib", "pio"] +default = ["app-uart"] diff --git a/services/cram-hal-service/src/main.rs b/services/cram-hal-service/src/main.rs index 39428d8e3..dbb83acc0 100644 --- a/services/cram-hal-service/src/main.rs +++ b/services/cram-hal-service/src/main.rs @@ -13,8 +13,10 @@ use utralib::*; #[cfg(feature = "swap")] use xous::SWAPPER_PID; use xous::sender::Sender; +#[cfg(feature = "pio")] use xous_pio::*; +#[cfg(feature = "quantum-timer")] struct PreemptionHw { pub timer_sm: PioSm, pub irq_csr: CSR, @@ -169,51 +171,54 @@ fn main() { // -------------------- begin timer workaround code // This code should go away with NTO as we have a proper, private ticktimer unit. - let mut pio_ss = xous_pio::PioSharedState::new(); - // map and enable the interrupt for the PIO system timer - let irq18_page = xous::syscall::map_memory( - xous::MemoryAddress::new(utralib::generated::HW_IRQARRAY18_BASE), - None, - 4096, - xous::MemoryFlags::R | xous::MemoryFlags::W, - ) - .expect("couldn't claim irq18 csr"); - let mut ptimer = PreemptionHw { - timer_sm: pio_ss.alloc_sm().unwrap(), - irq_csr: CSR::new(irq18_page.as_mut_ptr() as *mut u32), - }; - - // claim the IRQ for the quanta timer - xous::claim_interrupt( - utralib::LITEX_IRQARRAY18_INTERRUPT, - timer_tick, - &mut ptimer as *mut PreemptionHw as *mut usize, - ) - .expect("couldn't claim IRQ"); - - pio_ss.clear_instruction_memory(); - pio_ss.pio.rmwf(utra::rp_pio::SFR_CTRL_EN, 0); - #[rustfmt::skip] - let timer_code = pio_proc::pio_asm!( - "restart:", - "set x, 6", // 4 cycles overhead gets us to 10 iterations per pulse - "waitloop:", - "jmp x-- waitloop", - "irq set 0", - "jmp restart", - ); - let a_prog = LoadedProg::load(timer_code.program, &mut pio_ss).unwrap(); - ptimer.timer_sm.sm_set_enabled(false); - a_prog.setup_default_config(&mut ptimer.timer_sm); - ptimer.timer_sm.config_set_clkdiv(50_000.0f32); // set to 1ms per cycle - ptimer.timer_sm.sm_init(a_prog.entry()); - ptimer.timer_sm.sm_irq0_source_enabled(PioIntSource::Sm, true); - ptimer.timer_sm.sm_set_enabled(true); - - #[cfg(feature = "quantum-timer")] + #[cfg(feature = "pio")] { - ptimer.irq_csr.wfo(utra::irqarray18::EV_ENABLE_PIOIRQ0_DUPE, 1); - log::info!("Quantum timer setup!"); + let mut pio_ss = xous_pio::PioSharedState::new(); + // map and enable the interrupt for the PIO system timer + let irq18_page = xous::syscall::map_memory( + xous::MemoryAddress::new(utralib::generated::HW_IRQARRAY18_BASE), + None, + 4096, + xous::MemoryFlags::R | xous::MemoryFlags::W, + ) + .expect("couldn't claim irq18 csr"); + let mut ptimer = PreemptionHw { + timer_sm: pio_ss.alloc_sm().unwrap(), + irq_csr: CSR::new(irq18_page.as_mut_ptr() as *mut u32), + }; + + // claim the IRQ for the quanta timer + xous::claim_interrupt( + utralib::LITEX_IRQARRAY18_INTERRUPT, + timer_tick, + &mut ptimer as *mut PreemptionHw as *mut usize, + ) + .expect("couldn't claim IRQ"); + + pio_ss.clear_instruction_memory(); + pio_ss.pio.rmwf(utra::rp_pio::SFR_CTRL_EN, 0); + #[rustfmt::skip] + let timer_code = pio_proc::pio_asm!( + "restart:", + "set x, 6", // 4 cycles overhead gets us to 10 iterations per pulse + "waitloop:", + "jmp x-- waitloop", + "irq set 0", + "jmp restart", + ); + let a_prog = LoadedProg::load(timer_code.program, &mut pio_ss).unwrap(); + ptimer.timer_sm.sm_set_enabled(false); + a_prog.setup_default_config(&mut ptimer.timer_sm); + ptimer.timer_sm.config_set_clkdiv(50_000.0f32); // set to 1ms per cycle + ptimer.timer_sm.sm_init(a_prog.entry()); + ptimer.timer_sm.sm_irq0_source_enabled(PioIntSource::Sm, true); + ptimer.timer_sm.sm_set_enabled(true); + + #[cfg(feature = "quantum-timer")] + { + ptimer.irq_csr.wfo(utra::irqarray18::EV_ENABLE_PIOIRQ0_DUPE, 1); + log::info!("Quantum timer setup!"); + } } // -------------------- end timer workaround code diff --git a/utralib/cramium/core.svd b/utralib/cramium/core.svd index 688c51ce8..0b6be4938 100644 --- a/utralib/cramium/core.svd +++ b/utralib/cramium/core.svd @@ -3,7 +3,7 @@ litex SOC - + 8 32 @@ -265,215 +265,6 @@ register to disable individual events.]]> 21 - - COREUSER - 0xE0002000 - COREUSER - - - SET_ASID - 0x0000 - 0x00 - 32 - - - asid - 8 - [8:0] - 0 - - - - trusted - 9 - [9:9] - 9 - - - - - - GET_ASID_ADDR - 0x0004 - 0x00 - 32 - - - asid - 8 - [8:0] - 0 - - - - - - GET_ASID_VALUE - 0x0008 - 0x00 - 32 - - - value - 0 - [0:0] - 0 - - - - - - SET_PRIVILEGE - 0x000c - 0x00 - 32 - - - mpp - 1 - [1:0] - 0 - - - - - - CONTROL - 0x0010 - 0x00 - 32 - - - enable - 0 - [0:0] - 0 - - - - asid - 1 - [1:1] - 1 - - - - ppn_a - 2 - [2:2] - 2 - - - - ppn_b - 3 - [3:3] - 3 - - - - privilege - 4 - [4:4] - 4 - - - - - - PROTECT - - 0x0014 - 0x00 - 32 - - - protect - 0 - [0:0] - 0 - - - - - WINDOW_AL - 0x0018 - 0x00 - 32 - - - ppn - 21 - [21:0] - 0 - - - - - - WINDOW_AH - 0x001c - 0x00 - 32 - - - ppn - 21 - [21:0] - 0 - - - - - - WINDOW_BL - 0x0020 - 0x00 - 32 - - - ppn - 21 - [21:0] - 0 - - - - - - WINDOW_BH - 0x0024 - 0x00 - 32 - - - ppn - 21 - [21:0] - 0 - - - - - - - 0 - 0x28 - registers - - CSRTEST 0xE0003000 diff --git a/utralib/cramium/daric.svd b/utralib/cramium/daric.svd index 36706f86a..39c77f127 100644 --- a/utralib/cramium/daric.svd +++ b/utralib/cramium/daric.svd @@ -445,6 +445,7494 @@ + + ALU + 0x4002F000 + ALU + + + SFR_CRFUNC + + 0x0000 + 0x00 + 32 + + + sfr_crfunc + 7 + [7:0] + 0 + + + + + + SFR_AR + + 0x0004 + 0x00 + 32 + + + sfr_ar + 31 + [31:0] + 0 + + + + + + SFR_SRMFSM + + 0x0008 + 0x00 + 32 + + + mfsm + 7 + [7:0] + 0 + + + + crreg + 8 + [8:8] + 8 + + + + + + SFR_FR + + 0x000c + 0x00 + 32 + + + mfsm_done + 0 + [0:0] + 0 + + + + div_done + 1 + [1:1] + 1 + + + + chnlo_done + 2 + [2:2] + 2 + + + + chnli_done + 3 + [3:3] + 3 + + + + qs0err + 4 + [4:4] + 4 + + + + + + SFR_CRDIVLEN + + 0x0010 + 0x00 + 32 + + + sfr_crdivlen + 15 + [15:0] + 0 + + + + + + SFR_SRDIVLEN + + 0x0014 + 0x00 + 32 + + + sfr_srdivlen + 15 + [15:0] + 0 + + + + + + SFR_OPT + + 0x0018 + 0x00 + 32 + + + sfr_opt + 31 + [31:0] + 0 + + + + + + SFR_OPTLTX + + 0x001c + 0x00 + 32 + + + sfr_optltx + 7 + [7:0] + 0 + + + + + + SFR_SEGPTR_CR_SEGCFG0 + + 0x0030 + 0x00 + 32 + + + cr_segcfg0 + 19 + [19:0] + 0 + + + + + + SFR_SEGPTR_CR_SEGCFG1 + + 0x0034 + 0x00 + 32 + + + cr_segcfg1 + 19 + [19:0] + 0 + + + + + + SFR_SEGPTR_CR_SEGCFG2 + + 0x0038 + 0x00 + 32 + + + cr_segcfg2 + 19 + [19:0] + 0 + + + + + + SFR_SEGPTR_CR_SEGCFG3 + + 0x003c + 0x00 + 32 + + + cr_segcfg3 + 19 + [19:0] + 0 + + + + + + + 0 + 0x40 + registers + + + + AES + 0x4002D000 + AES + + + SFR_CRFUNC + + 0x0000 + 0x00 + 32 + + + sfr_crfunc + 7 + [7:0] + 0 + + + + + + SFR_AR + + 0x0004 + 0x00 + 32 + + + sfr_ar + 31 + [31:0] + 0 + + + + + + SFR_SRMFSM + + 0x0008 + 0x00 + 32 + + + sfr_srmfsm + 7 + [7:0] + 0 + + + + + + SFR_FR + + 0x000c + 0x00 + 32 + + + mfsm_done + 0 + [0:0] + 0 + + + + acore_done + 1 + [1:1] + 1 + + + + chnlo_done + 2 + [2:2] + 2 + + + + chnli_done + 3 + [3:3] + 3 + + + + + + SFR_OPT + + 0x0010 + 0x00 + 32 + + + opt_klen0 + 3 + [3:0] + 0 + + + + opt_mode0 + 7 + [7:4] + 4 + + + + opt_ifstart0 + 8 + [8:8] + 8 + + + + + + SFR_OPT1 + + 0x0014 + 0x00 + 32 + + + sfr_opt1 + 15 + [15:0] + 0 + + + + + + SFR_OPTLTX + + 0x0018 + 0x00 + 32 + + + sfr_optltx + 5 + [5:0] + 0 + + + + + + SFR_MASKSEED + + 0x0020 + 0x00 + 32 + + + sfr_maskseed + 31 + [31:0] + 0 + + + + + + SFR_MASKSEEDAR + + 0x0024 + 0x00 + 32 + + + sfr_maskseedar + 31 + [31:0] + 0 + + + + + + SFR_SEGPTR_PTRID_IV + + 0x0030 + 0x00 + 32 + + + PTRID_IV + 11 + [11:0] + 0 + + + + + + SFR_SEGPTR_PTRID_AKEY + + 0x0034 + 0x00 + 32 + + + PTRID_AKEY + 11 + [11:0] + 0 + + + + + + SFR_SEGPTR_PTRID_AIB + + 0x0038 + 0x00 + 32 + + + PTRID_AIB + 11 + [11:0] + 0 + + + + + + SFR_SEGPTR_PTRID_AOB + + 0x003c + 0x00 + 32 + + + PTRID_AOB + 11 + [11:0] + 0 + + + + + + + 0 + 0x40 + registers + + + + COMBOHASH + 0x4002B000 + COMBOHASH + + + SFR_CRFUNC + + 0x0000 + 0x00 + 32 + + + cr_func + 7 + [7:0] + 0 + + + + + + SFR_AR + + 0x0004 + 0x00 + 32 + + + sfr_ar + 31 + [31:0] + 0 + + + + + + SFR_SRMFSM + + 0x0008 + 0x00 + 32 + + + mfsm + 7 + [7:0] + 0 + + + + + + SFR_FR + + 0x000c + 0x00 + 32 + + + mfsm_done + 0 + [0:0] + 0 + + + + hash_done + 1 + [1:1] + 1 + + + + chnlo_done + 2 + [2:2] + 2 + + + + chnli_done + 3 + [3:3] + 3 + + + + chkdone + 4 + [4:4] + 4 + + + + chkpass + 5 + [5:5] + 5 + + + + + + SFR_OPT1 + + 0x0010 + 0x00 + 32 + + + cr_opt_hashcnt + 15 + [15:0] + 0 + + + + + + SFR_OPT2 + + 0x0014 + 0x00 + 32 + + + cr_opt_scrtchk + 0 + [0:0] + 0 + + + + cr_opt_ifsob + 1 + [1:1] + 1 + + + + cr_opt_ifstart + 2 + [2:2] + 2 + + + + opt_schnr1_0 + 3 + [3:3] + 3 + + + + + + SFR_OPT3 + + 0x0018 + 0x00 + 32 + + + sfr_opt3 + 7 + [7:0] + 0 + + + + + + SFR_BLKT0 + + 0x001c + 0x00 + 32 + + + sfr_blkt0 + 7 + [7:0] + 0 + + + + + + SFR_SEGPTR_SEGID_LKEY + + 0x0020 + 0x00 + 32 + + + SEGID_LKEY + 11 + [11:0] + 0 + + + + + + SFR_SEGPTR_SEGID_KEY + + 0x0024 + 0x00 + 32 + + + SEGID_KEY + 11 + [11:0] + 0 + + + + + + SFR_SEGPTR_SEGID_SCRT + + 0x002c + 0x00 + 32 + + + SEGID_SCRT + 11 + [11:0] + 0 + + + + + + SFR_SEGPTR_SEGID_MSG + + 0x0030 + 0x00 + 32 + + + SEGID_MSG + 11 + [11:0] + 0 + + + + + + SFR_SEGPTR_SEGID_HOUT + + 0x0034 + 0x00 + 32 + + + SEGID_HOUT + 11 + [11:0] + 0 + + + + + + SFR_SEGPTR_SEGID_HOUT2 + + 0x003c + 0x00 + 32 + + + SEGID_HOUT2 + 11 + [11:0] + 0 + + + + + + + 0 + 0x40 + registers + + + + PKE + 0x4002C000 + PKE + + + SFR_CRFUNC + + 0x0000 + 0x00 + 32 + + + cr_func + 7 + [7:0] + 0 + + + + cr_pcoreir + 15 + [15:8] + 8 + + + + + + SFR_AR + + 0x0004 + 0x00 + 32 + + + sfr_ar + 31 + [31:0] + 0 + + + + + + SFR_SRMFSM + + 0x0008 + 0x00 + 32 + + + mfsm + 7 + [7:0] + 0 + + + + modinvready + 8 + [8:8] + 8 + + + + + + SFR_FR + + 0x000c + 0x00 + 32 + + + mfsm_done + 0 + [0:0] + 0 + + + + pcore_done + 1 + [1:1] + 1 + + + + chnlo_done + 2 + [2:2] + 2 + + + + chnli_done + 3 + [3:3] + 3 + + + + chnlx_done + 4 + [4:4] + 4 + + + + + + SFR_OPTNW + + 0x0010 + 0x00 + 32 + + + sfr_optnw + 12 + [12:0] + 0 + + + + + + SFR_OPTEW + + 0x0014 + 0x00 + 32 + + + sfr_optew + 12 + [12:0] + 0 + + + + + + SFR_OPTRW + + 0x0018 + 0x00 + 32 + + + sfr_optrw + 9 + [9:0] + 0 + + + + + + SFR_OPTLTX + + 0x001c + 0x00 + 32 + + + sfr_optltx + 4 + [4:0] + 0 + + + + + + SFR_OPTMASK + + 0x0020 + 0x00 + 32 + + + sfr_optmask + 15 + [15:0] + 0 + + + + + + SFR_MIMMCR + + 0x0024 + 0x00 + 32 + + + sfr_mimmcr + 8 + [8:0] + 0 + + + + + + SFR_SEGPTR_PTRID_PCON + + 0x0030 + 0x00 + 32 + + + PTRID_PCON + 11 + [11:0] + 0 + + + + + + SFR_SEGPTR_PTRID_PIB0 + + 0x0034 + 0x00 + 32 + + + PTRID_PIB0 + 11 + [11:0] + 0 + + + + + + SFR_SEGPTR_PTRID_PIB1 + + 0x0038 + 0x00 + 32 + + + PTRID_PIB1 + 11 + [11:0] + 0 + + + + + + SFR_SEGPTR_PTRID_PKB + + 0x003c + 0x00 + 32 + + + PTRID_PKB + 11 + [11:0] + 0 + + + + + + SFR_SEGPTR_PTRID_POB + + 0x0040 + 0x00 + 32 + + + PTRID_POB + 11 + [11:0] + 0 + + + + + + + 0 + 0x44 + registers + + + + TRNG + 0x4002E000 + TRNG + + + SFR_CRSRC + + 0x0000 + 0x00 + 32 + + + sfr_crsrc + 11 + [11:0] + 0 + + + + + + SFR_CRANA + + 0x0004 + 0x00 + 32 + + + sfr_crana + 15 + [15:0] + 0 + + + + + + SFR_PP + + 0x0008 + 0x00 + 32 + + + sfr_pp + 16 + [16:0] + 0 + + + + + + SFR_OPT + + 0x000c + 0x00 + 32 + + + sfr_opt + 16 + [16:0] + 0 + + + + + + SFR_SR + + 0x0010 + 0x00 + 32 + + + sr_rng + 31 + [31:0] + 0 + + + + + + SFR_AR_GEN + + 0x0014 + 0x00 + 32 + + + sfr_ar_gen + 31 + [31:0] + 0 + + + + + + SFR_FR + + 0x0018 + 0x00 + 32 + + + sfr_fr + 1 + [1:0] + 0 + + + + + + SFR_DRPSZ + + 0x0020 + 0x00 + 32 + + + sfr_drpsz + 31 + [31:0] + 0 + + + + + + SFR_DRGEN + + 0x0024 + 0x00 + 32 + + + sfr_drgen + 31 + [31:0] + 0 + + + + + + SFR_DRRESEED + + 0x0028 + 0x00 + 32 + + + sfr_drreseed + 31 + [31:0] + 0 + + + + + + SFR_BUF + + 0x0030 + 0x00 + 32 + + + sfr_buf + 31 + [31:0] + 0 + + + + + + SFR_CHAIN_RNGCHAINEN0 + + 0x0040 + 0x00 + 32 + + + rngchainen0 + 31 + [31:0] + 0 + + + + + + SFR_CHAIN_RNGCHAINEN1 + + 0x0044 + 0x00 + 32 + + + rngchainen1 + 31 + [31:0] + 0 + + + + + + + 0 + 0x48 + registers + + + + SCEDMA + 0x40029000 + SCEDMA + + + SFR_SCHSTART_AR + + 0x0000 + 0x00 + 32 + + + sfr_schstart_ar + 31 + [31:0] + 0 + + + + + + SFR_XCH_FUNC + + 0x0010 + 0x00 + 32 + + + sfr_xch_func + 0 + [0:0] + 0 + + + + + + SFR_XCH_OPT + + 0x0014 + 0x00 + 32 + + + sfr_xch_opt + 7 + [7:0] + 0 + + + + + + SFR_XCH_AXSTART + + 0x0018 + 0x00 + 32 + + + sfr_xch_axstart + 31 + [31:0] + 0 + + + + + + SFR_XCH_SEGID + + 0x001c + 0x00 + 32 + + + sfr_xch_segid + 7 + [7:0] + 0 + + + + + + SFR_XCH_SEGSTART + + 0x0020 + 0x00 + 32 + + + xchcr_segstart + 11 + [11:0] + 0 + + + + + + SFR_XCH_TRANSIZE + + 0x0024 + 0x00 + 32 + + + xchcr_transize + 29 + [29:0] + 0 + + + + + + SFR_SCH_FUNC + + 0x0030 + 0x00 + 32 + + + sfr_sch_func + 0 + [0:0] + 0 + + + + + + SFR_SCH_OPT + + 0x0034 + 0x00 + 32 + + + sfr_sch_opt + 7 + [7:0] + 0 + + + + + + SFR_SCH_AXSTART + + 0x0038 + 0x00 + 32 + + + sfr_sch_axstart + 31 + [31:0] + 0 + + + + + + SFR_SCH_SEGID + + 0x003c + 0x00 + 32 + + + sfr_sch_segid + 7 + [7:0] + 0 + + + + + + SFR_SCH_SEGSTART + + 0x0040 + 0x00 + 32 + + + schcr_segstart + 11 + [11:0] + 0 + + + + + + SFR_SCH_TRANSIZE + + 0x0044 + 0x00 + 32 + + + schcr_transize + 29 + [29:0] + 0 + + + + + + SFR_ICH_OPT + + 0x0050 + 0x00 + 32 + + + sfr_ich_opt + 3 + [3:0] + 0 + + + + + + SFR_ICH_SEGID + + 0x0054 + 0x00 + 32 + + + sfr_ich_segid + 15 + [15:0] + 0 + + + + + + SFR_ICH_RPSTART + + 0x0058 + 0x00 + 32 + + + ichcr_rpstart + 11 + [11:0] + 0 + + + + + + SFR_ICH_WPSTART + + 0x005c + 0x00 + 32 + + + ichcr_wpstart + 11 + [11:0] + 0 + + + + + + SFR_ICH_TRANSIZE + + 0x0060 + 0x00 + 32 + + + ichcr_transize + 11 + [11:0] + 0 + + + + + + + 0 + 0x64 + registers + + + + SCE_GLBSFR + 0x40028000 + SCE_GLBSFR + + + SFR_SCEMODE + + 0x0000 + 0x00 + 32 + + + cr_scemode + 1 + [1:0] + 0 + + + + + + SFR_SUBEN + + 0x0004 + 0x00 + 32 + + + cr_suben + 15 + [15:0] + 0 + + + + + + SFR_AHBS + + 0x0008 + 0x00 + 32 + + + cr_ahbsopt + 4 + [4:0] + 0 + + + + + + SFR_SRBUSY + + 0x0010 + 0x00 + 32 + + + sr_busy + 15 + [15:0] + 0 + + + + + + SFR_FRDONE + + 0x0014 + 0x00 + 32 + + + fr_done + 15 + [15:0] + 0 + + + + + + SFR_FRERR + + 0x0018 + 0x00 + 32 + + + fr_err + 15 + [15:0] + 0 + + + + + + SFR_ARCLR + + 0x001c + 0x00 + 32 + + + ar_clrram + 31 + [31:0] + 0 + + + + + + SFR_TICKCYC + + 0x0020 + 0x00 + 32 + + + sfr_tickcyc + 7 + [7:0] + 0 + + + + + + SFR_TICKCNT + + 0x0024 + 0x00 + 32 + + + sfr_tickcnt + 31 + [31:0] + 0 + + + + + + SFR_FFEN + + 0x0030 + 0x00 + 32 + + + cr_ffen + 5 + [5:0] + 0 + + + + + + SFR_FFCLR + + 0x0034 + 0x00 + 32 + + + ar_ffclr + 31 + [31:0] + 0 + + + + + + SFR_FFCNT_SR_FF0 + + 0x0040 + 0x00 + 32 + + + sr_ff0 + 15 + [15:0] + 0 + + + + + + SFR_FFCNT_SR_FF1 + + 0x0044 + 0x00 + 32 + + + sr_ff1 + 15 + [15:0] + 0 + + + + + + SFR_FFCNT_SR_FF2 + + 0x0048 + 0x00 + 32 + + + sr_ff2 + 15 + [15:0] + 0 + + + + + + SFR_FFCNT_SR_FF3 + + 0x004c + 0x00 + 32 + + + sr_ff3 + 15 + [15:0] + 0 + + + + + + SFR_FFCNT_SR_FF4 + + 0x0050 + 0x00 + 32 + + + sr_ff4 + 15 + [15:0] + 0 + + + + + + SFR_FFCNT_SR_FF5 + + 0x0054 + 0x00 + 32 + + + sr_ff5 + 15 + [15:0] + 0 + + + + + + SFR_FRACERR + + 0x0060 + 0x00 + 32 + + + fr_acerr + 7 + [7:0] + 0 + + + + + + SFR_TS + + 0x00fc + 0x00 + 32 + + + cr_ts + 15 + [15:0] + 0 + + + + + + + 0 + 0x100 + registers + + + + DUART + 0x40042000 + DUART + + + SFR_TXD + + 0x0000 + 0x00 + 32 + + + sfr_txd + 7 + [7:0] + 0 + + + + + + SFR_CR + + 0x0004 + 0x00 + 32 + + + sfr_cr + 0 + [0:0] + 0 + + + + + + SFR_SR + + 0x0008 + 0x00 + 32 + + + sfr_sr + 0 + [0:0] + 0 + + + + + + SFR_ETUC + + 0x000c + 0x00 + 32 + + + sfr_etuc + 15 + [15:0] + 0 + + + + + + + 0 + 0x10 + registers + + + + RBIST_WRP + 0x40045000 + RBIST_WRP + + + SFRCR_TRM + + 0x0000 + 0x00 + 32 + + + sfrcr_trm + 23 + [23:0] + 0 + + + + + + SFRAR_TRM + + 0x0004 + 0x00 + 32 + + + sfrar_trm + 31 + [31:0] + 0 + + + + + + + 0 + 0x8 + registers + + + + WDG_INTF + 0x40041000 + WDG_INTF + + + + 0 + 0x4 + registers + + + + TIMER_INTF + 0x40043000 + TIMER_INTF + + + + 0 + 0x4 + registers + + + + EVC + 0x40044000 + EVC + + + SFR_CM7EVSEL_CM7EVSEL0 + + 0x0000 + 0x00 + 32 + + + cm7evsel0 + 7 + [7:0] + 0 + + + + + + SFR_CM7EVSEL_CM7EVSEL1 + + 0x0004 + 0x00 + 32 + + + cm7evsel1 + 7 + [7:0] + 0 + + + + + + SFR_CM7EVSEL_CM7EVSEL2 + + 0x0008 + 0x00 + 32 + + + cm7evsel2 + 7 + [7:0] + 0 + + + + + + SFR_CM7EVSEL_CM7EVSEL3 + + 0x000c + 0x00 + 32 + + + cm7evsel3 + 7 + [7:0] + 0 + + + + + + SFR_CM7EVSEL_CM7EVSEL4 + + 0x0010 + 0x00 + 32 + + + cm7evsel4 + 7 + [7:0] + 0 + + + + + + SFR_CM7EVSEL_CM7EVSEL5 + + 0x0014 + 0x00 + 32 + + + cm7evsel5 + 7 + [7:0] + 0 + + + + + + SFR_CM7EVSEL_CM7EVSEL6 + + 0x0018 + 0x00 + 32 + + + cm7evsel6 + 7 + [7:0] + 0 + + + + + + SFR_CM7EVSEL_CM7EVSEL7 + + 0x001c + 0x00 + 32 + + + cm7evsel7 + 7 + [7:0] + 0 + + + + + + SFR_CM7EVEN + + 0x0020 + 0x00 + 32 + + + cm7even + 7 + [7:0] + 0 + + + + + + SFR_CM7EVFR + + 0x0024 + 0x00 + 32 + + + cm7evs + 7 + [7:0] + 0 + + + + + + SFR_TMREVSEL + + 0x0030 + 0x00 + 32 + + + tmr_evsel + 15 + [15:0] + 0 + + + + + + SFR_PWMEVSEL + + 0x0034 + 0x00 + 32 + + + pwm_evsel + 31 + [31:0] + 0 + + + + + + SFR_IFEVEN_IFEVEN0 + + 0x0040 + 0x00 + 32 + + + ifeven0 + 31 + [31:0] + 0 + + + + + + SFR_IFEVEN_IFEVEN1 + + 0x0044 + 0x00 + 32 + + + ifeven1 + 31 + [31:0] + 0 + + + + + + SFR_IFEVEN_IFEVEN2 + + 0x0048 + 0x00 + 32 + + + ifeven2 + 31 + [31:0] + 0 + + + + + + SFR_IFEVEN_IFEVEN3 + + 0x004c + 0x00 + 32 + + + ifeven3 + 31 + [31:0] + 0 + + + + + + SFR_IFEVEN_IFEVEN4 + + 0x0050 + 0x00 + 32 + + + ifeven4 + 31 + [31:0] + 0 + + + + + + SFR_IFEVEN_IFEVEN5 + + 0x0054 + 0x00 + 32 + + + ifeven5 + 31 + [31:0] + 0 + + + + + + SFR_IFEVEN_IFEVEN6 + + 0x0058 + 0x00 + 32 + + + ifeven6 + 31 + [31:0] + 0 + + + + + + SFR_IFEVEN_IFEVEN7 + + 0x005c + 0x00 + 32 + + + ifeven7 + 31 + [31:0] + 0 + + + + + + SFR_IFEVERRFR + + 0x0060 + 0x00 + 32 + + + ifev_errs + 31 + [31:0] + 0 + + + + + + SFR_CM7ERRFR + + 0x0080 + 0x00 + 32 + + + errin + 31 + [31:0] + 0 + + + + + + + 0 + 0x84 + registers + + + + SYSCTRL + 0x40040000 + SYSCTRL + + + SFR_CGUSEC + + 0x0000 + 0x00 + 32 + + + sfr_cgusec + 15 + [15:0] + 0 + + + + + + SFR_CGULP + + 0x0004 + 0x00 + 32 + + + sfr_cgulp + 15 + [15:0] + 0 + + + + + + SFR_SEED + + 0x0008 + 0x00 + 32 + + + sfr_seed + 31 + [31:0] + 0 + + + + + + SFR_SEEDAR + + 0x000c + 0x00 + 32 + + + sfr_seedar + 31 + [31:0] + 0 + + + + + + SFR_CGUSEL0 + + 0x0010 + 0x00 + 32 + + + sfr_cgusel0 + 1 + [1:0] + 0 + + + + + + SFR_CGUFD_CFGFDCR_0_4_0 + + 0x0014 + 0x00 + 32 + + + cfgfdcr_0_4_0 + 23 + [23:0] + 0 + + + + + + SFR_CGUFD_CFGFDCR_0_4_1 + + 0x0018 + 0x00 + 32 + + + cfgfdcr_0_4_1 + 23 + [23:0] + 0 + + + + + + SFR_CGUFD_CFGFDCR_0_4_2 + + 0x001c + 0x00 + 32 + + + cfgfdcr_0_4_2 + 23 + [23:0] + 0 + + + + + + SFR_CGUFD_CFGFDCR_0_4_3 + + 0x0020 + 0x00 + 32 + + + cfgfdcr_0_4_3 + 23 + [23:0] + 0 + + + + + + SFR_CGUFD_CFGFDCR_0_4_4 + + 0x0024 + 0x00 + 32 + + + cfgfdcr_0_4_4 + 23 + [23:0] + 0 + + + + + + SFR_CGUFDAO + + 0x0028 + 0x00 + 32 + + + cfgfdcr + 23 + [23:0] + 0 + + + + + + SFR_CGUSET + + 0x002c + 0x00 + 32 + + + sfr_cguset + 31 + [31:0] + 0 + + + + + + SFR_CGUSEL1 + + 0x0030 + 0x00 + 32 + + + sfr_cgusel1 + 0 + [0:0] + 0 + + + + + + SFR_CGUFDPKE + + 0x0034 + 0x00 + 32 + + + sfr_cgufdpke + 8 + [8:0] + 0 + + + + + + SFR_CGUFSSR_FSFREQ0 + + 0x0040 + 0x00 + 32 + + + fsfreq0 + 15 + [15:0] + 0 + + + + + + SFR_CGUFSSR_FSFREQ1 + + 0x0044 + 0x00 + 32 + + + fsfreq1 + 15 + [15:0] + 0 + + + + + + SFR_CGUFSSR_FSFREQ2 + + 0x0048 + 0x00 + 32 + + + fsfreq2 + 15 + [15:0] + 0 + + + + + + SFR_CGUFSSR_FSFREQ3 + + 0x004c + 0x00 + 32 + + + fsfreq3 + 15 + [15:0] + 0 + + + + + + SFR_CGUFSVLD + + 0x0050 + 0x00 + 32 + + + sfr_cgufsvld + 3 + [3:0] + 0 + + + + + + SFR_CGUFSCR + + 0x0054 + 0x00 + 32 + + + sfr_cgufscr + 15 + [15:0] + 0 + + + + + + SFR_ACLKGR + + 0x0060 + 0x00 + 32 + + + sfr_aclkgr + 7 + [7:0] + 0 + + + + + + SFR_HCLKGR + + 0x0064 + 0x00 + 32 + + + sfr_hclkgr + 7 + [7:0] + 0 + + + + + + SFR_ICLKGR + + 0x0068 + 0x00 + 32 + + + sfr_iclkgr + 7 + [7:0] + 0 + + + + + + SFR_PCLKGR + + 0x006c + 0x00 + 32 + + + sfr_pclkgr + 7 + [7:0] + 0 + + + + + + SFR_RCURST0 + + 0x0080 + 0x00 + 32 + + + sfr_rcurst0 + 31 + [31:0] + 0 + + + + + + SFR_RCURST1 + + 0x0084 + 0x00 + 32 + + + sfr_rcurst1 + 31 + [31:0] + 0 + + + + + + SFR_RCUSRCFR + + 0x0088 + 0x00 + 32 + + + sfr_rcusrcfr + 15 + [15:0] + 0 + + + + + + SFR_IPCARIPFLOW + + 0x0090 + 0x00 + 32 + + + sfr_ipcaripflow + 31 + [31:0] + 0 + + + + + + SFR_IPCEN + + 0x0094 + 0x00 + 32 + + + sfr_ipcen + 15 + [15:0] + 0 + + + + + + SFR_IPCLPEN + + 0x0098 + 0x00 + 32 + + + sfr_ipclpen + 15 + [15:0] + 0 + + + + + + SFR_IPCOSC + + 0x009c + 0x00 + 32 + + + sfr_ipcosc + 6 + [6:0] + 0 + + + + + + SFR_IPCPLLMN + + 0x00a0 + 0x00 + 32 + + + sfr_ipcpllmn + 16 + [16:0] + 0 + + + + + + SFR_IPCPLLF + + 0x00a4 + 0x00 + 32 + + + sfr_ipcpllf + 24 + [24:0] + 0 + + + + + + SFR_IPCPLLQ + + 0x00a8 + 0x00 + 32 + + + sfr_ipcpllq + 14 + [14:0] + 0 + + + + + + SFR_IPCCR + + 0x00ac + 0x00 + 32 + + + sfr_ipccr + 15 + [15:0] + 0 + + + + + + + 0 + 0xb0 + registers + + + + APB_THRU + 0x50122000 + APB_THRU + + + + 0 + 0x4 + registers + + + + BIO_BDMA + 0x50124000 + BIO_BDMA + + + SFR_CTRL + + 0x0000 + 0x00 + 32 + + + en + 3 + [3:0] + 0 + + + + restart + 7 + [7:4] + 4 + + + + clkdiv_restart + 11 + [11:8] + 8 + + + + + + SFR_CFGINFO + + 0x0004 + 0x00 + 32 + + + constant0 + 7 + [7:0] + 0 + + + + constant1 + 15 + [15:8] + 8 + + + + constant2 + 31 + [31:16] + 16 + + + + + + SFR_CONFIG + + 0x0008 + 0x00 + 32 + + + snap_output_to_which + 1 + [1:0] + 0 + + + + snap_output_to_quantum + 2 + [2:2] + 2 + + + + snap_input_to_which + 4 + [4:3] + 3 + + + + snap_input_to_quantum + 5 + [5:5] + 5 + + + + disable_filter_peri + 6 + [6:6] + 6 + + + + disable_filter_mem + 7 + [7:7] + 7 + + + + + + SFR_FLEVEL + + 0x000c + 0x00 + 32 + + + pclk_regfifo_level0 + 3 + [3:0] + 0 + + + + pclk_regfifo_level1 + 7 + [7:4] + 4 + + + + pclk_regfifo_level2 + 11 + [11:8] + 8 + + + + pclk_regfifo_level3 + 15 + [15:12] + 12 + + + + + + SFR_TXF0 + + 0x0010 + 0x00 + 32 + + + fdin + 31 + [31:0] + 0 + + + + + + SFR_TXF1 + + 0x0014 + 0x00 + 32 + + + fdin + 31 + [31:0] + 0 + + + + + + SFR_TXF2 + + 0x0018 + 0x00 + 32 + + + fdin + 31 + [31:0] + 0 + + + + + + SFR_TXF3 + + 0x001c + 0x00 + 32 + + + fdin + 31 + [31:0] + 0 + + + + + + SFR_RXF0 + + 0x0020 + 0x00 + 32 + + + fdout + 31 + [31:0] + 0 + + + + + + SFR_RXF1 + + 0x0024 + 0x00 + 32 + + + fdout + 31 + [31:0] + 0 + + + + + + SFR_RXF2 + + 0x0028 + 0x00 + 32 + + + fdout + 31 + [31:0] + 0 + + + + + + SFR_RXF3 + + 0x002c + 0x00 + 32 + + + fdout + 31 + [31:0] + 0 + + + + + + SFR_ELEVEL + + 0x0030 + 0x00 + 32 + + + fifo_event_level0 + 3 + [3:0] + 0 + + + + fifo_event_level1 + 7 + [7:4] + 4 + + + + fifo_event_level2 + 11 + [11:8] + 8 + + + + fifo_event_level3 + 15 + [15:12] + 12 + + + + fifo_event_level4 + 19 + [19:16] + 16 + + + + fifo_event_level5 + 23 + [23:20] + 20 + + + + fifo_event_level6 + 27 + [27:24] + 24 + + + + fifo_event_level7 + 31 + [31:28] + 28 + + + + + + SFR_ETYPE + + 0x0034 + 0x00 + 32 + + + fifo_event_lt_mask + 7 + [7:0] + 0 + + + + fifo_event_eq_mask + 15 + [15:8] + 8 + + + + fifo_event_gt_mask + 23 + [23:16] + 16 + + + + + + SFR_EVENT_SET + + 0x0038 + 0x00 + 32 + + + sfr_event_set + 23 + [23:0] + 0 + + + + + + SFR_EVENT_CLR + + 0x003c + 0x00 + 32 + + + sfr_event_clr + 23 + [23:0] + 0 + + + + + + SFR_EVENT_STATUS + + 0x0040 + 0x00 + 32 + + + sfr_event_status + 31 + [31:0] + 0 + + + + + + SFR_EXTCLOCK + + 0x0044 + 0x00 + 32 + + + use_extclk + 3 + [3:0] + 0 + + + + extclk_gpio_0 + 8 + [8:4] + 4 + + + + extclk_gpio_1 + 13 + [13:9] + 9 + + + + extclk_gpio_2 + 18 + [18:14] + 14 + + + + extclk_gpio_3 + 23 + [23:19] + 19 + + + + + + SFR_FIFO_CLR + + 0x0048 + 0x00 + 32 + + + sfr_fifo_clr + 3 + [3:0] + 0 + + + + + + SFR_QDIV0 + + 0x0050 + 0x00 + 32 + + + unused_div + 0 + [0:0] + 0 + + + + div_frac + 1 + [1:1] + 1 + + + + div_int + 2 + [2:2] + 2 + + + + + + SFR_QDIV1 + + 0x0054 + 0x00 + 32 + + + unused_div + 0 + [0:0] + 0 + + + + div_frac + 1 + [1:1] + 1 + + + + div_int + 2 + [2:2] + 2 + + + + + + SFR_QDIV2 + + 0x0058 + 0x00 + 32 + + + unused_div + 0 + [0:0] + 0 + + + + div_frac + 1 + [1:1] + 1 + + + + div_int + 2 + [2:2] + 2 + + + + + + SFR_QDIV3 + + 0x005c + 0x00 + 32 + + + unused_div + 0 + [0:0] + 0 + + + + div_frac + 1 + [1:1] + 1 + + + + div_int + 2 + [2:2] + 2 + + + + + + SFR_SYNC_BYPASS + + 0x0060 + 0x00 + 32 + + + sfr_sync_bypass + 31 + [31:0] + 0 + + + + + + SFR_IO_OE_INV + + 0x0064 + 0x00 + 32 + + + sfr_io_oe_inv + 31 + [31:0] + 0 + + + + + + SFR_IO_O_INV + + 0x0068 + 0x00 + 32 + + + sfr_io_o_inv + 31 + [31:0] + 0 + + + + + + SFR_IO_I_INV + + 0x006c + 0x00 + 32 + + + sfr_io_i_inv + 31 + [31:0] + 0 + + + + + + SFR_IRQMASK_0 + + 0x0070 + 0x00 + 32 + + + sfr_irqmask_0 + 31 + [31:0] + 0 + + + + + + SFR_IRQMASK_1 + + 0x0074 + 0x00 + 32 + + + sfr_irqmask_1 + 31 + [31:0] + 0 + + + + + + SFR_IRQMASK_2 + + 0x0078 + 0x00 + 32 + + + sfr_irqmask_2 + 31 + [31:0] + 0 + + + + + + SFR_IRQMASK_3 + + 0x007c + 0x00 + 32 + + + sfr_irqmask_3 + 31 + [31:0] + 0 + + + + + + SFR_IRQ_EDGE + + 0x0080 + 0x00 + 32 + + + sfr_irq_edge + 3 + [3:0] + 0 + + + + + + SFR_DBG_PADOUT + + 0x0084 + 0x00 + 32 + + + sfr_dbg_padout + 31 + [31:0] + 0 + + + + + + SFR_DBG_PADOE + + 0x0088 + 0x00 + 32 + + + sfr_dbg_padoe + 31 + [31:0] + 0 + + + + + + SFR_DBG0 + + 0x0090 + 0x00 + 32 + + + dbg_pc + 0 + [0:0] + 0 + + + + trap + 1 + [1:1] + 1 + + + + + + SFR_DBG1 + + 0x0094 + 0x00 + 32 + + + dbg_pc + 0 + [0:0] + 0 + + + + trap + 1 + [1:1] + 1 + + + + + + SFR_DBG2 + + 0x0098 + 0x00 + 32 + + + dbg_pc + 0 + [0:0] + 0 + + + + trap + 1 + [1:1] + 1 + + + + + + SFR_DBG3 + + 0x009c + 0x00 + 32 + + + dbg_pc + 0 + [0:0] + 0 + + + + trap + 1 + [1:1] + 1 + + + + + + SFR_MEM_GUTTER + + 0x00a0 + 0x00 + 32 + + + sfr_mem_gutter + 31 + [31:0] + 0 + + + + + + SFR_PERI_GUTTER + + 0x00a4 + 0x00 + 32 + + + sfr_peri_gutter + 31 + [31:0] + 0 + + + + + + SFR_DMAREQ_MAP_CR_EVMAP0 + + 0x00b0 + 0x00 + 32 + + + cr_evmap0 + 31 + [31:0] + 0 + + + + + + SFR_DMAREQ_MAP_CR_EVMAP1 + + 0x00b4 + 0x00 + 32 + + + cr_evmap1 + 31 + [31:0] + 0 + + + + + + SFR_DMAREQ_MAP_CR_EVMAP2 + + 0x00b8 + 0x00 + 32 + + + cr_evmap2 + 31 + [31:0] + 0 + + + + + + SFR_DMAREQ_MAP_CR_EVMAP3 + + 0x00bc + 0x00 + 32 + + + cr_evmap3 + 31 + [31:0] + 0 + + + + + + SFR_DMAREQ_MAP_CR_EVMAP4 + + 0x00c0 + 0x00 + 32 + + + cr_evmap4 + 31 + [31:0] + 0 + + + + + + SFR_DMAREQ_MAP_CR_EVMAP5 + + 0x00c4 + 0x00 + 32 + + + cr_evmap5 + 31 + [31:0] + 0 + + + + + + SFR_DMAREQ_STAT_SR_EVSTAT0 + + 0x00c8 + 0x00 + 32 + + + sr_evstat0 + 31 + [31:0] + 0 + + + + + + SFR_DMAREQ_STAT_SR_EVSTAT1 + + 0x00cc + 0x00 + 32 + + + sr_evstat1 + 31 + [31:0] + 0 + + + + + + SFR_DMAREQ_STAT_SR_EVSTAT2 + + 0x00d0 + 0x00 + 32 + + + sr_evstat2 + 31 + [31:0] + 0 + + + + + + SFR_DMAREQ_STAT_SR_EVSTAT3 + + 0x00d4 + 0x00 + 32 + + + sr_evstat3 + 31 + [31:0] + 0 + + + + + + SFR_DMAREQ_STAT_SR_EVSTAT4 + + 0x00d8 + 0x00 + 32 + + + sr_evstat4 + 31 + [31:0] + 0 + + + + + + SFR_DMAREQ_STAT_SR_EVSTAT5 + + 0x00dc + 0x00 + 32 + + + sr_evstat5 + 31 + [31:0] + 0 + + + + + + SFR_FILTER_BASE_0 + + 0x00e0 + 0x00 + 32 + + + filter_base + 19 + [19:0] + 0 + + + + + + SFR_FILTER_BOUNDS_0 + + 0x00e4 + 0x00 + 32 + + + filter_bounds + 19 + [19:0] + 0 + + + + + + SFR_FILTER_BASE_1 + + 0x00e8 + 0x00 + 32 + + + filter_base + 19 + [19:0] + 0 + + + + + + SFR_FILTER_BOUNDS_1 + + 0x00ec + 0x00 + 32 + + + filter_bounds + 19 + [19:0] + 0 + + + + + + SFR_FILTER_BASE_2 + + 0x00f0 + 0x00 + 32 + + + filter_base + 19 + [19:0] + 0 + + + + + + SFR_FILTER_BOUNDS_2 + + 0x00f4 + 0x00 + 32 + + + filter_bounds + 19 + [19:0] + 0 + + + + + + SFR_FILTER_BASE_3 + + 0x00f8 + 0x00 + 32 + + + filter_base + 19 + [19:0] + 0 + + + + + + SFR_FILTER_BOUNDS_3 + + 0x00fc + 0x00 + 32 + + + filter_bounds + 19 + [19:0] + 0 + + + + + + + 0 + 0x100 + registers + + + + IOX + 0x5012F000 + IOX + + + SFR_AFSEL_CRAFSEL0 + + 0x0000 + 0x00 + 32 + + + crafsel0 + 15 + [15:0] + 0 + + + + + + SFR_AFSEL_CRAFSEL1 + + 0x0004 + 0x00 + 32 + + + crafsel1 + 15 + [15:0] + 0 + + + + + + SFR_AFSEL_CRAFSEL2 + + 0x0008 + 0x00 + 32 + + + crafsel2 + 15 + [15:0] + 0 + + + + + + SFR_AFSEL_CRAFSEL3 + + 0x000c + 0x00 + 32 + + + crafsel3 + 15 + [15:0] + 0 + + + + + + SFR_AFSEL_CRAFSEL4 + + 0x0010 + 0x00 + 32 + + + crafsel4 + 15 + [15:0] + 0 + + + + + + SFR_AFSEL_CRAFSEL5 + + 0x0014 + 0x00 + 32 + + + crafsel5 + 15 + [15:0] + 0 + + + + + + SFR_AFSEL_CRAFSEL6 + + 0x0018 + 0x00 + 32 + + + crafsel6 + 15 + [15:0] + 0 + + + + + + SFR_AFSEL_CRAFSEL7 + + 0x001c + 0x00 + 32 + + + crafsel7 + 15 + [15:0] + 0 + + + + + + SFR_AFSEL_CRAFSEL8 + + 0x0020 + 0x00 + 32 + + + crafsel8 + 15 + [15:0] + 0 + + + + + + SFR_AFSEL_CRAFSEL9 + + 0x0024 + 0x00 + 32 + + + crafsel9 + 15 + [15:0] + 0 + + + + + + SFR_AFSEL_CRAFSEL10 + + 0x0028 + 0x00 + 32 + + + crafsel10 + 15 + [15:0] + 0 + + + + + + SFR_AFSEL_CRAFSEL11 + + 0x002c + 0x00 + 32 + + + crafsel11 + 15 + [15:0] + 0 + + + + + + SFR_INTCR_CRINT0 + + 0x0100 + 0x00 + 32 + + + crint0 + 9 + [9:0] + 0 + + + + + + SFR_INTCR_CRINT1 + + 0x0104 + 0x00 + 32 + + + crint1 + 9 + [9:0] + 0 + + + + + + SFR_INTCR_CRINT2 + + 0x0108 + 0x00 + 32 + + + crint2 + 9 + [9:0] + 0 + + + + + + SFR_INTCR_CRINT3 + + 0x010c + 0x00 + 32 + + + crint3 + 9 + [9:0] + 0 + + + + + + SFR_INTCR_CRINT4 + + 0x0110 + 0x00 + 32 + + + crint4 + 9 + [9:0] + 0 + + + + + + SFR_INTCR_CRINT5 + + 0x0114 + 0x00 + 32 + + + crint5 + 9 + [9:0] + 0 + + + + + + SFR_INTCR_CRINT6 + + 0x0118 + 0x00 + 32 + + + crint6 + 9 + [9:0] + 0 + + + + + + SFR_INTCR_CRINT7 + + 0x011c + 0x00 + 32 + + + crint7 + 9 + [9:0] + 0 + + + + + + SFR_INTFR + + 0x0120 + 0x00 + 32 + + + frint + 7 + [7:0] + 0 + + + + + + SFR_GPIOOUT_CRGO0 + + 0x0130 + 0x00 + 32 + + + crgo0 + 15 + [15:0] + 0 + + + + + + SFR_GPIOOUT_CRGO1 + + 0x0134 + 0x00 + 32 + + + crgo1 + 15 + [15:0] + 0 + + + + + + SFR_GPIOOUT_CRGO2 + + 0x0138 + 0x00 + 32 + + + crgo2 + 15 + [15:0] + 0 + + + + + + SFR_GPIOOUT_CRGO3 + + 0x013c + 0x00 + 32 + + + crgo3 + 15 + [15:0] + 0 + + + + + + SFR_GPIOOUT_CRGO4 + + 0x0140 + 0x00 + 32 + + + crgo4 + 15 + [15:0] + 0 + + + + + + SFR_GPIOOUT_CRGO5 + + 0x0144 + 0x00 + 32 + + + crgo5 + 15 + [15:0] + 0 + + + + + + SFR_GPIOOE_CRGOE0 + + 0x0148 + 0x00 + 32 + + + crgoe0 + 15 + [15:0] + 0 + + + + + + SFR_GPIOOE_CRGOE1 + + 0x014c + 0x00 + 32 + + + crgoe1 + 15 + [15:0] + 0 + + + + + + SFR_GPIOOE_CRGOE2 + + 0x0150 + 0x00 + 32 + + + crgoe2 + 15 + [15:0] + 0 + + + + + + SFR_GPIOOE_CRGOE3 + + 0x0154 + 0x00 + 32 + + + crgoe3 + 15 + [15:0] + 0 + + + + + + SFR_GPIOOE_CRGOE4 + + 0x0158 + 0x00 + 32 + + + crgoe4 + 15 + [15:0] + 0 + + + + + + SFR_GPIOOE_CRGOE5 + + 0x015c + 0x00 + 32 + + + crgoe5 + 15 + [15:0] + 0 + + + + + + SFR_GPIOPU_CRGPU0 + + 0x0160 + 0x00 + 32 + + + crgpu0 + 15 + [15:0] + 0 + + + + + + SFR_GPIOPU_CRGPU1 + + 0x0164 + 0x00 + 32 + + + crgpu1 + 15 + [15:0] + 0 + + + + + + SFR_GPIOPU_CRGPU2 + + 0x0168 + 0x00 + 32 + + + crgpu2 + 15 + [15:0] + 0 + + + + + + SFR_GPIOPU_CRGPU3 + + 0x016c + 0x00 + 32 + + + crgpu3 + 15 + [15:0] + 0 + + + + + + SFR_GPIOPU_CRGPU4 + + 0x0170 + 0x00 + 32 + + + crgpu4 + 15 + [15:0] + 0 + + + + + + SFR_GPIOPU_CRGPU5 + + 0x0174 + 0x00 + 32 + + + crgpu5 + 15 + [15:0] + 0 + + + + + + SFR_GPIOIN_SRGI0 + + 0x0178 + 0x00 + 32 + + + srgi0 + 15 + [15:0] + 0 + + + + + + SFR_GPIOIN_SRGI1 + + 0x017c + 0x00 + 32 + + + srgi1 + 15 + [15:0] + 0 + + + + + + SFR_GPIOIN_SRGI2 + + 0x0180 + 0x00 + 32 + + + srgi2 + 15 + [15:0] + 0 + + + + + + SFR_GPIOIN_SRGI3 + + 0x0184 + 0x00 + 32 + + + srgi3 + 15 + [15:0] + 0 + + + + + + SFR_GPIOIN_SRGI4 + + 0x0188 + 0x00 + 32 + + + srgi4 + 15 + [15:0] + 0 + + + + + + SFR_GPIOIN_SRGI5 + + 0x018c + 0x00 + 32 + + + srgi5 + 15 + [15:0] + 0 + + + + + + SFR_PIOSEL + + 0x0200 + 0x00 + 32 + + + piosel + 31 + [31:0] + 0 + + + + + + SFR_CFG_SCHM_CR_CFG_SCHMSEL0 + + 0x0230 + 0x00 + 32 + + + cr_cfg_schmsel0 + 15 + [15:0] + 0 + + + + + + SFR_CFG_SCHM_CR_CFG_SCHMSEL1 + + 0x0234 + 0x00 + 32 + + + cr_cfg_schmsel1 + 15 + [15:0] + 0 + + + + + + SFR_CFG_SCHM_CR_CFG_SCHMSEL2 + + 0x0238 + 0x00 + 32 + + + cr_cfg_schmsel2 + 15 + [15:0] + 0 + + + + + + SFR_CFG_SCHM_CR_CFG_SCHMSEL3 + + 0x023c + 0x00 + 32 + + + cr_cfg_schmsel3 + 15 + [15:0] + 0 + + + + + + SFR_CFG_SCHM_CR_CFG_SCHMSEL4 + + 0x0240 + 0x00 + 32 + + + cr_cfg_schmsel4 + 15 + [15:0] + 0 + + + + + + SFR_CFG_SCHM_CR_CFG_SCHMSEL5 + + 0x0244 + 0x00 + 32 + + + cr_cfg_schmsel5 + 15 + [15:0] + 0 + + + + + + SFR_CFG_SLEW_CR_CFG_SLEWSLOW0 + + 0x0248 + 0x00 + 32 + + + cr_cfg_slewslow0 + 15 + [15:0] + 0 + + + + + + SFR_CFG_SLEW_CR_CFG_SLEWSLOW1 + + 0x024c + 0x00 + 32 + + + cr_cfg_slewslow1 + 15 + [15:0] + 0 + + + + + + SFR_CFG_SLEW_CR_CFG_SLEWSLOW2 + + 0x0250 + 0x00 + 32 + + + cr_cfg_slewslow2 + 15 + [15:0] + 0 + + + + + + SFR_CFG_SLEW_CR_CFG_SLEWSLOW3 + + 0x0254 + 0x00 + 32 + + + cr_cfg_slewslow3 + 15 + [15:0] + 0 + + + + + + SFR_CFG_SLEW_CR_CFG_SLEWSLOW4 + + 0x0258 + 0x00 + 32 + + + cr_cfg_slewslow4 + 15 + [15:0] + 0 + + + + + + SFR_CFG_SLEW_CR_CFG_SLEWSLOW5 + + 0x025c + 0x00 + 32 + + + cr_cfg_slewslow5 + 15 + [15:0] + 0 + + + + + + SFR_CFG_DRVSEL_CR_CFG_DRVSEL0 + + 0x0260 + 0x00 + 32 + + + cr_cfg_drvsel0 + 31 + [31:0] + 0 + + + + + + SFR_CFG_DRVSEL_CR_CFG_DRVSEL1 + + 0x0264 + 0x00 + 32 + + + cr_cfg_drvsel1 + 31 + [31:0] + 0 + + + + + + SFR_CFG_DRVSEL_CR_CFG_DRVSEL2 + + 0x0268 + 0x00 + 32 + + + cr_cfg_drvsel2 + 31 + [31:0] + 0 + + + + + + SFR_CFG_DRVSEL_CR_CFG_DRVSEL3 + + 0x026c + 0x00 + 32 + + + cr_cfg_drvsel3 + 31 + [31:0] + 0 + + + + + + SFR_CFG_DRVSEL_CR_CFG_DRVSEL4 + + 0x0270 + 0x00 + 32 + + + cr_cfg_drvsel4 + 31 + [31:0] + 0 + + + + + + SFR_CFG_DRVSEL_CR_CFG_DRVSEL5 + + 0x0274 + 0x00 + 32 + + + cr_cfg_drvsel5 + 31 + [31:0] + 0 + + + + + + + 0 + 0x278 + registers + + + + PWM + 0x50120000 + PWM + + + REG_TIM0_CMD + + 0x0000 + 0x00 + 32 + + + r_timer0_start + 0 + [0:0] + 0 + + + + r_timer0_stop + 1 + [1:1] + 1 + + + + r_timer0_update + 2 + [2:2] + 2 + + + + r_timer0_rst + 3 + [3:3] + 3 + + + + r_timer0_arm + 4 + [4:4] + 4 + + + + + + REG_TIM0_CFG + + 0x0004 + 0x00 + 32 + + + r_timer0_in_sel + 7 + [7:0] + 0 + + + + r_timer0_in_mode + 10 + [10:8] + 8 + + + + r_timer0_in_clk + 11 + [11:11] + 11 + + + + r_timer0_saw + 12 + [12:12] + 12 + + + + r_timer0_presc + 23 + [23:16] + 16 + + + + + + REG_TIM0_CH0_TH + + 0x000c + 0x00 + 32 + + + r_timer0_ch0_th + 15 + [15:0] + 0 + + + + r_timer0_ch0_mode + 18 + [18:16] + 16 + + + + + + REG_TIM0_CH1_TH + + 0x0010 + 0x00 + 32 + + + r_timer0_ch1_th + 15 + [15:0] + 0 + + + + r_timer0_ch1_mode + 18 + [18:16] + 16 + + + + + + REG_TIM0_CH2_TH + + 0x0014 + 0x00 + 32 + + + r_timer0_ch2_th + 15 + [15:0] + 0 + + + + r_timer0_ch2_mode + 18 + [18:16] + 16 + + + + + + REG_TIM0_CH3_TH + + 0x0018 + 0x00 + 32 + + + r_timer0_ch3_th + 15 + [15:0] + 0 + + + + r_timer0_ch3_mode + 18 + [18:16] + 16 + + + + + + REG_TIM0_CH0_LUT + + 0x001c + 0x00 + 32 + + + r_timer0_ch0_lut + 15 + [15:0] + 0 + + + + r_timer0_ch0_flt + 17 + [17:16] + 16 + + + + + + REG_TIM0_CH1_LUT + + 0x0020 + 0x00 + 32 + + + r_timer0_ch1_lut + 15 + [15:0] + 0 + + + + r_timer0_ch1_flt + 17 + [17:16] + 16 + + + + + + REG_TIM0_CH2_LUT + + 0x0024 + 0x00 + 32 + + + r_timer0_ch2_lut + 15 + [15:0] + 0 + + + + r_timer0_ch2_flt + 17 + [17:16] + 16 + + + + + + REG_TIM0_CH3_LUT + + 0x0028 + 0x00 + 32 + + + r_timer0_ch3_lut + 15 + [15:0] + 0 + + + + r_timer0_ch3_flt + 17 + [17:16] + 16 + + + + + + REG_TIM1_CMD + + 0x0040 + 0x00 + 32 + + + r_timer1_start + 0 + [0:0] + 0 + + + + r_timer1_stop + 1 + [1:1] + 1 + + + + r_timer1_update + 2 + [2:2] + 2 + + + + r_timer1_rst + 3 + [3:3] + 3 + + + + r_timer1_arm + 4 + [4:4] + 4 + + + + + + REG_TIM1_CFG + + 0x0044 + 0x00 + 32 + + + r_timer1_in_sel + 7 + [7:0] + 0 + + + + r_timer1_in_mode + 10 + [10:8] + 8 + + + + r_timer1_in_clk + 11 + [11:11] + 11 + + + + r_timer1_saw + 12 + [12:12] + 12 + + + + r_timer1_presc + 23 + [23:16] + 16 + + + + + + REG_TIM1_CH0_TH + + 0x004c + 0x00 + 32 + + + r_timer1_ch0_th + 15 + [15:0] + 0 + + + + r_timer1_ch0_mode + 18 + [18:16] + 16 + + + + + + REG_TIM1_CH1_TH + + 0x0050 + 0x00 + 32 + + + r_timer1_ch1_th + 15 + [15:0] + 0 + + + + r_timer1_ch1_mode + 18 + [18:16] + 16 + + + + + + REG_TIM1_CH2_TH + + 0x0054 + 0x00 + 32 + + + r_timer1_ch2_th + 15 + [15:0] + 0 + + + + r_timer1_ch2_mode + 18 + [18:16] + 16 + + + + + + REG_TIM1_CH3_TH + + 0x0058 + 0x00 + 32 + + + r_timer1_ch3_th + 15 + [15:0] + 0 + + + + r_timer1_ch3_mode + 18 + [18:16] + 16 + + + + + + REG_TIM1_CH0_LUT + + 0x005c + 0x00 + 32 + + + r_timer1_ch0_lut + 15 + [15:0] + 0 + + + + r_timer1_ch0_flt + 17 + [17:16] + 16 + + + + + + REG_TIM1_CH1_LUT + + 0x0060 + 0x00 + 32 + + + r_timer1_ch1_lut + 15 + [15:0] + 0 + + + + r_timer1_ch1_flt + 17 + [17:16] + 16 + + + + + + REG_TIM1_CH2_LUT + + 0x0064 + 0x00 + 32 + + + r_timer1_ch2_lut + 15 + [15:0] + 0 + + + + r_timer1_ch2_flt + 17 + [17:16] + 16 + + + + + + REG_TIM1_CH3_LUT + + 0x0068 + 0x00 + 32 + + + r_timer1_ch3_lut + 15 + [15:0] + 0 + + + + r_timer1_ch3_flt + 17 + [17:16] + 16 + + + + + + REG_TIM2_CMD + + 0x0080 + 0x00 + 32 + + + r_timer2_start + 0 + [0:0] + 0 + + + + r_timer2_stop + 1 + [1:1] + 1 + + + + r_timer2_update + 2 + [2:2] + 2 + + + + r_timer2_rst + 3 + [3:3] + 3 + + + + r_timer2_arm + 4 + [4:4] + 4 + + + + + + REG_TIM2_CFG + + 0x0084 + 0x00 + 32 + + + r_timer2_in_sel + 7 + [7:0] + 0 + + + + r_timer2_in_mode + 10 + [10:8] + 8 + + + + r_timer2_in_clk + 11 + [11:11] + 11 + + + + r_timer2_saw + 12 + [12:12] + 12 + + + + r_timer2_presc + 23 + [23:16] + 16 + + + + + + REG_TIM2_CH0_TH + + 0x008c + 0x00 + 32 + + + r_timer2_ch0_th + 15 + [15:0] + 0 + + + + r_timer2_ch0_mode + 18 + [18:16] + 16 + + + + + + REG_TIM2_CH1_TH + + 0x0090 + 0x00 + 32 + + + r_timer2_ch1_th + 15 + [15:0] + 0 + + + + r_timer2_ch1_mode + 18 + [18:16] + 16 + + + + + + REG_TIM2_CH2_TH + + 0x0094 + 0x00 + 32 + + + r_timer2_ch2_th + 15 + [15:0] + 0 + + + + r_timer2_ch2_mode + 18 + [18:16] + 16 + + + + + + REG_TIM2_CH3_TH + + 0x0098 + 0x00 + 32 + + + r_timer2_ch3_th + 15 + [15:0] + 0 + + + + r_timer2_ch3_mode + 18 + [18:16] + 16 + + + + + + REG_TIM2_CH0_LUT + + 0x009c + 0x00 + 32 + + + r_timer2_ch0_lut + 15 + [15:0] + 0 + + + + r_timer2_ch0_flt + 17 + [17:16] + 16 + + + + + + REG_TIM2_CH1_LUT + + 0x00a0 + 0x00 + 32 + + + r_timer2_ch1_lut + 15 + [15:0] + 0 + + + + r_timer2_ch1_flt + 17 + [17:16] + 16 + + + + + + REG_TIM2_CH2_LUT + + 0x00a4 + 0x00 + 32 + + + r_timer2_ch2_lut + 15 + [15:0] + 0 + + + + r_timer2_ch2_flt + 17 + [17:16] + 16 + + + + + + REG_TIM2_CH3_LUT + + 0x00a8 + 0x00 + 32 + + + r_timer2_ch3_lut + 15 + [15:0] + 0 + + + + r_timer2_ch3_flt + 17 + [17:16] + 16 + + + + + + REG_TIM3_CMD + + 0x00c0 + 0x00 + 32 + + + r_timer3_start + 0 + [0:0] + 0 + + + + r_timer3_stop + 1 + [1:1] + 1 + + + + r_timer3_update + 2 + [2:2] + 2 + + + + r_timer3_rst + 3 + [3:3] + 3 + + + + r_timer3_arm + 4 + [4:4] + 4 + + + + + + REG_TIM3_CFG + + 0x00c4 + 0x00 + 32 + + + r_timer3_in_sel + 7 + [7:0] + 0 + + + + r_timer3_in_mode + 10 + [10:8] + 8 + + + + r_timer3_in_clk + 11 + [11:11] + 11 + + + + r_timer3_saw + 12 + [12:12] + 12 + + + + r_timer3_presc + 23 + [23:16] + 16 + + + + + + REG_TIM3_CH0_TH + + 0x00cc + 0x00 + 32 + + + r_timer3_ch0_th + 15 + [15:0] + 0 + + + + r_timer3_ch0_mode + 18 + [18:16] + 16 + + + + + + REG_TIM3_CH1_TH + + 0x00d0 + 0x00 + 32 + + + r_timer3_ch1_th + 15 + [15:0] + 0 + + + + r_timer3_ch1_mode + 18 + [18:16] + 16 + + + + + + REG_TIM3_CH2_TH + + 0x00d4 + 0x00 + 32 + + + r_timer3_ch2_th + 15 + [15:0] + 0 + + + + r_timer3_ch2_mode + 18 + [18:16] + 16 + + + + + + REG_TIM3_CH3_TH + + 0x00d8 + 0x00 + 32 + + + r_timer3_ch3_th + 15 + [15:0] + 0 + + + + r_timer3_ch3_mode + 18 + [18:16] + 16 + + + + + + REG_TIM3_CH0_LUT + + 0x00dc + 0x00 + 32 + + + r_timer3_ch0_lut + 15 + [15:0] + 0 + + + + r_timer3_ch0_flt + 17 + [17:16] + 16 + + + + + + REG_TIM3_CH1_LUT + + 0x00e0 + 0x00 + 32 + + + r_timer3_ch1_lut + 15 + [15:0] + 0 + + + + r_timer3_ch1_flt + 17 + [17:16] + 16 + + + + + + REG_TIM3_CH2_LUT + + 0x00e4 + 0x00 + 32 + + + r_timer3_ch2_lut + 15 + [15:0] + 0 + + + + r_timer3_ch2_flt + 17 + [17:16] + 16 + + + + + + REG_TIM3_CH3_LUT + + 0x00e8 + 0x00 + 32 + + + r_timer3_ch3_lut + 15 + [15:0] + 0 + + + + r_timer3_ch3_flt + 17 + [17:16] + 16 + + + + + + REG_EVENT_CFG + + 0x0100 + 0x00 + 32 + + + r_event_sel_0 + 3 + [3:0] + 0 + + + + r_event_sel_1 + 7 + [7:4] + 4 + + + + r_event_sel_2 + 11 + [11:8] + 8 + + + + r_event_sel_3 + 15 + [15:12] + 12 + + + + r_event_en + 19 + [19:16] + 16 + + + + + + REG_CH_EN + + 0x0104 + 0x00 + 32 + + + r_clk_en + 3 + [3:0] + 0 + + + + + + REG_PREFD0 + + 0x0140 + 0x00 + 32 + + + lsclk_prefd_0 + 9 + [9:0] + 0 + + + + + + REG_PREFD1 + + 0x0144 + 0x00 + 32 + + + lsclk_prefd_1 + 9 + [9:0] + 0 + + + + + + REG_PREFD2 + + 0x0148 + 0x00 + 32 + + + lsclk_prefd_2 + 9 + [9:0] + 0 + + + + + + REG_PREFD3 + + 0x014c + 0x00 + 32 + + + lsclk_prefd_3 + 9 + [9:0] + 0 + + + + + + + 0 + 0x150 + registers + + + + CORESUB_SRAMTRM + 0x40014000 + CORESUB_SRAMTRM + + + SFR_CACHE + + 0x0000 + 0x00 + 32 + + + sfr_cache + 2 + [2:0] + 0 + + + + + + SFR_ITCM + + 0x0004 + 0x00 + 32 + + + sfr_itcm + 4 + [4:0] + 0 + + + + + + SFR_DTCM + + 0x0008 + 0x00 + 32 + + + sfr_dtcm + 4 + [4:0] + 0 + + + + + + SFR_SRAM0 + + 0x000c + 0x00 + 32 + + + sfr_sram0 + 4 + [4:0] + 0 + + + + + + SFR_SRAM1 + + 0x0010 + 0x00 + 32 + + + sfr_sram1 + 4 + [4:0] + 0 + + + + + + SFR_VEXRAM + + 0x0014 + 0x00 + 32 + + + sfr_vexram + 2 + [2:0] + 0 + + + + + + SFR_SRAMERR + + 0x0020 + 0x00 + 32 + + + srambankerr + 3 + [3:0] + 0 + + + + + + + 0 + 0x24 + registers + + + + MDMA + 0x40012000 + MDMA + + + SFR_EVSEL_CR_EVSEL0 + + 0x0000 + 0x00 + 32 + + + cr_evsel0 + 7 + [7:0] + 0 + + + + + + SFR_EVSEL_CR_EVSEL1 + + 0x0004 + 0x00 + 32 + + + cr_evsel1 + 7 + [7:0] + 0 + + + + + + SFR_EVSEL_CR_EVSEL2 + + 0x0008 + 0x00 + 32 + + + cr_evsel2 + 7 + [7:0] + 0 + + + + + + SFR_EVSEL_CR_EVSEL3 + + 0x000c + 0x00 + 32 + + + cr_evsel3 + 7 + [7:0] + 0 + + + + + + SFR_EVSEL_CR_EVSEL4 + + 0x0010 + 0x00 + 32 + + + cr_evsel4 + 7 + [7:0] + 0 + + + + + + SFR_EVSEL_CR_EVSEL5 + + 0x0014 + 0x00 + 32 + + + cr_evsel5 + 7 + [7:0] + 0 + + + + + + SFR_EVSEL_CR_EVSEL6 + + 0x0018 + 0x00 + 32 + + + cr_evsel6 + 7 + [7:0] + 0 + + + + + + SFR_EVSEL_CR_EVSEL7 + + 0x001c + 0x00 + 32 + + + cr_evsel7 + 7 + [7:0] + 0 + + + + + + SFR_CR_CR_MDMAREQ0 + + 0x0020 + 0x00 + 32 + + + cr_mdmareq0 + 4 + [4:0] + 0 + + + + + + SFR_CR_CR_MDMAREQ1 + + 0x0024 + 0x00 + 32 + + + cr_mdmareq1 + 4 + [4:0] + 0 + + + + + + SFR_CR_CR_MDMAREQ2 + + 0x0028 + 0x00 + 32 + + + cr_mdmareq2 + 4 + [4:0] + 0 + + + + + + SFR_CR_CR_MDMAREQ3 + + 0x002c + 0x00 + 32 + + + cr_mdmareq3 + 4 + [4:0] + 0 + + + + + + SFR_CR_CR_MDMAREQ4 + + 0x0030 + 0x00 + 32 + + + cr_mdmareq4 + 4 + [4:0] + 0 + + + + + + SFR_CR_CR_MDMAREQ5 + + 0x0034 + 0x00 + 32 + + + cr_mdmareq5 + 4 + [4:0] + 0 + + + + + + SFR_CR_CR_MDMAREQ6 + + 0x0038 + 0x00 + 32 + + + cr_mdmareq6 + 4 + [4:0] + 0 + + + + + + SFR_CR_CR_MDMAREQ7 + + 0x003c + 0x00 + 32 + + + cr_mdmareq7 + 4 + [4:0] + 0 + + + + + + SFR_SR_SR_MDMAREQ0 + + 0x0040 + 0x00 + 32 + + + sr_mdmareq0 + 4 + [4:0] + 0 + + + + + + SFR_SR_SR_MDMAREQ1 + + 0x0044 + 0x00 + 32 + + + sr_mdmareq1 + 4 + [4:0] + 0 + + + + + + SFR_SR_SR_MDMAREQ2 + + 0x0048 + 0x00 + 32 + + + sr_mdmareq2 + 4 + [4:0] + 0 + + + + + + SFR_SR_SR_MDMAREQ3 + + 0x004c + 0x00 + 32 + + + sr_mdmareq3 + 4 + [4:0] + 0 + + + + + + SFR_SR_SR_MDMAREQ4 + + 0x0050 + 0x00 + 32 + + + sr_mdmareq4 + 4 + [4:0] + 0 + + + + + + SFR_SR_SR_MDMAREQ5 + + 0x0054 + 0x00 + 32 + + + sr_mdmareq5 + 4 + [4:0] + 0 + + + + + + SFR_SR_SR_MDMAREQ6 + + 0x0058 + 0x00 + 32 + + + sr_mdmareq6 + 4 + [4:0] + 0 + + + + + + SFR_SR_SR_MDMAREQ7 + + 0x005c + 0x00 + 32 + + + sr_mdmareq7 + 4 + [4:0] + 0 + + + + + + + 0 + 0x60 + registers + + + + QFC + 0x40010000 + QFC + + + SFR_IO + + 0x0000 + 0x00 + 32 + + + sfr_io + 7 + [7:0] + 0 + + + + + + SFR_AR + + 0x0004 + 0x00 + 32 + + + sfr_ar + 31 + [31:0] + 0 + + + + + + SFR_IODRV + + 0x0008 + 0x00 + 32 + + + paddrvsel + 11 + [11:0] + 0 + + + + + + CR_XIP_ADDRMODE + + 0x0010 + 0x00 + 32 + + + cr_xip_addrmode + 1 + [1:0] + 0 + + + + + + CR_XIP_OPCODE + + 0x0014 + 0x00 + 32 + + + cr_xip_opcode + 31 + [31:0] + 0 + + + + + + CR_XIP_WIDTH + + 0x0018 + 0x00 + 32 + + + cr_xip_width + 5 + [5:0] + 0 + + + + + + CR_XIP_SSEL + + 0x001c + 0x00 + 32 + + + cr_xip_ssel + 6 + [6:0] + 0 + + + + + + CR_XIP_DUMCYC + + 0x0020 + 0x00 + 32 + + + cr_xip_dumcyc + 15 + [15:0] + 0 + + + + + + CR_XIP_CFG + + 0x0024 + 0x00 + 32 + + + cr_xip_cfg + 14 + [14:0] + 0 + + + + + + CR_AESKEY_AESKEYIN0 + + 0x0040 + 0x00 + 32 + + + aeskeyin0 + 31 + [31:0] + 0 + + + + + + CR_AESKEY_AESKEYIN1 + + 0x0044 + 0x00 + 32 + + + aeskeyin1 + 31 + [31:0] + 0 + + + + + + CR_AESKEY_AESKEYIN2 + + 0x0048 + 0x00 + 32 + + + aeskeyin2 + 31 + [31:0] + 0 + + + + + + CR_AESKEY_AESKEYIN3 + + 0x004c + 0x00 + 32 + + + aeskeyin3 + 31 + [31:0] + 0 + + + + + + CR_AESENA + + 0x0050 + 0x00 + 32 + + + cr_aesena + 0 + [0:0] + 0 + + + + + + + 0 + 0x54 + registers + + + + MBOX_APB + 0x40013000 + MBOX_APB + + + SFR_WDATA + + 0x0000 + 0x00 + 32 + + + sfr_wdata + 31 + [31:0] + 0 + + + + + + SFR_RDATA + + 0x0004 + 0x00 + 32 + + + sfr_rdata + 31 + [31:0] + 0 + + + + + + SFR_STATUS + + 0x0008 + 0x00 + 32 + + + rx_avail + 0 + [0:0] + 0 + + + + tx_free + 1 + [1:1] + 1 + + + + abort_in_progress + 2 + [2:2] + 2 + + + + abort_ack + 3 + [3:3] + 3 + + + + tx_err + 4 + [4:4] + 4 + + + + rx_err + 5 + [5:5] + 5 + + + + + + SFR_ABORT + + 0x0018 + 0x00 + 32 + + + sfr_abort + 31 + [31:0] + 0 + + + + + + SFR_DONE + + 0x001c + 0x00 + 32 + + + sfr_done + 31 + [31:0] + 0 + + + + + + + 0 + 0x20 + registers + + + + GLUECHAIN + 0x40054000 + GLUECHAIN + + + SFR_GCMASK + + 0x0000 + 0x00 + 32 + + + cr_gcmask + 31 + [31:0] + 0 + + + + + + SFR_GCSR + + 0x0004 + 0x00 + 32 + + + gluereg + 31 + [31:0] + 0 + + + + + + SFR_GCRST + + 0x0008 + 0x00 + 32 + + + gluerst + 31 + [31:0] + 0 + + + + + + SFR_GCTEST + + 0x000c + 0x00 + 32 + + + gluetest + 31 + [31:0] + 0 + + + + + + + 0 + 0x10 + registers + + UDMA_CTRL 0x50100000 @@ -452,7 +7940,7 @@ REG_CG - + 0x0000 0x00 32 @@ -468,7 +7956,7 @@ REG_CFG_EVT - + 0x0004 0x00 32 @@ -505,7 +7993,7 @@ REG_RST - + 0x0008 0x00 32 @@ -533,7 +8021,7 @@ REG_RX_SADDR - + 0x0000 0x00 32 @@ -549,7 +8037,7 @@ REG_RX_SIZE - + 0x0004 0x00 32 @@ -565,7 +8053,7 @@ REG_RX_CFG - + 0x0008 0x00 32 @@ -595,7 +8083,7 @@ REG_TX_SADDR - + 0x0010 0x00 32 @@ -611,7 +8099,7 @@ REG_TX_SIZE - + 0x0014 0x00 32 @@ -627,7 +8115,7 @@ REG_TX_CFG - + 0x0018 0x00 32 @@ -657,7 +8145,7 @@ REG_STATUS - + 0x0020 0x00 32 @@ -673,7 +8161,7 @@ REG_UART_SETUP - + 0x0024 0x00 32 @@ -738,7 +8226,7 @@ REG_ERROR - + 0x0028 0x00 32 @@ -761,7 +8249,7 @@ REG_IRQ_EN - + 0x002c 0x00 32 @@ -784,7 +8272,7 @@ REG_VALID - + 0x0030 0x00 32 @@ -800,7 +8288,7 @@ REG_DATA - + 0x0034 0x00 32 @@ -828,7 +8316,7 @@ REG_RX_SADDR - + 0x0000 0x00 32 @@ -844,7 +8332,7 @@ REG_RX_SIZE - + 0x0004 0x00 32 @@ -860,7 +8348,7 @@ REG_RX_CFG - + 0x0008 0x00 32 @@ -890,7 +8378,7 @@ REG_TX_SADDR - + 0x0010 0x00 32 @@ -906,7 +8394,7 @@ REG_TX_SIZE - + 0x0014 0x00 32 @@ -922,7 +8410,7 @@ REG_TX_CFG - + 0x0018 0x00 32 @@ -952,7 +8440,7 @@ REG_STATUS - + 0x0020 0x00 32 @@ -968,7 +8456,7 @@ REG_UART_SETUP - + 0x0024 0x00 32 @@ -1033,7 +8521,7 @@ REG_ERROR - + 0x0028 0x00 32 @@ -1056,7 +8544,7 @@ REG_IRQ_EN - + 0x002c 0x00 32 @@ -1079,7 +8567,7 @@ REG_VALID - + 0x0030 0x00 32 @@ -1095,7 +8583,7 @@ REG_DATA - + 0x0034 0x00 32 @@ -1123,7 +8611,7 @@ REG_RX_SADDR - + 0x0000 0x00 32 @@ -1139,7 +8627,7 @@ REG_RX_SIZE - + 0x0004 0x00 32 @@ -1155,7 +8643,7 @@ REG_RX_CFG - + 0x0008 0x00 32 @@ -1185,7 +8673,7 @@ REG_TX_SADDR - + 0x0010 0x00 32 @@ -1201,7 +8689,7 @@ REG_TX_SIZE - + 0x0014 0x00 32 @@ -1217,7 +8705,7 @@ REG_TX_CFG - + 0x0018 0x00 32 @@ -1247,7 +8735,7 @@ REG_STATUS - + 0x0020 0x00 32 @@ -1263,7 +8751,7 @@ REG_UART_SETUP - + 0x0024 0x00 32 @@ -1328,7 +8816,7 @@ REG_ERROR - + 0x0028 0x00 32 @@ -1351,7 +8839,7 @@ REG_IRQ_EN - + 0x002c 0x00 32 @@ -1374,7 +8862,7 @@ REG_VALID - + 0x0030 0x00 32 @@ -1390,7 +8878,7 @@ REG_DATA - + 0x0034 0x00 32 @@ -1418,7 +8906,7 @@ REG_RX_SADDR - + 0x0000 0x00 32 @@ -1434,7 +8922,7 @@ REG_RX_SIZE - + 0x0004 0x00 32 @@ -1450,7 +8938,7 @@ REG_RX_CFG - + 0x0008 0x00 32 @@ -1480,7 +8968,7 @@ REG_TX_SADDR - + 0x0010 0x00 32 @@ -1496,7 +8984,7 @@ REG_TX_SIZE - + 0x0014 0x00 32 @@ -1512,7 +9000,7 @@ REG_TX_CFG - + 0x0018 0x00 32 @@ -1542,7 +9030,7 @@ REG_STATUS - + 0x0020 0x00 32 @@ -1558,7 +9046,7 @@ REG_UART_SETUP - + 0x0024 0x00 32 @@ -1623,7 +9111,7 @@ REG_ERROR - + 0x0028 0x00 32 @@ -1646,7 +9134,7 @@ REG_IRQ_EN - + 0x002c 0x00 32 @@ -1669,7 +9157,7 @@ REG_VALID - + 0x0030 0x00 32 @@ -1685,7 +9173,7 @@ REG_DATA - + 0x0034 0x00 32 @@ -1713,7 +9201,7 @@ REG_RX_SADDR - + 0x0000 0x00 32 @@ -1729,7 +9217,7 @@ REG_RX_SIZE - + 0x0004 0x00 32 @@ -1745,7 +9233,7 @@ REG_RX_CFG - + 0x0008 0x00 32 @@ -1778,11 +9266,18 @@ 6 + + r_rx_backpressure + 7 + [7:7] + 7 + + REG_TX_SADDR - + 0x0010 0x00 32 @@ -1798,7 +9293,7 @@ REG_TX_SIZE - + 0x0014 0x00 32 @@ -1814,7 +9309,7 @@ REG_TX_CFG - + 0x0018 0x00 32 @@ -1851,7 +9346,7 @@ REG_CMD_SADDR - + 0x0020 0x00 32 @@ -1867,7 +9362,7 @@ REG_CMD_SIZE - + 0x0024 0x00 32 @@ -1883,7 +9378,7 @@ REG_CMD_CFG - + 0x0028 0x00 32 @@ -1913,7 +9408,7 @@ REG_STATUS - + 0x0030 0x00 32 @@ -1941,7 +9436,7 @@ REG_RX_SADDR - + 0x0000 0x00 32 @@ -1957,7 +9452,7 @@ REG_RX_SIZE - + 0x0004 0x00 32 @@ -1973,7 +9468,7 @@ REG_RX_CFG - + 0x0008 0x00 32 @@ -2006,11 +9501,18 @@ 6 + + r_rx_backpressure + 7 + [7:7] + 7 + + REG_TX_SADDR - + 0x0010 0x00 32 @@ -2026,7 +9528,7 @@ REG_TX_SIZE - + 0x0014 0x00 32 @@ -2042,7 +9544,7 @@ REG_TX_CFG - + 0x0018 0x00 32 @@ -2079,7 +9581,7 @@ REG_CMD_SADDR - + 0x0020 0x00 32 @@ -2095,7 +9597,7 @@ REG_CMD_SIZE - + 0x0024 0x00 32 @@ -2111,7 +9613,7 @@ REG_CMD_CFG - + 0x0028 0x00 32 @@ -2141,7 +9643,7 @@ REG_STATUS - + 0x0030 0x00 32 @@ -2169,7 +9671,7 @@ REG_RX_SADDR - + 0x0000 0x00 32 @@ -2185,7 +9687,7 @@ REG_RX_SIZE - + 0x0004 0x00 32 @@ -2201,7 +9703,7 @@ REG_RX_CFG - + 0x0008 0x00 32 @@ -2234,11 +9736,18 @@ 6 + + r_rx_backpressure + 7 + [7:7] + 7 + + REG_TX_SADDR - + 0x0010 0x00 32 @@ -2254,7 +9763,7 @@ REG_TX_SIZE - + 0x0014 0x00 32 @@ -2270,7 +9779,7 @@ REG_TX_CFG - + 0x0018 0x00 32 @@ -2307,7 +9816,7 @@ REG_CMD_SADDR - + 0x0020 0x00 32 @@ -2323,7 +9832,7 @@ REG_CMD_SIZE - + 0x0024 0x00 32 @@ -2339,7 +9848,7 @@ REG_CMD_CFG - + 0x0028 0x00 32 @@ -2369,7 +9878,7 @@ REG_STATUS - + 0x0030 0x00 32 @@ -2397,7 +9906,7 @@ REG_RX_SADDR - + 0x0000 0x00 32 @@ -2413,7 +9922,7 @@ REG_RX_SIZE - + 0x0004 0x00 32 @@ -2429,7 +9938,7 @@ REG_RX_CFG - + 0x0008 0x00 32 @@ -2462,11 +9971,18 @@ 6 + + r_rx_backpressure + 7 + [7:7] + 7 + + REG_TX_SADDR - + 0x0010 0x00 32 @@ -2482,7 +9998,7 @@ REG_TX_SIZE - + 0x0014 0x00 32 @@ -2498,7 +10014,7 @@ REG_TX_CFG - + 0x0018 0x00 32 @@ -2535,7 +10051,7 @@ REG_CMD_SADDR - + 0x0020 0x00 32 @@ -2551,7 +10067,7 @@ REG_CMD_SIZE - + 0x0024 0x00 32 @@ -2567,7 +10083,7 @@ REG_CMD_CFG - + 0x0028 0x00 32 @@ -2597,7 +10113,7 @@ REG_STATUS - + 0x0030 0x00 32 @@ -2625,7 +10141,7 @@ REG_RX_SADDR - + 0x0000 0x00 32 @@ -2641,7 +10157,7 @@ REG_RX_SIZE - + 0x0004 0x00 32 @@ -2657,7 +10173,7 @@ REG_RX_CFG - + 0x0008 0x00 32 @@ -2687,7 +10203,7 @@ REG_TX_SADDR - + 0x0010 0x00 32 @@ -2703,7 +10219,7 @@ REG_TX_SIZE - + 0x0014 0x00 32 @@ -2719,7 +10235,7 @@ REG_TX_CFG - + 0x0018 0x00 32 @@ -2749,7 +10265,7 @@ REG_CMD_SADDR - + 0x0020 0x00 32 @@ -2765,7 +10281,7 @@ REG_CMD_SIZE - + 0x0024 0x00 32 @@ -2781,7 +10297,7 @@ REG_CMD_CFG - + 0x0028 0x00 32 @@ -2811,7 +10327,7 @@ REG_STATUS - + 0x0030 0x00 32 @@ -2834,7 +10350,7 @@ REG_SETUP - + 0x0034 0x00 32 @@ -2850,7 +10366,7 @@ REG_ACK - + 0x0038 0x00 32 @@ -2878,7 +10394,7 @@ REG_RX_SADDR - + 0x0000 0x00 32 @@ -2894,7 +10410,7 @@ REG_RX_SIZE - + 0x0004 0x00 32 @@ -2910,7 +10426,7 @@ REG_RX_CFG - + 0x0008 0x00 32 @@ -2940,7 +10456,7 @@ REG_TX_SADDR - + 0x0010 0x00 32 @@ -2956,7 +10472,7 @@ REG_TX_SIZE - + 0x0014 0x00 32 @@ -2972,7 +10488,7 @@ REG_TX_CFG - + 0x0018 0x00 32 @@ -3002,7 +10518,7 @@ REG_CMD_SADDR - + 0x0020 0x00 32 @@ -3018,7 +10534,7 @@ REG_CMD_SIZE - + 0x0024 0x00 32 @@ -3034,7 +10550,7 @@ REG_CMD_CFG - + 0x0028 0x00 32 @@ -3064,7 +10580,7 @@ REG_STATUS - + 0x0030 0x00 32 @@ -3087,7 +10603,7 @@ REG_SETUP - + 0x0034 0x00 32 @@ -3103,7 +10619,7 @@ REG_ACK - + 0x0038 0x00 32 @@ -3131,7 +10647,7 @@ REG_RX_SADDR - + 0x0000 0x00 32 @@ -3147,7 +10663,7 @@ REG_RX_SIZE - + 0x0004 0x00 32 @@ -3163,7 +10679,7 @@ REG_RX_CFG - + 0x0008 0x00 32 @@ -3193,7 +10709,7 @@ REG_TX_SADDR - + 0x0010 0x00 32 @@ -3209,7 +10725,7 @@ REG_TX_SIZE - + 0x0014 0x00 32 @@ -3225,7 +10741,7 @@ REG_TX_CFG - + 0x0018 0x00 32 @@ -3255,7 +10771,7 @@ REG_CMD_SADDR - + 0x0020 0x00 32 @@ -3271,7 +10787,7 @@ REG_CMD_SIZE - + 0x0024 0x00 32 @@ -3287,7 +10803,7 @@ REG_CMD_CFG - + 0x0028 0x00 32 @@ -3317,7 +10833,7 @@ REG_STATUS - + 0x0030 0x00 32 @@ -3340,7 +10856,7 @@ REG_SETUP - + 0x0034 0x00 32 @@ -3356,7 +10872,7 @@ REG_ACK - + 0x0038 0x00 32 @@ -3384,7 +10900,7 @@ REG_RX_SADDR - + 0x0000 0x00 32 @@ -3400,7 +10916,7 @@ REG_RX_SIZE - + 0x0004 0x00 32 @@ -3416,7 +10932,7 @@ REG_RX_CFG - + 0x0008 0x00 32 @@ -3446,7 +10962,7 @@ REG_TX_SADDR - + 0x0010 0x00 32 @@ -3462,7 +10978,7 @@ REG_TX_SIZE - + 0x0014 0x00 32 @@ -3478,7 +10994,7 @@ REG_TX_CFG - + 0x0018 0x00 32 @@ -3508,7 +11024,7 @@ REG_CMD_SADDR - + 0x0020 0x00 32 @@ -3524,7 +11040,7 @@ REG_CMD_SIZE - + 0x0024 0x00 32 @@ -3540,7 +11056,7 @@ REG_CMD_CFG - + 0x0028 0x00 32 @@ -3570,7 +11086,7 @@ REG_STATUS - + 0x0030 0x00 32 @@ -3593,7 +11109,7 @@ REG_SETUP - + 0x0034 0x00 32 @@ -3609,7 +11125,7 @@ REG_ACK - + 0x0038 0x00 32 @@ -3631,13 +11147,13 @@ - UDMA_I2S_0 + UDMA_SDIO 0x5010D000 - UDMA_I2S_0 + UDMA_SDIO REG_RX_SADDR - + 0x0000 0x00 32 @@ -3653,7 +11169,7 @@ REG_RX_SIZE - + 0x0004 0x00 32 @@ -3669,7 +11185,7 @@ REG_RX_CFG - + 0x0008 0x00 32 @@ -3681,13 +11197,6 @@ 0 - - r_rx_datasize - 2 - [2:1] - 1 - - r_rx_en 4 @@ -3706,7 +11215,7 @@ REG_TX_SADDR - + 0x0010 0x00 32 @@ -3722,7 +11231,7 @@ REG_TX_SIZE - + 0x0014 0x00 32 @@ -3738,7 +11247,7 @@ REG_TX_CFG - + 0x0018 0x00 32 @@ -3750,13 +11259,6 @@ 0 - - r_tx_datasize - 2 - [2:1] - 1 - - r_tx_en 4 @@ -3774,224 +11276,236 @@ - REG_I2S_CLKCFG_SETUP - + REG_CMD_OP + 0x0020 0x00 32 - r_master_gen_clk_div - 7 - [7:0] - 0 - - - - r_slave_gen_clk_div - 15 - [15:8] - 8 - - - - r_common_gen_clk_div - 23 - [23:16] - 16 - - - - r_slave_clk_en - 24 - [24:24] - 24 - - - - r_master_clk_en - 25 - [25:25] - 25 - - - - r_pdm_clk_en - 26 - [26:26] - 26 - - - - r_slave_sel_ext - 28 - [28:28] - 28 - - - - r_slave_sel_num - 29 - [29:29] - 29 - - - - r_master_sel_ext - 30 - [30:30] - 30 - - - - r_master_sel_num - 31 - [31:31] - 31 - - - - - - REG_I2S_SLV_SETUP - - 0x0024 - 0x00 - 32 - - - r_slave_i2s_words + r_cmd_rsp_type 2 [2:0] 0 - + - r_slave_i2s_bits_word - 12 - [12:8] + r_cmd_op + 13 + [13:8] 8 - + - r_slave_i2s_lsb_first - 16 - [16:16] - 16 - - - - r_slave_i2s_2ch + r_cmd_stopopt 17 - [17:17] - 17 - - - - r_slave_i2s_en - 31 - [31:31] - 31 - + [17:16] + 16 + - REG_I2S_MST_SETUP - + REG_DATA_SETUP + 0x0028 0x00 32 - r_master_i2s_words - 2 - [2:0] + r_data_en + 0 + [0:0] 0 - + - r_master_i2s_bits_word - 12 - [12:8] + r_data_rwn + 1 + [1:1] + 1 + + + + r_data_quad + 2 + [2:2] + 2 + + + + r_data_block_num + 15 + [15:8] 8 - + - r_master_i2s_lsb_first - 16 - [16:16] + r_data_block_size + 25 + [25:16] 16 - - - - r_master_i2s_2ch - 17 - [17:17] - 17 - - - - r_master_i2s_en - 31 - [31:31] - 31 - + - REG_I2S_PDM_SETUP - + REG_START + 0x002c 0x00 32 - r_slave_pdm_shift - 2 - [2:0] + r_sdio_start + 0 + [0:0] 0 - + + + + + REG_RSP0 + + 0x0030 + 0x00 + 32 + - r_slave_pdm_decimation - 12 - [12:3] - 3 - - - - r_slave_pdm_mode - 14 - [14:13] - 13 - - - - r_slave_pdm_en + cfg_rsp_data_i_31_0 31 - [31:31] - 31 - + [31:0] + 0 + + + + + + REG_RSP1 + + 0x0034 + 0x00 + 32 + + + cfg_rsp_data_i_63_32 + 31 + [31:0] + 0 + + + + + + REG_RSP2 + + 0x0038 + 0x00 + 32 + + + cfg_rsp_data_i_95_64 + 31 + [31:0] + 0 + + + + + + REG_RSP3 + + 0x003c + 0x00 + 32 + + + cfg_rsp_data_i_127_96 + 31 + [31:0] + 0 + + + + + + REG_CLK_DIV + + 0x0040 + 0x00 + 32 + + + r_clk_div_data + 7 + [7:0] + 0 + + + + r_clk_div_valid + 8 + [8:8] + 8 + + + + + + REG_STATUS + + 0x0044 + 0x00 + 32 + + + r_eot + 0 + [0:0] + 0 + + + + r_err + 1 + [1:1] + 1 + + + + + + REG_DATA_TIMEOUT + + 0x0048 + 0x00 + 32 + + + r_data_timeout + 19 + [19:0] + 0 + 0 - 0x30 + 0x4c registers - UDMA_I2S_1 + UDMA_I2S 0x5010E000 - UDMA_I2S_1 + UDMA_I2S REG_RX_SADDR - + 0x0000 0x00 32 @@ -4007,7 +11521,7 @@ REG_RX_SIZE - + 0x0004 0x00 32 @@ -4023,7 +11537,7 @@ REG_RX_CFG - + 0x0008 0x00 32 @@ -4060,7 +11574,7 @@ REG_TX_SADDR - + 0x0010 0x00 32 @@ -4076,7 +11590,7 @@ REG_TX_SIZE - + 0x0014 0x00 32 @@ -4092,7 +11606,7 @@ REG_TX_CFG - + 0x0018 0x00 32 @@ -4129,7 +11643,7 @@ REG_I2S_CLKCFG_SETUP - + 0x0020 0x00 32 @@ -4208,7 +11722,7 @@ REG_I2S_SLV_SETUP - + 0x0024 0x00 32 @@ -4252,7 +11766,7 @@ REG_I2S_MST_SETUP - + 0x0028 0x00 32 @@ -4296,7 +11810,7 @@ REG_I2S_PDM_SETUP - + 0x002c 0x00 32 @@ -4345,7 +11859,7 @@ REG_RX_SADDR - + 0x0000 0x00 32 @@ -4361,7 +11875,7 @@ REG_RX_SIZE - + 0x0004 0x00 32 @@ -4377,7 +11891,7 @@ REG_RX_CFG - + 0x0008 0x00 32 @@ -4414,7 +11928,7 @@ REG_CAM_CFG_GLOB - + 0x0020 0x00 32 @@ -4437,7 +11951,7 @@ REG_CAM_CFG_LL - + 0x0024 0x00 32 @@ -4453,7 +11967,7 @@ REG_CAM_CFG_UR - + 0x0028 0x00 32 @@ -4469,7 +11983,7 @@ REG_CAM_CFG_SIZE - + 0x002c 0x00 32 @@ -4485,7 +11999,7 @@ REG_CAM_CFG_FILTER - + 0x0030 0x00 32 @@ -4501,7 +12015,7 @@ REG_CAM_VSYNC_POLARITY - + 0x0034 0x00 32 @@ -4536,8 +12050,7 @@ REG_TX_CH0_ADD - + 0x0000 0x00 32 @@ -4553,8 +12066,7 @@ soc/soc_oss/ips/udma/udma_filter/rtl/udma_filter_reg_if.sv]]> REG_TX_CH0_CFG - + 0x0004 0x00 32 @@ -4577,8 +12089,7 @@ soc/soc_oss/ips/udma/udma_filter/rtl/udma_filter_reg_if.sv]]> REG_TX_CH0_LEN0 - + 0x0008 0x00 32 @@ -4594,8 +12105,7 @@ soc/soc_oss/ips/udma/udma_filter/rtl/udma_filter_reg_if.sv]]> REG_TX_CH0_LEN1 - + 0x000c 0x00 32 @@ -4611,8 +12121,7 @@ soc/soc_oss/ips/udma/udma_filter/rtl/udma_filter_reg_if.sv]]> REG_TX_CH0_LEN2 - + 0x0010 0x00 32 @@ -4628,8 +12137,7 @@ soc/soc_oss/ips/udma/udma_filter/rtl/udma_filter_reg_if.sv]]> REG_TX_CH1_ADD - + 0x0014 0x00 32 @@ -4645,8 +12153,7 @@ soc/soc_oss/ips/udma/udma_filter/rtl/udma_filter_reg_if.sv]]> REG_TX_CH1_CFG - + 0x0018 0x00 32 @@ -4669,8 +12176,7 @@ soc/soc_oss/ips/udma/udma_filter/rtl/udma_filter_reg_if.sv]]> REG_TX_CH1_LEN0 - + 0x001c 0x00 32 @@ -4686,8 +12192,7 @@ soc/soc_oss/ips/udma/udma_filter/rtl/udma_filter_reg_if.sv]]> REG_TX_CH1_LEN1 - + 0x0020 0x00 32 @@ -4703,8 +12208,7 @@ soc/soc_oss/ips/udma/udma_filter/rtl/udma_filter_reg_if.sv]]> REG_TX_CH1_LEN2 - + 0x0024 0x00 32 @@ -4720,8 +12224,7 @@ soc/soc_oss/ips/udma/udma_filter/rtl/udma_filter_reg_if.sv]]> REG_RX_CH_ADD - + 0x0028 0x00 32 @@ -4737,8 +12240,7 @@ soc/soc_oss/ips/udma/udma_filter/rtl/udma_filter_reg_if.sv]]> REG_RX_CH_CFG - + 0x002c 0x00 32 @@ -4761,8 +12263,7 @@ soc/soc_oss/ips/udma/udma_filter/rtl/udma_filter_reg_if.sv]]> REG_RX_CH_LEN0 - + 0x0030 0x00 32 @@ -4778,8 +12279,7 @@ soc/soc_oss/ips/udma/udma_filter/rtl/udma_filter_reg_if.sv]]> REG_RX_CH_LEN1 - + 0x0034 0x00 32 @@ -4795,8 +12295,7 @@ soc/soc_oss/ips/udma/udma_filter/rtl/udma_filter_reg_if.sv]]> REG_RX_CH_LEN2 - + 0x0038 0x00 32 @@ -4812,8 +12311,7 @@ soc/soc_oss/ips/udma/udma_filter/rtl/udma_filter_reg_if.sv]]> REG_AU_CFG - + 0x003c 0x00 32 @@ -4850,8 +12348,7 @@ soc/soc_oss/ips/udma/udma_filter/rtl/udma_filter_reg_if.sv]]> REG_AU_REG0 - + 0x0040 0x00 32 @@ -4867,8 +12364,7 @@ soc/soc_oss/ips/udma/udma_filter/rtl/udma_filter_reg_if.sv]]> REG_AU_REG1 - + 0x0044 0x00 32 @@ -4884,8 +12380,7 @@ soc/soc_oss/ips/udma/udma_filter/rtl/udma_filter_reg_if.sv]]> REG_BINCU_TH - + 0x0048 0x00 32 @@ -4901,8 +12396,7 @@ soc/soc_oss/ips/udma/udma_filter/rtl/udma_filter_reg_if.sv]]> REG_BINCU_CNT - + 0x004c 0x00 32 @@ -4925,8 +12419,7 @@ soc/soc_oss/ips/udma/udma_filter/rtl/udma_filter_reg_if.sv]]> REG_BINCU_SETUP - + 0x0050 0x00 32 @@ -4942,8 +12435,7 @@ soc/soc_oss/ips/udma/udma_filter/rtl/udma_filter_reg_if.sv]]> REG_BINCU_VAL - + 0x0054 0x00 32 @@ -4959,8 +12451,7 @@ soc/soc_oss/ips/udma/udma_filter/rtl/udma_filter_reg_if.sv]]> REG_FILT - + 0x0058 0x00 32 @@ -4976,8 +12467,7 @@ soc/soc_oss/ips/udma/udma_filter/rtl/udma_filter_reg_if.sv]]> REG_STATUS - + 0x0060 0x00 32 @@ -5005,7 +12495,7 @@ soc/soc_oss/ips/udma/udma_filter/rtl/udma_filter_reg_if.sv]]> REG_RX_SADDR - + 0x0000 0x00 32 @@ -5021,7 +12511,7 @@ soc/soc_oss/ips/udma/udma_filter/rtl/udma_filter_reg_if.sv]]> REG_RX_SIZE - + 0x0004 0x00 32 @@ -5037,7 +12527,7 @@ soc/soc_oss/ips/udma/udma_filter/rtl/udma_filter_reg_if.sv]]> REG_RX_CFG - + 0x0008 0x00 32 @@ -5049,11 +12539,25 @@ soc/soc_oss/ips/udma/udma_filter/rtl/udma_filter_reg_if.sv]]> 0 + + r_rx_en + 4 + [4:4] + 4 + + + + r_rx_clr + 6 + [6:6] + 6 + + REG_TX_SADDR - + 0x0010 0x00 32 @@ -5069,7 +12573,7 @@ soc/soc_oss/ips/udma/udma_filter/rtl/udma_filter_reg_if.sv]]> REG_TX_SIZE - + 0x0014 0x00 32 @@ -5085,7 +12589,7 @@ soc/soc_oss/ips/udma/udma_filter/rtl/udma_filter_reg_if.sv]]> REG_TX_CFG - + 0x0018 0x00 32 @@ -5097,11 +12601,25 @@ soc/soc_oss/ips/udma/udma_filter/rtl/udma_filter_reg_if.sv]]> 0 + + r_tx_en + 4 + [4:4] + 4 + + + + r_tx_clr + 6 + [6:6] + 6 + + REG_STATUS - + 0x0020 0x00 32 @@ -5117,7 +12635,7 @@ soc/soc_oss/ips/udma/udma_filter/rtl/udma_filter_reg_if.sv]]> REG_SCIF_SETUP - + 0x0024 0x00 32 @@ -5189,7 +12707,7 @@ soc/soc_oss/ips/udma/udma_filter/rtl/udma_filter_reg_if.sv]]> REG_ERROR - + 0x0028 0x00 32 @@ -5212,7 +12730,7 @@ soc/soc_oss/ips/udma/udma_filter/rtl/udma_filter_reg_if.sv]]> REG_IRQ_EN - + 0x002c 0x00 32 @@ -5235,7 +12753,7 @@ soc/soc_oss/ips/udma/udma_filter/rtl/udma_filter_reg_if.sv]]> REG_VALID - + 0x0030 0x00 32 @@ -5251,7 +12769,7 @@ soc/soc_oss/ips/udma/udma_filter/rtl/udma_filter_reg_if.sv]]> REG_DATA - + 0x0034 0x00 32 @@ -5267,7 +12785,7 @@ soc/soc_oss/ips/udma/udma_filter/rtl/udma_filter_reg_if.sv]]> REG_SCIF_ETU - + 0x0038 0x00 32 @@ -5295,7 +12813,7 @@ soc/soc_oss/ips/udma/udma_filter/rtl/udma_filter_reg_if.sv]]> REG_RX_SADDR - + 0x0000 0x00 32 @@ -5311,7 +12829,7 @@ soc/soc_oss/ips/udma/udma_filter/rtl/udma_filter_reg_if.sv]]> REG_RX_SIZE - + 0x0004 0x00 32 @@ -5327,7 +12845,7 @@ soc/soc_oss/ips/udma/udma_filter/rtl/udma_filter_reg_if.sv]]> REG_RX_CFG - + 0x0008 0x00 32 @@ -5357,7 +12875,7 @@ soc/soc_oss/ips/udma/udma_filter/rtl/udma_filter_reg_if.sv]]> REG_TX_SADDR - + 0x0010 0x00 32 @@ -5373,7 +12891,7 @@ soc/soc_oss/ips/udma/udma_filter/rtl/udma_filter_reg_if.sv]]> REG_TX_SIZE - + 0x0014 0x00 32 @@ -5389,7 +12907,7 @@ soc/soc_oss/ips/udma/udma_filter/rtl/udma_filter_reg_if.sv]]> REG_TX_CFG - + 0x0018 0x00 32 @@ -5419,7 +12937,7 @@ soc/soc_oss/ips/udma/udma_filter/rtl/udma_filter_reg_if.sv]]> REG_SPIS_SETUP - + 0x0020 0x00 32 @@ -5442,7 +12960,7 @@ soc/soc_oss/ips/udma/udma_filter/rtl/udma_filter_reg_if.sv]]> REG_SEOT_CNT - + 0x0024 0x00 32 @@ -5458,7 +12976,7 @@ soc/soc_oss/ips/udma/udma_filter/rtl/udma_filter_reg_if.sv]]> REG_SPIS_IRQ_EN - + 0x0028 0x00 32 @@ -5474,7 +12992,7 @@ soc/soc_oss/ips/udma/udma_filter/rtl/udma_filter_reg_if.sv]]> REG_SPIS_RXCNT - + 0x002c 0x00 32 @@ -5490,7 +13008,7 @@ soc/soc_oss/ips/udma/udma_filter/rtl/udma_filter_reg_if.sv]]> REG_SPIS_TXCNT - + 0x0030 0x00 32 @@ -5506,7 +13024,7 @@ soc/soc_oss/ips/udma/udma_filter/rtl/udma_filter_reg_if.sv]]> REG_SPIS_DMCNT - + 0x0034 0x00 32 @@ -5534,7 +13052,7 @@ soc/soc_oss/ips/udma/udma_filter/rtl/udma_filter_reg_if.sv]]> REG_RX_SADDR - + 0x0000 0x00 32 @@ -5550,7 +13068,7 @@ soc/soc_oss/ips/udma/udma_filter/rtl/udma_filter_reg_if.sv]]> REG_RX_SIZE - + 0x0004 0x00 32 @@ -5566,7 +13084,7 @@ soc/soc_oss/ips/udma/udma_filter/rtl/udma_filter_reg_if.sv]]> REG_RX_CFG - + 0x0008 0x00 32 @@ -5596,7 +13114,7 @@ soc/soc_oss/ips/udma/udma_filter/rtl/udma_filter_reg_if.sv]]> REG_TX_SADDR - + 0x0010 0x00 32 @@ -5612,7 +13130,7 @@ soc/soc_oss/ips/udma/udma_filter/rtl/udma_filter_reg_if.sv]]> REG_TX_SIZE - + 0x0014 0x00 32 @@ -5628,7 +13146,7 @@ soc/soc_oss/ips/udma/udma_filter/rtl/udma_filter_reg_if.sv]]> REG_TX_CFG - + 0x0018 0x00 32 @@ -5658,7 +13176,7 @@ soc/soc_oss/ips/udma/udma_filter/rtl/udma_filter_reg_if.sv]]> REG_SPIS_SETUP - + 0x0020 0x00 32 @@ -5681,7 +13199,7 @@ soc/soc_oss/ips/udma/udma_filter/rtl/udma_filter_reg_if.sv]]> REG_SEOT_CNT - + 0x0024 0x00 32 @@ -5697,7 +13215,7 @@ soc/soc_oss/ips/udma/udma_filter/rtl/udma_filter_reg_if.sv]]> REG_SPIS_IRQ_EN - + 0x0028 0x00 32 @@ -5713,7 +13231,7 @@ soc/soc_oss/ips/udma/udma_filter/rtl/udma_filter_reg_if.sv]]> REG_SPIS_RXCNT - + 0x002c 0x00 32 @@ -5729,7 +13247,7 @@ soc/soc_oss/ips/udma/udma_filter/rtl/udma_filter_reg_if.sv]]> REG_SPIS_TXCNT - + 0x0030 0x00 32 @@ -5745,7 +13263,7 @@ soc/soc_oss/ips/udma/udma_filter/rtl/udma_filter_reg_if.sv]]> REG_SPIS_DMCNT - + 0x0034 0x00 32 @@ -5770,10461 +13288,89 @@ soc/soc_oss/ips/udma/udma_filter/rtl/udma_filter_reg_if.sv]]> UDMA_ADC 0x50114000 UDMA_ADC - - - - 0 - 0x4 - registers - - - - AES - 0x4002D000 - AES - SFR_CRFUNC - + REG_RX_SADDR + 0x0000 0x00 32 - sfr_crfunc - 7 - [7:0] + r_rx_startaddr + 11 + [11:0] 0 - + - SFR_AR - + REG_RX_SIZE + 0x0004 0x00 32 - sfr_ar - 31 - [31:0] - 0 - - - - - - SFR_SRMFSM - - 0x0008 - 0x00 - 32 - - - sfr_srmfsm - 7 - [7:0] - 0 - - - - - - SFR_FR - - 0x000c - 0x00 - 32 - - - mfsm_done - 0 - [0:0] - 0 - - - - acore_done - 1 - [1:1] - 1 - - - - chnlo_done - 2 - [2:2] - 2 - - - - chnli_done - 3 - [3:3] - 3 - - - - - - SFR_OPT - - 0x0010 - 0x00 - 32 - - - opt_klen0 - 3 - [3:0] - 0 - - - - opt_mode0 - 7 - [7:4] - 4 - - - - opt_ifstart0 - 8 - [8:8] - 8 - - - - - - SFR_OPT1 - - 0x0014 - 0x00 - 32 - - - sfr_opt1 + r_rx_size 15 [15:0] 0 - + - SFR_OPTLTX - - 0x0018 - 0x00 - 32 - - - sfr_optltx - 5 - [5:0] - 0 - - - - - - SFR_MASKSEED - - 0x0020 - 0x00 - 32 - - - sfr_maskseed - 31 - [31:0] - 0 - - - - - - SFR_MASKSEEDAR - - 0x0024 - 0x00 - 32 - - - sfr_maskseedar - 31 - [31:0] - 0 - - - - - - SFR_SEGPTR_PTRID_IV - - 0x0030 - 0x00 - 32 - - - PTRID_IV - 11 - [11:0] - 0 - - - - - - SFR_SEGPTR_PTRID_AKEY - - 0x0034 - 0x00 - 32 - - - PTRID_AKEY - 11 - [11:0] - 0 - - - - - - SFR_SEGPTR_PTRID_AIB - - 0x0038 - 0x00 - 32 - - - PTRID_AIB - 11 - [11:0] - 0 - - - - - - SFR_SEGPTR_PTRID_AOB - - 0x003c - 0x00 - 32 - - - PTRID_AOB - 11 - [11:0] - 0 - - - - - - - 0 - 0x40 - registers - - - - COMBOHASH - 0x4002B000 - COMBOHASH - - - SFR_CRFUNC - - 0x0000 - 0x00 - 32 - - - cr_func - 7 - [7:0] - 0 - - - - - - SFR_AR - - 0x0004 - 0x00 - 32 - - - sfr_ar - 31 - [31:0] - 0 - - - - - - SFR_SRMFSM - + REG_RX_CFG + 0x0008 0x00 32 - mfsm - 7 - [7:0] - 0 - - - - - - SFR_FR - - 0x000c - 0x00 - 32 - - - mfsm_done + r_rx_continuous 0 [0:0] 0 - + - hash_done - 1 - [1:1] - 1 - - - - chnlo_done - 2 - [2:2] - 2 - - - - chnli_done - 3 - [3:3] - 3 - - - - chkdone + r_rx_en 4 [4:4] 4 - + - chkpass + r_rx_clr 5 [5:5] 5 - + - SFR_OPT1 - + REG_CR_ADC + 0x0010 0x00 32 - cr_opt_hashcnt - 15 - [15:0] - 0 - - - - - - SFR_OPT2 - - 0x0014 - 0x00 - 32 - - - cr_opt_scrtchk - 0 - [0:0] - 0 - - - - cr_opt_ifsob - 1 - [1:1] - 1 - - - - cr_opt_ifstart - 2 - [2:2] - 2 - - - - - - SFR_OPT3 - - 0x0018 - 0x00 - 32 - - - sfr_opt3 - 7 - [7:0] - 0 - - - - - - SFR_BLKT0 - - 0x001c - 0x00 - 32 - - - sfr_blkt0 - 7 - [7:0] - 0 - - - - - - SFR_SEGPTR_SEGID_LKEY - - 0x0020 - 0x00 - 32 - - - SEGID_LKEY - 11 - [11:0] - 0 - - - - - - SFR_SEGPTR_SEGID_KEY - - 0x0024 - 0x00 - 32 - - - SEGID_KEY - 11 - [11:0] - 0 - - - - - - SFR_SEGPTR_SEGID_SCRT - - 0x002c - 0x00 - 32 - - - SEGID_SCRT - 11 - [11:0] - 0 - - - - - - SFR_SEGPTR_SEGID_MSG - - 0x0030 - 0x00 - 32 - - - SEGID_MSG - 11 - [11:0] - 0 - - - - - - SFR_SEGPTR_SEGID_HOUT - - 0x0034 - 0x00 - 32 - - - SEGID_HOUT - 11 - [11:0] - 0 - - - - - - SFR_SEGPTR_SEGID_HOUT2 - - 0x003c - 0x00 - 32 - - - SEGID_HOUT2 - 11 - [11:0] - 0 - - - - - - - 0 - 0x40 - registers - - - - PKE - 0x4002C000 - PKE - - - SFR_CRFUNC - - 0x0000 - 0x00 - 32 - - - cr_func - 7 - [7:0] - 0 - - - - cr_pcoreir - 15 - [15:8] - 8 - - - - - - SFR_AR - - 0x0004 - 0x00 - 32 - - - sfr_ar - 31 - [31:0] - 0 - - - - - - SFR_SRMFSM - - 0x0008 - 0x00 - 32 - - - mfsm - 7 - [7:0] - 0 - - - - modinvready - 8 - [8:8] - 8 - - - - - - SFR_FR - - 0x000c - 0x00 - 32 - - - mfsm_done - 0 - [0:0] - 0 - - - - pcore_done - 1 - [1:1] - 1 - - - - chnlo_done - 2 - [2:2] - 2 - - - - chnli_done - 3 - [3:3] - 3 - - - - chnlx_done - 4 - [4:4] - 4 - - - - - - SFR_OPTNW - - 0x0010 - 0x00 - 32 - - - sfr_optnw - 12 - [12:0] - 0 - - - - - - SFR_OPTEW - - 0x0014 - 0x00 - 32 - - - sfr_optew - 12 - [12:0] - 0 - - - - - - SFR_OPTRW - - 0x0018 - 0x00 - 32 - - - sfr_optrw - 9 - [9:0] - 0 - - - - - - SFR_OPTLTX - - 0x001c - 0x00 - 32 - - - sfr_optltx - 4 - [4:0] - 0 - - - - - - SFR_OPTMASK - - 0x0020 - 0x00 - 32 - - - sfr_optmask - 15 - [15:0] - 0 - - - - - - SFR_SEGPTR_PTRID_PCON - - 0x0030 - 0x00 - 32 - - - PTRID_PCON - 11 - [11:0] - 0 - - - - - - SFR_SEGPTR_PTRID_PIB0 - - 0x0034 - 0x00 - 32 - - - PTRID_PIB0 - 11 - [11:0] - 0 - - - - - - SFR_SEGPTR_PTRID_PIB1 - - 0x0038 - 0x00 - 32 - - - PTRID_PIB1 - 11 - [11:0] - 0 - - - - - - SFR_SEGPTR_PTRID_PKB - - 0x003c - 0x00 - 32 - - - PTRID_PKB - 11 - [11:0] - 0 - - - - - - SFR_SEGPTR_PTRID_POB - - 0x0040 - 0x00 - 32 - - - PTRID_POB - 11 - [11:0] - 0 - - - - - - - 0 - 0x44 - registers - - - - SCEDMA - 0x40029000 - SCEDMA - - - SFR_SCHSTART_AR - - 0x0000 - 0x00 - 32 - - - sfr_schstart_ar - 31 - [31:0] - 0 - - - - - - SFR_XCH_FUNC - - 0x0010 - 0x00 - 32 - - - sfr_xch_func - 0 - [0:0] - 0 - - - - - - SFR_XCH_OPT - - 0x0014 - 0x00 - 32 - - - sfr_xch_opt - 7 - [7:0] - 0 - - - - - - SFR_XCH_AXSTART - - 0x0018 - 0x00 - 32 - - - sfr_xch_axstart - 31 - [31:0] - 0 - - - - - - SFR_XCH_SEGID - - 0x001c - 0x00 - 32 - - - sfr_xch_segid - 7 - [7:0] - 0 - - - - - - SFR_XCH_SEGSTART - - 0x0020 - 0x00 - 32 - - - xchcr_segstart - 11 - [11:0] - 0 - - - - - - SFR_XCH_TRANSIZE - - 0x0024 - 0x00 - 32 - - - xchcr_transize - 29 - [29:0] - 0 - - - - - - SFR_SCH_FUNC - - 0x0030 - 0x00 - 32 - - - sfr_sch_func - 0 - [0:0] - 0 - - - - - - SFR_SCH_OPT - - 0x0034 - 0x00 - 32 - - - sfr_sch_opt - 7 - [7:0] - 0 - - - - - - SFR_SCH_AXSTART - - 0x0038 - 0x00 - 32 - - - sfr_sch_axstart - 31 - [31:0] - 0 - - - - - - SFR_SCH_SEGID - - 0x003c - 0x00 - 32 - - - sfr_sch_segid - 7 - [7:0] - 0 - - - - - - SFR_SCH_SEGSTART - - 0x0040 - 0x00 - 32 - - - schcr_segstart - 11 - [11:0] - 0 - - - - - - SFR_SCH_TRANSIZE - - 0x0044 - 0x00 - 32 - - - schcr_transize - 29 - [29:0] - 0 - - - - - - SFR_ICH_OPT - - 0x0050 - 0x00 - 32 - - - sfr_ich_opt - 3 - [3:0] - 0 - - - - - - SFR_ICH_SEGID - - 0x0054 - 0x00 - 32 - - - sfr_ich_segid - 15 - [15:0] - 0 - - - - - - SFR_ICH_RPSTART - - 0x0058 - 0x00 - 32 - - - ichcr_rpstart - 11 - [11:0] - 0 - - - - - - SFR_ICH_WPSTART - - 0x005c - 0x00 - 32 - - - ichcr_wpstart - 11 - [11:0] - 0 - - - - - - SFR_ICH_TRANSIZE - - 0x0060 - 0x00 - 32 - - - ichcr_transize - 11 - [11:0] - 0 - - - - - - - 0 - 0x64 - registers - - - - SCE_GLBSFR - 0x40028000 - SCE_GLBSFR - - - SFR_SCEMODE - - 0x0000 - 0x00 - 32 - - - cr_scemode - 1 - [1:0] - 0 - - - - - - SFR_SUBEN - - 0x0004 - 0x00 - 32 - - - cr_suben - 15 - [15:0] - 0 - - - - - - SFR_AHBS - - 0x0008 - 0x00 - 32 - - - cr_ahbsopt - 4 - [4:0] - 0 - - - - - - SFR_SRBUSY - - 0x0010 - 0x00 - 32 - - - sr_busy - 15 - [15:0] - 0 - - - - - - SFR_FRDONE - - 0x0014 - 0x00 - 32 - - - fr_done - 15 - [15:0] - 0 - - - - - - SFR_FRERR - - 0x0018 - 0x00 - 32 - - - fr_err - 15 - [15:0] - 0 - - - - - - SFR_ARCLR - - 0x001c - 0x00 - 32 - - - ar_clrram - 31 - [31:0] - 0 - - - - - - SFR_FRACERR - - 0x0020 - 0x00 - 32 - - - fr_acerr - 7 - [7:0] - 0 - - - - - - SFR_TICKCNT - - 0x0024 - 0x00 - 32 - - - sfr_tickcnt - 31 - [31:0] - 0 - - - - - - SFR_FFEN - - 0x0030 - 0x00 - 32 - - - cr_ffen - 5 - [5:0] - 0 - - - - - - SFR_FFCLR - - 0x0034 - 0x00 - 32 - - - ar_ffclr - 31 - [31:0] - 0 - - - - - - SFR_FFCNT_SR_FF0 - - 0x0040 - 0x00 - 32 - - - sr_ff0 - 15 - [15:0] - 0 - - - - - - SFR_FFCNT_SR_FF1 - - 0x0044 - 0x00 - 32 - - - sr_ff1 - 15 - [15:0] - 0 - - - - - - SFR_FFCNT_SR_FF2 - - 0x0048 - 0x00 - 32 - - - sr_ff2 - 15 - [15:0] - 0 - - - - - - SFR_FFCNT_SR_FF3 - - 0x004c - 0x00 - 32 - - - sr_ff3 - 15 - [15:0] - 0 - - - - - - SFR_FFCNT_SR_FF4 - - 0x0050 - 0x00 - 32 - - - sr_ff4 - 15 - [15:0] - 0 - - - - - - SFR_FFCNT_SR_FF5 - - 0x0054 - 0x00 - 32 - - - sr_ff5 - 15 - [15:0] - 0 - - - - - - SFR_TS - - 0x00fc - 0x00 - 32 - - - cr_ts - 15 - [15:0] - 0 - - - - - - - 0 - 0x100 - registers - - - - TRNG - 0x4002E000 - TRNG - - - SFR_CRSRC - - 0x0000 - 0x00 - 32 - - - sfr_crsrc - 11 - [11:0] - 0 - - - - - - SFR_CRANA - - 0x0004 - 0x00 - 32 - - - sfr_crana - 15 - [15:0] - 0 - - - - - - SFR_PP - - 0x0008 - 0x00 - 32 - - - sfr_pp - 16 - [16:0] - 0 - - - - - - SFR_OPT - - 0x000c - 0x00 - 32 - - - sfr_opt - 16 - [16:0] - 0 - - - - - - SFR_SR - - 0x0010 - 0x00 - 32 - - - sr_rng - 31 - [31:0] - 0 - - - - - - SFR_AR_GEN - - 0x0014 - 0x00 - 32 - - - sfr_ar_gen - 31 - [31:0] - 0 - - - - - - SFR_FR - - 0x0018 - 0x00 - 32 - - - sfr_fr - 1 - [1:0] - 0 - - - - - - SFR_DRPSZ - - 0x0020 - 0x00 - 32 - - - sfr_drpsz - 31 - [31:0] - 0 - - - - - - SFR_DRGEN - - 0x0024 - 0x00 - 32 - - - sfr_drgen - 31 - [31:0] - 0 - - - - - - SFR_DRRESEED - - 0x0028 - 0x00 - 32 - - - sfr_drreseed - 31 - [31:0] - 0 - - - - - - SFR_BUF - - 0x0030 - 0x00 - 32 - - - sfr_buf - 31 - [31:0] - 0 - - - - - - SFR_CHAIN_RNGCHAINEN0 - - 0x0040 - 0x00 - 32 - - - rngchainen0 - 31 - [31:0] - 0 - - - - - - SFR_CHAIN_RNGCHAINEN1 - - 0x0044 - 0x00 - 32 - - - rngchainen1 - 31 - [31:0] - 0 - - - - - - - 0 - 0x48 - registers - - - - ALU - 0x4002F000 - ALU - - - - 0 - 0x4 - registers - - - - DUART - 0x40042000 - DUART - - - SFR_TXD - - 0x0000 - 0x00 - 32 - - - sfr_txd - 7 - [7:0] - 0 - - - - - - SFR_CR - - 0x0004 - 0x00 - 32 - - - sfr_cr - 0 - [0:0] - 0 - - - - - - SFR_SR - - 0x0008 - 0x00 - 32 - - - sfr_sr - 0 - [0:0] - 0 - - - - - - SFR_ETUC - - 0x000c - 0x00 - 32 - - - sfr_etuc - 15 - [15:0] - 0 - - - - - - - 0 - 0x10 - registers - - - - WDG_INTF - 0x40041000 - WDG_INTF - - - - 0 - 0x4 - registers - - - - TIMER_INTF - 0x40043000 - TIMER_INTF - - - - 0 - 0x4 - registers - - - - EVC - 0x40044000 - EVC - - - SFR_CM7EVSEL_CM7EVSEL0 - - 0x0000 - 0x00 - 32 - - - cm7evsel0 - 7 - [7:0] - 0 - - - - - - SFR_CM7EVSEL_CM7EVSEL1 - - 0x0004 - 0x00 - 32 - - - cm7evsel1 - 7 - [7:0] - 0 - - - - - - SFR_CM7EVSEL_CM7EVSEL2 - - 0x0008 - 0x00 - 32 - - - cm7evsel2 - 7 - [7:0] - 0 - - - - - - SFR_CM7EVSEL_CM7EVSEL3 - - 0x000c - 0x00 - 32 - - - cm7evsel3 - 7 - [7:0] - 0 - - - - - - SFR_CM7EVSEL_CM7EVSEL4 - - 0x0010 - 0x00 - 32 - - - cm7evsel4 - 7 - [7:0] - 0 - - - - - - SFR_CM7EVSEL_CM7EVSEL5 - - 0x0014 - 0x00 - 32 - - - cm7evsel5 - 7 - [7:0] - 0 - - - - - - SFR_CM7EVSEL_CM7EVSEL6 - - 0x0018 - 0x00 - 32 - - - cm7evsel6 - 7 - [7:0] - 0 - - - - - - SFR_CM7EVSEL_CM7EVSEL7 - - 0x001c - 0x00 - 32 - - - cm7evsel7 - 7 - [7:0] - 0 - - - - - - SFR_CM7EVEN - - 0x0020 - 0x00 - 32 - - - cm7even - 7 - [7:0] - 0 - - - - - - SFR_CM7EVFR - - 0x0024 - 0x00 - 32 - - - cm7evs - 7 - [7:0] - 0 - - - - - - SFR_TMREVSEL - - 0x0030 - 0x00 - 32 - - - tmr_evsel - 15 - [15:0] - 0 - - - - - - SFR_PWMEVSEL - - 0x0034 - 0x00 - 32 - - - pwm_evsel - 31 - [31:0] - 0 - - - - - - SFR_IFEVEN_IFEVEN0 - - 0x0040 - 0x00 - 32 - - - ifeven0 - 31 - [31:0] - 0 - - - - - - SFR_IFEVEN_IFEVEN1 - - 0x0044 - 0x00 - 32 - - - ifeven1 - 31 - [31:0] - 0 - - - - - - SFR_IFEVEN_IFEVEN2 - - 0x0048 - 0x00 - 32 - - - ifeven2 - 31 - [31:0] - 0 - - - - - - SFR_IFEVEN_IFEVEN3 - - 0x004c - 0x00 - 32 - - - ifeven3 - 31 - [31:0] - 0 - - - - - - SFR_IFEVEN_IFEVEN4 - - 0x0050 - 0x00 - 32 - - - ifeven4 - 31 - [31:0] - 0 - - - - - - SFR_IFEVEN_IFEVEN5 - - 0x0054 - 0x00 - 32 - - - ifeven5 - 31 - [31:0] - 0 - - - - - - SFR_IFEVEN_IFEVEN6 - - 0x0058 - 0x00 - 32 - - - ifeven6 - 31 - [31:0] - 0 - - - - - - SFR_IFEVEN_IFEVEN7 - - 0x005c - 0x00 - 32 - - - ifeven7 - 31 - [31:0] - 0 - - - - - - SFR_IFEVERRFR - - 0x0060 - 0x00 - 32 - - - ifev_errs - 31 - [31:0] - 0 - - - - - - SFR_CM7ERRFR - - 0x0080 - 0x00 - 32 - - - errin - 31 - [31:0] - 0 - - - - - - - 0 - 0x84 - registers - - - - SYSCTRL - 0x40040000 - SYSCTRL - - - SFR_CGUSEC - - 0x0000 - 0x00 - 32 - - - sfr_cgusec - 15 - [15:0] - 0 - - - - - - SFR_CGULP - - 0x0004 - 0x00 - 32 - - - sfr_cgulp - 15 - [15:0] - 0 - - - - - - SFR_SEED - - 0x0008 - 0x00 - 32 - - - sfr_seed - 31 - [31:0] - 0 - - - - - - SFR_SEEDAR - - 0x000c - 0x00 - 32 - - - sfr_seedar - 31 - [31:0] - 0 - - - - - - SFR_CGUSEL0 - - 0x0010 - 0x00 - 32 - - - sfr_cgusel0 - 1 - [1:0] - 0 - - - - - - SFR_CGUFD_CFGFDCR_0_4_0 - - 0x0014 - 0x00 - 32 - - - cfgfdcr_0_4_0 - 15 - [15:0] - 0 - - - - - - SFR_CGUFD_CFGFDCR_0_4_1 - - 0x0018 - 0x00 - 32 - - - cfgfdcr_0_4_1 - 15 - [15:0] - 0 - - - - - - SFR_CGUFD_CFGFDCR_0_4_2 - - 0x001c - 0x00 - 32 - - - cfgfdcr_0_4_2 - 15 - [15:0] - 0 - - - - - - SFR_CGUFD_CFGFDCR_0_4_3 - - 0x0020 - 0x00 - 32 - - - cfgfdcr_0_4_3 - 15 - [15:0] - 0 - - - - - - SFR_CGUFD_CFGFDCR_0_4_4 - - 0x0024 - 0x00 - 32 - - - cfgfdcr_0_4_4 - 15 - [15:0] - 0 - - - - - - SFR_CGUFDAO - - 0x0028 - 0x00 - 32 - - - cfgfdcr - 15 - [15:0] - 0 - - - - - - SFR_CGUSET - - 0x002c - 0x00 - 32 - - - sfr_cguset - 31 - [31:0] - 0 - - - - - - SFR_CGUSEL1 - - 0x0030 - 0x00 - 32 - - - sfr_cgusel1 - 0 - [0:0] - 0 - - - - - - SFR_CGUFDPKE - - 0x0034 - 0x00 - 32 - - - sfr_cgufdpke - 8 - [8:0] - 0 - - - - - - SFR_CGUFSSR_FSFREQ0 - - 0x0040 - 0x00 - 32 - - - fsfreq0 - 15 - [15:0] - 0 - - - - - - SFR_CGUFSSR_FSFREQ1 - - 0x0044 - 0x00 - 32 - - - fsfreq1 - 15 - [15:0] - 0 - - - - - - SFR_CGUFSSR_FSFREQ2 - - 0x0048 - 0x00 - 32 - - - fsfreq2 - 15 - [15:0] - 0 - - - - - - SFR_CGUFSSR_FSFREQ3 - - 0x004c - 0x00 - 32 - - - fsfreq3 - 15 - [15:0] - 0 - - - - - - SFR_CGUFSVLD - - 0x0050 - 0x00 - 32 - - - sfr_cgufsvld - 3 - [3:0] - 0 - - - - - - SFR_CGUFSCR - - 0x0054 - 0x00 - 32 - - - sfr_cgufscr - 15 - [15:0] - 0 - - - - - - SFR_ACLKGR - - 0x0060 - 0x00 - 32 - - - sfr_aclkgr - 7 - [7:0] - 0 - - - - - - SFR_HCLKGR - - 0x0064 - 0x00 - 32 - - - sfr_hclkgr - 7 - [7:0] - 0 - - - - - - SFR_ICLKGR - - 0x0068 - 0x00 - 32 - - - sfr_iclkgr - 7 - [7:0] - 0 - - - - - - SFR_PCLKGR - - 0x006c - 0x00 - 32 - - - sfr_pclkgr - 7 - [7:0] - 0 - - - - - - SFR_RCURST0 - - 0x0080 - 0x00 - 32 - - - sfr_rcurst0 - 31 - [31:0] - 0 - - - - - - SFR_RCURST1 - - 0x0084 - 0x00 - 32 - - - sfr_rcurst1 - 31 - [31:0] - 0 - - - - - - SFR_RCUSRCFR - - 0x0088 - 0x00 - 32 - - - sfr_rcusrcfr - 15 - [15:0] - 0 - - - - - - SFR_IPCARIPFLOW - - 0x0090 - 0x00 - 32 - - - sfr_ipcaripflow - 31 - [31:0] - 0 - - - - - - SFR_IPCEN - - 0x0094 - 0x00 - 32 - - - sfr_ipcen - 15 - [15:0] - 0 - - - - - - SFR_IPCLPEN - - 0x0098 - 0x00 - 32 - - - sfr_ipclpen - 15 - [15:0] - 0 - - - - - - SFR_IPCOSC - - 0x009c - 0x00 - 32 - - - sfr_ipcosc - 6 - [6:0] - 0 - - - - - - SFR_IPCPLLMN - - 0x00a0 - 0x00 - 32 - - - sfr_ipcpllmn - 16 - [16:0] - 0 - - - - - - SFR_IPCPLLF - - 0x00a4 - 0x00 - 32 - - - sfr_ipcpllf - 24 - [24:0] - 0 - - - - - - SFR_IPCPLLQ - - 0x00a8 - 0x00 - 32 - - - sfr_ipcpllq - 14 - [14:0] - 0 - - - - - - SFR_IPCCR - - 0x00ac - 0x00 - 32 - - - sfr_ipccr - 15 - [15:0] - 0 - - - - - - - 0 - 0xb0 - registers - - - - APB_THRU - 0x50122000 - APB_THRU - - - - 0 - 0x4 - registers - - - - IOX - 0x5012F000 - IOX - - - SFR_AFSEL_CRAFSEL0 - - 0x0000 - 0x00 - 32 - - - crafsel0 - 15 - [15:0] - 0 - - - - - - SFR_AFSEL_CRAFSEL1 - - 0x0004 - 0x00 - 32 - - - crafsel1 - 15 - [15:0] - 0 - - - - - - SFR_AFSEL_CRAFSEL2 - - 0x0008 - 0x00 - 32 - - - crafsel2 - 15 - [15:0] - 0 - - - - - - SFR_AFSEL_CRAFSEL3 - - 0x000c - 0x00 - 32 - - - crafsel3 - 15 - [15:0] - 0 - - - - - - SFR_AFSEL_CRAFSEL4 - - 0x0010 - 0x00 - 32 - - - crafsel4 - 15 - [15:0] - 0 - - - - - - SFR_AFSEL_CRAFSEL5 - - 0x0014 - 0x00 - 32 - - - crafsel5 - 15 - [15:0] - 0 - - - - - - SFR_AFSEL_CRAFSEL6 - - 0x0018 - 0x00 - 32 - - - crafsel6 - 15 - [15:0] - 0 - - - - - - SFR_AFSEL_CRAFSEL7 - - 0x001c - 0x00 - 32 - - - crafsel7 - 15 - [15:0] - 0 - - - - - - SFR_AFSEL_CRAFSEL8 - - 0x0020 - 0x00 - 32 - - - crafsel8 - 15 - [15:0] - 0 - - - - - - SFR_AFSEL_CRAFSEL9 - - 0x0024 - 0x00 - 32 - - - crafsel9 - 15 - [15:0] - 0 - - - - - - SFR_AFSEL_CRAFSEL10 - - 0x0028 - 0x00 - 32 - - - crafsel10 - 15 - [15:0] - 0 - - - - - - SFR_AFSEL_CRAFSEL11 - - 0x002c - 0x00 - 32 - - - crafsel11 - 15 - [15:0] - 0 - - - - - - SFR_INTCR_CRINT0 - - 0x0100 - 0x00 - 32 - - - crint0 - 9 - [9:0] - 0 - - - - - - SFR_INTCR_CRINT1 - - 0x0104 - 0x00 - 32 - - - crint1 - 9 - [9:0] - 0 - - - - - - SFR_INTCR_CRINT2 - - 0x0108 - 0x00 - 32 - - - crint2 - 9 - [9:0] - 0 - - - - - - SFR_INTCR_CRINT3 - - 0x010c - 0x00 - 32 - - - crint3 - 9 - [9:0] - 0 - - - - - - SFR_INTCR_CRINT4 - - 0x0110 - 0x00 - 32 - - - crint4 - 9 - [9:0] - 0 - - - - - - SFR_INTCR_CRINT5 - - 0x0114 - 0x00 - 32 - - - crint5 - 9 - [9:0] - 0 - - - - - - SFR_INTCR_CRINT6 - - 0x0118 - 0x00 - 32 - - - crint6 - 9 - [9:0] - 0 - - - - - - SFR_INTCR_CRINT7 - - 0x011c - 0x00 - 32 - - - crint7 - 9 - [9:0] - 0 - - - - - - SFR_INTFR - - 0x0120 - 0x00 - 32 - - - frint - 7 - [7:0] - 0 - - - - - - SFR_GPIOOUT_CRGO0 - - 0x0130 - 0x00 - 32 - - - crgo0 - 15 - [15:0] - 0 - - - - - - SFR_GPIOOUT_CRGO1 - - 0x0134 - 0x00 - 32 - - - crgo1 - 15 - [15:0] - 0 - - - - - - SFR_GPIOOUT_CRGO2 - - 0x0138 - 0x00 - 32 - - - crgo2 - 15 - [15:0] - 0 - - - - - - SFR_GPIOOUT_CRGO3 - - 0x013c - 0x00 - 32 - - - crgo3 - 15 - [15:0] - 0 - - - - - - SFR_GPIOOUT_CRGO4 - - 0x0140 - 0x00 - 32 - - - crgo4 - 15 - [15:0] - 0 - - - - - - SFR_GPIOOUT_CRGO5 - - 0x0144 - 0x00 - 32 - - - crgo5 - 15 - [15:0] - 0 - - - - - - SFR_GPIOOE_CRGOE0 - - 0x0148 - 0x00 - 32 - - - crgoe0 - 15 - [15:0] - 0 - - - - - - SFR_GPIOOE_CRGOE1 - - 0x014c - 0x00 - 32 - - - crgoe1 - 15 - [15:0] - 0 - - - - - - SFR_GPIOOE_CRGOE2 - - 0x0150 - 0x00 - 32 - - - crgoe2 - 15 - [15:0] - 0 - - - - - - SFR_GPIOOE_CRGOE3 - - 0x0154 - 0x00 - 32 - - - crgoe3 - 15 - [15:0] - 0 - - - - - - SFR_GPIOOE_CRGOE4 - - 0x0158 - 0x00 - 32 - - - crgoe4 - 15 - [15:0] - 0 - - - - - - SFR_GPIOOE_CRGOE5 - - 0x015c - 0x00 - 32 - - - crgoe5 - 15 - [15:0] - 0 - - - - - - SFR_GPIOPU_CRGPU0 - - 0x0160 - 0x00 - 32 - - - crgpu0 - 15 - [15:0] - 0 - - - - - - SFR_GPIOPU_CRGPU1 - - 0x0164 - 0x00 - 32 - - - crgpu1 - 15 - [15:0] - 0 - - - - - - SFR_GPIOPU_CRGPU2 - - 0x0168 - 0x00 - 32 - - - crgpu2 - 15 - [15:0] - 0 - - - - - - SFR_GPIOPU_CRGPU3 - - 0x016c - 0x00 - 32 - - - crgpu3 - 15 - [15:0] - 0 - - - - - - SFR_GPIOPU_CRGPU4 - - 0x0170 - 0x00 - 32 - - - crgpu4 - 15 - [15:0] - 0 - - - - - - SFR_GPIOPU_CRGPU5 - - 0x0174 - 0x00 - 32 - - - crgpu5 - 15 - [15:0] - 0 - - - - - - SFR_GPIOIN_SRGI0 - - 0x0178 - 0x00 - 32 - - - srgi0 - 15 - [15:0] - 0 - - - - - - SFR_GPIOIN_SRGI1 - - 0x017c - 0x00 - 32 - - - srgi1 - 15 - [15:0] - 0 - - - - - - SFR_GPIOIN_SRGI2 - - 0x0180 - 0x00 - 32 - - - srgi2 - 15 - [15:0] - 0 - - - - - - SFR_GPIOIN_SRGI3 - - 0x0184 - 0x00 - 32 - - - srgi3 - 15 - [15:0] - 0 - - - - - - SFR_GPIOIN_SRGI4 - - 0x0188 - 0x00 - 32 - - - srgi4 - 15 - [15:0] - 0 - - - - - - SFR_GPIOIN_SRGI5 - - 0x018c - 0x00 - 32 - - - srgi5 - 15 - [15:0] - 0 - - - - - - SFR_PIOSEL - - 0x0200 - 0x00 - 32 - - - piosel - 31 - [31:0] - 0 - - - - - - SFR_CFG_SCHM_CR_CFG_SCHMSEL0 - - 0x0230 - 0x00 - 32 - - - cr_cfg_schmsel0 - 15 - [15:0] - 0 - - - - - - SFR_CFG_SCHM_CR_CFG_SCHMSEL1 - - 0x0234 - 0x00 - 32 - - - cr_cfg_schmsel1 - 15 - [15:0] - 0 - - - - - - SFR_CFG_SCHM_CR_CFG_SCHMSEL2 - - 0x0238 - 0x00 - 32 - - - cr_cfg_schmsel2 - 15 - [15:0] - 0 - - - - - - SFR_CFG_SCHM_CR_CFG_SCHMSEL3 - - 0x023c - 0x00 - 32 - - - cr_cfg_schmsel3 - 15 - [15:0] - 0 - - - - - - SFR_CFG_SCHM_CR_CFG_SCHMSEL4 - - 0x0240 - 0x00 - 32 - - - cr_cfg_schmsel4 - 15 - [15:0] - 0 - - - - - - SFR_CFG_SCHM_CR_CFG_SCHMSEL5 - - 0x0244 - 0x00 - 32 - - - cr_cfg_schmsel5 - 15 - [15:0] - 0 - - - - - - SFR_CFG_SLEW_CR_CFG_SLEWSLOW0 - - 0x0248 - 0x00 - 32 - - - cr_cfg_slewslow0 - 15 - [15:0] - 0 - - - - - - SFR_CFG_SLEW_CR_CFG_SLEWSLOW1 - - 0x024c - 0x00 - 32 - - - cr_cfg_slewslow1 - 15 - [15:0] - 0 - - - - - - SFR_CFG_SLEW_CR_CFG_SLEWSLOW2 - - 0x0250 - 0x00 - 32 - - - cr_cfg_slewslow2 - 15 - [15:0] - 0 - - - - - - SFR_CFG_SLEW_CR_CFG_SLEWSLOW3 - - 0x0254 - 0x00 - 32 - - - cr_cfg_slewslow3 - 15 - [15:0] - 0 - - - - - - SFR_CFG_SLEW_CR_CFG_SLEWSLOW4 - - 0x0258 - 0x00 - 32 - - - cr_cfg_slewslow4 - 15 - [15:0] - 0 - - - - - - SFR_CFG_SLEW_CR_CFG_SLEWSLOW5 - - 0x025c - 0x00 - 32 - - - cr_cfg_slewslow5 - 15 - [15:0] - 0 - - - - - - SFR_CFG_DRVSEL_CR_CFG_DRVSEL0 - - 0x0260 - 0x00 - 32 - - - cr_cfg_drvsel0 - 31 - [31:0] - 0 - - - - - - SFR_CFG_DRVSEL_CR_CFG_DRVSEL1 - - 0x0264 - 0x00 - 32 - - - cr_cfg_drvsel1 - 31 - [31:0] - 0 - - - - - - SFR_CFG_DRVSEL_CR_CFG_DRVSEL2 - - 0x0268 - 0x00 - 32 - - - cr_cfg_drvsel2 - 31 - [31:0] - 0 - - - - - - SFR_CFG_DRVSEL_CR_CFG_DRVSEL3 - - 0x026c - 0x00 - 32 - - - cr_cfg_drvsel3 - 31 - [31:0] - 0 - - - - - - SFR_CFG_DRVSEL_CR_CFG_DRVSEL4 - - 0x0270 - 0x00 - 32 - - - cr_cfg_drvsel4 - 31 - [31:0] - 0 - - - - - - SFR_CFG_DRVSEL_CR_CFG_DRVSEL5 - - 0x0274 - 0x00 - 32 - - - cr_cfg_drvsel5 - 31 - [31:0] - 0 - - - - - - - 0 - 0x278 - registers - - - - PWM - 0x50120000 - PWM - - - - 0 - 0x4 - registers - - - - SDDC - 0x50121000 - SDDC - - - SFR_IO - - 0x0000 - 0x00 - 32 - - - sfr_io - 1 - [1:0] - 0 - - - - - - SFR_AR - - 0x0004 - 0x00 - 32 - - - sfr_ar - 31 - [31:0] - 0 - - - - - - CR_OCR - - 0x0010 - 0x00 - 32 - - - cr_ocr - 23 - [23:0] - 0 - - - - - - CR_RDFFTHRES - - 0x0014 - 0x00 - 32 - - - cr_rdffthres - 7 - [7:0] - 0 - - - - - - CR_REV - - 0x0018 - 0x00 - 32 - - - cfg_reg_sd_spec_revision - 7 - [7:0] - 0 - - - - cfg_reg_cccr_sdio_revision - 15 - [15:8] - 8 - - - - - - CR_BACSA - - 0x001c - 0x00 - 32 - - - cfg_base_addr_csa - 17 - [17:0] - 0 - - - - - - CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC0 - - 0x0020 - 0x00 - 32 - - - cfg_base_addr_io_func0 - 17 - [17:0] - 0 - - - - - - CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC1 - - 0x0024 - 0x00 - 32 - - - cfg_base_addr_io_func1 - 17 - [17:0] - 0 - - - - - - CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC2 - - 0x0028 - 0x00 - 32 - - - cfg_base_addr_io_func2 - 17 - [17:0] - 0 - - - - - - CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC3 - - 0x002c - 0x00 - 32 - - - cfg_base_addr_io_func3 - 17 - [17:0] - 0 - - - - - - CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC4 - - 0x0030 - 0x00 - 32 - - - cfg_base_addr_io_func4 - 17 - [17:0] - 0 - - - - - - CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC5 - - 0x0034 - 0x00 - 32 - - - cfg_base_addr_io_func5 - 17 - [17:0] - 0 - - - - - - CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC6 - - 0x0038 - 0x00 - 32 - - - cfg_base_addr_io_func6 - 17 - [17:0] - 0 - - - - - - CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC7 - - 0x003c - 0x00 - 32 - - - cfg_base_addr_io_func7 - 17 - [17:0] - 0 - - - - - - CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR0 - - 0x0040 - 0x00 - 32 - - - cfg_reg_func_cis_ptr0 - 16 - [16:0] - 0 - - - - - - CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR1 - - 0x0044 - 0x00 - 32 - - - cfg_reg_func_cis_ptr1 - 16 - [16:0] - 0 - - - - - - CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR2 - - 0x0048 - 0x00 - 32 - - - cfg_reg_func_cis_ptr2 - 16 - [16:0] - 0 - - - - - - CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR3 - - 0x004c - 0x00 - 32 - - - cfg_reg_func_cis_ptr3 - 16 - [16:0] - 0 - - - - - - CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR4 - - 0x0050 - 0x00 - 32 - - - cfg_reg_func_cis_ptr4 - 16 - [16:0] - 0 - - - - - - CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR5 - - 0x0054 - 0x00 - 32 - - - cfg_reg_func_cis_ptr5 - 16 - [16:0] - 0 - - - - - - CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR6 - - 0x0058 - 0x00 - 32 - - - cfg_reg_func_cis_ptr6 - 16 - [16:0] - 0 - - - - - - CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR7 - - 0x005c - 0x00 - 32 - - - cfg_reg_func_cis_ptr7 - 16 - [16:0] - 0 - - - - - - CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE0 - - 0x0060 - 0x00 - 32 - - - cfg_reg_func_ext_std_code0 - 7 - [7:0] - 0 - - - - - - CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE1 - - 0x0064 - 0x00 - 32 - - - cfg_reg_func_ext_std_code1 - 7 - [7:0] - 0 - - - - - - CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE2 - - 0x0068 - 0x00 - 32 - - - cfg_reg_func_ext_std_code2 - 7 - [7:0] - 0 - - - - - - CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE3 - - 0x006c - 0x00 - 32 - - - cfg_reg_func_ext_std_code3 - 7 - [7:0] - 0 - - - - - - CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE4 - - 0x0070 - 0x00 - 32 - - - cfg_reg_func_ext_std_code4 - 7 - [7:0] - 0 - - - - - - CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE5 - - 0x0074 - 0x00 - 32 - - - cfg_reg_func_ext_std_code5 - 7 - [7:0] - 0 - - - - - - CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE6 - - 0x0078 - 0x00 - 32 - - - cfg_reg_func_ext_std_code6 - 7 - [7:0] - 0 - - - - - - CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE7 - - 0x007c - 0x00 - 32 - - - cfg_reg_func_ext_std_code7 - 7 - [7:0] - 0 - - - - - - CR_WRITE_PROTECT - - 0x0080 - 0x00 - 32 - - - cr_write_protect - 0 - [0:0] - 0 - - - - - - CR_REG_DSR - - 0x0084 - 0x00 - 32 - - - cr_reg_dsr - 15 - [15:0] - 0 - - - - - - CR_REG_CID_CFG_REG_CID0 - - 0x0088 - 0x00 - 32 - - - cfg_reg_cid0 - 31 - [31:0] - 0 - - - - - - CR_REG_CID_CFG_REG_CID1 - - 0x008c - 0x00 - 32 - - - cfg_reg_cid1 - 31 - [31:0] - 0 - - - - - - CR_REG_CID_CFG_REG_CID2 - - 0x0090 - 0x00 - 32 - - - cfg_reg_cid2 - 31 - [31:0] - 0 - - - - - - CR_REG_CID_CFG_REG_CID3 - - 0x0094 - 0x00 - 32 - - - cfg_reg_cid3 - 31 - [31:0] - 0 - - - - - - CR_REG_CSD_CFG_REG_CSD0 - - 0x0098 - 0x00 - 32 - - - cfg_reg_csd0 - 31 - [31:0] - 0 - - - - - - CR_REG_CSD_CFG_REG_CSD1 - - 0x009c - 0x00 - 32 - - - cfg_reg_csd1 - 31 - [31:0] - 0 - - - - - - CR_REG_CSD_CFG_REG_CSD2 - - 0x00a0 - 0x00 - 32 - - - cfg_reg_csd2 - 31 - [31:0] - 0 - - - - - - CR_REG_CSD_CFG_REG_CSD3 - - 0x00a4 - 0x00 - 32 - - - cfg_reg_csd3 - 31 - [31:0] - 0 - - - - - - CR_REG_SCR_CFG_REG_SCR0 - - 0x00a8 - 0x00 - 32 - - - cfg_reg_scr0 - 31 - [31:0] - 0 - - - - - - CR_REG_SCR_CFG_REG_SCR1 - - 0x00ac - 0x00 - 32 - - - cfg_reg_scr1 - 31 - [31:0] - 0 - - - - - - CR_REG_SD_STATUS_CFG_REG_SD_STATUS0 - - 0x00b0 - 0x00 - 32 - - - cfg_reg_sd_status0 - 31 - [31:0] - 0 - - - - - - CR_REG_SD_STATUS_CFG_REG_SD_STATUS1 - - 0x00b4 - 0x00 - 32 - - - cfg_reg_sd_status1 - 31 - [31:0] - 0 - - - - - - CR_REG_SD_STATUS_CFG_REG_SD_STATUS2 - - 0x00b8 - 0x00 - 32 - - - cfg_reg_sd_status2 - 31 - [31:0] - 0 - - - - - - CR_REG_SD_STATUS_CFG_REG_SD_STATUS3 - - 0x00bc - 0x00 - 32 - - - cfg_reg_sd_status3 - 31 - [31:0] - 0 - - - - - - CR_REG_SD_STATUS_CFG_REG_SD_STATUS4 - - 0x00c0 - 0x00 - 32 - - - cfg_reg_sd_status4 - 31 - [31:0] - 0 - - - - - - CR_REG_SD_STATUS_CFG_REG_SD_STATUS5 - - 0x00c4 - 0x00 - 32 - - - cfg_reg_sd_status5 - 31 - [31:0] - 0 - - - - - - CR_REG_SD_STATUS_CFG_REG_SD_STATUS6 - - 0x00c8 - 0x00 - 32 - - - cfg_reg_sd_status6 - 31 - [31:0] - 0 - - - - - - CR_REG_SD_STATUS_CFG_REG_SD_STATUS7 - - 0x00cc - 0x00 - 32 - - - cfg_reg_sd_status7 - 31 - [31:0] - 0 - - - - - - CR_REG_SD_STATUS_CFG_REG_SD_STATUS8 - - 0x00d0 - 0x00 - 32 - - - cfg_reg_sd_status8 - 31 - [31:0] - 0 - - - - - - CR_REG_SD_STATUS_CFG_REG_SD_STATUS9 - - 0x00d4 - 0x00 - 32 - - - cfg_reg_sd_status9 - 31 - [31:0] - 0 - - - - - - CR_REG_SD_STATUS_CFG_REG_SD_STATUS10 - - 0x00d8 - 0x00 - 32 - - - cfg_reg_sd_status10 - 31 - [31:0] - 0 - - - - - - CR_REG_SD_STATUS_CFG_REG_SD_STATUS11 - - 0x00dc - 0x00 - 32 - - - cfg_reg_sd_status11 - 31 - [31:0] - 0 - - - - - - CR_REG_SD_STATUS_CFG_REG_SD_STATUS12 - - 0x00e0 - 0x00 - 32 - - - cfg_reg_sd_status12 - 31 - [31:0] - 0 - - - - - - CR_REG_SD_STATUS_CFG_REG_SD_STATUS13 - - 0x00e4 - 0x00 - 32 - - - cfg_reg_sd_status13 - 31 - [31:0] - 0 - - - - - - CR_REG_SD_STATUS_CFG_REG_SD_STATUS14 - - 0x00e8 - 0x00 - 32 - - - cfg_reg_sd_status14 - 31 - [31:0] - 0 - - - - - - CR_REG_SD_STATUS_CFG_REG_SD_STATUS15 - - 0x00ec - 0x00 - 32 - - - cfg_reg_sd_status15 - 31 - [31:0] - 0 - - - - - - CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC0 - - 0x0100 - 0x00 - 32 - - - cfg_base_addr_mem_func0 - 17 - [17:0] - 0 - - - - - - CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC1 - - 0x0104 - 0x00 - 32 - - - cfg_base_addr_mem_func1 - 17 - [17:0] - 0 - - - - - - CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC2 - - 0x0108 - 0x00 - 32 - - - cfg_base_addr_mem_func2 - 17 - [17:0] - 0 - - - - - - CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC3 - - 0x010c - 0x00 - 32 - - - cfg_base_addr_mem_func3 - 17 - [17:0] - 0 - - - - - - CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC4 - - 0x0110 - 0x00 - 32 - - - cfg_base_addr_mem_func4 - 17 - [17:0] - 0 - - - - - - CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC5 - - 0x0114 - 0x00 - 32 - - - cfg_base_addr_mem_func5 - 17 - [17:0] - 0 - - - - - - CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC6 - - 0x0118 - 0x00 - 32 - - - cfg_base_addr_mem_func6 - 17 - [17:0] - 0 - - - - - - CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC7 - - 0x011c - 0x00 - 32 - - - cfg_base_addr_mem_func7 - 17 - [17:0] - 0 - - - - - - CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC8 - - 0x0120 - 0x00 - 32 - - - cfg_base_addr_mem_func8 - 17 - [17:0] - 0 - - - - - - CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC9 - - 0x0124 - 0x00 - 32 - - - cfg_base_addr_mem_func9 - 17 - [17:0] - 0 - - - - - - CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC10 - - 0x0128 - 0x00 - 32 - - - cfg_base_addr_mem_func10 - 17 - [17:0] - 0 - - - - - - CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC11 - - 0x012c - 0x00 - 32 - - - cfg_base_addr_mem_func11 - 17 - [17:0] - 0 - - - - - - CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC12 - - 0x0130 - 0x00 - 32 - - - cfg_base_addr_mem_func12 - 17 - [17:0] - 0 - - - - - - CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC13 - - 0x0134 - 0x00 - 32 - - - cfg_base_addr_mem_func13 - 17 - [17:0] - 0 - - - - - - CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC14 - - 0x0138 - 0x00 - 32 - - - cfg_base_addr_mem_func14 - 17 - [17:0] - 0 - - - - - - CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC15 - - 0x013c - 0x00 - 32 - - - cfg_base_addr_mem_func15 - 17 - [17:0] - 0 - - - - - - CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC16 - - 0x0140 - 0x00 - 32 - - - cfg_base_addr_mem_func16 - 17 - [17:0] - 0 - - - - - - CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC17 - - 0x0144 - 0x00 - 32 - - - cfg_base_addr_mem_func17 - 17 - [17:0] - 0 - - - - - - CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE0 - - 0x0148 - 0x00 - 32 - - - cfg_reg_func_isdio_interface_code0 - 7 - [7:0] - 0 - - - - - - CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE1 - - 0x014c - 0x00 - 32 - - - cfg_reg_func_isdio_interface_code1 - 7 - [7:0] - 0 - - - - - - CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE2 - - 0x0150 - 0x00 - 32 - - - cfg_reg_func_isdio_interface_code2 - 7 - [7:0] - 0 - - - - - - CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE3 - - 0x0154 - 0x00 - 32 - - - cfg_reg_func_isdio_interface_code3 - 7 - [7:0] - 0 - - - - - - CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE4 - - 0x0158 - 0x00 - 32 - - - cfg_reg_func_isdio_interface_code4 - 7 - [7:0] - 0 - - - - - - CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE5 - - 0x015c - 0x00 - 32 - - - cfg_reg_func_isdio_interface_code5 - 7 - [7:0] - 0 - - - - - - CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE6 - - 0x0160 - 0x00 - 32 - - - cfg_reg_func_isdio_interface_code6 - 7 - [7:0] - 0 - - - - - - CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE0 - - 0x0168 - 0x00 - 32 - - - cfg_reg_func_manufact_code0 - 15 - [15:0] - 0 - - - - - - CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE1 - - 0x016c - 0x00 - 32 - - - cfg_reg_func_manufact_code1 - 15 - [15:0] - 0 - - - - - - CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE2 - - 0x0170 - 0x00 - 32 - - - cfg_reg_func_manufact_code2 - 15 - [15:0] - 0 - - - - - - CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE3 - - 0x0174 - 0x00 - 32 - - - cfg_reg_func_manufact_code3 - 15 - [15:0] - 0 - - - - - - CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE4 - - 0x0178 - 0x00 - 32 - - - cfg_reg_func_manufact_code4 - 15 - [15:0] - 0 - - - - - - CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE5 - - 0x017c - 0x00 - 32 - - - cfg_reg_func_manufact_code5 - 15 - [15:0] - 0 - - - - - - CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE6 - - 0x0180 - 0x00 - 32 - - - cfg_reg_func_manufact_code6 - 15 - [15:0] - 0 - - - - - - CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO0 - - 0x0188 - 0x00 - 32 - - - cfg_reg_func_manufact_info0 - 15 - [15:0] - 0 - - - - - - CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO1 - - 0x018c - 0x00 - 32 - - - cfg_reg_func_manufact_info1 - 15 - [15:0] - 0 - - - - - - CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO2 - - 0x0190 - 0x00 - 32 - - - cfg_reg_func_manufact_info2 - 15 - [15:0] - 0 - - - - - - CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO3 - - 0x0194 - 0x00 - 32 - - - cfg_reg_func_manufact_info3 - 15 - [15:0] - 0 - - - - - - CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO4 - - 0x0198 - 0x00 - 32 - - - cfg_reg_func_manufact_info4 - 15 - [15:0] - 0 - - - - - - CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO5 - - 0x019c - 0x00 - 32 - - - cfg_reg_func_manufact_info5 - 15 - [15:0] - 0 - - - - - - CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO6 - - 0x01a0 - 0x00 - 32 - - - cfg_reg_func_manufact_info6 - 15 - [15:0] - 0 - - - - - - CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE0 - - 0x01a8 - 0x00 - 32 - - - cfg_reg_func_isdio_type_sup_code0 - 7 - [7:0] - 0 - - - - - - CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE1 - - 0x01ac - 0x00 - 32 - - - cfg_reg_func_isdio_type_sup_code1 - 7 - [7:0] - 0 - - - - - - CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE2 - - 0x01b0 - 0x00 - 32 - - - cfg_reg_func_isdio_type_sup_code2 - 7 - [7:0] - 0 - - - - - - CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE3 - - 0x01b4 - 0x00 - 32 - - - cfg_reg_func_isdio_type_sup_code3 - 7 - [7:0] - 0 - - - - - - CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE4 - - 0x01b8 - 0x00 - 32 - - - cfg_reg_func_isdio_type_sup_code4 - 7 - [7:0] - 0 - - - - - - CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE5 - - 0x01bc - 0x00 - 32 - - - cfg_reg_func_isdio_type_sup_code5 - 7 - [7:0] - 0 - - - - - - CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE6 - - 0x01c0 - 0x00 - 32 - - - cfg_reg_func_isdio_type_sup_code6 - 7 - [7:0] - 0 - - - - - - CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO0 - - 0x01c8 - 0x00 - 32 - - - cfg_reg_func_info0 - 15 - [15:0] - 0 - - - - - - CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO1 - - 0x01cc - 0x00 - 32 - - - cfg_reg_func_info1 - 15 - [15:0] - 0 - - - - - - CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO2 - - 0x01d0 - 0x00 - 32 - - - cfg_reg_func_info2 - 15 - [15:0] - 0 - - - - - - CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO3 - - 0x01d4 - 0x00 - 32 - - - cfg_reg_func_info3 - 15 - [15:0] - 0 - - - - - - CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO4 - - 0x01d8 - 0x00 - 32 - - - cfg_reg_func_info4 - 15 - [15:0] - 0 - - - - - - CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO5 - - 0x01dc - 0x00 - 32 - - - cfg_reg_func_info5 - 15 - [15:0] - 0 - - - - - - CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO6 - - 0x01e0 - 0x00 - 32 - - - cfg_reg_func_info6 - 15 - [15:0] - 0 - - - - - - CR_REG_UHS_1_SUPPORT - - 0x01f0 - 0x00 - 32 - - - cfg_reg_max_current - 15 - [15:0] - 0 - - - - cfg_reg_data_strc_version - 23 - [23:16] - 16 - - - - cfg_reg_uhs_1_support - 31 - [31:24] - 24 - - - - - - - 0 - 0x1f4 - registers - - - - RP_PIO - 0x50123000 - RP_PIO - - - SFR_CTRL - - 0x0000 - 0x00 - 32 - - - en - 3 - [3:0] - 0 - - - - restart - 7 - [7:4] - 4 - - - - clkdiv_restart - 11 - [11:8] - 8 - - - - - - SFR_FSTAT - - 0x0004 - 0x00 - 32 - - - rx_full - 3 - [3:0] - 0 - - - - constant0 - 7 - [7:4] - 4 - - - - rx_empty - 11 - [11:8] - 8 - - - - constant1 - 15 - [15:12] - 12 - - - - tx_full - 19 - [19:16] - 16 - - - - constant2 - 23 - [23:20] - 20 - - - - tx_empty + cr_adc 27 - [27:24] - 24 - - - - constant3 - 31 - [31:28] - 28 - - - - - - SFR_FDEBUG - - 0x0008 - 0x00 - 32 - - - rxstall - 3 - [3:0] + [27:0] 0 - - - - nc_dbg3 - 7 - [7:4] - 4 - - - - rxunder - 11 - [11:8] - 8 - - - - nc_dbg2 - 15 - [15:12] - 12 - - - - txover - 19 - [19:16] - 16 - - - - nc_dbg1 - 23 - [23:20] - 20 - - - - txstall - 27 - [27:24] - 24 - - - - nc_dbg0 - 31 - [31:28] - 28 - - - - - - SFR_FLEVEL - - 0x000c - 0x00 - 32 - - - tx_level0 - 2 - [2:0] - 0 - - - - constant0 - 3 - [3:3] - 3 - - - - rx_level0 - 6 - [6:4] - 4 - - - - constant1 - 7 - [7:7] - 7 - - - - tx_level1 - 10 - [10:8] - 8 - - - - constant2 - 11 - [11:11] - 11 - - - - rx_level1 - 14 - [14:12] - 12 - - - - constant3 - 15 - [15:15] - 15 - - - - tx_level2 - 18 - [18:16] - 16 - - - - constant4 - 19 - [19:19] - 19 - - - - rx_level2 - 22 - [22:20] - 20 - - - - constant5 - 23 - [23:23] - 23 - - - - tx_level3 - 26 - [26:24] - 24 - - - - constant6 - 27 - [27:27] - 27 - - - - rx_level3 - 30 - [30:28] - 28 - - - - constant7 - 31 - [31:31] - 31 - - - - - - SFR_TXF0 - - 0x0010 - 0x00 - 32 - - - fdin - 31 - [31:0] - 0 - - - - - - SFR_TXF1 - - 0x0014 - 0x00 - 32 - - - fdin - 31 - [31:0] - 0 - - - - - - SFR_TXF2 - - 0x0018 - 0x00 - 32 - - - fdin - 31 - [31:0] - 0 - - - - - - SFR_TXF3 - - 0x001c - 0x00 - 32 - - - fdin - 31 - [31:0] - 0 - - - - - - SFR_RXF0 - - 0x0020 - 0x00 - 32 - - - pdout - 31 - [31:0] - 0 - - - - - - SFR_RXF1 - - 0x0024 - 0x00 - 32 - - - pdout - 31 - [31:0] - 0 - - - - - - SFR_RXF2 - - 0x0028 - 0x00 - 32 - - - pdout - 31 - [31:0] - 0 - - - - - - SFR_RXF3 - - 0x002c - 0x00 - 32 - - - pdout - 31 - [31:0] - 0 - - - - - - SFR_IRQ - - 0x0030 - 0x00 - 32 - - - sfr_irq - 7 - [7:0] - 0 - - - - - - SFR_IRQ_FORCE - - 0x0034 - 0x00 - 32 - - - sfr_irq_force - 7 - [7:0] - 0 - - - - - - SFR_SYNC_BYPASS - - 0x0038 - 0x00 - 32 - - - sfr_sync_bypass - 31 - [31:0] - 0 - - - - - - SFR_DBG_PADOUT - - 0x003c - 0x00 - 32 - - - sfr_dbg_padout - 31 - [31:0] - 0 - - - - - - SFR_DBG_PADOE - - 0x0040 - 0x00 - 32 - - - sfr_dbg_padoe - 31 - [31:0] - 0 - - - - - - SFR_DBG_CFGINFO - - 0x0044 - 0x00 - 32 - - - constant0 - 7 - [7:0] - 0 - - - - constant1 - 15 - [15:8] - 8 - - - - constant2 - 31 - [31:16] - 16 - - - - - - SFR_INSTR_MEM0 - - 0x0048 - 0x00 - 32 - - - instr - 15 - [15:0] - 0 - - - - - - SFR_INSTR_MEM1 - - 0x004c - 0x00 - 32 - - - instr - 15 - [15:0] - 0 - - - - - - SFR_INSTR_MEM2 - - 0x0050 - 0x00 - 32 - - - instr - 15 - [15:0] - 0 - - - - - - SFR_INSTR_MEM3 - - 0x0054 - 0x00 - 32 - - - instr - 15 - [15:0] - 0 - - - - - - SFR_INSTR_MEM4 - - 0x0058 - 0x00 - 32 - - - instr - 15 - [15:0] - 0 - - - - - - SFR_INSTR_MEM5 - - 0x005c - 0x00 - 32 - - - instr - 15 - [15:0] - 0 - - - - - - SFR_INSTR_MEM6 - - 0x0060 - 0x00 - 32 - - - instr - 15 - [15:0] - 0 - - - - - - SFR_INSTR_MEM7 - - 0x0064 - 0x00 - 32 - - - instr - 15 - [15:0] - 0 - - - - - - SFR_INSTR_MEM8 - - 0x0068 - 0x00 - 32 - - - instr - 15 - [15:0] - 0 - - - - - - SFR_INSTR_MEM9 - - 0x006c - 0x00 - 32 - - - instr - 15 - [15:0] - 0 - - - - - - SFR_INSTR_MEM10 - - 0x0070 - 0x00 - 32 - - - instr - 15 - [15:0] - 0 - - - - - - SFR_INSTR_MEM11 - - 0x0074 - 0x00 - 32 - - - instr - 15 - [15:0] - 0 - - - - - - SFR_INSTR_MEM12 - - 0x0078 - 0x00 - 32 - - - instr - 15 - [15:0] - 0 - - - - - - SFR_INSTR_MEM13 - - 0x007c - 0x00 - 32 - - - instr - 15 - [15:0] - 0 - - - - - - SFR_INSTR_MEM14 - - 0x0080 - 0x00 - 32 - - - instr - 15 - [15:0] - 0 - - - - - - SFR_INSTR_MEM15 - - 0x0084 - 0x00 - 32 - - - instr - 15 - [15:0] - 0 - - - - - - SFR_INSTR_MEM16 - - 0x0088 - 0x00 - 32 - - - instr - 15 - [15:0] - 0 - - - - - - SFR_INSTR_MEM17 - - 0x008c - 0x00 - 32 - - - instr - 15 - [15:0] - 0 - - - - - - SFR_INSTR_MEM18 - - 0x0090 - 0x00 - 32 - - - instr - 15 - [15:0] - 0 - - - - - - SFR_INSTR_MEM19 - - 0x0094 - 0x00 - 32 - - - instr - 15 - [15:0] - 0 - - - - - - SFR_INSTR_MEM20 - - 0x0098 - 0x00 - 32 - - - instr - 15 - [15:0] - 0 - - - - - - SFR_INSTR_MEM21 - - 0x009c - 0x00 - 32 - - - instr - 15 - [15:0] - 0 - - - - - - SFR_INSTR_MEM22 - - 0x00a0 - 0x00 - 32 - - - instr - 15 - [15:0] - 0 - - - - - - SFR_INSTR_MEM23 - - 0x00a4 - 0x00 - 32 - - - instr - 15 - [15:0] - 0 - - - - - - SFR_INSTR_MEM24 - - 0x00a8 - 0x00 - 32 - - - instr - 15 - [15:0] - 0 - - - - - - SFR_INSTR_MEM25 - - 0x00ac - 0x00 - 32 - - - instr - 15 - [15:0] - 0 - - - - - - SFR_INSTR_MEM26 - - 0x00b0 - 0x00 - 32 - - - instr - 15 - [15:0] - 0 - - - - - - SFR_INSTR_MEM27 - - 0x00b4 - 0x00 - 32 - - - instr - 15 - [15:0] - 0 - - - - - - SFR_INSTR_MEM28 - - 0x00b8 - 0x00 - 32 - - - instr - 15 - [15:0] - 0 - - - - - - SFR_INSTR_MEM29 - - 0x00bc - 0x00 - 32 - - - instr - 15 - [15:0] - 0 - - - - - - SFR_INSTR_MEM30 - - 0x00c0 - 0x00 - 32 - - - instr - 15 - [15:0] - 0 - - - - - - SFR_INSTR_MEM31 - - 0x00c4 - 0x00 - 32 - - - instr - 15 - [15:0] - 0 - - - - - - SFR_SM0_CLKDIV - - 0x00c8 - 0x00 - 32 - - - unused_div - 7 - [7:0] - 0 - - - - div_frac - 15 - [15:8] - 8 - - - - div_int - 31 - [31:16] - 16 - - - - - - SFR_SM0_EXECCTRL - - 0x00cc - 0x00 - 32 - - - status_n - 3 - [3:0] - 0 - - - - status_sel - 4 - [4:4] - 4 - - - - resvd_exec - 6 - [6:5] - 5 - - - - wrap_target - 11 - [11:7] - 7 - - - - pend - 16 - [16:12] - 12 - - - - out_sticky - 17 - [17:17] - 17 - - - - inline_out_en - 18 - [18:18] - 18 - - - - out_en_sel - 23 - [23:19] - 19 - - - - jmp_pin - 28 - [28:24] - 24 - - - - side_pindir - 29 - [29:29] - 29 - - - - sideset_enable_bit - 30 - [30:30] - 30 - - - - exec_stalled_ro0 - 31 - [31:31] - 31 - - - - - - SFR_SM0_SHIFTCTRL - - 0x00d0 - 0x00 - 32 - - - resvd_shift - 15 - [15:0] - 0 - - - - auto_push - 16 - [16:16] - 16 - - - - auto_pull - 17 - [17:17] - 17 - - - - in_shift_dir - 18 - [18:18] - 18 - - - - out_shift_dir - 19 - [19:19] - 19 - - - - isr_threshold - 24 - [24:20] - 20 - - - - osr_threshold - 29 - [29:25] - 25 - - - - join_tx - 30 - [30:30] - 30 - - - - join_rx - 31 - [31:31] - 31 - - - - - - SFR_SM0_ADDR - - 0x00d4 - 0x00 - 32 - - - pc - 4 - [4:0] - 0 - - - - - - SFR_SM0_INSTR - - 0x00d8 - 0x00 - 32 - - - imm_instr - 15 - [15:0] - 0 - - - - - - SFR_SM0_PINCTRL - - 0x00dc - 0x00 - 32 - - - pins_out_base - 4 - [4:0] - 0 - - - - pins_set_base - 9 - [9:5] - 5 - - - - pins_side_base - 14 - [14:10] - 10 - - - - pins_in_base - 19 - [19:15] - 15 - - - - pins_out_count - 25 - [25:20] - 20 - - - - pins_set_count - 28 - [28:26] - 26 - - - - pins_side_count - 31 - [31:29] - 29 - - - - - - SFR_SM1_CLKDIV - - 0x00e0 - 0x00 - 32 - - - unused_div - 7 - [7:0] - 0 - - - - div_frac - 15 - [15:8] - 8 - - - - div_int - 31 - [31:16] - 16 - - - - - - SFR_SM1_EXECCTRL - - 0x00e4 - 0x00 - 32 - - - status_n - 3 - [3:0] - 0 - - - - status_sel - 4 - [4:4] - 4 - - - - resvd_exec - 6 - [6:5] - 5 - - - - wrap_target - 11 - [11:7] - 7 - - - - pend - 16 - [16:12] - 12 - - - - out_sticky - 17 - [17:17] - 17 - - - - inline_out_en - 18 - [18:18] - 18 - - - - out_en_sel - 23 - [23:19] - 19 - - - - jmp_pin - 28 - [28:24] - 24 - - - - side_pindir - 29 - [29:29] - 29 - - - - sideset_enable_bit - 30 - [30:30] - 30 - - - - exec_stalled_ro1 - 31 - [31:31] - 31 - - - - - - SFR_SM1_SHIFTCTRL - - 0x00e8 - 0x00 - 32 - - - resvd_shift - 15 - [15:0] - 0 - - - - auto_push - 16 - [16:16] - 16 - - - - auto_pull - 17 - [17:17] - 17 - - - - in_shift_dir - 18 - [18:18] - 18 - - - - out_shift_dir - 19 - [19:19] - 19 - - - - isr_threshold - 24 - [24:20] - 20 - - - - osr_threshold - 29 - [29:25] - 25 - - - - join_tx - 30 - [30:30] - 30 - - - - join_rx - 31 - [31:31] - 31 - - - - - - SFR_SM1_ADDR - - 0x00ec - 0x00 - 32 - - - pc - 4 - [4:0] - 0 - - - - - - SFR_SM1_INSTR - - 0x00f0 - 0x00 - 32 - - - imm_instr - 15 - [15:0] - 0 - - - - - - SFR_SM1_PINCTRL - - 0x00f4 - 0x00 - 32 - - - pins_out_base - 4 - [4:0] - 0 - - - - pins_set_base - 9 - [9:5] - 5 - - - - pins_side_base - 14 - [14:10] - 10 - - - - pins_in_base - 19 - [19:15] - 15 - - - - pins_out_count - 25 - [25:20] - 20 - - - - pins_set_count - 28 - [28:26] - 26 - - - - pins_side_count - 31 - [31:29] - 29 - - - - - - SFR_SM2_CLKDIV - - 0x00f8 - 0x00 - 32 - - - unused_div - 7 - [7:0] - 0 - - - - div_frac - 15 - [15:8] - 8 - - - - div_int - 31 - [31:16] - 16 - - - - - - SFR_SM2_EXECCTRL - - 0x00fc - 0x00 - 32 - - - status_n - 3 - [3:0] - 0 - - - - status_sel - 4 - [4:4] - 4 - - - - resvd_exec - 6 - [6:5] - 5 - - - - wrap_target - 11 - [11:7] - 7 - - - - pend - 16 - [16:12] - 12 - - - - out_sticky - 17 - [17:17] - 17 - - - - inline_out_en - 18 - [18:18] - 18 - - - - out_en_sel - 23 - [23:19] - 19 - - - - jmp_pin - 28 - [28:24] - 24 - - - - side_pindir - 29 - [29:29] - 29 - - - - sideset_enable_bit - 30 - [30:30] - 30 - - - - exec_stalled_ro2 - 31 - [31:31] - 31 - - - - - - SFR_SM2_SHIFTCTRL - - 0x0100 - 0x00 - 32 - - - resvd_shift - 15 - [15:0] - 0 - - - - auto_push - 16 - [16:16] - 16 - - - - auto_pull - 17 - [17:17] - 17 - - - - in_shift_dir - 18 - [18:18] - 18 - - - - out_shift_dir - 19 - [19:19] - 19 - - - - isr_threshold - 24 - [24:20] - 20 - - - - osr_threshold - 29 - [29:25] - 25 - - - - join_tx - 30 - [30:30] - 30 - - - - join_rx - 31 - [31:31] - 31 - - - - - - SFR_SM2_ADDR - - 0x0104 - 0x00 - 32 - - - pc - 4 - [4:0] - 0 - - - - - - SFR_SM2_INSTR - - 0x0108 - 0x00 - 32 - - - imm_instr - 15 - [15:0] - 0 - - - - - - SFR_SM2_PINCTRL - - 0x010c - 0x00 - 32 - - - pins_out_base - 4 - [4:0] - 0 - - - - pins_set_base - 9 - [9:5] - 5 - - - - pins_side_base - 14 - [14:10] - 10 - - - - pins_in_base - 19 - [19:15] - 15 - - - - pins_out_count - 25 - [25:20] - 20 - - - - pins_set_count - 28 - [28:26] - 26 - - - - pins_side_count - 31 - [31:29] - 29 - - - - - - SFR_SM3_CLKDIV - - 0x0110 - 0x00 - 32 - - - unused_div - 7 - [7:0] - 0 - - - - div_frac - 15 - [15:8] - 8 - - - - div_int - 31 - [31:16] - 16 - - - - - - SFR_SM3_EXECCTRL - - 0x0114 - 0x00 - 32 - - - status_n - 3 - [3:0] - 0 - - - - status_sel - 4 - [4:4] - 4 - - - - resvd_exec - 6 - [6:5] - 5 - - - - wrap_target - 11 - [11:7] - 7 - - - - pend - 16 - [16:12] - 12 - - - - out_sticky - 17 - [17:17] - 17 - - - - inline_out_en - 18 - [18:18] - 18 - - - - out_en_sel - 23 - [23:19] - 19 - - - - jmp_pin - 28 - [28:24] - 24 - - - - side_pindir - 29 - [29:29] - 29 - - - - sideset_enable_bit - 30 - [30:30] - 30 - - - - exec_stalled_ro3 - 31 - [31:31] - 31 - - - - - - SFR_SM3_SHIFTCTRL - - 0x0118 - 0x00 - 32 - - - resvd_shift - 15 - [15:0] - 0 - - - - auto_push - 16 - [16:16] - 16 - - - - auto_pull - 17 - [17:17] - 17 - - - - in_shift_dir - 18 - [18:18] - 18 - - - - out_shift_dir - 19 - [19:19] - 19 - - - - isr_threshold - 24 - [24:20] - 20 - - - - osr_threshold - 29 - [29:25] - 25 - - - - join_tx - 30 - [30:30] - 30 - - - - join_rx - 31 - [31:31] - 31 - - - - - - SFR_SM3_ADDR - - 0x011c - 0x00 - 32 - - - pc - 4 - [4:0] - 0 - - - - - - SFR_SM3_INSTR - - 0x0120 - 0x00 - 32 - - - imm_instr - 15 - [15:0] - 0 - - - - - - SFR_SM3_PINCTRL - - 0x0124 - 0x00 - 32 - - - pins_out_base - 4 - [4:0] - 0 - - - - pins_set_base - 9 - [9:5] - 5 - - - - pins_side_base - 14 - [14:10] - 10 - - - - pins_in_base - 19 - [19:15] - 15 - - - - pins_out_count - 25 - [25:20] - 20 - - - - pins_set_count - 28 - [28:26] - 26 - - - - pins_side_count - 31 - [31:29] - 29 - - - - - - SFR_INTR - - 0x0128 - 0x00 - 32 - - - intr_rxnempty - 3 - [3:0] - 0 - - - - intr_txnfull - 7 - [7:4] - 4 - - - - intr_sm - 11 - [11:8] - 8 - - - - - - SFR_IRQ0_INTE - - 0x012c - 0x00 - 32 - - - irq0_inte_rxnempty - 3 - [3:0] - 0 - - - - irq0_inte_txnfull - 7 - [7:4] - 4 - - - - irq0_inte_sm - 11 - [11:8] - 8 - - - - - - SFR_IRQ0_INTF - - 0x0130 - 0x00 - 32 - - - irq0_intf_rxnempty - 3 - [3:0] - 0 - - - - irq0_intf_txnfull - 7 - [7:4] - 4 - - - - irq0_intf_sm - 11 - [11:8] - 8 - - - - - - SFR_IRQ0_INTS - - 0x0134 - 0x00 - 32 - - - irq0_ints_rxnempty - 3 - [3:0] - 0 - - - - irq0_ints_txnfull - 7 - [7:4] - 4 - - - - irq0_ints_sm - 11 - [11:8] - 8 - - - - - - SFR_IRQ1_INTE - - 0x0138 - 0x00 - 32 - - - irq1_inte_rxnempty - 3 - [3:0] - 0 - - - - irq1_inte_txnfull - 7 - [7:4] - 4 - - - - irq1_inte_sm - 11 - [11:8] - 8 - - - - - - SFR_IRQ1_INTF - - 0x013c - 0x00 - 32 - - - irq1_intf_rxnempty - 3 - [3:0] - 0 - - - - irq1_intf_txnfull - 7 - [7:4] - 4 - - - - irq1_intf_sm - 11 - [11:8] - 8 - - - - - - SFR_IRQ1_INTS - - 0x0140 - 0x00 - 32 - - - irq1_ints_rxnempty - 3 - [3:0] - 0 - - - - irq1_ints_txnfull - 7 - [7:4] - 4 - - - - irq1_ints_sm - 11 - [11:8] - 8 - - - - - - SFR_IO_OE_INV - - 0x0180 - 0x00 - 32 - - - sfr_io_oe_inv - 31 - [31:0] - 0 - - - - - - SFR_IO_O_INV - - 0x0184 - 0x00 - 32 - - - sfr_io_o_inv - 31 - [31:0] - 0 - - - - - - SFR_IO_I_INV - - 0x0188 - 0x00 - 32 - - - sfr_io_i_inv - 31 - [31:0] - 0 - - - - - - SFR_FIFO_MARGIN - - 0x018c - 0x00 - 32 - - - fifo_tx_margin0 - 1 - [1:0] - 0 - - - - fifo_rx_margin0 - 3 - [3:2] - 2 - - - - fifo_tx_margin1 - 5 - [5:4] - 4 - - - - fifo_rx_margin1 - 7 - [7:6] - 6 - - - - fifo_tx_margin2 - 9 - [9:8] - 8 - - - - fifo_rx_margin2 - 11 - [11:10] - 10 - - - - fifo_tx_margin3 - 13 - [13:12] - 12 - - - - fifo_rx_margin3 - 15 - [15:14] - 14 - - - - - - SFR_ZERO0 - - 0x0190 - 0x00 - 32 - - - sfr_zero0 - 31 - [31:0] - 0 - - - - - - SFR_ZERO1 - - 0x0194 - 0x00 - 32 - - - sfr_zero1 - 31 - [31:0] - 0 - - - - - - SFR_ZERO2 - - 0x0198 - 0x00 - 32 - - - sfr_zero2 - 31 - [31:0] - 0 - - - - - - SFR_ZERO3 - - 0x019c - 0x00 - 32 - - - sfr_zero3 - 31 - [31:0] - 0 - + 0 - 0x1a0 - registers - - - - BIO_BDMA - 0x50124000 - BIO_BDMA - - - SFR_CTRL - - 0x0000 - 0x00 - 32 - - - en - 3 - [3:0] - 0 - - - - restart - 7 - [7:4] - 4 - - - - clkdiv_restart - 11 - [11:8] - 8 - - - - - - SFR_CFGINFO - - 0x0004 - 0x00 - 32 - - - constant0 - 7 - [7:0] - 0 - - - - constant1 - 15 - [15:8] - 8 - - - - constant2 - 31 - [31:16] - 16 - - - - - - SFR_CONFIG - - 0x0008 - 0x00 - 32 - - - snap_output_to_which - 1 - [1:0] - 0 - - - - snap_output_to_quantum - 2 - [2:2] - 2 - - - - snap_input_to_which - 4 - [4:3] - 3 - - - - snap_input_to_quantum - 5 - [5:5] - 5 - - - - disable_filter_peri - 6 - [6:6] - 6 - - - - disable_filter_mem - 7 - [7:7] - 7 - - - - - - SFR_FLEVEL - - 0x000c - 0x00 - 32 - - - pclk_regfifo_level0 - 3 - [3:0] - 0 - - - - pclk_regfifo_level1 - 7 - [7:4] - 4 - - - - pclk_regfifo_level2 - 11 - [11:8] - 8 - - - - pclk_regfifo_level3 - 15 - [15:12] - 12 - - - - - - SFR_TXF0 - - 0x0010 - 0x00 - 32 - - - fdin - 31 - [31:0] - 0 - - - - - - SFR_TXF1 - - 0x0014 - 0x00 - 32 - - - fdin - 31 - [31:0] - 0 - - - - - - SFR_TXF2 - - 0x0018 - 0x00 - 32 - - - fdin - 31 - [31:0] - 0 - - - - - - SFR_TXF3 - - 0x001c - 0x00 - 32 - - - fdin - 31 - [31:0] - 0 - - - - - - SFR_RXF0 - - 0x0020 - 0x00 - 32 - - - fdout - 31 - [31:0] - 0 - - - - - - SFR_RXF1 - - 0x0024 - 0x00 - 32 - - - fdout - 31 - [31:0] - 0 - - - - - - SFR_RXF2 - - 0x0028 - 0x00 - 32 - - - fdout - 31 - [31:0] - 0 - - - - - - SFR_RXF3 - - 0x002c - 0x00 - 32 - - - fdout - 31 - [31:0] - 0 - - - - - - SFR_ELEVEL - - 0x0030 - 0x00 - 32 - - - fifo_event_level0 - 3 - [3:0] - 0 - - - - fifo_event_level1 - 7 - [7:4] - 4 - - - - fifo_event_level2 - 11 - [11:8] - 8 - - - - fifo_event_level3 - 15 - [15:12] - 12 - - - - fifo_event_level4 - 19 - [19:16] - 16 - - - - fifo_event_level5 - 23 - [23:20] - 20 - - - - fifo_event_level6 - 27 - [27:24] - 24 - - - - fifo_event_level7 - 31 - [31:28] - 28 - - - - - - SFR_ETYPE - - 0x0034 - 0x00 - 32 - - - fifo_event_lt_mask - 7 - [7:0] - 0 - - - - fifo_event_eq_mask - 15 - [15:8] - 8 - - - - fifo_event_gt_mask - 23 - [23:16] - 16 - - - - - - SFR_EVENT_SET - - 0x0038 - 0x00 - 32 - - - sfr_event_set - 23 - [23:0] - 0 - - - - - - SFR_EVENT_CLR - - 0x003c - 0x00 - 32 - - - sfr_event_clr - 23 - [23:0] - 0 - - - - - - SFR_EVENT_STATUS - - 0x0040 - 0x00 - 32 - - - sfr_event_status - 31 - [31:0] - 0 - - - - - - SFR_EXTCLOCK - - 0x0044 - 0x00 - 32 - - - use_extclk - 3 - [3:0] - 0 - - - - extclk_gpio_0 - 8 - [8:4] - 4 - - - - extclk_gpio_1 - 13 - [13:9] - 9 - - - - extclk_gpio_2 - 18 - [18:14] - 14 - - - - extclk_gpio_3 - 23 - [23:19] - 19 - - - - - - SFR_FIFO_CLR - - 0x0048 - 0x00 - 32 - - - sfr_fifo_clr - 3 - [3:0] - 0 - - - - - - SFR_QDIV0 - - 0x0050 - 0x00 - 32 - - - unused_div - 0 - [0:0] - 0 - - - - div_frac - 1 - [1:1] - 1 - - - - div_int - 2 - [2:2] - 2 - - - - - - SFR_QDIV1 - - 0x0054 - 0x00 - 32 - - - unused_div - 0 - [0:0] - 0 - - - - div_frac - 1 - [1:1] - 1 - - - - div_int - 2 - [2:2] - 2 - - - - - - SFR_QDIV2 - - 0x0058 - 0x00 - 32 - - - unused_div - 0 - [0:0] - 0 - - - - div_frac - 1 - [1:1] - 1 - - - - div_int - 2 - [2:2] - 2 - - - - - - SFR_QDIV3 - - 0x005c - 0x00 - 32 - - - unused_div - 0 - [0:0] - 0 - - - - div_frac - 1 - [1:1] - 1 - - - - div_int - 2 - [2:2] - 2 - - - - - - SFR_SYNC_BYPASS - - 0x0060 - 0x00 - 32 - - - sfr_sync_bypass - 31 - [31:0] - 0 - - - - - - SFR_IO_OE_INV - - 0x0064 - 0x00 - 32 - - - sfr_io_oe_inv - 31 - [31:0] - 0 - - - - - - SFR_IO_O_INV - - 0x0068 - 0x00 - 32 - - - sfr_io_o_inv - 31 - [31:0] - 0 - - - - - - SFR_IO_I_INV - - 0x006c - 0x00 - 32 - - - sfr_io_i_inv - 31 - [31:0] - 0 - - - - - - SFR_IRQMASK_0 - - 0x0070 - 0x00 - 32 - - - sfr_irqmask_0 - 31 - [31:0] - 0 - - - - - - SFR_IRQMASK_1 - - 0x0074 - 0x00 - 32 - - - sfr_irqmask_1 - 31 - [31:0] - 0 - - - - - - SFR_IRQMASK_2 - - 0x0078 - 0x00 - 32 - - - sfr_irqmask_2 - 31 - [31:0] - 0 - - - - - - SFR_IRQMASK_3 - - 0x007c - 0x00 - 32 - - - sfr_irqmask_3 - 31 - [31:0] - 0 - - - - - - SFR_IRQ_EDGE - - 0x0080 - 0x00 - 32 - - - sfr_irq_edge - 3 - [3:0] - 0 - - - - - - SFR_DBG_PADOUT - - 0x0084 - 0x00 - 32 - - - sfr_dbg_padout - 31 - [31:0] - 0 - - - - - - SFR_DBG_PADOE - - 0x0088 - 0x00 - 32 - - - sfr_dbg_padoe - 31 - [31:0] - 0 - - - - - - SFR_DBG0 - - 0x0090 - 0x00 - 32 - - - dbg_pc - 0 - [0:0] - 0 - - - - trap - 1 - [1:1] - 1 - - - - - - SFR_DBG1 - - 0x0094 - 0x00 - 32 - - - dbg_pc - 0 - [0:0] - 0 - - - - trap - 1 - [1:1] - 1 - - - - - - SFR_DBG2 - - 0x0098 - 0x00 - 32 - - - dbg_pc - 0 - [0:0] - 0 - - - - trap - 1 - [1:1] - 1 - - - - - - SFR_DBG3 - - 0x009c - 0x00 - 32 - - - dbg_pc - 0 - [0:0] - 0 - - - - trap - 1 - [1:1] - 1 - - - - - - SFR_MEM_GUTTER - - 0x00a0 - 0x00 - 32 - - - sfr_mem_gutter - 19 - [19:0] - 0 - - - - - - SFR_PERI_GUTTER - - 0x00a4 - 0x00 - 32 - - - sfr_peri_gutter - 19 - [19:0] - 0 - - - - - - SFR_DMAREQ_MAP_CR_EVMAP0 - - 0x00b0 - 0x00 - 32 - - - cr_evmap0 - 31 - [31:0] - 0 - - - - - - SFR_DMAREQ_MAP_CR_EVMAP1 - - 0x00b4 - 0x00 - 32 - - - cr_evmap1 - 31 - [31:0] - 0 - - - - - - SFR_DMAREQ_MAP_CR_EVMAP2 - - 0x00b8 - 0x00 - 32 - - - cr_evmap2 - 31 - [31:0] - 0 - - - - - - SFR_DMAREQ_MAP_CR_EVMAP3 - - 0x00bc - 0x00 - 32 - - - cr_evmap3 - 31 - [31:0] - 0 - - - - - - SFR_DMAREQ_MAP_CR_EVMAP4 - - 0x00c0 - 0x00 - 32 - - - cr_evmap4 - 31 - [31:0] - 0 - - - - - - SFR_DMAREQ_MAP_CR_EVMAP5 - - 0x00c4 - 0x00 - 32 - - - cr_evmap5 - 31 - [31:0] - 0 - - - - - - SFR_DMAREQ_STAT_SR_EVSTAT0 - - 0x00c8 - 0x00 - 32 - - - sr_evstat0 - 31 - [31:0] - 0 - - - - - - SFR_DMAREQ_STAT_SR_EVSTAT1 - - 0x00cc - 0x00 - 32 - - - sr_evstat1 - 31 - [31:0] - 0 - - - - - - SFR_DMAREQ_STAT_SR_EVSTAT2 - - 0x00d0 - 0x00 - 32 - - - sr_evstat2 - 31 - [31:0] - 0 - - - - - - SFR_DMAREQ_STAT_SR_EVSTAT3 - - 0x00d4 - 0x00 - 32 - - - sr_evstat3 - 31 - [31:0] - 0 - - - - - - SFR_DMAREQ_STAT_SR_EVSTAT4 - - 0x00d8 - 0x00 - 32 - - - sr_evstat4 - 31 - [31:0] - 0 - - - - - - SFR_DMAREQ_STAT_SR_EVSTAT5 - - 0x00dc - 0x00 - 32 - - - sr_evstat5 - 31 - [31:0] - 0 - - - - - - SFR_FILTER_BASE_0 - - 0x00e0 - 0x00 - 32 - - - filter_base - 19 - [19:0] - 0 - - - - - - SFR_FILTER_BOUNDS_0 - - 0x00e4 - 0x00 - 32 - - - filter_bounds - 19 - [19:0] - 0 - - - - - - SFR_FILTER_BASE_1 - - 0x00e8 - 0x00 - 32 - - - filter_base - 19 - [19:0] - 0 - - - - - - SFR_FILTER_BOUNDS_1 - - 0x00ec - 0x00 - 32 - - - filter_bounds - 19 - [19:0] - 0 - - - - - - SFR_FILTER_BASE_2 - - 0x00f0 - 0x00 - 32 - - - filter_base - 19 - [19:0] - 0 - - - - - - SFR_FILTER_BOUNDS_2 - - 0x00f4 - 0x00 - 32 - - - filter_bounds - 19 - [19:0] - 0 - - - - - - SFR_FILTER_BASE_3 - - 0x00f8 - 0x00 - 32 - - - filter_base - 19 - [19:0] - 0 - - - - - - SFR_FILTER_BOUNDS_3 - - 0x00fc - 0x00 - 32 - - - filter_bounds - 19 - [19:0] - 0 - - - - - - - 0 - 0x100 - registers - - - - CORESUB_SRAMTRM - 0x40014000 - CORESUB_SRAMTRM - - - SFR_CACHE - - 0x0000 - 0x00 - 32 - - - sfr_cache - 2 - [2:0] - 0 - - - - - - SFR_ITCM - - 0x0004 - 0x00 - 32 - - - sfr_itcm - 4 - [4:0] - 0 - - - - - - SFR_DTCM - - 0x0008 - 0x00 - 32 - - - sfr_dtcm - 4 - [4:0] - 0 - - - - - - SFR_SRAM0 - - 0x000c - 0x00 - 32 - - - sfr_sram0 - 4 - [4:0] - 0 - - - - - - SFR_SRAM1 - - 0x0010 - 0x00 - 32 - - - sfr_sram1 - 4 - [4:0] - 0 - - - - - - SFR_VEXRAM - - 0x0014 - 0x00 - 32 - - - sfr_vexram - 2 - [2:0] - 0 - - - - - - SFR_SRAMERR - - 0x0020 - 0x00 - 32 - - - srambankerr - 3 - [3:0] - 0 - - - - - - - 0 - 0x24 - registers - - - - MDMA - 0x40012000 - MDMA - - - SFR_EVSEL_CR_EVSEL0 - - 0x0000 - 0x00 - 32 - - - cr_evsel0 - 7 - [7:0] - 0 - - - - - - SFR_EVSEL_CR_EVSEL1 - - 0x0004 - 0x00 - 32 - - - cr_evsel1 - 7 - [7:0] - 0 - - - - - - SFR_EVSEL_CR_EVSEL2 - - 0x0008 - 0x00 - 32 - - - cr_evsel2 - 7 - [7:0] - 0 - - - - - - SFR_EVSEL_CR_EVSEL3 - - 0x000c - 0x00 - 32 - - - cr_evsel3 - 7 - [7:0] - 0 - - - - - - SFR_EVSEL_CR_EVSEL4 - - 0x0010 - 0x00 - 32 - - - cr_evsel4 - 7 - [7:0] - 0 - - - - - - SFR_EVSEL_CR_EVSEL5 - - 0x0014 - 0x00 - 32 - - - cr_evsel5 - 7 - [7:0] - 0 - - - - - - SFR_EVSEL_CR_EVSEL6 - - 0x0018 - 0x00 - 32 - - - cr_evsel6 - 7 - [7:0] - 0 - - - - - - SFR_EVSEL_CR_EVSEL7 - - 0x001c - 0x00 - 32 - - - cr_evsel7 - 7 - [7:0] - 0 - - - - - - SFR_CR_CR_MDMAREQ0 - - 0x0020 - 0x00 - 32 - - - cr_mdmareq0 - 4 - [4:0] - 0 - - - - - - SFR_CR_CR_MDMAREQ1 - - 0x0024 - 0x00 - 32 - - - cr_mdmareq1 - 4 - [4:0] - 0 - - - - - - SFR_CR_CR_MDMAREQ2 - - 0x0028 - 0x00 - 32 - - - cr_mdmareq2 - 4 - [4:0] - 0 - - - - - - SFR_CR_CR_MDMAREQ3 - - 0x002c - 0x00 - 32 - - - cr_mdmareq3 - 4 - [4:0] - 0 - - - - - - SFR_CR_CR_MDMAREQ4 - - 0x0030 - 0x00 - 32 - - - cr_mdmareq4 - 4 - [4:0] - 0 - - - - - - SFR_CR_CR_MDMAREQ5 - - 0x0034 - 0x00 - 32 - - - cr_mdmareq5 - 4 - [4:0] - 0 - - - - - - SFR_CR_CR_MDMAREQ6 - - 0x0038 - 0x00 - 32 - - - cr_mdmareq6 - 4 - [4:0] - 0 - - - - - - SFR_CR_CR_MDMAREQ7 - - 0x003c - 0x00 - 32 - - - cr_mdmareq7 - 4 - [4:0] - 0 - - - - - - SFR_SR_SR_MDMAREQ0 - - 0x0040 - 0x00 - 32 - - - sr_mdmareq0 - 4 - [4:0] - 0 - - - - - - SFR_SR_SR_MDMAREQ1 - - 0x0044 - 0x00 - 32 - - - sr_mdmareq1 - 4 - [4:0] - 0 - - - - - - SFR_SR_SR_MDMAREQ2 - - 0x0048 - 0x00 - 32 - - - sr_mdmareq2 - 4 - [4:0] - 0 - - - - - - SFR_SR_SR_MDMAREQ3 - - 0x004c - 0x00 - 32 - - - sr_mdmareq3 - 4 - [4:0] - 0 - - - - - - SFR_SR_SR_MDMAREQ4 - - 0x0050 - 0x00 - 32 - - - sr_mdmareq4 - 4 - [4:0] - 0 - - - - - - SFR_SR_SR_MDMAREQ5 - - 0x0054 - 0x00 - 32 - - - sr_mdmareq5 - 4 - [4:0] - 0 - - - - - - SFR_SR_SR_MDMAREQ6 - - 0x0058 - 0x00 - 32 - - - sr_mdmareq6 - 4 - [4:0] - 0 - - - - - - SFR_SR_SR_MDMAREQ7 - - 0x005c - 0x00 - 32 - - - sr_mdmareq7 - 4 - [4:0] - 0 - - - - - - - 0 - 0x60 - registers - - - - QFC - 0x40010000 - QFC - - - SFR_IO - - 0x0000 - 0x00 - 32 - - - sfr_io - 7 - [7:0] - 0 - - - - - - SFR_AR - - 0x0004 - 0x00 - 32 - - - sfr_ar - 31 - [31:0] - 0 - - - - - - SFR_IODRV - - 0x0008 - 0x00 - 32 - - - paddrvsel - 11 - [11:0] - 0 - - - - - - CR_XIP_ADDRMODE - - 0x0010 - 0x00 - 32 - - - cr_xip_addrmode - 1 - [1:0] - 0 - - - - - - CR_XIP_OPCODE - - 0x0014 - 0x00 - 32 - - - cr_xip_opcode - 31 - [31:0] - 0 - - - - - - CR_XIP_WIDTH - - 0x0018 - 0x00 - 32 - - - cr_xip_width - 5 - [5:0] - 0 - - - - - - CR_XIP_SSEL - - 0x001c - 0x00 - 32 - - - cr_xip_ssel - 6 - [6:0] - 0 - - - - - - CR_XIP_DUMCYC - - 0x0020 - 0x00 - 32 - - - cr_xip_dumcyc - 15 - [15:0] - 0 - - - - - - CR_XIP_CFG - - 0x0024 - 0x00 - 32 - - - cr_xip_cfg - 13 - [13:0] - 0 - - - - - - CR_AESKEY_AESKEYIN0 - - 0x0040 - 0x00 - 32 - - - aeskeyin0 - 31 - [31:0] - 0 - - - - - - CR_AESKEY_AESKEYIN1 - - 0x0044 - 0x00 - 32 - - - aeskeyin1 - 31 - [31:0] - 0 - - - - - - CR_AESKEY_AESKEYIN2 - - 0x0048 - 0x00 - 32 - - - aeskeyin2 - 31 - [31:0] - 0 - - - - - - CR_AESKEY_AESKEYIN3 - - 0x004c - 0x00 - 32 - - - aeskeyin3 - 31 - [31:0] - 0 - - - - - - CR_AESENA - - 0x0050 - 0x00 - 32 - - - cr_aesena - 0 - [0:0] - 0 - - - - - - - 0 - 0x54 - registers - - - - MBOX_APB - 0x40013000 - MBOX_APB - - - SFR_WDATA - - 0x0000 - 0x00 - 32 - - - sfr_wdata - 31 - [31:0] - 0 - - - - - - SFR_RDATA - - 0x0004 - 0x00 - 32 - - - sfr_rdata - 31 - [31:0] - 0 - - - - - - SFR_STATUS - - 0x0008 - 0x00 - 32 - - - rx_avail - 0 - [0:0] - 0 - - - - tx_free - 1 - [1:1] - 1 - - - - abort_in_progress - 2 - [2:2] - 2 - - - - abort_ack - 3 - [3:3] - 3 - - - - tx_err - 4 - [4:4] - 4 - - - - rx_err - 5 - [5:5] - 5 - - - - - - SFR_ABORT - - 0x0018 - 0x00 - 32 - - - sfr_abort - 31 - [31:0] - 0 - - - - - - SFR_DONE - - 0x001c - 0x00 - 32 - - - sfr_done - 31 - [31:0] - 0 - - - - - - - 0 - 0x20 - registers - - - - GLUECHAIN - 0x40054000 - GLUECHAIN - - - SFR_GCMASK - - 0x0000 - 0x00 - 32 - - - cr_gcmask - 31 - [31:0] - 0 - - - - - - SFR_GCSR - - 0x0004 - 0x00 - 32 - - - gluereg - 31 - [31:0] - 0 - - - - - - SFR_GCRST - - 0x0008 - 0x00 - 32 - - - gluerst - 31 - [31:0] - 0 - - - - - - SFR_GCTEST - - 0x000c - 0x00 - 32 - - - gluetest - 31 - [31:0] - 0 - - - - - - - 0 - 0x10 + 0x14 registers @@ -16235,7 +13381,7 @@ soc/candidate/mbox_v0.1.sv]]> SFR_FLEVEL - + 0x000c 0x00 32 @@ -16272,7 +13418,7 @@ soc/candidate/mbox_v0.1.sv]]> SFR_TXF0 - + 0x0010 0x00 32 @@ -16288,7 +13434,7 @@ soc/candidate/mbox_v0.1.sv]]> SFR_RXF0 - + 0x0020 0x00 32 @@ -16304,7 +13450,7 @@ soc/candidate/mbox_v0.1.sv]]> SFR_EVENT_SET - + 0x0038 0x00 32 @@ -16320,7 +13466,7 @@ soc/candidate/mbox_v0.1.sv]]> SFR_EVENT_CLR - + 0x003c 0x00 32 @@ -16336,7 +13482,7 @@ soc/candidate/mbox_v0.1.sv]]> SFR_EVENT_STATUS - + 0x0040 0x00 32 @@ -16364,7 +13510,7 @@ soc/candidate/mbox_v0.1.sv]]> SFR_FLEVEL - + 0x000c 0x00 32 @@ -16401,7 +13547,7 @@ soc/candidate/mbox_v0.1.sv]]> SFR_TXF1 - + 0x0014 0x00 32 @@ -16417,7 +13563,7 @@ soc/candidate/mbox_v0.1.sv]]> SFR_RXF1 - + 0x0024 0x00 32 @@ -16433,7 +13579,7 @@ soc/candidate/mbox_v0.1.sv]]> SFR_EVENT_SET - + 0x0038 0x00 32 @@ -16449,7 +13595,7 @@ soc/candidate/mbox_v0.1.sv]]> SFR_EVENT_CLR - + 0x003c 0x00 32 @@ -16465,7 +13611,7 @@ soc/candidate/mbox_v0.1.sv]]> SFR_EVENT_STATUS - + 0x0040 0x00 32 @@ -16493,7 +13639,7 @@ soc/candidate/mbox_v0.1.sv]]> SFR_FLEVEL - + 0x000c 0x00 32 @@ -16530,7 +13676,7 @@ soc/candidate/mbox_v0.1.sv]]> SFR_TXF2 - + 0x0018 0x00 32 @@ -16546,7 +13692,7 @@ soc/candidate/mbox_v0.1.sv]]> SFR_RXF2 - + 0x0028 0x00 32 @@ -16562,7 +13708,7 @@ soc/candidate/mbox_v0.1.sv]]> SFR_EVENT_SET - + 0x0038 0x00 32 @@ -16578,7 +13724,7 @@ soc/candidate/mbox_v0.1.sv]]> SFR_EVENT_CLR - + 0x003c 0x00 32 @@ -16594,7 +13740,7 @@ soc/candidate/mbox_v0.1.sv]]> SFR_EVENT_STATUS - + 0x0040 0x00 32 @@ -16622,7 +13768,7 @@ soc/candidate/mbox_v0.1.sv]]> SFR_FLEVEL - + 0x000c 0x00 32 @@ -16659,7 +13805,7 @@ soc/candidate/mbox_v0.1.sv]]> SFR_TXF3 - + 0x001c 0x00 32 @@ -16675,7 +13821,7 @@ soc/candidate/mbox_v0.1.sv]]> SFR_RXF3 - + 0x002c 0x00 32 @@ -16691,7 +13837,7 @@ soc/candidate/mbox_v0.1.sv]]> SFR_EVENT_SET - + 0x0038 0x00 32 @@ -16707,7 +13853,7 @@ soc/candidate/mbox_v0.1.sv]]> SFR_EVENT_CLR - + 0x003c 0x00 32 @@ -16723,7 +13869,7 @@ soc/candidate/mbox_v0.1.sv]]> SFR_EVENT_STATUS - + 0x0040 0x00 32 @@ -17257,51 +14403,51 @@ soc/candidate/mbox_v0.1.sv]]> SEG_PKB 0x40020800 - 0x00000200 + 0x00000400 SEG_PIB - 0x40020A00 + 0x40020C00 0x00000400 SEG_PSIB - 0x40020E00 + 0x40021000 0x00000400 SEG_POB - 0x40021200 + 0x40021400 0x00000400 SEG_PSOB - 0x40021600 + 0x40021800 0x00000400 SEG_AKEY - 0x40021A00 - 0x00000100 - - - SEG_AIB - 0x40021B00 - 0x00000100 - - - SEG_AOB 0x40021C00 0x00000100 - SEG_RNGA + SEG_AIB 0x40021D00 + 0x00000100 + + + SEG_AOB + 0x40021E00 + 0x00000100 + + + SEG_RNGA + 0x40021F00 0x00000400 SEG_RNGB - 0x40022100 + 0x40022300 0x00000400 diff --git a/utralib/cramium/soc.svd b/utralib/cramium/soc.svd index b56a90a1d..3612be918 100644 --- a/utralib/cramium/soc.svd +++ b/utralib/cramium/soc.svd @@ -3,7 +3,7 @@ litex SOC - + 8 32 diff --git a/utralib/src/generated/cramium_soc.rs b/utralib/src/generated/cramium_soc.rs index 25930dd79..e9a1402be 100644 --- a/utralib/src/generated/cramium_soc.rs +++ b/utralib/src/generated/cramium_soc.rs @@ -277,24 +277,24 @@ pub const HW_SEG_SOB_MEM_LEN: usize = 256; pub const HW_SEG_PCON_MEM: usize = 0x40020800; pub const HW_SEG_PCON_MEM_LEN: usize = 0; pub const HW_SEG_PKB_MEM: usize = 0x40020800; -pub const HW_SEG_PKB_MEM_LEN: usize = 512; -pub const HW_SEG_PIB_MEM: usize = 0x40020a00; +pub const HW_SEG_PKB_MEM_LEN: usize = 1024; +pub const HW_SEG_PIB_MEM: usize = 0x40020c00; pub const HW_SEG_PIB_MEM_LEN: usize = 1024; -pub const HW_SEG_PSIB_MEM: usize = 0x40020e00; +pub const HW_SEG_PSIB_MEM: usize = 0x40021000; pub const HW_SEG_PSIB_MEM_LEN: usize = 1024; -pub const HW_SEG_POB_MEM: usize = 0x40021200; +pub const HW_SEG_POB_MEM: usize = 0x40021400; pub const HW_SEG_POB_MEM_LEN: usize = 1024; -pub const HW_SEG_PSOB_MEM: usize = 0x40021600; +pub const HW_SEG_PSOB_MEM: usize = 0x40021800; pub const HW_SEG_PSOB_MEM_LEN: usize = 1024; -pub const HW_SEG_AKEY_MEM: usize = 0x40021a00; +pub const HW_SEG_AKEY_MEM: usize = 0x40021c00; pub const HW_SEG_AKEY_MEM_LEN: usize = 256; -pub const HW_SEG_AIB_MEM: usize = 0x40021b00; +pub const HW_SEG_AIB_MEM: usize = 0x40021d00; pub const HW_SEG_AIB_MEM_LEN: usize = 256; -pub const HW_SEG_AOB_MEM: usize = 0x40021c00; +pub const HW_SEG_AOB_MEM: usize = 0x40021e00; pub const HW_SEG_AOB_MEM_LEN: usize = 256; -pub const HW_SEG_RNGA_MEM: usize = 0x40021d00; +pub const HW_SEG_RNGA_MEM: usize = 0x40021f00; pub const HW_SEG_RNGA_MEM_LEN: usize = 1024; -pub const HW_SEG_RNGB_MEM: usize = 0x40022100; +pub const HW_SEG_RNGB_MEM: usize = 0x40022300; pub const HW_SEG_RNGB_MEM_LEN: usize = 1024; pub const HW_IFRAM0_MEM: usize = 0x50000000; pub const HW_IFRAM0_MEM_LEN: usize = 131072; @@ -346,7 +346,6 @@ pub const HW_BIO_FIFO3_MEM_LEN: usize = 4096; // Physical base addresses of registers pub const HW_D11CTIME_BASE : usize = 0xe0000000; pub const HW_SUSRES_BASE : usize = 0xe0001000; -pub const HW_COREUSER_BASE : usize = 0xe0002000; pub const HW_CSRTEST_BASE : usize = 0xe0003000; pub const HW_IRQARRAY0_BASE : usize = 0xe0004000; pub const HW_IRQARRAY1_BASE : usize = 0xe0005000; @@ -374,6 +373,28 @@ pub const HW_RESETVALUE_BASE : usize = 0xe001a000; pub const HW_TICKTIMER_BASE : usize = 0xe001b000; pub const HW_TIMER0_BASE : usize = 0xe001c000; pub const HW_PL230_BASE : usize = 0x40011000; +pub const HW_ALU_BASE : usize = 0x4002f000; +pub const HW_AES_BASE : usize = 0x4002d000; +pub const HW_COMBOHASH_BASE : usize = 0x4002b000; +pub const HW_PKE_BASE : usize = 0x4002c000; +pub const HW_TRNG_BASE : usize = 0x4002e000; +pub const HW_SCEDMA_BASE : usize = 0x40029000; +pub const HW_SCE_GLBSFR_BASE : usize = 0x40028000; +pub const HW_DUART_BASE : usize = 0x40042000; +pub const HW_RBIST_WRP_BASE : usize = 0x40045000; +pub const HW_WDG_INTF_BASE : usize = 0x40041000; +pub const HW_TIMER_INTF_BASE : usize = 0x40043000; +pub const HW_EVC_BASE : usize = 0x40044000; +pub const HW_SYSCTRL_BASE : usize = 0x40040000; +pub const HW_APB_THRU_BASE : usize = 0x50122000; +pub const HW_BIO_BDMA_BASE : usize = 0x50124000; +pub const HW_IOX_BASE : usize = 0x5012f000; +pub const HW_PWM_BASE : usize = 0x50120000; +pub const HW_CORESUB_SRAMTRM_BASE : usize = 0x40014000; +pub const HW_MDMA_BASE : usize = 0x40012000; +pub const HW_QFC_BASE : usize = 0x40010000; +pub const HW_MBOX_APB_BASE : usize = 0x40013000; +pub const HW_GLUECHAIN_BASE : usize = 0x40054000; pub const HW_UDMA_CTRL_BASE : usize = 0x50100000; pub const HW_UDMA_UART_0_BASE : usize = 0x50101000; pub const HW_UDMA_UART_1_BASE : usize = 0x50102000; @@ -387,37 +408,14 @@ pub const HW_UDMA_I2C_0_BASE : usize = 0x50109000; pub const HW_UDMA_I2C_1_BASE : usize = 0x5010a000; pub const HW_UDMA_I2C_2_BASE : usize = 0x5010b000; pub const HW_UDMA_I2C_3_BASE : usize = 0x5010c000; -pub const HW_UDMA_I2S_0_BASE : usize = 0x5010d000; -pub const HW_UDMA_I2S_1_BASE : usize = 0x5010e000; +pub const HW_UDMA_SDIO_BASE : usize = 0x5010d000; +pub const HW_UDMA_I2S_BASE : usize = 0x5010e000; pub const HW_UDMA_CAMERA_BASE : usize = 0x5010f000; pub const HW_UDMA_FILTER_BASE : usize = 0x50110000; pub const HW_UDMA_SCIF_BASE : usize = 0x50111000; pub const HW_UDMA_SPIS_0_BASE : usize = 0x50112000; pub const HW_UDMA_SPIS_1_BASE : usize = 0x50113000; pub const HW_UDMA_ADC_BASE : usize = 0x50114000; -pub const HW_AES_BASE : usize = 0x4002d000; -pub const HW_COMBOHASH_BASE : usize = 0x4002b000; -pub const HW_PKE_BASE : usize = 0x4002c000; -pub const HW_SCEDMA_BASE : usize = 0x40029000; -pub const HW_SCE_GLBSFR_BASE : usize = 0x40028000; -pub const HW_TRNG_BASE : usize = 0x4002e000; -pub const HW_ALU_BASE : usize = 0x4002f000; -pub const HW_DUART_BASE : usize = 0x40042000; -pub const HW_WDG_INTF_BASE : usize = 0x40041000; -pub const HW_TIMER_INTF_BASE : usize = 0x40043000; -pub const HW_EVC_BASE : usize = 0x40044000; -pub const HW_SYSCTRL_BASE : usize = 0x40040000; -pub const HW_APB_THRU_BASE : usize = 0x50122000; -pub const HW_IOX_BASE : usize = 0x5012f000; -pub const HW_PWM_BASE : usize = 0x50120000; -pub const HW_SDDC_BASE : usize = 0x50121000; -pub const HW_RP_PIO_BASE : usize = 0x50123000; -pub const HW_BIO_BDMA_BASE : usize = 0x50124000; -pub const HW_CORESUB_SRAMTRM_BASE : usize = 0x40014000; -pub const HW_MDMA_BASE : usize = 0x40012000; -pub const HW_QFC_BASE : usize = 0x40010000; -pub const HW_MBOX_APB_BASE : usize = 0x40013000; -pub const HW_GLUECHAIN_BASE : usize = 0x40054000; pub const HW_BIO_FIFO0_BASE : usize = 0x50129000; pub const HW_BIO_FIFO1_BASE : usize = 0x5012a000; pub const HW_BIO_FIFO2_BASE : usize = 0x5012b000; @@ -480,47 +478,6 @@ pub mod utra { pub const HW_SUSRES_BASE: usize = 0xe0001000; } - pub mod coreuser { - pub const COREUSER_NUMREGS: usize = 10; - - pub const SET_ASID: crate::Register = crate::Register::new(0, 0x3ff); - pub const SET_ASID_ASID: crate::Field = crate::Field::new(9, 0, SET_ASID); - pub const SET_ASID_TRUSTED: crate::Field = crate::Field::new(1, 9, SET_ASID); - - pub const GET_ASID_ADDR: crate::Register = crate::Register::new(1, 0x1ff); - pub const GET_ASID_ADDR_ASID: crate::Field = crate::Field::new(9, 0, GET_ASID_ADDR); - - pub const GET_ASID_VALUE: crate::Register = crate::Register::new(2, 0x1); - pub const GET_ASID_VALUE_VALUE: crate::Field = crate::Field::new(1, 0, GET_ASID_VALUE); - - pub const SET_PRIVILEGE: crate::Register = crate::Register::new(3, 0x3); - pub const SET_PRIVILEGE_MPP: crate::Field = crate::Field::new(2, 0, SET_PRIVILEGE); - - pub const CONTROL: crate::Register = crate::Register::new(4, 0x1f); - pub const CONTROL_ENABLE: crate::Field = crate::Field::new(1, 0, CONTROL); - pub const CONTROL_ASID: crate::Field = crate::Field::new(1, 1, CONTROL); - pub const CONTROL_PPN_A: crate::Field = crate::Field::new(1, 2, CONTROL); - pub const CONTROL_PPN_B: crate::Field = crate::Field::new(1, 3, CONTROL); - pub const CONTROL_PRIVILEGE: crate::Field = crate::Field::new(1, 4, CONTROL); - - pub const PROTECT: crate::Register = crate::Register::new(5, 0x1); - pub const PROTECT_PROTECT: crate::Field = crate::Field::new(1, 0, PROTECT); - - pub const WINDOW_AL: crate::Register = crate::Register::new(6, 0x3fffff); - pub const WINDOW_AL_PPN: crate::Field = crate::Field::new(22, 0, WINDOW_AL); - - pub const WINDOW_AH: crate::Register = crate::Register::new(7, 0x3fffff); - pub const WINDOW_AH_PPN: crate::Field = crate::Field::new(22, 0, WINDOW_AH); - - pub const WINDOW_BL: crate::Register = crate::Register::new(8, 0x3fffff); - pub const WINDOW_BL_PPN: crate::Field = crate::Field::new(22, 0, WINDOW_BL); - - pub const WINDOW_BH: crate::Register = crate::Register::new(9, 0x3fffff); - pub const WINDOW_BH_PPN: crate::Field = crate::Field::new(22, 0, WINDOW_BH); - - pub const HW_COREUSER_BASE: usize = 0xe0002000; - } - pub mod csrtest { pub const CSRTEST_NUMREGS: usize = 2; @@ -2173,6 +2130,1445 @@ pub mod utra { pub const HW_PL230_BASE: usize = 0x40011000; } + pub mod alu { + pub const ALU_NUMREGS: usize = 12; + + pub const SFR_CRFUNC: crate::Register = crate::Register::new(0, 0xff); + pub const SFR_CRFUNC_SFR_CRFUNC: crate::Field = crate::Field::new(8, 0, SFR_CRFUNC); + + pub const SFR_AR: crate::Register = crate::Register::new(1, 0xffffffff); + pub const SFR_AR_SFR_AR: crate::Field = crate::Field::new(32, 0, SFR_AR); + + pub const SFR_SRMFSM: crate::Register = crate::Register::new(2, 0x1ff); + pub const SFR_SRMFSM_MFSM: crate::Field = crate::Field::new(8, 0, SFR_SRMFSM); + pub const SFR_SRMFSM_CRREG: crate::Field = crate::Field::new(1, 8, SFR_SRMFSM); + + pub const SFR_FR: crate::Register = crate::Register::new(3, 0x1f); + pub const SFR_FR_MFSM_DONE: crate::Field = crate::Field::new(1, 0, SFR_FR); + pub const SFR_FR_DIV_DONE: crate::Field = crate::Field::new(1, 1, SFR_FR); + pub const SFR_FR_CHNLO_DONE: crate::Field = crate::Field::new(1, 2, SFR_FR); + pub const SFR_FR_CHNLI_DONE: crate::Field = crate::Field::new(1, 3, SFR_FR); + pub const SFR_FR_QS0ERR: crate::Field = crate::Field::new(1, 4, SFR_FR); + + pub const SFR_CRDIVLEN: crate::Register = crate::Register::new(4, 0xffff); + pub const SFR_CRDIVLEN_SFR_CRDIVLEN: crate::Field = crate::Field::new(16, 0, SFR_CRDIVLEN); + + pub const SFR_SRDIVLEN: crate::Register = crate::Register::new(5, 0xffff); + pub const SFR_SRDIVLEN_SFR_SRDIVLEN: crate::Field = crate::Field::new(16, 0, SFR_SRDIVLEN); + + pub const SFR_OPT: crate::Register = crate::Register::new(6, 0xffffffff); + pub const SFR_OPT_SFR_OPT: crate::Field = crate::Field::new(32, 0, SFR_OPT); + + pub const SFR_OPTLTX: crate::Register = crate::Register::new(7, 0xff); + pub const SFR_OPTLTX_SFR_OPTLTX: crate::Field = crate::Field::new(8, 0, SFR_OPTLTX); + + pub const SFR_SEGPTR_CR_SEGCFG0: crate::Register = crate::Register::new(12, 0xfffff); + pub const SFR_SEGPTR_CR_SEGCFG0_CR_SEGCFG0: crate::Field = crate::Field::new(20, 0, SFR_SEGPTR_CR_SEGCFG0); + + pub const SFR_SEGPTR_CR_SEGCFG1: crate::Register = crate::Register::new(13, 0xfffff); + pub const SFR_SEGPTR_CR_SEGCFG1_CR_SEGCFG1: crate::Field = crate::Field::new(20, 0, SFR_SEGPTR_CR_SEGCFG1); + + pub const SFR_SEGPTR_CR_SEGCFG2: crate::Register = crate::Register::new(14, 0xfffff); + pub const SFR_SEGPTR_CR_SEGCFG2_CR_SEGCFG2: crate::Field = crate::Field::new(20, 0, SFR_SEGPTR_CR_SEGCFG2); + + pub const SFR_SEGPTR_CR_SEGCFG3: crate::Register = crate::Register::new(15, 0xfffff); + pub const SFR_SEGPTR_CR_SEGCFG3_CR_SEGCFG3: crate::Field = crate::Field::new(20, 0, SFR_SEGPTR_CR_SEGCFG3); + + pub const HW_ALU_BASE: usize = 0x4002f000; + } + + pub mod aes { + pub const AES_NUMREGS: usize = 13; + + pub const SFR_CRFUNC: crate::Register = crate::Register::new(0, 0xff); + pub const SFR_CRFUNC_SFR_CRFUNC: crate::Field = crate::Field::new(8, 0, SFR_CRFUNC); + + pub const SFR_AR: crate::Register = crate::Register::new(1, 0xffffffff); + pub const SFR_AR_SFR_AR: crate::Field = crate::Field::new(32, 0, SFR_AR); + + pub const SFR_SRMFSM: crate::Register = crate::Register::new(2, 0xff); + pub const SFR_SRMFSM_SFR_SRMFSM: crate::Field = crate::Field::new(8, 0, SFR_SRMFSM); + + pub const SFR_FR: crate::Register = crate::Register::new(3, 0xf); + pub const SFR_FR_MFSM_DONE: crate::Field = crate::Field::new(1, 0, SFR_FR); + pub const SFR_FR_ACORE_DONE: crate::Field = crate::Field::new(1, 1, SFR_FR); + pub const SFR_FR_CHNLO_DONE: crate::Field = crate::Field::new(1, 2, SFR_FR); + pub const SFR_FR_CHNLI_DONE: crate::Field = crate::Field::new(1, 3, SFR_FR); + + pub const SFR_OPT: crate::Register = crate::Register::new(4, 0x1ff); + pub const SFR_OPT_OPT_KLEN0: crate::Field = crate::Field::new(4, 0, SFR_OPT); + pub const SFR_OPT_OPT_MODE0: crate::Field = crate::Field::new(4, 4, SFR_OPT); + pub const SFR_OPT_OPT_IFSTART0: crate::Field = crate::Field::new(1, 8, SFR_OPT); + + pub const SFR_OPT1: crate::Register = crate::Register::new(5, 0xffff); + pub const SFR_OPT1_SFR_OPT1: crate::Field = crate::Field::new(16, 0, SFR_OPT1); + + pub const SFR_OPTLTX: crate::Register = crate::Register::new(6, 0x3f); + pub const SFR_OPTLTX_SFR_OPTLTX: crate::Field = crate::Field::new(6, 0, SFR_OPTLTX); + + pub const SFR_MASKSEED: crate::Register = crate::Register::new(8, 0xffffffff); + pub const SFR_MASKSEED_SFR_MASKSEED: crate::Field = crate::Field::new(32, 0, SFR_MASKSEED); + + pub const SFR_MASKSEEDAR: crate::Register = crate::Register::new(9, 0xffffffff); + pub const SFR_MASKSEEDAR_SFR_MASKSEEDAR: crate::Field = crate::Field::new(32, 0, SFR_MASKSEEDAR); + + pub const SFR_SEGPTR_PTRID_IV: crate::Register = crate::Register::new(12, 0xfff); + pub const SFR_SEGPTR_PTRID_IV_PTRID_IV: crate::Field = crate::Field::new(12, 0, SFR_SEGPTR_PTRID_IV); + + pub const SFR_SEGPTR_PTRID_AKEY: crate::Register = crate::Register::new(13, 0xfff); + pub const SFR_SEGPTR_PTRID_AKEY_PTRID_AKEY: crate::Field = crate::Field::new(12, 0, SFR_SEGPTR_PTRID_AKEY); + + pub const SFR_SEGPTR_PTRID_AIB: crate::Register = crate::Register::new(14, 0xfff); + pub const SFR_SEGPTR_PTRID_AIB_PTRID_AIB: crate::Field = crate::Field::new(12, 0, SFR_SEGPTR_PTRID_AIB); + + pub const SFR_SEGPTR_PTRID_AOB: crate::Register = crate::Register::new(15, 0xfff); + pub const SFR_SEGPTR_PTRID_AOB_PTRID_AOB: crate::Field = crate::Field::new(12, 0, SFR_SEGPTR_PTRID_AOB); + + pub const HW_AES_BASE: usize = 0x4002d000; + } + + pub mod combohash { + pub const COMBOHASH_NUMREGS: usize = 14; + + pub const SFR_CRFUNC: crate::Register = crate::Register::new(0, 0xff); + pub const SFR_CRFUNC_CR_FUNC: crate::Field = crate::Field::new(8, 0, SFR_CRFUNC); + + pub const SFR_AR: crate::Register = crate::Register::new(1, 0xffffffff); + pub const SFR_AR_SFR_AR: crate::Field = crate::Field::new(32, 0, SFR_AR); + + pub const SFR_SRMFSM: crate::Register = crate::Register::new(2, 0xff); + pub const SFR_SRMFSM_MFSM: crate::Field = crate::Field::new(8, 0, SFR_SRMFSM); + + pub const SFR_FR: crate::Register = crate::Register::new(3, 0x3f); + pub const SFR_FR_MFSM_DONE: crate::Field = crate::Field::new(1, 0, SFR_FR); + pub const SFR_FR_HASH_DONE: crate::Field = crate::Field::new(1, 1, SFR_FR); + pub const SFR_FR_CHNLO_DONE: crate::Field = crate::Field::new(1, 2, SFR_FR); + pub const SFR_FR_CHNLI_DONE: crate::Field = crate::Field::new(1, 3, SFR_FR); + pub const SFR_FR_CHKDONE: crate::Field = crate::Field::new(1, 4, SFR_FR); + pub const SFR_FR_CHKPASS: crate::Field = crate::Field::new(1, 5, SFR_FR); + + pub const SFR_OPT1: crate::Register = crate::Register::new(4, 0xffff); + pub const SFR_OPT1_CR_OPT_HASHCNT: crate::Field = crate::Field::new(16, 0, SFR_OPT1); + + pub const SFR_OPT2: crate::Register = crate::Register::new(5, 0xf); + pub const SFR_OPT2_CR_OPT_SCRTCHK: crate::Field = crate::Field::new(1, 0, SFR_OPT2); + pub const SFR_OPT2_CR_OPT_IFSOB: crate::Field = crate::Field::new(1, 1, SFR_OPT2); + pub const SFR_OPT2_CR_OPT_IFSTART: crate::Field = crate::Field::new(1, 2, SFR_OPT2); + pub const SFR_OPT2_OPT_SCHNR1_0: crate::Field = crate::Field::new(1, 3, SFR_OPT2); + + pub const SFR_OPT3: crate::Register = crate::Register::new(6, 0xff); + pub const SFR_OPT3_SFR_OPT3: crate::Field = crate::Field::new(8, 0, SFR_OPT3); + + pub const SFR_BLKT0: crate::Register = crate::Register::new(7, 0xff); + pub const SFR_BLKT0_SFR_BLKT0: crate::Field = crate::Field::new(8, 0, SFR_BLKT0); + + pub const SFR_SEGPTR_SEGID_LKEY: crate::Register = crate::Register::new(8, 0xfff); + pub const SFR_SEGPTR_SEGID_LKEY_SEGID_LKEY: crate::Field = crate::Field::new(12, 0, SFR_SEGPTR_SEGID_LKEY); + + pub const SFR_SEGPTR_SEGID_KEY: crate::Register = crate::Register::new(9, 0xfff); + pub const SFR_SEGPTR_SEGID_KEY_SEGID_KEY: crate::Field = crate::Field::new(12, 0, SFR_SEGPTR_SEGID_KEY); + + pub const SFR_SEGPTR_SEGID_SCRT: crate::Register = crate::Register::new(11, 0xfff); + pub const SFR_SEGPTR_SEGID_SCRT_SEGID_SCRT: crate::Field = crate::Field::new(12, 0, SFR_SEGPTR_SEGID_SCRT); + + pub const SFR_SEGPTR_SEGID_MSG: crate::Register = crate::Register::new(12, 0xfff); + pub const SFR_SEGPTR_SEGID_MSG_SEGID_MSG: crate::Field = crate::Field::new(12, 0, SFR_SEGPTR_SEGID_MSG); + + pub const SFR_SEGPTR_SEGID_HOUT: crate::Register = crate::Register::new(13, 0xfff); + pub const SFR_SEGPTR_SEGID_HOUT_SEGID_HOUT: crate::Field = crate::Field::new(12, 0, SFR_SEGPTR_SEGID_HOUT); + + pub const SFR_SEGPTR_SEGID_HOUT2: crate::Register = crate::Register::new(15, 0xfff); + pub const SFR_SEGPTR_SEGID_HOUT2_SEGID_HOUT2: crate::Field = crate::Field::new(12, 0, SFR_SEGPTR_SEGID_HOUT2); + + pub const HW_COMBOHASH_BASE: usize = 0x4002b000; + } + + pub mod pke { + pub const PKE_NUMREGS: usize = 15; + + pub const SFR_CRFUNC: crate::Register = crate::Register::new(0, 0xffff); + pub const SFR_CRFUNC_CR_FUNC: crate::Field = crate::Field::new(8, 0, SFR_CRFUNC); + pub const SFR_CRFUNC_CR_PCOREIR: crate::Field = crate::Field::new(8, 8, SFR_CRFUNC); + + pub const SFR_AR: crate::Register = crate::Register::new(1, 0xffffffff); + pub const SFR_AR_SFR_AR: crate::Field = crate::Field::new(32, 0, SFR_AR); + + pub const SFR_SRMFSM: crate::Register = crate::Register::new(2, 0x1ff); + pub const SFR_SRMFSM_MFSM: crate::Field = crate::Field::new(8, 0, SFR_SRMFSM); + pub const SFR_SRMFSM_MODINVREADY: crate::Field = crate::Field::new(1, 8, SFR_SRMFSM); + + pub const SFR_FR: crate::Register = crate::Register::new(3, 0x1f); + pub const SFR_FR_MFSM_DONE: crate::Field = crate::Field::new(1, 0, SFR_FR); + pub const SFR_FR_PCORE_DONE: crate::Field = crate::Field::new(1, 1, SFR_FR); + pub const SFR_FR_CHNLO_DONE: crate::Field = crate::Field::new(1, 2, SFR_FR); + pub const SFR_FR_CHNLI_DONE: crate::Field = crate::Field::new(1, 3, SFR_FR); + pub const SFR_FR_CHNLX_DONE: crate::Field = crate::Field::new(1, 4, SFR_FR); + + pub const SFR_OPTNW: crate::Register = crate::Register::new(4, 0x1fff); + pub const SFR_OPTNW_SFR_OPTNW: crate::Field = crate::Field::new(13, 0, SFR_OPTNW); + + pub const SFR_OPTEW: crate::Register = crate::Register::new(5, 0x1fff); + pub const SFR_OPTEW_SFR_OPTEW: crate::Field = crate::Field::new(13, 0, SFR_OPTEW); + + pub const SFR_OPTRW: crate::Register = crate::Register::new(6, 0x3ff); + pub const SFR_OPTRW_SFR_OPTRW: crate::Field = crate::Field::new(10, 0, SFR_OPTRW); + + pub const SFR_OPTLTX: crate::Register = crate::Register::new(7, 0x1f); + pub const SFR_OPTLTX_SFR_OPTLTX: crate::Field = crate::Field::new(5, 0, SFR_OPTLTX); + + pub const SFR_OPTMASK: crate::Register = crate::Register::new(8, 0xffff); + pub const SFR_OPTMASK_SFR_OPTMASK: crate::Field = crate::Field::new(16, 0, SFR_OPTMASK); + + pub const SFR_MIMMCR: crate::Register = crate::Register::new(9, 0x1ff); + pub const SFR_MIMMCR_SFR_MIMMCR: crate::Field = crate::Field::new(9, 0, SFR_MIMMCR); + + pub const SFR_SEGPTR_PTRID_PCON: crate::Register = crate::Register::new(12, 0xfff); + pub const SFR_SEGPTR_PTRID_PCON_PTRID_PCON: crate::Field = crate::Field::new(12, 0, SFR_SEGPTR_PTRID_PCON); + + pub const SFR_SEGPTR_PTRID_PIB0: crate::Register = crate::Register::new(13, 0xfff); + pub const SFR_SEGPTR_PTRID_PIB0_PTRID_PIB0: crate::Field = crate::Field::new(12, 0, SFR_SEGPTR_PTRID_PIB0); + + pub const SFR_SEGPTR_PTRID_PIB1: crate::Register = crate::Register::new(14, 0xfff); + pub const SFR_SEGPTR_PTRID_PIB1_PTRID_PIB1: crate::Field = crate::Field::new(12, 0, SFR_SEGPTR_PTRID_PIB1); + + pub const SFR_SEGPTR_PTRID_PKB: crate::Register = crate::Register::new(15, 0xfff); + pub const SFR_SEGPTR_PTRID_PKB_PTRID_PKB: crate::Field = crate::Field::new(12, 0, SFR_SEGPTR_PTRID_PKB); + + pub const SFR_SEGPTR_PTRID_POB: crate::Register = crate::Register::new(16, 0xfff); + pub const SFR_SEGPTR_PTRID_POB_PTRID_POB: crate::Field = crate::Field::new(12, 0, SFR_SEGPTR_PTRID_POB); + + pub const HW_PKE_BASE: usize = 0x4002c000; + } + + pub mod trng { + pub const TRNG_NUMREGS: usize = 13; + + pub const SFR_CRSRC: crate::Register = crate::Register::new(0, 0xfff); + pub const SFR_CRSRC_SFR_CRSRC: crate::Field = crate::Field::new(12, 0, SFR_CRSRC); + + pub const SFR_CRANA: crate::Register = crate::Register::new(1, 0xffff); + pub const SFR_CRANA_SFR_CRANA: crate::Field = crate::Field::new(16, 0, SFR_CRANA); + + pub const SFR_PP: crate::Register = crate::Register::new(2, 0x1ffff); + pub const SFR_PP_SFR_PP: crate::Field = crate::Field::new(17, 0, SFR_PP); + + pub const SFR_OPT: crate::Register = crate::Register::new(3, 0x1ffff); + pub const SFR_OPT_SFR_OPT: crate::Field = crate::Field::new(17, 0, SFR_OPT); + + pub const SFR_SR: crate::Register = crate::Register::new(4, 0xffffffff); + pub const SFR_SR_SR_RNG: crate::Field = crate::Field::new(32, 0, SFR_SR); + + pub const SFR_AR_GEN: crate::Register = crate::Register::new(5, 0xffffffff); + pub const SFR_AR_GEN_SFR_AR_GEN: crate::Field = crate::Field::new(32, 0, SFR_AR_GEN); + + pub const SFR_FR: crate::Register = crate::Register::new(6, 0x3); + pub const SFR_FR_SFR_FR: crate::Field = crate::Field::new(2, 0, SFR_FR); + + pub const SFR_DRPSZ: crate::Register = crate::Register::new(8, 0xffffffff); + pub const SFR_DRPSZ_SFR_DRPSZ: crate::Field = crate::Field::new(32, 0, SFR_DRPSZ); + + pub const SFR_DRGEN: crate::Register = crate::Register::new(9, 0xffffffff); + pub const SFR_DRGEN_SFR_DRGEN: crate::Field = crate::Field::new(32, 0, SFR_DRGEN); + + pub const SFR_DRRESEED: crate::Register = crate::Register::new(10, 0xffffffff); + pub const SFR_DRRESEED_SFR_DRRESEED: crate::Field = crate::Field::new(32, 0, SFR_DRRESEED); + + pub const SFR_BUF: crate::Register = crate::Register::new(12, 0xffffffff); + pub const SFR_BUF_SFR_BUF: crate::Field = crate::Field::new(32, 0, SFR_BUF); + + pub const SFR_CHAIN_RNGCHAINEN0: crate::Register = crate::Register::new(16, 0xffffffff); + pub const SFR_CHAIN_RNGCHAINEN0_RNGCHAINEN0: crate::Field = crate::Field::new(32, 0, SFR_CHAIN_RNGCHAINEN0); + + pub const SFR_CHAIN_RNGCHAINEN1: crate::Register = crate::Register::new(17, 0xffffffff); + pub const SFR_CHAIN_RNGCHAINEN1_RNGCHAINEN1: crate::Field = crate::Field::new(32, 0, SFR_CHAIN_RNGCHAINEN1); + + pub const HW_TRNG_BASE: usize = 0x4002e000; + } + + pub mod scedma { + pub const SCEDMA_NUMREGS: usize = 18; + + pub const SFR_SCHSTART_AR: crate::Register = crate::Register::new(0, 0xffffffff); + pub const SFR_SCHSTART_AR_SFR_SCHSTART_AR: crate::Field = crate::Field::new(32, 0, SFR_SCHSTART_AR); + + pub const SFR_XCH_FUNC: crate::Register = crate::Register::new(4, 0x1); + pub const SFR_XCH_FUNC_SFR_XCH_FUNC: crate::Field = crate::Field::new(1, 0, SFR_XCH_FUNC); + + pub const SFR_XCH_OPT: crate::Register = crate::Register::new(5, 0xff); + pub const SFR_XCH_OPT_SFR_XCH_OPT: crate::Field = crate::Field::new(8, 0, SFR_XCH_OPT); + + pub const SFR_XCH_AXSTART: crate::Register = crate::Register::new(6, 0xffffffff); + pub const SFR_XCH_AXSTART_SFR_XCH_AXSTART: crate::Field = crate::Field::new(32, 0, SFR_XCH_AXSTART); + + pub const SFR_XCH_SEGID: crate::Register = crate::Register::new(7, 0xff); + pub const SFR_XCH_SEGID_SFR_XCH_SEGID: crate::Field = crate::Field::new(8, 0, SFR_XCH_SEGID); + + pub const SFR_XCH_SEGSTART: crate::Register = crate::Register::new(8, 0xfff); + pub const SFR_XCH_SEGSTART_XCHCR_SEGSTART: crate::Field = crate::Field::new(12, 0, SFR_XCH_SEGSTART); + + pub const SFR_XCH_TRANSIZE: crate::Register = crate::Register::new(9, 0x3fffffff); + pub const SFR_XCH_TRANSIZE_XCHCR_TRANSIZE: crate::Field = crate::Field::new(30, 0, SFR_XCH_TRANSIZE); + + pub const SFR_SCH_FUNC: crate::Register = crate::Register::new(12, 0x1); + pub const SFR_SCH_FUNC_SFR_SCH_FUNC: crate::Field = crate::Field::new(1, 0, SFR_SCH_FUNC); + + pub const SFR_SCH_OPT: crate::Register = crate::Register::new(13, 0xff); + pub const SFR_SCH_OPT_SFR_SCH_OPT: crate::Field = crate::Field::new(8, 0, SFR_SCH_OPT); + + pub const SFR_SCH_AXSTART: crate::Register = crate::Register::new(14, 0xffffffff); + pub const SFR_SCH_AXSTART_SFR_SCH_AXSTART: crate::Field = crate::Field::new(32, 0, SFR_SCH_AXSTART); + + pub const SFR_SCH_SEGID: crate::Register = crate::Register::new(15, 0xff); + pub const SFR_SCH_SEGID_SFR_SCH_SEGID: crate::Field = crate::Field::new(8, 0, SFR_SCH_SEGID); + + pub const SFR_SCH_SEGSTART: crate::Register = crate::Register::new(16, 0xfff); + pub const SFR_SCH_SEGSTART_SCHCR_SEGSTART: crate::Field = crate::Field::new(12, 0, SFR_SCH_SEGSTART); + + pub const SFR_SCH_TRANSIZE: crate::Register = crate::Register::new(17, 0x3fffffff); + pub const SFR_SCH_TRANSIZE_SCHCR_TRANSIZE: crate::Field = crate::Field::new(30, 0, SFR_SCH_TRANSIZE); + + pub const SFR_ICH_OPT: crate::Register = crate::Register::new(20, 0xf); + pub const SFR_ICH_OPT_SFR_ICH_OPT: crate::Field = crate::Field::new(4, 0, SFR_ICH_OPT); + + pub const SFR_ICH_SEGID: crate::Register = crate::Register::new(21, 0xffff); + pub const SFR_ICH_SEGID_SFR_ICH_SEGID: crate::Field = crate::Field::new(16, 0, SFR_ICH_SEGID); + + pub const SFR_ICH_RPSTART: crate::Register = crate::Register::new(22, 0xfff); + pub const SFR_ICH_RPSTART_ICHCR_RPSTART: crate::Field = crate::Field::new(12, 0, SFR_ICH_RPSTART); + + pub const SFR_ICH_WPSTART: crate::Register = crate::Register::new(23, 0xfff); + pub const SFR_ICH_WPSTART_ICHCR_WPSTART: crate::Field = crate::Field::new(12, 0, SFR_ICH_WPSTART); + + pub const SFR_ICH_TRANSIZE: crate::Register = crate::Register::new(24, 0xfff); + pub const SFR_ICH_TRANSIZE_ICHCR_TRANSIZE: crate::Field = crate::Field::new(12, 0, SFR_ICH_TRANSIZE); + + pub const HW_SCEDMA_BASE: usize = 0x40029000; + } + + pub mod sce_glbsfr { + pub const SCE_GLBSFR_NUMREGS: usize = 19; + + pub const SFR_SCEMODE: crate::Register = crate::Register::new(0, 0x3); + pub const SFR_SCEMODE_CR_SCEMODE: crate::Field = crate::Field::new(2, 0, SFR_SCEMODE); + + pub const SFR_SUBEN: crate::Register = crate::Register::new(1, 0xffff); + pub const SFR_SUBEN_CR_SUBEN: crate::Field = crate::Field::new(16, 0, SFR_SUBEN); + + pub const SFR_AHBS: crate::Register = crate::Register::new(2, 0x1f); + pub const SFR_AHBS_CR_AHBSOPT: crate::Field = crate::Field::new(5, 0, SFR_AHBS); + + pub const SFR_SRBUSY: crate::Register = crate::Register::new(4, 0xffff); + pub const SFR_SRBUSY_SR_BUSY: crate::Field = crate::Field::new(16, 0, SFR_SRBUSY); + + pub const SFR_FRDONE: crate::Register = crate::Register::new(5, 0xffff); + pub const SFR_FRDONE_FR_DONE: crate::Field = crate::Field::new(16, 0, SFR_FRDONE); + + pub const SFR_FRERR: crate::Register = crate::Register::new(6, 0xffff); + pub const SFR_FRERR_FR_ERR: crate::Field = crate::Field::new(16, 0, SFR_FRERR); + + pub const SFR_ARCLR: crate::Register = crate::Register::new(7, 0xffffffff); + pub const SFR_ARCLR_AR_CLRRAM: crate::Field = crate::Field::new(32, 0, SFR_ARCLR); + + pub const SFR_TICKCYC: crate::Register = crate::Register::new(8, 0xff); + pub const SFR_TICKCYC_SFR_TICKCYC: crate::Field = crate::Field::new(8, 0, SFR_TICKCYC); + + pub const SFR_TICKCNT: crate::Register = crate::Register::new(9, 0xffffffff); + pub const SFR_TICKCNT_SFR_TICKCNT: crate::Field = crate::Field::new(32, 0, SFR_TICKCNT); + + pub const SFR_FFEN: crate::Register = crate::Register::new(12, 0x3f); + pub const SFR_FFEN_CR_FFEN: crate::Field = crate::Field::new(6, 0, SFR_FFEN); + + pub const SFR_FFCLR: crate::Register = crate::Register::new(13, 0xffffffff); + pub const SFR_FFCLR_AR_FFCLR: crate::Field = crate::Field::new(32, 0, SFR_FFCLR); + + pub const SFR_FFCNT_SR_FF0: crate::Register = crate::Register::new(16, 0xffff); + pub const SFR_FFCNT_SR_FF0_SR_FF0: crate::Field = crate::Field::new(16, 0, SFR_FFCNT_SR_FF0); + + pub const SFR_FFCNT_SR_FF1: crate::Register = crate::Register::new(17, 0xffff); + pub const SFR_FFCNT_SR_FF1_SR_FF1: crate::Field = crate::Field::new(16, 0, SFR_FFCNT_SR_FF1); + + pub const SFR_FFCNT_SR_FF2: crate::Register = crate::Register::new(18, 0xffff); + pub const SFR_FFCNT_SR_FF2_SR_FF2: crate::Field = crate::Field::new(16, 0, SFR_FFCNT_SR_FF2); + + pub const SFR_FFCNT_SR_FF3: crate::Register = crate::Register::new(19, 0xffff); + pub const SFR_FFCNT_SR_FF3_SR_FF3: crate::Field = crate::Field::new(16, 0, SFR_FFCNT_SR_FF3); + + pub const SFR_FFCNT_SR_FF4: crate::Register = crate::Register::new(20, 0xffff); + pub const SFR_FFCNT_SR_FF4_SR_FF4: crate::Field = crate::Field::new(16, 0, SFR_FFCNT_SR_FF4); + + pub const SFR_FFCNT_SR_FF5: crate::Register = crate::Register::new(21, 0xffff); + pub const SFR_FFCNT_SR_FF5_SR_FF5: crate::Field = crate::Field::new(16, 0, SFR_FFCNT_SR_FF5); + + pub const SFR_FRACERR: crate::Register = crate::Register::new(24, 0xff); + pub const SFR_FRACERR_FR_ACERR: crate::Field = crate::Field::new(8, 0, SFR_FRACERR); + + pub const SFR_TS: crate::Register = crate::Register::new(63, 0xffff); + pub const SFR_TS_CR_TS: crate::Field = crate::Field::new(16, 0, SFR_TS); + + pub const HW_SCE_GLBSFR_BASE: usize = 0x40028000; + } + + pub mod duart { + pub const DUART_NUMREGS: usize = 4; + + pub const SFR_TXD: crate::Register = crate::Register::new(0, 0xff); + pub const SFR_TXD_SFR_TXD: crate::Field = crate::Field::new(8, 0, SFR_TXD); + + pub const SFR_CR: crate::Register = crate::Register::new(1, 0x1); + pub const SFR_CR_SFR_CR: crate::Field = crate::Field::new(1, 0, SFR_CR); + + pub const SFR_SR: crate::Register = crate::Register::new(2, 0x1); + pub const SFR_SR_SFR_SR: crate::Field = crate::Field::new(1, 0, SFR_SR); + + pub const SFR_ETUC: crate::Register = crate::Register::new(3, 0xffff); + pub const SFR_ETUC_SFR_ETUC: crate::Field = crate::Field::new(16, 0, SFR_ETUC); + + pub const HW_DUART_BASE: usize = 0x40042000; + } + + pub mod rbist_wrp { + pub const RBIST_WRP_NUMREGS: usize = 2; + + pub const SFRCR_TRM: crate::Register = crate::Register::new(0, 0xffffff); + pub const SFRCR_TRM_SFRCR_TRM: crate::Field = crate::Field::new(24, 0, SFRCR_TRM); + + pub const SFRAR_TRM: crate::Register = crate::Register::new(1, 0xffffffff); + pub const SFRAR_TRM_SFRAR_TRM: crate::Field = crate::Field::new(32, 0, SFRAR_TRM); + + pub const HW_RBIST_WRP_BASE: usize = 0x40045000; + } + + pub mod wdg_intf { + pub const WDG_INTF_NUMREGS: usize = 0; + + pub const HW_WDG_INTF_BASE: usize = 0x40041000; + } + + pub mod timer_intf { + pub const TIMER_INTF_NUMREGS: usize = 0; + + pub const HW_TIMER_INTF_BASE: usize = 0x40043000; + } + + pub mod evc { + pub const EVC_NUMREGS: usize = 22; + + pub const SFR_CM7EVSEL_CM7EVSEL0: crate::Register = crate::Register::new(0, 0xff); + pub const SFR_CM7EVSEL_CM7EVSEL0_CM7EVSEL0: crate::Field = crate::Field::new(8, 0, SFR_CM7EVSEL_CM7EVSEL0); + + pub const SFR_CM7EVSEL_CM7EVSEL1: crate::Register = crate::Register::new(1, 0xff); + pub const SFR_CM7EVSEL_CM7EVSEL1_CM7EVSEL1: crate::Field = crate::Field::new(8, 0, SFR_CM7EVSEL_CM7EVSEL1); + + pub const SFR_CM7EVSEL_CM7EVSEL2: crate::Register = crate::Register::new(2, 0xff); + pub const SFR_CM7EVSEL_CM7EVSEL2_CM7EVSEL2: crate::Field = crate::Field::new(8, 0, SFR_CM7EVSEL_CM7EVSEL2); + + pub const SFR_CM7EVSEL_CM7EVSEL3: crate::Register = crate::Register::new(3, 0xff); + pub const SFR_CM7EVSEL_CM7EVSEL3_CM7EVSEL3: crate::Field = crate::Field::new(8, 0, SFR_CM7EVSEL_CM7EVSEL3); + + pub const SFR_CM7EVSEL_CM7EVSEL4: crate::Register = crate::Register::new(4, 0xff); + pub const SFR_CM7EVSEL_CM7EVSEL4_CM7EVSEL4: crate::Field = crate::Field::new(8, 0, SFR_CM7EVSEL_CM7EVSEL4); + + pub const SFR_CM7EVSEL_CM7EVSEL5: crate::Register = crate::Register::new(5, 0xff); + pub const SFR_CM7EVSEL_CM7EVSEL5_CM7EVSEL5: crate::Field = crate::Field::new(8, 0, SFR_CM7EVSEL_CM7EVSEL5); + + pub const SFR_CM7EVSEL_CM7EVSEL6: crate::Register = crate::Register::new(6, 0xff); + pub const SFR_CM7EVSEL_CM7EVSEL6_CM7EVSEL6: crate::Field = crate::Field::new(8, 0, SFR_CM7EVSEL_CM7EVSEL6); + + pub const SFR_CM7EVSEL_CM7EVSEL7: crate::Register = crate::Register::new(7, 0xff); + pub const SFR_CM7EVSEL_CM7EVSEL7_CM7EVSEL7: crate::Field = crate::Field::new(8, 0, SFR_CM7EVSEL_CM7EVSEL7); + + pub const SFR_CM7EVEN: crate::Register = crate::Register::new(8, 0xff); + pub const SFR_CM7EVEN_CM7EVEN: crate::Field = crate::Field::new(8, 0, SFR_CM7EVEN); + + pub const SFR_CM7EVFR: crate::Register = crate::Register::new(9, 0xff); + pub const SFR_CM7EVFR_CM7EVS: crate::Field = crate::Field::new(8, 0, SFR_CM7EVFR); + + pub const SFR_TMREVSEL: crate::Register = crate::Register::new(12, 0xffff); + pub const SFR_TMREVSEL_TMR_EVSEL: crate::Field = crate::Field::new(16, 0, SFR_TMREVSEL); + + pub const SFR_PWMEVSEL: crate::Register = crate::Register::new(13, 0xffffffff); + pub const SFR_PWMEVSEL_PWM_EVSEL: crate::Field = crate::Field::new(32, 0, SFR_PWMEVSEL); + + pub const SFR_IFEVEN_IFEVEN0: crate::Register = crate::Register::new(16, 0xffffffff); + pub const SFR_IFEVEN_IFEVEN0_IFEVEN0: crate::Field = crate::Field::new(32, 0, SFR_IFEVEN_IFEVEN0); + + pub const SFR_IFEVEN_IFEVEN1: crate::Register = crate::Register::new(17, 0xffffffff); + pub const SFR_IFEVEN_IFEVEN1_IFEVEN1: crate::Field = crate::Field::new(32, 0, SFR_IFEVEN_IFEVEN1); + + pub const SFR_IFEVEN_IFEVEN2: crate::Register = crate::Register::new(18, 0xffffffff); + pub const SFR_IFEVEN_IFEVEN2_IFEVEN2: crate::Field = crate::Field::new(32, 0, SFR_IFEVEN_IFEVEN2); + + pub const SFR_IFEVEN_IFEVEN3: crate::Register = crate::Register::new(19, 0xffffffff); + pub const SFR_IFEVEN_IFEVEN3_IFEVEN3: crate::Field = crate::Field::new(32, 0, SFR_IFEVEN_IFEVEN3); + + pub const SFR_IFEVEN_IFEVEN4: crate::Register = crate::Register::new(20, 0xffffffff); + pub const SFR_IFEVEN_IFEVEN4_IFEVEN4: crate::Field = crate::Field::new(32, 0, SFR_IFEVEN_IFEVEN4); + + pub const SFR_IFEVEN_IFEVEN5: crate::Register = crate::Register::new(21, 0xffffffff); + pub const SFR_IFEVEN_IFEVEN5_IFEVEN5: crate::Field = crate::Field::new(32, 0, SFR_IFEVEN_IFEVEN5); + + pub const SFR_IFEVEN_IFEVEN6: crate::Register = crate::Register::new(22, 0xffffffff); + pub const SFR_IFEVEN_IFEVEN6_IFEVEN6: crate::Field = crate::Field::new(32, 0, SFR_IFEVEN_IFEVEN6); + + pub const SFR_IFEVEN_IFEVEN7: crate::Register = crate::Register::new(23, 0xffffffff); + pub const SFR_IFEVEN_IFEVEN7_IFEVEN7: crate::Field = crate::Field::new(32, 0, SFR_IFEVEN_IFEVEN7); + + pub const SFR_IFEVERRFR: crate::Register = crate::Register::new(24, 0xffffffff); + pub const SFR_IFEVERRFR_IFEV_ERRS: crate::Field = crate::Field::new(32, 0, SFR_IFEVERRFR); + + pub const SFR_CM7ERRFR: crate::Register = crate::Register::new(32, 0xffffffff); + pub const SFR_CM7ERRFR_ERRIN: crate::Field = crate::Field::new(32, 0, SFR_CM7ERRFR); + + pub const HW_EVC_BASE: usize = 0x40044000; + } + + pub mod sysctrl { + pub const SYSCTRL_NUMREGS: usize = 35; + + pub const SFR_CGUSEC: crate::Register = crate::Register::new(0, 0xffff); + pub const SFR_CGUSEC_SFR_CGUSEC: crate::Field = crate::Field::new(16, 0, SFR_CGUSEC); + + pub const SFR_CGULP: crate::Register = crate::Register::new(1, 0xffff); + pub const SFR_CGULP_SFR_CGULP: crate::Field = crate::Field::new(16, 0, SFR_CGULP); + + pub const SFR_SEED: crate::Register = crate::Register::new(2, 0xffffffff); + pub const SFR_SEED_SFR_SEED: crate::Field = crate::Field::new(32, 0, SFR_SEED); + + pub const SFR_SEEDAR: crate::Register = crate::Register::new(3, 0xffffffff); + pub const SFR_SEEDAR_SFR_SEEDAR: crate::Field = crate::Field::new(32, 0, SFR_SEEDAR); + + pub const SFR_CGUSEL0: crate::Register = crate::Register::new(4, 0x3); + pub const SFR_CGUSEL0_SFR_CGUSEL0: crate::Field = crate::Field::new(2, 0, SFR_CGUSEL0); + + pub const SFR_CGUFD_CFGFDCR_0_4_0: crate::Register = crate::Register::new(5, 0xffffff); + pub const SFR_CGUFD_CFGFDCR_0_4_0_CFGFDCR_0_4_0: crate::Field = crate::Field::new(24, 0, SFR_CGUFD_CFGFDCR_0_4_0); + + pub const SFR_CGUFD_CFGFDCR_0_4_1: crate::Register = crate::Register::new(6, 0xffffff); + pub const SFR_CGUFD_CFGFDCR_0_4_1_CFGFDCR_0_4_1: crate::Field = crate::Field::new(24, 0, SFR_CGUFD_CFGFDCR_0_4_1); + + pub const SFR_CGUFD_CFGFDCR_0_4_2: crate::Register = crate::Register::new(7, 0xffffff); + pub const SFR_CGUFD_CFGFDCR_0_4_2_CFGFDCR_0_4_2: crate::Field = crate::Field::new(24, 0, SFR_CGUFD_CFGFDCR_0_4_2); + + pub const SFR_CGUFD_CFGFDCR_0_4_3: crate::Register = crate::Register::new(8, 0xffffff); + pub const SFR_CGUFD_CFGFDCR_0_4_3_CFGFDCR_0_4_3: crate::Field = crate::Field::new(24, 0, SFR_CGUFD_CFGFDCR_0_4_3); + + pub const SFR_CGUFD_CFGFDCR_0_4_4: crate::Register = crate::Register::new(9, 0xffffff); + pub const SFR_CGUFD_CFGFDCR_0_4_4_CFGFDCR_0_4_4: crate::Field = crate::Field::new(24, 0, SFR_CGUFD_CFGFDCR_0_4_4); + + pub const SFR_CGUFDAO: crate::Register = crate::Register::new(10, 0xffffff); + pub const SFR_CGUFDAO_CFGFDCR: crate::Field = crate::Field::new(24, 0, SFR_CGUFDAO); + + pub const SFR_CGUSET: crate::Register = crate::Register::new(11, 0xffffffff); + pub const SFR_CGUSET_SFR_CGUSET: crate::Field = crate::Field::new(32, 0, SFR_CGUSET); + + pub const SFR_CGUSEL1: crate::Register = crate::Register::new(12, 0x1); + pub const SFR_CGUSEL1_SFR_CGUSEL1: crate::Field = crate::Field::new(1, 0, SFR_CGUSEL1); + + pub const SFR_CGUFDPKE: crate::Register = crate::Register::new(13, 0x1ff); + pub const SFR_CGUFDPKE_SFR_CGUFDPKE: crate::Field = crate::Field::new(9, 0, SFR_CGUFDPKE); + + pub const SFR_CGUFSSR_FSFREQ0: crate::Register = crate::Register::new(16, 0xffff); + pub const SFR_CGUFSSR_FSFREQ0_FSFREQ0: crate::Field = crate::Field::new(16, 0, SFR_CGUFSSR_FSFREQ0); + + pub const SFR_CGUFSSR_FSFREQ1: crate::Register = crate::Register::new(17, 0xffff); + pub const SFR_CGUFSSR_FSFREQ1_FSFREQ1: crate::Field = crate::Field::new(16, 0, SFR_CGUFSSR_FSFREQ1); + + pub const SFR_CGUFSSR_FSFREQ2: crate::Register = crate::Register::new(18, 0xffff); + pub const SFR_CGUFSSR_FSFREQ2_FSFREQ2: crate::Field = crate::Field::new(16, 0, SFR_CGUFSSR_FSFREQ2); + + pub const SFR_CGUFSSR_FSFREQ3: crate::Register = crate::Register::new(19, 0xffff); + pub const SFR_CGUFSSR_FSFREQ3_FSFREQ3: crate::Field = crate::Field::new(16, 0, SFR_CGUFSSR_FSFREQ3); + + pub const SFR_CGUFSVLD: crate::Register = crate::Register::new(20, 0xf); + pub const SFR_CGUFSVLD_SFR_CGUFSVLD: crate::Field = crate::Field::new(4, 0, SFR_CGUFSVLD); + + pub const SFR_CGUFSCR: crate::Register = crate::Register::new(21, 0xffff); + pub const SFR_CGUFSCR_SFR_CGUFSCR: crate::Field = crate::Field::new(16, 0, SFR_CGUFSCR); + + pub const SFR_ACLKGR: crate::Register = crate::Register::new(24, 0xff); + pub const SFR_ACLKGR_SFR_ACLKGR: crate::Field = crate::Field::new(8, 0, SFR_ACLKGR); + + pub const SFR_HCLKGR: crate::Register = crate::Register::new(25, 0xff); + pub const SFR_HCLKGR_SFR_HCLKGR: crate::Field = crate::Field::new(8, 0, SFR_HCLKGR); + + pub const SFR_ICLKGR: crate::Register = crate::Register::new(26, 0xff); + pub const SFR_ICLKGR_SFR_ICLKGR: crate::Field = crate::Field::new(8, 0, SFR_ICLKGR); + + pub const SFR_PCLKGR: crate::Register = crate::Register::new(27, 0xff); + pub const SFR_PCLKGR_SFR_PCLKGR: crate::Field = crate::Field::new(8, 0, SFR_PCLKGR); + + pub const SFR_RCURST0: crate::Register = crate::Register::new(32, 0xffffffff); + pub const SFR_RCURST0_SFR_RCURST0: crate::Field = crate::Field::new(32, 0, SFR_RCURST0); + + pub const SFR_RCURST1: crate::Register = crate::Register::new(33, 0xffffffff); + pub const SFR_RCURST1_SFR_RCURST1: crate::Field = crate::Field::new(32, 0, SFR_RCURST1); + + pub const SFR_RCUSRCFR: crate::Register = crate::Register::new(34, 0xffff); + pub const SFR_RCUSRCFR_SFR_RCUSRCFR: crate::Field = crate::Field::new(16, 0, SFR_RCUSRCFR); + + pub const SFR_IPCARIPFLOW: crate::Register = crate::Register::new(36, 0xffffffff); + pub const SFR_IPCARIPFLOW_SFR_IPCARIPFLOW: crate::Field = crate::Field::new(32, 0, SFR_IPCARIPFLOW); + + pub const SFR_IPCEN: crate::Register = crate::Register::new(37, 0xffff); + pub const SFR_IPCEN_SFR_IPCEN: crate::Field = crate::Field::new(16, 0, SFR_IPCEN); + + pub const SFR_IPCLPEN: crate::Register = crate::Register::new(38, 0xffff); + pub const SFR_IPCLPEN_SFR_IPCLPEN: crate::Field = crate::Field::new(16, 0, SFR_IPCLPEN); + + pub const SFR_IPCOSC: crate::Register = crate::Register::new(39, 0x7f); + pub const SFR_IPCOSC_SFR_IPCOSC: crate::Field = crate::Field::new(7, 0, SFR_IPCOSC); + + pub const SFR_IPCPLLMN: crate::Register = crate::Register::new(40, 0x1ffff); + pub const SFR_IPCPLLMN_SFR_IPCPLLMN: crate::Field = crate::Field::new(17, 0, SFR_IPCPLLMN); + + pub const SFR_IPCPLLF: crate::Register = crate::Register::new(41, 0x1ffffff); + pub const SFR_IPCPLLF_SFR_IPCPLLF: crate::Field = crate::Field::new(25, 0, SFR_IPCPLLF); + + pub const SFR_IPCPLLQ: crate::Register = crate::Register::new(42, 0x7fff); + pub const SFR_IPCPLLQ_SFR_IPCPLLQ: crate::Field = crate::Field::new(15, 0, SFR_IPCPLLQ); + + pub const SFR_IPCCR: crate::Register = crate::Register::new(43, 0xffff); + pub const SFR_IPCCR_SFR_IPCCR: crate::Field = crate::Field::new(16, 0, SFR_IPCCR); + + pub const HW_SYSCTRL_BASE: usize = 0x40040000; + } + + pub mod apb_thru { + pub const APB_THRU_NUMREGS: usize = 0; + + pub const HW_APB_THRU_BASE: usize = 0x50122000; + } + + pub mod bio_bdma { + pub const BIO_BDMA_NUMREGS: usize = 60; + + pub const SFR_CTRL: crate::Register = crate::Register::new(0, 0xfff); + pub const SFR_CTRL_EN: crate::Field = crate::Field::new(4, 0, SFR_CTRL); + pub const SFR_CTRL_RESTART: crate::Field = crate::Field::new(4, 4, SFR_CTRL); + pub const SFR_CTRL_CLKDIV_RESTART: crate::Field = crate::Field::new(4, 8, SFR_CTRL); + + pub const SFR_CFGINFO: crate::Register = crate::Register::new(1, 0xffffffff); + pub const SFR_CFGINFO_CONSTANT0: crate::Field = crate::Field::new(8, 0, SFR_CFGINFO); + pub const SFR_CFGINFO_CONSTANT1: crate::Field = crate::Field::new(8, 8, SFR_CFGINFO); + pub const SFR_CFGINFO_CONSTANT2: crate::Field = crate::Field::new(16, 16, SFR_CFGINFO); + + pub const SFR_CONFIG: crate::Register = crate::Register::new(2, 0xff); + pub const SFR_CONFIG_SNAP_OUTPUT_TO_WHICH: crate::Field = crate::Field::new(2, 0, SFR_CONFIG); + pub const SFR_CONFIG_SNAP_OUTPUT_TO_QUANTUM: crate::Field = crate::Field::new(1, 2, SFR_CONFIG); + pub const SFR_CONFIG_SNAP_INPUT_TO_WHICH: crate::Field = crate::Field::new(2, 3, SFR_CONFIG); + pub const SFR_CONFIG_SNAP_INPUT_TO_QUANTUM: crate::Field = crate::Field::new(1, 5, SFR_CONFIG); + pub const SFR_CONFIG_DISABLE_FILTER_PERI: crate::Field = crate::Field::new(1, 6, SFR_CONFIG); + pub const SFR_CONFIG_DISABLE_FILTER_MEM: crate::Field = crate::Field::new(1, 7, SFR_CONFIG); + + pub const SFR_FLEVEL: crate::Register = crate::Register::new(3, 0xffff); + pub const SFR_FLEVEL_PCLK_REGFIFO_LEVEL0: crate::Field = crate::Field::new(4, 0, SFR_FLEVEL); + pub const SFR_FLEVEL_PCLK_REGFIFO_LEVEL1: crate::Field = crate::Field::new(4, 4, SFR_FLEVEL); + pub const SFR_FLEVEL_PCLK_REGFIFO_LEVEL2: crate::Field = crate::Field::new(4, 8, SFR_FLEVEL); + pub const SFR_FLEVEL_PCLK_REGFIFO_LEVEL3: crate::Field = crate::Field::new(4, 12, SFR_FLEVEL); + + pub const SFR_TXF0: crate::Register = crate::Register::new(4, 0xffffffff); + pub const SFR_TXF0_FDIN: crate::Field = crate::Field::new(32, 0, SFR_TXF0); + + pub const SFR_TXF1: crate::Register = crate::Register::new(5, 0xffffffff); + pub const SFR_TXF1_FDIN: crate::Field = crate::Field::new(32, 0, SFR_TXF1); + + pub const SFR_TXF2: crate::Register = crate::Register::new(6, 0xffffffff); + pub const SFR_TXF2_FDIN: crate::Field = crate::Field::new(32, 0, SFR_TXF2); + + pub const SFR_TXF3: crate::Register = crate::Register::new(7, 0xffffffff); + pub const SFR_TXF3_FDIN: crate::Field = crate::Field::new(32, 0, SFR_TXF3); + + pub const SFR_RXF0: crate::Register = crate::Register::new(8, 0xffffffff); + pub const SFR_RXF0_FDOUT: crate::Field = crate::Field::new(32, 0, SFR_RXF0); + + pub const SFR_RXF1: crate::Register = crate::Register::new(9, 0xffffffff); + pub const SFR_RXF1_FDOUT: crate::Field = crate::Field::new(32, 0, SFR_RXF1); + + pub const SFR_RXF2: crate::Register = crate::Register::new(10, 0xffffffff); + pub const SFR_RXF2_FDOUT: crate::Field = crate::Field::new(32, 0, SFR_RXF2); + + pub const SFR_RXF3: crate::Register = crate::Register::new(11, 0xffffffff); + pub const SFR_RXF3_FDOUT: crate::Field = crate::Field::new(32, 0, SFR_RXF3); + + pub const SFR_ELEVEL: crate::Register = crate::Register::new(12, 0xffffffff); + pub const SFR_ELEVEL_FIFO_EVENT_LEVEL0: crate::Field = crate::Field::new(4, 0, SFR_ELEVEL); + pub const SFR_ELEVEL_FIFO_EVENT_LEVEL1: crate::Field = crate::Field::new(4, 4, SFR_ELEVEL); + pub const SFR_ELEVEL_FIFO_EVENT_LEVEL2: crate::Field = crate::Field::new(4, 8, SFR_ELEVEL); + pub const SFR_ELEVEL_FIFO_EVENT_LEVEL3: crate::Field = crate::Field::new(4, 12, SFR_ELEVEL); + pub const SFR_ELEVEL_FIFO_EVENT_LEVEL4: crate::Field = crate::Field::new(4, 16, SFR_ELEVEL); + pub const SFR_ELEVEL_FIFO_EVENT_LEVEL5: crate::Field = crate::Field::new(4, 20, SFR_ELEVEL); + pub const SFR_ELEVEL_FIFO_EVENT_LEVEL6: crate::Field = crate::Field::new(4, 24, SFR_ELEVEL); + pub const SFR_ELEVEL_FIFO_EVENT_LEVEL7: crate::Field = crate::Field::new(4, 28, SFR_ELEVEL); + + pub const SFR_ETYPE: crate::Register = crate::Register::new(13, 0xffffff); + pub const SFR_ETYPE_FIFO_EVENT_LT_MASK: crate::Field = crate::Field::new(8, 0, SFR_ETYPE); + pub const SFR_ETYPE_FIFO_EVENT_EQ_MASK: crate::Field = crate::Field::new(8, 8, SFR_ETYPE); + pub const SFR_ETYPE_FIFO_EVENT_GT_MASK: crate::Field = crate::Field::new(8, 16, SFR_ETYPE); + + pub const SFR_EVENT_SET: crate::Register = crate::Register::new(14, 0xffffff); + pub const SFR_EVENT_SET_SFR_EVENT_SET: crate::Field = crate::Field::new(24, 0, SFR_EVENT_SET); + + pub const SFR_EVENT_CLR: crate::Register = crate::Register::new(15, 0xffffff); + pub const SFR_EVENT_CLR_SFR_EVENT_CLR: crate::Field = crate::Field::new(24, 0, SFR_EVENT_CLR); + + pub const SFR_EVENT_STATUS: crate::Register = crate::Register::new(16, 0xffffffff); + pub const SFR_EVENT_STATUS_SFR_EVENT_STATUS: crate::Field = crate::Field::new(32, 0, SFR_EVENT_STATUS); + + pub const SFR_EXTCLOCK: crate::Register = crate::Register::new(17, 0xffffff); + pub const SFR_EXTCLOCK_USE_EXTCLK: crate::Field = crate::Field::new(4, 0, SFR_EXTCLOCK); + pub const SFR_EXTCLOCK_EXTCLK_GPIO_0: crate::Field = crate::Field::new(5, 4, SFR_EXTCLOCK); + pub const SFR_EXTCLOCK_EXTCLK_GPIO_1: crate::Field = crate::Field::new(5, 9, SFR_EXTCLOCK); + pub const SFR_EXTCLOCK_EXTCLK_GPIO_2: crate::Field = crate::Field::new(5, 14, SFR_EXTCLOCK); + pub const SFR_EXTCLOCK_EXTCLK_GPIO_3: crate::Field = crate::Field::new(5, 19, SFR_EXTCLOCK); + + pub const SFR_FIFO_CLR: crate::Register = crate::Register::new(18, 0xf); + pub const SFR_FIFO_CLR_SFR_FIFO_CLR: crate::Field = crate::Field::new(4, 0, SFR_FIFO_CLR); + + pub const SFR_QDIV0: crate::Register = crate::Register::new(20, 0x7); + pub const SFR_QDIV0_UNUSED_DIV: crate::Field = crate::Field::new(1, 0, SFR_QDIV0); + pub const SFR_QDIV0_DIV_FRAC: crate::Field = crate::Field::new(1, 1, SFR_QDIV0); + pub const SFR_QDIV0_DIV_INT: crate::Field = crate::Field::new(1, 2, SFR_QDIV0); + + pub const SFR_QDIV1: crate::Register = crate::Register::new(21, 0x7); + pub const SFR_QDIV1_UNUSED_DIV: crate::Field = crate::Field::new(1, 0, SFR_QDIV1); + pub const SFR_QDIV1_DIV_FRAC: crate::Field = crate::Field::new(1, 1, SFR_QDIV1); + pub const SFR_QDIV1_DIV_INT: crate::Field = crate::Field::new(1, 2, SFR_QDIV1); + + pub const SFR_QDIV2: crate::Register = crate::Register::new(22, 0x7); + pub const SFR_QDIV2_UNUSED_DIV: crate::Field = crate::Field::new(1, 0, SFR_QDIV2); + pub const SFR_QDIV2_DIV_FRAC: crate::Field = crate::Field::new(1, 1, SFR_QDIV2); + pub const SFR_QDIV2_DIV_INT: crate::Field = crate::Field::new(1, 2, SFR_QDIV2); + + pub const SFR_QDIV3: crate::Register = crate::Register::new(23, 0x7); + pub const SFR_QDIV3_UNUSED_DIV: crate::Field = crate::Field::new(1, 0, SFR_QDIV3); + pub const SFR_QDIV3_DIV_FRAC: crate::Field = crate::Field::new(1, 1, SFR_QDIV3); + pub const SFR_QDIV3_DIV_INT: crate::Field = crate::Field::new(1, 2, SFR_QDIV3); + + pub const SFR_SYNC_BYPASS: crate::Register = crate::Register::new(24, 0xffffffff); + pub const SFR_SYNC_BYPASS_SFR_SYNC_BYPASS: crate::Field = crate::Field::new(32, 0, SFR_SYNC_BYPASS); + + pub const SFR_IO_OE_INV: crate::Register = crate::Register::new(25, 0xffffffff); + pub const SFR_IO_OE_INV_SFR_IO_OE_INV: crate::Field = crate::Field::new(32, 0, SFR_IO_OE_INV); + + pub const SFR_IO_O_INV: crate::Register = crate::Register::new(26, 0xffffffff); + pub const SFR_IO_O_INV_SFR_IO_O_INV: crate::Field = crate::Field::new(32, 0, SFR_IO_O_INV); + + pub const SFR_IO_I_INV: crate::Register = crate::Register::new(27, 0xffffffff); + pub const SFR_IO_I_INV_SFR_IO_I_INV: crate::Field = crate::Field::new(32, 0, SFR_IO_I_INV); + + pub const SFR_IRQMASK_0: crate::Register = crate::Register::new(28, 0xffffffff); + pub const SFR_IRQMASK_0_SFR_IRQMASK_0: crate::Field = crate::Field::new(32, 0, SFR_IRQMASK_0); + + pub const SFR_IRQMASK_1: crate::Register = crate::Register::new(29, 0xffffffff); + pub const SFR_IRQMASK_1_SFR_IRQMASK_1: crate::Field = crate::Field::new(32, 0, SFR_IRQMASK_1); + + pub const SFR_IRQMASK_2: crate::Register = crate::Register::new(30, 0xffffffff); + pub const SFR_IRQMASK_2_SFR_IRQMASK_2: crate::Field = crate::Field::new(32, 0, SFR_IRQMASK_2); + + pub const SFR_IRQMASK_3: crate::Register = crate::Register::new(31, 0xffffffff); + pub const SFR_IRQMASK_3_SFR_IRQMASK_3: crate::Field = crate::Field::new(32, 0, SFR_IRQMASK_3); + + pub const SFR_IRQ_EDGE: crate::Register = crate::Register::new(32, 0xf); + pub const SFR_IRQ_EDGE_SFR_IRQ_EDGE: crate::Field = crate::Field::new(4, 0, SFR_IRQ_EDGE); + + pub const SFR_DBG_PADOUT: crate::Register = crate::Register::new(33, 0xffffffff); + pub const SFR_DBG_PADOUT_SFR_DBG_PADOUT: crate::Field = crate::Field::new(32, 0, SFR_DBG_PADOUT); + + pub const SFR_DBG_PADOE: crate::Register = crate::Register::new(34, 0xffffffff); + pub const SFR_DBG_PADOE_SFR_DBG_PADOE: crate::Field = crate::Field::new(32, 0, SFR_DBG_PADOE); + + pub const SFR_DBG0: crate::Register = crate::Register::new(36, 0x3); + pub const SFR_DBG0_DBG_PC: crate::Field = crate::Field::new(1, 0, SFR_DBG0); + pub const SFR_DBG0_TRAP: crate::Field = crate::Field::new(1, 1, SFR_DBG0); + + pub const SFR_DBG1: crate::Register = crate::Register::new(37, 0x3); + pub const SFR_DBG1_DBG_PC: crate::Field = crate::Field::new(1, 0, SFR_DBG1); + pub const SFR_DBG1_TRAP: crate::Field = crate::Field::new(1, 1, SFR_DBG1); + + pub const SFR_DBG2: crate::Register = crate::Register::new(38, 0x3); + pub const SFR_DBG2_DBG_PC: crate::Field = crate::Field::new(1, 0, SFR_DBG2); + pub const SFR_DBG2_TRAP: crate::Field = crate::Field::new(1, 1, SFR_DBG2); + + pub const SFR_DBG3: crate::Register = crate::Register::new(39, 0x3); + pub const SFR_DBG3_DBG_PC: crate::Field = crate::Field::new(1, 0, SFR_DBG3); + pub const SFR_DBG3_TRAP: crate::Field = crate::Field::new(1, 1, SFR_DBG3); + + pub const SFR_MEM_GUTTER: crate::Register = crate::Register::new(40, 0xffffffff); + pub const SFR_MEM_GUTTER_SFR_MEM_GUTTER: crate::Field = crate::Field::new(32, 0, SFR_MEM_GUTTER); + + pub const SFR_PERI_GUTTER: crate::Register = crate::Register::new(41, 0xffffffff); + pub const SFR_PERI_GUTTER_SFR_PERI_GUTTER: crate::Field = crate::Field::new(32, 0, SFR_PERI_GUTTER); + + pub const SFR_DMAREQ_MAP_CR_EVMAP0: crate::Register = crate::Register::new(44, 0xffffffff); + pub const SFR_DMAREQ_MAP_CR_EVMAP0_CR_EVMAP0: crate::Field = crate::Field::new(32, 0, SFR_DMAREQ_MAP_CR_EVMAP0); + + pub const SFR_DMAREQ_MAP_CR_EVMAP1: crate::Register = crate::Register::new(45, 0xffffffff); + pub const SFR_DMAREQ_MAP_CR_EVMAP1_CR_EVMAP1: crate::Field = crate::Field::new(32, 0, SFR_DMAREQ_MAP_CR_EVMAP1); + + pub const SFR_DMAREQ_MAP_CR_EVMAP2: crate::Register = crate::Register::new(46, 0xffffffff); + pub const SFR_DMAREQ_MAP_CR_EVMAP2_CR_EVMAP2: crate::Field = crate::Field::new(32, 0, SFR_DMAREQ_MAP_CR_EVMAP2); + + pub const SFR_DMAREQ_MAP_CR_EVMAP3: crate::Register = crate::Register::new(47, 0xffffffff); + pub const SFR_DMAREQ_MAP_CR_EVMAP3_CR_EVMAP3: crate::Field = crate::Field::new(32, 0, SFR_DMAREQ_MAP_CR_EVMAP3); + + pub const SFR_DMAREQ_MAP_CR_EVMAP4: crate::Register = crate::Register::new(48, 0xffffffff); + pub const SFR_DMAREQ_MAP_CR_EVMAP4_CR_EVMAP4: crate::Field = crate::Field::new(32, 0, SFR_DMAREQ_MAP_CR_EVMAP4); + + pub const SFR_DMAREQ_MAP_CR_EVMAP5: crate::Register = crate::Register::new(49, 0xffffffff); + pub const SFR_DMAREQ_MAP_CR_EVMAP5_CR_EVMAP5: crate::Field = crate::Field::new(32, 0, SFR_DMAREQ_MAP_CR_EVMAP5); + + pub const SFR_DMAREQ_STAT_SR_EVSTAT0: crate::Register = crate::Register::new(50, 0xffffffff); + pub const SFR_DMAREQ_STAT_SR_EVSTAT0_SR_EVSTAT0: crate::Field = crate::Field::new(32, 0, SFR_DMAREQ_STAT_SR_EVSTAT0); + + pub const SFR_DMAREQ_STAT_SR_EVSTAT1: crate::Register = crate::Register::new(51, 0xffffffff); + pub const SFR_DMAREQ_STAT_SR_EVSTAT1_SR_EVSTAT1: crate::Field = crate::Field::new(32, 0, SFR_DMAREQ_STAT_SR_EVSTAT1); + + pub const SFR_DMAREQ_STAT_SR_EVSTAT2: crate::Register = crate::Register::new(52, 0xffffffff); + pub const SFR_DMAREQ_STAT_SR_EVSTAT2_SR_EVSTAT2: crate::Field = crate::Field::new(32, 0, SFR_DMAREQ_STAT_SR_EVSTAT2); + + pub const SFR_DMAREQ_STAT_SR_EVSTAT3: crate::Register = crate::Register::new(53, 0xffffffff); + pub const SFR_DMAREQ_STAT_SR_EVSTAT3_SR_EVSTAT3: crate::Field = crate::Field::new(32, 0, SFR_DMAREQ_STAT_SR_EVSTAT3); + + pub const SFR_DMAREQ_STAT_SR_EVSTAT4: crate::Register = crate::Register::new(54, 0xffffffff); + pub const SFR_DMAREQ_STAT_SR_EVSTAT4_SR_EVSTAT4: crate::Field = crate::Field::new(32, 0, SFR_DMAREQ_STAT_SR_EVSTAT4); + + pub const SFR_DMAREQ_STAT_SR_EVSTAT5: crate::Register = crate::Register::new(55, 0xffffffff); + pub const SFR_DMAREQ_STAT_SR_EVSTAT5_SR_EVSTAT5: crate::Field = crate::Field::new(32, 0, SFR_DMAREQ_STAT_SR_EVSTAT5); + + pub const SFR_FILTER_BASE_0: crate::Register = crate::Register::new(56, 0xfffff); + pub const SFR_FILTER_BASE_0_FILTER_BASE: crate::Field = crate::Field::new(20, 0, SFR_FILTER_BASE_0); + + pub const SFR_FILTER_BOUNDS_0: crate::Register = crate::Register::new(57, 0xfffff); + pub const SFR_FILTER_BOUNDS_0_FILTER_BOUNDS: crate::Field = crate::Field::new(20, 0, SFR_FILTER_BOUNDS_0); + + pub const SFR_FILTER_BASE_1: crate::Register = crate::Register::new(58, 0xfffff); + pub const SFR_FILTER_BASE_1_FILTER_BASE: crate::Field = crate::Field::new(20, 0, SFR_FILTER_BASE_1); + + pub const SFR_FILTER_BOUNDS_1: crate::Register = crate::Register::new(59, 0xfffff); + pub const SFR_FILTER_BOUNDS_1_FILTER_BOUNDS: crate::Field = crate::Field::new(20, 0, SFR_FILTER_BOUNDS_1); + + pub const SFR_FILTER_BASE_2: crate::Register = crate::Register::new(60, 0xfffff); + pub const SFR_FILTER_BASE_2_FILTER_BASE: crate::Field = crate::Field::new(20, 0, SFR_FILTER_BASE_2); + + pub const SFR_FILTER_BOUNDS_2: crate::Register = crate::Register::new(61, 0xfffff); + pub const SFR_FILTER_BOUNDS_2_FILTER_BOUNDS: crate::Field = crate::Field::new(20, 0, SFR_FILTER_BOUNDS_2); + + pub const SFR_FILTER_BASE_3: crate::Register = crate::Register::new(62, 0xfffff); + pub const SFR_FILTER_BASE_3_FILTER_BASE: crate::Field = crate::Field::new(20, 0, SFR_FILTER_BASE_3); + + pub const SFR_FILTER_BOUNDS_3: crate::Register = crate::Register::new(63, 0xfffff); + pub const SFR_FILTER_BOUNDS_3_FILTER_BOUNDS: crate::Field = crate::Field::new(20, 0, SFR_FILTER_BOUNDS_3); + + pub const HW_BIO_BDMA_BASE: usize = 0x50124000; + } + + pub mod iox { + pub const IOX_NUMREGS: usize = 64; + + pub const SFR_AFSEL_CRAFSEL0: crate::Register = crate::Register::new(0, 0xffff); + pub const SFR_AFSEL_CRAFSEL0_CRAFSEL0: crate::Field = crate::Field::new(16, 0, SFR_AFSEL_CRAFSEL0); + + pub const SFR_AFSEL_CRAFSEL1: crate::Register = crate::Register::new(1, 0xffff); + pub const SFR_AFSEL_CRAFSEL1_CRAFSEL1: crate::Field = crate::Field::new(16, 0, SFR_AFSEL_CRAFSEL1); + + pub const SFR_AFSEL_CRAFSEL2: crate::Register = crate::Register::new(2, 0xffff); + pub const SFR_AFSEL_CRAFSEL2_CRAFSEL2: crate::Field = crate::Field::new(16, 0, SFR_AFSEL_CRAFSEL2); + + pub const SFR_AFSEL_CRAFSEL3: crate::Register = crate::Register::new(3, 0xffff); + pub const SFR_AFSEL_CRAFSEL3_CRAFSEL3: crate::Field = crate::Field::new(16, 0, SFR_AFSEL_CRAFSEL3); + + pub const SFR_AFSEL_CRAFSEL4: crate::Register = crate::Register::new(4, 0xffff); + pub const SFR_AFSEL_CRAFSEL4_CRAFSEL4: crate::Field = crate::Field::new(16, 0, SFR_AFSEL_CRAFSEL4); + + pub const SFR_AFSEL_CRAFSEL5: crate::Register = crate::Register::new(5, 0xffff); + pub const SFR_AFSEL_CRAFSEL5_CRAFSEL5: crate::Field = crate::Field::new(16, 0, SFR_AFSEL_CRAFSEL5); + + pub const SFR_AFSEL_CRAFSEL6: crate::Register = crate::Register::new(6, 0xffff); + pub const SFR_AFSEL_CRAFSEL6_CRAFSEL6: crate::Field = crate::Field::new(16, 0, SFR_AFSEL_CRAFSEL6); + + pub const SFR_AFSEL_CRAFSEL7: crate::Register = crate::Register::new(7, 0xffff); + pub const SFR_AFSEL_CRAFSEL7_CRAFSEL7: crate::Field = crate::Field::new(16, 0, SFR_AFSEL_CRAFSEL7); + + pub const SFR_AFSEL_CRAFSEL8: crate::Register = crate::Register::new(8, 0xffff); + pub const SFR_AFSEL_CRAFSEL8_CRAFSEL8: crate::Field = crate::Field::new(16, 0, SFR_AFSEL_CRAFSEL8); + + pub const SFR_AFSEL_CRAFSEL9: crate::Register = crate::Register::new(9, 0xffff); + pub const SFR_AFSEL_CRAFSEL9_CRAFSEL9: crate::Field = crate::Field::new(16, 0, SFR_AFSEL_CRAFSEL9); + + pub const SFR_AFSEL_CRAFSEL10: crate::Register = crate::Register::new(10, 0xffff); + pub const SFR_AFSEL_CRAFSEL10_CRAFSEL10: crate::Field = crate::Field::new(16, 0, SFR_AFSEL_CRAFSEL10); + + pub const SFR_AFSEL_CRAFSEL11: crate::Register = crate::Register::new(11, 0xffff); + pub const SFR_AFSEL_CRAFSEL11_CRAFSEL11: crate::Field = crate::Field::new(16, 0, SFR_AFSEL_CRAFSEL11); + + pub const SFR_INTCR_CRINT0: crate::Register = crate::Register::new(64, 0x3ff); + pub const SFR_INTCR_CRINT0_CRINT0: crate::Field = crate::Field::new(10, 0, SFR_INTCR_CRINT0); + + pub const SFR_INTCR_CRINT1: crate::Register = crate::Register::new(65, 0x3ff); + pub const SFR_INTCR_CRINT1_CRINT1: crate::Field = crate::Field::new(10, 0, SFR_INTCR_CRINT1); + + pub const SFR_INTCR_CRINT2: crate::Register = crate::Register::new(66, 0x3ff); + pub const SFR_INTCR_CRINT2_CRINT2: crate::Field = crate::Field::new(10, 0, SFR_INTCR_CRINT2); + + pub const SFR_INTCR_CRINT3: crate::Register = crate::Register::new(67, 0x3ff); + pub const SFR_INTCR_CRINT3_CRINT3: crate::Field = crate::Field::new(10, 0, SFR_INTCR_CRINT3); + + pub const SFR_INTCR_CRINT4: crate::Register = crate::Register::new(68, 0x3ff); + pub const SFR_INTCR_CRINT4_CRINT4: crate::Field = crate::Field::new(10, 0, SFR_INTCR_CRINT4); + + pub const SFR_INTCR_CRINT5: crate::Register = crate::Register::new(69, 0x3ff); + pub const SFR_INTCR_CRINT5_CRINT5: crate::Field = crate::Field::new(10, 0, SFR_INTCR_CRINT5); + + pub const SFR_INTCR_CRINT6: crate::Register = crate::Register::new(70, 0x3ff); + pub const SFR_INTCR_CRINT6_CRINT6: crate::Field = crate::Field::new(10, 0, SFR_INTCR_CRINT6); + + pub const SFR_INTCR_CRINT7: crate::Register = crate::Register::new(71, 0x3ff); + pub const SFR_INTCR_CRINT7_CRINT7: crate::Field = crate::Field::new(10, 0, SFR_INTCR_CRINT7); + + pub const SFR_INTFR: crate::Register = crate::Register::new(72, 0xff); + pub const SFR_INTFR_FRINT: crate::Field = crate::Field::new(8, 0, SFR_INTFR); + + pub const SFR_GPIOOUT_CRGO0: crate::Register = crate::Register::new(76, 0xffff); + pub const SFR_GPIOOUT_CRGO0_CRGO0: crate::Field = crate::Field::new(16, 0, SFR_GPIOOUT_CRGO0); + + pub const SFR_GPIOOUT_CRGO1: crate::Register = crate::Register::new(77, 0xffff); + pub const SFR_GPIOOUT_CRGO1_CRGO1: crate::Field = crate::Field::new(16, 0, SFR_GPIOOUT_CRGO1); + + pub const SFR_GPIOOUT_CRGO2: crate::Register = crate::Register::new(78, 0xffff); + pub const SFR_GPIOOUT_CRGO2_CRGO2: crate::Field = crate::Field::new(16, 0, SFR_GPIOOUT_CRGO2); + + pub const SFR_GPIOOUT_CRGO3: crate::Register = crate::Register::new(79, 0xffff); + pub const SFR_GPIOOUT_CRGO3_CRGO3: crate::Field = crate::Field::new(16, 0, SFR_GPIOOUT_CRGO3); + + pub const SFR_GPIOOUT_CRGO4: crate::Register = crate::Register::new(80, 0xffff); + pub const SFR_GPIOOUT_CRGO4_CRGO4: crate::Field = crate::Field::new(16, 0, SFR_GPIOOUT_CRGO4); + + pub const SFR_GPIOOUT_CRGO5: crate::Register = crate::Register::new(81, 0xffff); + pub const SFR_GPIOOUT_CRGO5_CRGO5: crate::Field = crate::Field::new(16, 0, SFR_GPIOOUT_CRGO5); + + pub const SFR_GPIOOE_CRGOE0: crate::Register = crate::Register::new(82, 0xffff); + pub const SFR_GPIOOE_CRGOE0_CRGOE0: crate::Field = crate::Field::new(16, 0, SFR_GPIOOE_CRGOE0); + + pub const SFR_GPIOOE_CRGOE1: crate::Register = crate::Register::new(83, 0xffff); + pub const SFR_GPIOOE_CRGOE1_CRGOE1: crate::Field = crate::Field::new(16, 0, SFR_GPIOOE_CRGOE1); + + pub const SFR_GPIOOE_CRGOE2: crate::Register = crate::Register::new(84, 0xffff); + pub const SFR_GPIOOE_CRGOE2_CRGOE2: crate::Field = crate::Field::new(16, 0, SFR_GPIOOE_CRGOE2); + + pub const SFR_GPIOOE_CRGOE3: crate::Register = crate::Register::new(85, 0xffff); + pub const SFR_GPIOOE_CRGOE3_CRGOE3: crate::Field = crate::Field::new(16, 0, SFR_GPIOOE_CRGOE3); + + pub const SFR_GPIOOE_CRGOE4: crate::Register = crate::Register::new(86, 0xffff); + pub const SFR_GPIOOE_CRGOE4_CRGOE4: crate::Field = crate::Field::new(16, 0, SFR_GPIOOE_CRGOE4); + + pub const SFR_GPIOOE_CRGOE5: crate::Register = crate::Register::new(87, 0xffff); + pub const SFR_GPIOOE_CRGOE5_CRGOE5: crate::Field = crate::Field::new(16, 0, SFR_GPIOOE_CRGOE5); + + pub const SFR_GPIOPU_CRGPU0: crate::Register = crate::Register::new(88, 0xffff); + pub const SFR_GPIOPU_CRGPU0_CRGPU0: crate::Field = crate::Field::new(16, 0, SFR_GPIOPU_CRGPU0); + + pub const SFR_GPIOPU_CRGPU1: crate::Register = crate::Register::new(89, 0xffff); + pub const SFR_GPIOPU_CRGPU1_CRGPU1: crate::Field = crate::Field::new(16, 0, SFR_GPIOPU_CRGPU1); + + pub const SFR_GPIOPU_CRGPU2: crate::Register = crate::Register::new(90, 0xffff); + pub const SFR_GPIOPU_CRGPU2_CRGPU2: crate::Field = crate::Field::new(16, 0, SFR_GPIOPU_CRGPU2); + + pub const SFR_GPIOPU_CRGPU3: crate::Register = crate::Register::new(91, 0xffff); + pub const SFR_GPIOPU_CRGPU3_CRGPU3: crate::Field = crate::Field::new(16, 0, SFR_GPIOPU_CRGPU3); + + pub const SFR_GPIOPU_CRGPU4: crate::Register = crate::Register::new(92, 0xffff); + pub const SFR_GPIOPU_CRGPU4_CRGPU4: crate::Field = crate::Field::new(16, 0, SFR_GPIOPU_CRGPU4); + + pub const SFR_GPIOPU_CRGPU5: crate::Register = crate::Register::new(93, 0xffff); + pub const SFR_GPIOPU_CRGPU5_CRGPU5: crate::Field = crate::Field::new(16, 0, SFR_GPIOPU_CRGPU5); + + pub const SFR_GPIOIN_SRGI0: crate::Register = crate::Register::new(94, 0xffff); + pub const SFR_GPIOIN_SRGI0_SRGI0: crate::Field = crate::Field::new(16, 0, SFR_GPIOIN_SRGI0); + + pub const SFR_GPIOIN_SRGI1: crate::Register = crate::Register::new(95, 0xffff); + pub const SFR_GPIOIN_SRGI1_SRGI1: crate::Field = crate::Field::new(16, 0, SFR_GPIOIN_SRGI1); + + pub const SFR_GPIOIN_SRGI2: crate::Register = crate::Register::new(96, 0xffff); + pub const SFR_GPIOIN_SRGI2_SRGI2: crate::Field = crate::Field::new(16, 0, SFR_GPIOIN_SRGI2); + + pub const SFR_GPIOIN_SRGI3: crate::Register = crate::Register::new(97, 0xffff); + pub const SFR_GPIOIN_SRGI3_SRGI3: crate::Field = crate::Field::new(16, 0, SFR_GPIOIN_SRGI3); + + pub const SFR_GPIOIN_SRGI4: crate::Register = crate::Register::new(98, 0xffff); + pub const SFR_GPIOIN_SRGI4_SRGI4: crate::Field = crate::Field::new(16, 0, SFR_GPIOIN_SRGI4); + + pub const SFR_GPIOIN_SRGI5: crate::Register = crate::Register::new(99, 0xffff); + pub const SFR_GPIOIN_SRGI5_SRGI5: crate::Field = crate::Field::new(16, 0, SFR_GPIOIN_SRGI5); + + pub const SFR_PIOSEL: crate::Register = crate::Register::new(128, 0xffffffff); + pub const SFR_PIOSEL_PIOSEL: crate::Field = crate::Field::new(32, 0, SFR_PIOSEL); + + pub const SFR_CFG_SCHM_CR_CFG_SCHMSEL0: crate::Register = crate::Register::new(140, 0xffff); + pub const SFR_CFG_SCHM_CR_CFG_SCHMSEL0_CR_CFG_SCHMSEL0: crate::Field = crate::Field::new(16, 0, SFR_CFG_SCHM_CR_CFG_SCHMSEL0); + + pub const SFR_CFG_SCHM_CR_CFG_SCHMSEL1: crate::Register = crate::Register::new(141, 0xffff); + pub const SFR_CFG_SCHM_CR_CFG_SCHMSEL1_CR_CFG_SCHMSEL1: crate::Field = crate::Field::new(16, 0, SFR_CFG_SCHM_CR_CFG_SCHMSEL1); + + pub const SFR_CFG_SCHM_CR_CFG_SCHMSEL2: crate::Register = crate::Register::new(142, 0xffff); + pub const SFR_CFG_SCHM_CR_CFG_SCHMSEL2_CR_CFG_SCHMSEL2: crate::Field = crate::Field::new(16, 0, SFR_CFG_SCHM_CR_CFG_SCHMSEL2); + + pub const SFR_CFG_SCHM_CR_CFG_SCHMSEL3: crate::Register = crate::Register::new(143, 0xffff); + pub const SFR_CFG_SCHM_CR_CFG_SCHMSEL3_CR_CFG_SCHMSEL3: crate::Field = crate::Field::new(16, 0, SFR_CFG_SCHM_CR_CFG_SCHMSEL3); + + pub const SFR_CFG_SCHM_CR_CFG_SCHMSEL4: crate::Register = crate::Register::new(144, 0xffff); + pub const SFR_CFG_SCHM_CR_CFG_SCHMSEL4_CR_CFG_SCHMSEL4: crate::Field = crate::Field::new(16, 0, SFR_CFG_SCHM_CR_CFG_SCHMSEL4); + + pub const SFR_CFG_SCHM_CR_CFG_SCHMSEL5: crate::Register = crate::Register::new(145, 0xffff); + pub const SFR_CFG_SCHM_CR_CFG_SCHMSEL5_CR_CFG_SCHMSEL5: crate::Field = crate::Field::new(16, 0, SFR_CFG_SCHM_CR_CFG_SCHMSEL5); + + pub const SFR_CFG_SLEW_CR_CFG_SLEWSLOW0: crate::Register = crate::Register::new(146, 0xffff); + pub const SFR_CFG_SLEW_CR_CFG_SLEWSLOW0_CR_CFG_SLEWSLOW0: crate::Field = crate::Field::new(16, 0, SFR_CFG_SLEW_CR_CFG_SLEWSLOW0); + + pub const SFR_CFG_SLEW_CR_CFG_SLEWSLOW1: crate::Register = crate::Register::new(147, 0xffff); + pub const SFR_CFG_SLEW_CR_CFG_SLEWSLOW1_CR_CFG_SLEWSLOW1: crate::Field = crate::Field::new(16, 0, SFR_CFG_SLEW_CR_CFG_SLEWSLOW1); + + pub const SFR_CFG_SLEW_CR_CFG_SLEWSLOW2: crate::Register = crate::Register::new(148, 0xffff); + pub const SFR_CFG_SLEW_CR_CFG_SLEWSLOW2_CR_CFG_SLEWSLOW2: crate::Field = crate::Field::new(16, 0, SFR_CFG_SLEW_CR_CFG_SLEWSLOW2); + + pub const SFR_CFG_SLEW_CR_CFG_SLEWSLOW3: crate::Register = crate::Register::new(149, 0xffff); + pub const SFR_CFG_SLEW_CR_CFG_SLEWSLOW3_CR_CFG_SLEWSLOW3: crate::Field = crate::Field::new(16, 0, SFR_CFG_SLEW_CR_CFG_SLEWSLOW3); + + pub const SFR_CFG_SLEW_CR_CFG_SLEWSLOW4: crate::Register = crate::Register::new(150, 0xffff); + pub const SFR_CFG_SLEW_CR_CFG_SLEWSLOW4_CR_CFG_SLEWSLOW4: crate::Field = crate::Field::new(16, 0, SFR_CFG_SLEW_CR_CFG_SLEWSLOW4); + + pub const SFR_CFG_SLEW_CR_CFG_SLEWSLOW5: crate::Register = crate::Register::new(151, 0xffff); + pub const SFR_CFG_SLEW_CR_CFG_SLEWSLOW5_CR_CFG_SLEWSLOW5: crate::Field = crate::Field::new(16, 0, SFR_CFG_SLEW_CR_CFG_SLEWSLOW5); + + pub const SFR_CFG_DRVSEL_CR_CFG_DRVSEL0: crate::Register = crate::Register::new(152, 0xffffffff); + pub const SFR_CFG_DRVSEL_CR_CFG_DRVSEL0_CR_CFG_DRVSEL0: crate::Field = crate::Field::new(32, 0, SFR_CFG_DRVSEL_CR_CFG_DRVSEL0); + + pub const SFR_CFG_DRVSEL_CR_CFG_DRVSEL1: crate::Register = crate::Register::new(153, 0xffffffff); + pub const SFR_CFG_DRVSEL_CR_CFG_DRVSEL1_CR_CFG_DRVSEL1: crate::Field = crate::Field::new(32, 0, SFR_CFG_DRVSEL_CR_CFG_DRVSEL1); + + pub const SFR_CFG_DRVSEL_CR_CFG_DRVSEL2: crate::Register = crate::Register::new(154, 0xffffffff); + pub const SFR_CFG_DRVSEL_CR_CFG_DRVSEL2_CR_CFG_DRVSEL2: crate::Field = crate::Field::new(32, 0, SFR_CFG_DRVSEL_CR_CFG_DRVSEL2); + + pub const SFR_CFG_DRVSEL_CR_CFG_DRVSEL3: crate::Register = crate::Register::new(155, 0xffffffff); + pub const SFR_CFG_DRVSEL_CR_CFG_DRVSEL3_CR_CFG_DRVSEL3: crate::Field = crate::Field::new(32, 0, SFR_CFG_DRVSEL_CR_CFG_DRVSEL3); + + pub const SFR_CFG_DRVSEL_CR_CFG_DRVSEL4: crate::Register = crate::Register::new(156, 0xffffffff); + pub const SFR_CFG_DRVSEL_CR_CFG_DRVSEL4_CR_CFG_DRVSEL4: crate::Field = crate::Field::new(32, 0, SFR_CFG_DRVSEL_CR_CFG_DRVSEL4); + + pub const SFR_CFG_DRVSEL_CR_CFG_DRVSEL5: crate::Register = crate::Register::new(157, 0xffffffff); + pub const SFR_CFG_DRVSEL_CR_CFG_DRVSEL5_CR_CFG_DRVSEL5: crate::Field = crate::Field::new(32, 0, SFR_CFG_DRVSEL_CR_CFG_DRVSEL5); + + pub const HW_IOX_BASE: usize = 0x5012f000; + } + + pub mod pwm { + pub const PWM_NUMREGS: usize = 46; + + pub const REG_TIM0_CMD: crate::Register = crate::Register::new(0, 0x1f); + pub const REG_TIM0_CMD_R_TIMER0_START: crate::Field = crate::Field::new(1, 0, REG_TIM0_CMD); + pub const REG_TIM0_CMD_R_TIMER0_STOP: crate::Field = crate::Field::new(1, 1, REG_TIM0_CMD); + pub const REG_TIM0_CMD_R_TIMER0_UPDATE: crate::Field = crate::Field::new(1, 2, REG_TIM0_CMD); + pub const REG_TIM0_CMD_R_TIMER0_RST: crate::Field = crate::Field::new(1, 3, REG_TIM0_CMD); + pub const REG_TIM0_CMD_R_TIMER0_ARM: crate::Field = crate::Field::new(1, 4, REG_TIM0_CMD); + + pub const REG_TIM0_CFG: crate::Register = crate::Register::new(1, 0xff1fff); + pub const REG_TIM0_CFG_R_TIMER0_IN_SEL: crate::Field = crate::Field::new(8, 0, REG_TIM0_CFG); + pub const REG_TIM0_CFG_R_TIMER0_IN_MODE: crate::Field = crate::Field::new(3, 8, REG_TIM0_CFG); + pub const REG_TIM0_CFG_R_TIMER0_IN_CLK: crate::Field = crate::Field::new(1, 11, REG_TIM0_CFG); + pub const REG_TIM0_CFG_R_TIMER0_SAW: crate::Field = crate::Field::new(1, 12, REG_TIM0_CFG); + pub const REG_TIM0_CFG_R_TIMER0_PRESC: crate::Field = crate::Field::new(8, 16, REG_TIM0_CFG); + + pub const REG_TIM0_CH0_TH: crate::Register = crate::Register::new(3, 0x7ffff); + pub const REG_TIM0_CH0_TH_R_TIMER0_CH0_TH: crate::Field = crate::Field::new(16, 0, REG_TIM0_CH0_TH); + pub const REG_TIM0_CH0_TH_R_TIMER0_CH0_MODE: crate::Field = crate::Field::new(3, 16, REG_TIM0_CH0_TH); + + pub const REG_TIM0_CH1_TH: crate::Register = crate::Register::new(4, 0x7ffff); + pub const REG_TIM0_CH1_TH_R_TIMER0_CH1_TH: crate::Field = crate::Field::new(16, 0, REG_TIM0_CH1_TH); + pub const REG_TIM0_CH1_TH_R_TIMER0_CH1_MODE: crate::Field = crate::Field::new(3, 16, REG_TIM0_CH1_TH); + + pub const REG_TIM0_CH2_TH: crate::Register = crate::Register::new(5, 0x7ffff); + pub const REG_TIM0_CH2_TH_R_TIMER0_CH2_TH: crate::Field = crate::Field::new(16, 0, REG_TIM0_CH2_TH); + pub const REG_TIM0_CH2_TH_R_TIMER0_CH2_MODE: crate::Field = crate::Field::new(3, 16, REG_TIM0_CH2_TH); + + pub const REG_TIM0_CH3_TH: crate::Register = crate::Register::new(6, 0x7ffff); + pub const REG_TIM0_CH3_TH_R_TIMER0_CH3_TH: crate::Field = crate::Field::new(16, 0, REG_TIM0_CH3_TH); + pub const REG_TIM0_CH3_TH_R_TIMER0_CH3_MODE: crate::Field = crate::Field::new(3, 16, REG_TIM0_CH3_TH); + + pub const REG_TIM0_CH0_LUT: crate::Register = crate::Register::new(7, 0x3ffff); + pub const REG_TIM0_CH0_LUT_R_TIMER0_CH0_LUT: crate::Field = crate::Field::new(16, 0, REG_TIM0_CH0_LUT); + pub const REG_TIM0_CH0_LUT_R_TIMER0_CH0_FLT: crate::Field = crate::Field::new(2, 16, REG_TIM0_CH0_LUT); + + pub const REG_TIM0_CH1_LUT: crate::Register = crate::Register::new(8, 0x3ffff); + pub const REG_TIM0_CH1_LUT_R_TIMER0_CH1_LUT: crate::Field = crate::Field::new(16, 0, REG_TIM0_CH1_LUT); + pub const REG_TIM0_CH1_LUT_R_TIMER0_CH1_FLT: crate::Field = crate::Field::new(2, 16, REG_TIM0_CH1_LUT); + + pub const REG_TIM0_CH2_LUT: crate::Register = crate::Register::new(9, 0x3ffff); + pub const REG_TIM0_CH2_LUT_R_TIMER0_CH2_LUT: crate::Field = crate::Field::new(16, 0, REG_TIM0_CH2_LUT); + pub const REG_TIM0_CH2_LUT_R_TIMER0_CH2_FLT: crate::Field = crate::Field::new(2, 16, REG_TIM0_CH2_LUT); + + pub const REG_TIM0_CH3_LUT: crate::Register = crate::Register::new(10, 0x3ffff); + pub const REG_TIM0_CH3_LUT_R_TIMER0_CH3_LUT: crate::Field = crate::Field::new(16, 0, REG_TIM0_CH3_LUT); + pub const REG_TIM0_CH3_LUT_R_TIMER0_CH3_FLT: crate::Field = crate::Field::new(2, 16, REG_TIM0_CH3_LUT); + + pub const REG_TIM1_CMD: crate::Register = crate::Register::new(16, 0x1f); + pub const REG_TIM1_CMD_R_TIMER1_START: crate::Field = crate::Field::new(1, 0, REG_TIM1_CMD); + pub const REG_TIM1_CMD_R_TIMER1_STOP: crate::Field = crate::Field::new(1, 1, REG_TIM1_CMD); + pub const REG_TIM1_CMD_R_TIMER1_UPDATE: crate::Field = crate::Field::new(1, 2, REG_TIM1_CMD); + pub const REG_TIM1_CMD_R_TIMER1_RST: crate::Field = crate::Field::new(1, 3, REG_TIM1_CMD); + pub const REG_TIM1_CMD_R_TIMER1_ARM: crate::Field = crate::Field::new(1, 4, REG_TIM1_CMD); + + pub const REG_TIM1_CFG: crate::Register = crate::Register::new(17, 0xff1fff); + pub const REG_TIM1_CFG_R_TIMER1_IN_SEL: crate::Field = crate::Field::new(8, 0, REG_TIM1_CFG); + pub const REG_TIM1_CFG_R_TIMER1_IN_MODE: crate::Field = crate::Field::new(3, 8, REG_TIM1_CFG); + pub const REG_TIM1_CFG_R_TIMER1_IN_CLK: crate::Field = crate::Field::new(1, 11, REG_TIM1_CFG); + pub const REG_TIM1_CFG_R_TIMER1_SAW: crate::Field = crate::Field::new(1, 12, REG_TIM1_CFG); + pub const REG_TIM1_CFG_R_TIMER1_PRESC: crate::Field = crate::Field::new(8, 16, REG_TIM1_CFG); + + pub const REG_TIM1_CH0_TH: crate::Register = crate::Register::new(19, 0x7ffff); + pub const REG_TIM1_CH0_TH_R_TIMER1_CH0_TH: crate::Field = crate::Field::new(16, 0, REG_TIM1_CH0_TH); + pub const REG_TIM1_CH0_TH_R_TIMER1_CH0_MODE: crate::Field = crate::Field::new(3, 16, REG_TIM1_CH0_TH); + + pub const REG_TIM1_CH1_TH: crate::Register = crate::Register::new(20, 0x7ffff); + pub const REG_TIM1_CH1_TH_R_TIMER1_CH1_TH: crate::Field = crate::Field::new(16, 0, REG_TIM1_CH1_TH); + pub const REG_TIM1_CH1_TH_R_TIMER1_CH1_MODE: crate::Field = crate::Field::new(3, 16, REG_TIM1_CH1_TH); + + pub const REG_TIM1_CH2_TH: crate::Register = crate::Register::new(21, 0x7ffff); + pub const REG_TIM1_CH2_TH_R_TIMER1_CH2_TH: crate::Field = crate::Field::new(16, 0, REG_TIM1_CH2_TH); + pub const REG_TIM1_CH2_TH_R_TIMER1_CH2_MODE: crate::Field = crate::Field::new(3, 16, REG_TIM1_CH2_TH); + + pub const REG_TIM1_CH3_TH: crate::Register = crate::Register::new(22, 0x7ffff); + pub const REG_TIM1_CH3_TH_R_TIMER1_CH3_TH: crate::Field = crate::Field::new(16, 0, REG_TIM1_CH3_TH); + pub const REG_TIM1_CH3_TH_R_TIMER1_CH3_MODE: crate::Field = crate::Field::new(3, 16, REG_TIM1_CH3_TH); + + pub const REG_TIM1_CH0_LUT: crate::Register = crate::Register::new(23, 0x3ffff); + pub const REG_TIM1_CH0_LUT_R_TIMER1_CH0_LUT: crate::Field = crate::Field::new(16, 0, REG_TIM1_CH0_LUT); + pub const REG_TIM1_CH0_LUT_R_TIMER1_CH0_FLT: crate::Field = crate::Field::new(2, 16, REG_TIM1_CH0_LUT); + + pub const REG_TIM1_CH1_LUT: crate::Register = crate::Register::new(24, 0x3ffff); + pub const REG_TIM1_CH1_LUT_R_TIMER1_CH1_LUT: crate::Field = crate::Field::new(16, 0, REG_TIM1_CH1_LUT); + pub const REG_TIM1_CH1_LUT_R_TIMER1_CH1_FLT: crate::Field = crate::Field::new(2, 16, REG_TIM1_CH1_LUT); + + pub const REG_TIM1_CH2_LUT: crate::Register = crate::Register::new(25, 0x3ffff); + pub const REG_TIM1_CH2_LUT_R_TIMER1_CH2_LUT: crate::Field = crate::Field::new(16, 0, REG_TIM1_CH2_LUT); + pub const REG_TIM1_CH2_LUT_R_TIMER1_CH2_FLT: crate::Field = crate::Field::new(2, 16, REG_TIM1_CH2_LUT); + + pub const REG_TIM1_CH3_LUT: crate::Register = crate::Register::new(26, 0x3ffff); + pub const REG_TIM1_CH3_LUT_R_TIMER1_CH3_LUT: crate::Field = crate::Field::new(16, 0, REG_TIM1_CH3_LUT); + pub const REG_TIM1_CH3_LUT_R_TIMER1_CH3_FLT: crate::Field = crate::Field::new(2, 16, REG_TIM1_CH3_LUT); + + pub const REG_TIM2_CMD: crate::Register = crate::Register::new(32, 0x1f); + pub const REG_TIM2_CMD_R_TIMER2_START: crate::Field = crate::Field::new(1, 0, REG_TIM2_CMD); + pub const REG_TIM2_CMD_R_TIMER2_STOP: crate::Field = crate::Field::new(1, 1, REG_TIM2_CMD); + pub const REG_TIM2_CMD_R_TIMER2_UPDATE: crate::Field = crate::Field::new(1, 2, REG_TIM2_CMD); + pub const REG_TIM2_CMD_R_TIMER2_RST: crate::Field = crate::Field::new(1, 3, REG_TIM2_CMD); + pub const REG_TIM2_CMD_R_TIMER2_ARM: crate::Field = crate::Field::new(1, 4, REG_TIM2_CMD); + + pub const REG_TIM2_CFG: crate::Register = crate::Register::new(33, 0xff1fff); + pub const REG_TIM2_CFG_R_TIMER2_IN_SEL: crate::Field = crate::Field::new(8, 0, REG_TIM2_CFG); + pub const REG_TIM2_CFG_R_TIMER2_IN_MODE: crate::Field = crate::Field::new(3, 8, REG_TIM2_CFG); + pub const REG_TIM2_CFG_R_TIMER2_IN_CLK: crate::Field = crate::Field::new(1, 11, REG_TIM2_CFG); + pub const REG_TIM2_CFG_R_TIMER2_SAW: crate::Field = crate::Field::new(1, 12, REG_TIM2_CFG); + pub const REG_TIM2_CFG_R_TIMER2_PRESC: crate::Field = crate::Field::new(8, 16, REG_TIM2_CFG); + + pub const REG_TIM2_CH0_TH: crate::Register = crate::Register::new(35, 0x7ffff); + pub const REG_TIM2_CH0_TH_R_TIMER2_CH0_TH: crate::Field = crate::Field::new(16, 0, REG_TIM2_CH0_TH); + pub const REG_TIM2_CH0_TH_R_TIMER2_CH0_MODE: crate::Field = crate::Field::new(3, 16, REG_TIM2_CH0_TH); + + pub const REG_TIM2_CH1_TH: crate::Register = crate::Register::new(36, 0x7ffff); + pub const REG_TIM2_CH1_TH_R_TIMER2_CH1_TH: crate::Field = crate::Field::new(16, 0, REG_TIM2_CH1_TH); + pub const REG_TIM2_CH1_TH_R_TIMER2_CH1_MODE: crate::Field = crate::Field::new(3, 16, REG_TIM2_CH1_TH); + + pub const REG_TIM2_CH2_TH: crate::Register = crate::Register::new(37, 0x7ffff); + pub const REG_TIM2_CH2_TH_R_TIMER2_CH2_TH: crate::Field = crate::Field::new(16, 0, REG_TIM2_CH2_TH); + pub const REG_TIM2_CH2_TH_R_TIMER2_CH2_MODE: crate::Field = crate::Field::new(3, 16, REG_TIM2_CH2_TH); + + pub const REG_TIM2_CH3_TH: crate::Register = crate::Register::new(38, 0x7ffff); + pub const REG_TIM2_CH3_TH_R_TIMER2_CH3_TH: crate::Field = crate::Field::new(16, 0, REG_TIM2_CH3_TH); + pub const REG_TIM2_CH3_TH_R_TIMER2_CH3_MODE: crate::Field = crate::Field::new(3, 16, REG_TIM2_CH3_TH); + + pub const REG_TIM2_CH0_LUT: crate::Register = crate::Register::new(39, 0x3ffff); + pub const REG_TIM2_CH0_LUT_R_TIMER2_CH0_LUT: crate::Field = crate::Field::new(16, 0, REG_TIM2_CH0_LUT); + pub const REG_TIM2_CH0_LUT_R_TIMER2_CH0_FLT: crate::Field = crate::Field::new(2, 16, REG_TIM2_CH0_LUT); + + pub const REG_TIM2_CH1_LUT: crate::Register = crate::Register::new(40, 0x3ffff); + pub const REG_TIM2_CH1_LUT_R_TIMER2_CH1_LUT: crate::Field = crate::Field::new(16, 0, REG_TIM2_CH1_LUT); + pub const REG_TIM2_CH1_LUT_R_TIMER2_CH1_FLT: crate::Field = crate::Field::new(2, 16, REG_TIM2_CH1_LUT); + + pub const REG_TIM2_CH2_LUT: crate::Register = crate::Register::new(41, 0x3ffff); + pub const REG_TIM2_CH2_LUT_R_TIMER2_CH2_LUT: crate::Field = crate::Field::new(16, 0, REG_TIM2_CH2_LUT); + pub const REG_TIM2_CH2_LUT_R_TIMER2_CH2_FLT: crate::Field = crate::Field::new(2, 16, REG_TIM2_CH2_LUT); + + pub const REG_TIM2_CH3_LUT: crate::Register = crate::Register::new(42, 0x3ffff); + pub const REG_TIM2_CH3_LUT_R_TIMER2_CH3_LUT: crate::Field = crate::Field::new(16, 0, REG_TIM2_CH3_LUT); + pub const REG_TIM2_CH3_LUT_R_TIMER2_CH3_FLT: crate::Field = crate::Field::new(2, 16, REG_TIM2_CH3_LUT); + + pub const REG_TIM3_CMD: crate::Register = crate::Register::new(48, 0x1f); + pub const REG_TIM3_CMD_R_TIMER3_START: crate::Field = crate::Field::new(1, 0, REG_TIM3_CMD); + pub const REG_TIM3_CMD_R_TIMER3_STOP: crate::Field = crate::Field::new(1, 1, REG_TIM3_CMD); + pub const REG_TIM3_CMD_R_TIMER3_UPDATE: crate::Field = crate::Field::new(1, 2, REG_TIM3_CMD); + pub const REG_TIM3_CMD_R_TIMER3_RST: crate::Field = crate::Field::new(1, 3, REG_TIM3_CMD); + pub const REG_TIM3_CMD_R_TIMER3_ARM: crate::Field = crate::Field::new(1, 4, REG_TIM3_CMD); + + pub const REG_TIM3_CFG: crate::Register = crate::Register::new(49, 0xff1fff); + pub const REG_TIM3_CFG_R_TIMER3_IN_SEL: crate::Field = crate::Field::new(8, 0, REG_TIM3_CFG); + pub const REG_TIM3_CFG_R_TIMER3_IN_MODE: crate::Field = crate::Field::new(3, 8, REG_TIM3_CFG); + pub const REG_TIM3_CFG_R_TIMER3_IN_CLK: crate::Field = crate::Field::new(1, 11, REG_TIM3_CFG); + pub const REG_TIM3_CFG_R_TIMER3_SAW: crate::Field = crate::Field::new(1, 12, REG_TIM3_CFG); + pub const REG_TIM3_CFG_R_TIMER3_PRESC: crate::Field = crate::Field::new(8, 16, REG_TIM3_CFG); + + pub const REG_TIM3_CH0_TH: crate::Register = crate::Register::new(51, 0x7ffff); + pub const REG_TIM3_CH0_TH_R_TIMER3_CH0_TH: crate::Field = crate::Field::new(16, 0, REG_TIM3_CH0_TH); + pub const REG_TIM3_CH0_TH_R_TIMER3_CH0_MODE: crate::Field = crate::Field::new(3, 16, REG_TIM3_CH0_TH); + + pub const REG_TIM3_CH1_TH: crate::Register = crate::Register::new(52, 0x7ffff); + pub const REG_TIM3_CH1_TH_R_TIMER3_CH1_TH: crate::Field = crate::Field::new(16, 0, REG_TIM3_CH1_TH); + pub const REG_TIM3_CH1_TH_R_TIMER3_CH1_MODE: crate::Field = crate::Field::new(3, 16, REG_TIM3_CH1_TH); + + pub const REG_TIM3_CH2_TH: crate::Register = crate::Register::new(53, 0x7ffff); + pub const REG_TIM3_CH2_TH_R_TIMER3_CH2_TH: crate::Field = crate::Field::new(16, 0, REG_TIM3_CH2_TH); + pub const REG_TIM3_CH2_TH_R_TIMER3_CH2_MODE: crate::Field = crate::Field::new(3, 16, REG_TIM3_CH2_TH); + + pub const REG_TIM3_CH3_TH: crate::Register = crate::Register::new(54, 0x7ffff); + pub const REG_TIM3_CH3_TH_R_TIMER3_CH3_TH: crate::Field = crate::Field::new(16, 0, REG_TIM3_CH3_TH); + pub const REG_TIM3_CH3_TH_R_TIMER3_CH3_MODE: crate::Field = crate::Field::new(3, 16, REG_TIM3_CH3_TH); + + pub const REG_TIM3_CH0_LUT: crate::Register = crate::Register::new(55, 0x3ffff); + pub const REG_TIM3_CH0_LUT_R_TIMER3_CH0_LUT: crate::Field = crate::Field::new(16, 0, REG_TIM3_CH0_LUT); + pub const REG_TIM3_CH0_LUT_R_TIMER3_CH0_FLT: crate::Field = crate::Field::new(2, 16, REG_TIM3_CH0_LUT); + + pub const REG_TIM3_CH1_LUT: crate::Register = crate::Register::new(56, 0x3ffff); + pub const REG_TIM3_CH1_LUT_R_TIMER3_CH1_LUT: crate::Field = crate::Field::new(16, 0, REG_TIM3_CH1_LUT); + pub const REG_TIM3_CH1_LUT_R_TIMER3_CH1_FLT: crate::Field = crate::Field::new(2, 16, REG_TIM3_CH1_LUT); + + pub const REG_TIM3_CH2_LUT: crate::Register = crate::Register::new(57, 0x3ffff); + pub const REG_TIM3_CH2_LUT_R_TIMER3_CH2_LUT: crate::Field = crate::Field::new(16, 0, REG_TIM3_CH2_LUT); + pub const REG_TIM3_CH2_LUT_R_TIMER3_CH2_FLT: crate::Field = crate::Field::new(2, 16, REG_TIM3_CH2_LUT); + + pub const REG_TIM3_CH3_LUT: crate::Register = crate::Register::new(58, 0x3ffff); + pub const REG_TIM3_CH3_LUT_R_TIMER3_CH3_LUT: crate::Field = crate::Field::new(16, 0, REG_TIM3_CH3_LUT); + pub const REG_TIM3_CH3_LUT_R_TIMER3_CH3_FLT: crate::Field = crate::Field::new(2, 16, REG_TIM3_CH3_LUT); + + pub const REG_EVENT_CFG: crate::Register = crate::Register::new(64, 0xfffff); + pub const REG_EVENT_CFG_R_EVENT_SEL_0: crate::Field = crate::Field::new(4, 0, REG_EVENT_CFG); + pub const REG_EVENT_CFG_R_EVENT_SEL_1: crate::Field = crate::Field::new(4, 4, REG_EVENT_CFG); + pub const REG_EVENT_CFG_R_EVENT_SEL_2: crate::Field = crate::Field::new(4, 8, REG_EVENT_CFG); + pub const REG_EVENT_CFG_R_EVENT_SEL_3: crate::Field = crate::Field::new(4, 12, REG_EVENT_CFG); + pub const REG_EVENT_CFG_R_EVENT_EN: crate::Field = crate::Field::new(4, 16, REG_EVENT_CFG); + + pub const REG_CH_EN: crate::Register = crate::Register::new(65, 0xf); + pub const REG_CH_EN_R_CLK_EN: crate::Field = crate::Field::new(4, 0, REG_CH_EN); + + pub const REG_PREFD0: crate::Register = crate::Register::new(80, 0x3ff); + pub const REG_PREFD0_LSCLK_PREFD_0: crate::Field = crate::Field::new(10, 0, REG_PREFD0); + + pub const REG_PREFD1: crate::Register = crate::Register::new(81, 0x3ff); + pub const REG_PREFD1_LSCLK_PREFD_1: crate::Field = crate::Field::new(10, 0, REG_PREFD1); + + pub const REG_PREFD2: crate::Register = crate::Register::new(82, 0x3ff); + pub const REG_PREFD2_LSCLK_PREFD_2: crate::Field = crate::Field::new(10, 0, REG_PREFD2); + + pub const REG_PREFD3: crate::Register = crate::Register::new(83, 0x3ff); + pub const REG_PREFD3_LSCLK_PREFD_3: crate::Field = crate::Field::new(10, 0, REG_PREFD3); + + pub const HW_PWM_BASE: usize = 0x50120000; + } + + pub mod coresub_sramtrm { + pub const CORESUB_SRAMTRM_NUMREGS: usize = 7; + + pub const SFR_CACHE: crate::Register = crate::Register::new(0, 0x7); + pub const SFR_CACHE_SFR_CACHE: crate::Field = crate::Field::new(3, 0, SFR_CACHE); + + pub const SFR_ITCM: crate::Register = crate::Register::new(1, 0x1f); + pub const SFR_ITCM_SFR_ITCM: crate::Field = crate::Field::new(5, 0, SFR_ITCM); + + pub const SFR_DTCM: crate::Register = crate::Register::new(2, 0x1f); + pub const SFR_DTCM_SFR_DTCM: crate::Field = crate::Field::new(5, 0, SFR_DTCM); + + pub const SFR_SRAM0: crate::Register = crate::Register::new(3, 0x1f); + pub const SFR_SRAM0_SFR_SRAM0: crate::Field = crate::Field::new(5, 0, SFR_SRAM0); + + pub const SFR_SRAM1: crate::Register = crate::Register::new(4, 0x1f); + pub const SFR_SRAM1_SFR_SRAM1: crate::Field = crate::Field::new(5, 0, SFR_SRAM1); + + pub const SFR_VEXRAM: crate::Register = crate::Register::new(5, 0x7); + pub const SFR_VEXRAM_SFR_VEXRAM: crate::Field = crate::Field::new(3, 0, SFR_VEXRAM); + + pub const SFR_SRAMERR: crate::Register = crate::Register::new(8, 0xf); + pub const SFR_SRAMERR_SRAMBANKERR: crate::Field = crate::Field::new(4, 0, SFR_SRAMERR); + + pub const HW_CORESUB_SRAMTRM_BASE: usize = 0x40014000; + } + + pub mod mdma { + pub const MDMA_NUMREGS: usize = 24; + + pub const SFR_EVSEL_CR_EVSEL0: crate::Register = crate::Register::new(0, 0xff); + pub const SFR_EVSEL_CR_EVSEL0_CR_EVSEL0: crate::Field = crate::Field::new(8, 0, SFR_EVSEL_CR_EVSEL0); + + pub const SFR_EVSEL_CR_EVSEL1: crate::Register = crate::Register::new(1, 0xff); + pub const SFR_EVSEL_CR_EVSEL1_CR_EVSEL1: crate::Field = crate::Field::new(8, 0, SFR_EVSEL_CR_EVSEL1); + + pub const SFR_EVSEL_CR_EVSEL2: crate::Register = crate::Register::new(2, 0xff); + pub const SFR_EVSEL_CR_EVSEL2_CR_EVSEL2: crate::Field = crate::Field::new(8, 0, SFR_EVSEL_CR_EVSEL2); + + pub const SFR_EVSEL_CR_EVSEL3: crate::Register = crate::Register::new(3, 0xff); + pub const SFR_EVSEL_CR_EVSEL3_CR_EVSEL3: crate::Field = crate::Field::new(8, 0, SFR_EVSEL_CR_EVSEL3); + + pub const SFR_EVSEL_CR_EVSEL4: crate::Register = crate::Register::new(4, 0xff); + pub const SFR_EVSEL_CR_EVSEL4_CR_EVSEL4: crate::Field = crate::Field::new(8, 0, SFR_EVSEL_CR_EVSEL4); + + pub const SFR_EVSEL_CR_EVSEL5: crate::Register = crate::Register::new(5, 0xff); + pub const SFR_EVSEL_CR_EVSEL5_CR_EVSEL5: crate::Field = crate::Field::new(8, 0, SFR_EVSEL_CR_EVSEL5); + + pub const SFR_EVSEL_CR_EVSEL6: crate::Register = crate::Register::new(6, 0xff); + pub const SFR_EVSEL_CR_EVSEL6_CR_EVSEL6: crate::Field = crate::Field::new(8, 0, SFR_EVSEL_CR_EVSEL6); + + pub const SFR_EVSEL_CR_EVSEL7: crate::Register = crate::Register::new(7, 0xff); + pub const SFR_EVSEL_CR_EVSEL7_CR_EVSEL7: crate::Field = crate::Field::new(8, 0, SFR_EVSEL_CR_EVSEL7); + + pub const SFR_CR_CR_MDMAREQ0: crate::Register = crate::Register::new(8, 0x1f); + pub const SFR_CR_CR_MDMAREQ0_CR_MDMAREQ0: crate::Field = crate::Field::new(5, 0, SFR_CR_CR_MDMAREQ0); + + pub const SFR_CR_CR_MDMAREQ1: crate::Register = crate::Register::new(9, 0x1f); + pub const SFR_CR_CR_MDMAREQ1_CR_MDMAREQ1: crate::Field = crate::Field::new(5, 0, SFR_CR_CR_MDMAREQ1); + + pub const SFR_CR_CR_MDMAREQ2: crate::Register = crate::Register::new(10, 0x1f); + pub const SFR_CR_CR_MDMAREQ2_CR_MDMAREQ2: crate::Field = crate::Field::new(5, 0, SFR_CR_CR_MDMAREQ2); + + pub const SFR_CR_CR_MDMAREQ3: crate::Register = crate::Register::new(11, 0x1f); + pub const SFR_CR_CR_MDMAREQ3_CR_MDMAREQ3: crate::Field = crate::Field::new(5, 0, SFR_CR_CR_MDMAREQ3); + + pub const SFR_CR_CR_MDMAREQ4: crate::Register = crate::Register::new(12, 0x1f); + pub const SFR_CR_CR_MDMAREQ4_CR_MDMAREQ4: crate::Field = crate::Field::new(5, 0, SFR_CR_CR_MDMAREQ4); + + pub const SFR_CR_CR_MDMAREQ5: crate::Register = crate::Register::new(13, 0x1f); + pub const SFR_CR_CR_MDMAREQ5_CR_MDMAREQ5: crate::Field = crate::Field::new(5, 0, SFR_CR_CR_MDMAREQ5); + + pub const SFR_CR_CR_MDMAREQ6: crate::Register = crate::Register::new(14, 0x1f); + pub const SFR_CR_CR_MDMAREQ6_CR_MDMAREQ6: crate::Field = crate::Field::new(5, 0, SFR_CR_CR_MDMAREQ6); + + pub const SFR_CR_CR_MDMAREQ7: crate::Register = crate::Register::new(15, 0x1f); + pub const SFR_CR_CR_MDMAREQ7_CR_MDMAREQ7: crate::Field = crate::Field::new(5, 0, SFR_CR_CR_MDMAREQ7); + + pub const SFR_SR_SR_MDMAREQ0: crate::Register = crate::Register::new(16, 0x1f); + pub const SFR_SR_SR_MDMAREQ0_SR_MDMAREQ0: crate::Field = crate::Field::new(5, 0, SFR_SR_SR_MDMAREQ0); + + pub const SFR_SR_SR_MDMAREQ1: crate::Register = crate::Register::new(17, 0x1f); + pub const SFR_SR_SR_MDMAREQ1_SR_MDMAREQ1: crate::Field = crate::Field::new(5, 0, SFR_SR_SR_MDMAREQ1); + + pub const SFR_SR_SR_MDMAREQ2: crate::Register = crate::Register::new(18, 0x1f); + pub const SFR_SR_SR_MDMAREQ2_SR_MDMAREQ2: crate::Field = crate::Field::new(5, 0, SFR_SR_SR_MDMAREQ2); + + pub const SFR_SR_SR_MDMAREQ3: crate::Register = crate::Register::new(19, 0x1f); + pub const SFR_SR_SR_MDMAREQ3_SR_MDMAREQ3: crate::Field = crate::Field::new(5, 0, SFR_SR_SR_MDMAREQ3); + + pub const SFR_SR_SR_MDMAREQ4: crate::Register = crate::Register::new(20, 0x1f); + pub const SFR_SR_SR_MDMAREQ4_SR_MDMAREQ4: crate::Field = crate::Field::new(5, 0, SFR_SR_SR_MDMAREQ4); + + pub const SFR_SR_SR_MDMAREQ5: crate::Register = crate::Register::new(21, 0x1f); + pub const SFR_SR_SR_MDMAREQ5_SR_MDMAREQ5: crate::Field = crate::Field::new(5, 0, SFR_SR_SR_MDMAREQ5); + + pub const SFR_SR_SR_MDMAREQ6: crate::Register = crate::Register::new(22, 0x1f); + pub const SFR_SR_SR_MDMAREQ6_SR_MDMAREQ6: crate::Field = crate::Field::new(5, 0, SFR_SR_SR_MDMAREQ6); + + pub const SFR_SR_SR_MDMAREQ7: crate::Register = crate::Register::new(23, 0x1f); + pub const SFR_SR_SR_MDMAREQ7_SR_MDMAREQ7: crate::Field = crate::Field::new(5, 0, SFR_SR_SR_MDMAREQ7); + + pub const HW_MDMA_BASE: usize = 0x40012000; + } + + pub mod qfc { + pub const QFC_NUMREGS: usize = 14; + + pub const SFR_IO: crate::Register = crate::Register::new(0, 0xff); + pub const SFR_IO_SFR_IO: crate::Field = crate::Field::new(8, 0, SFR_IO); + + pub const SFR_AR: crate::Register = crate::Register::new(1, 0xffffffff); + pub const SFR_AR_SFR_AR: crate::Field = crate::Field::new(32, 0, SFR_AR); + + pub const SFR_IODRV: crate::Register = crate::Register::new(2, 0xfff); + pub const SFR_IODRV_PADDRVSEL: crate::Field = crate::Field::new(12, 0, SFR_IODRV); + + pub const CR_XIP_ADDRMODE: crate::Register = crate::Register::new(4, 0x3); + pub const CR_XIP_ADDRMODE_CR_XIP_ADDRMODE: crate::Field = crate::Field::new(2, 0, CR_XIP_ADDRMODE); + + pub const CR_XIP_OPCODE: crate::Register = crate::Register::new(5, 0xffffffff); + pub const CR_XIP_OPCODE_CR_XIP_OPCODE: crate::Field = crate::Field::new(32, 0, CR_XIP_OPCODE); + + pub const CR_XIP_WIDTH: crate::Register = crate::Register::new(6, 0x3f); + pub const CR_XIP_WIDTH_CR_XIP_WIDTH: crate::Field = crate::Field::new(6, 0, CR_XIP_WIDTH); + + pub const CR_XIP_SSEL: crate::Register = crate::Register::new(7, 0x7f); + pub const CR_XIP_SSEL_CR_XIP_SSEL: crate::Field = crate::Field::new(7, 0, CR_XIP_SSEL); + + pub const CR_XIP_DUMCYC: crate::Register = crate::Register::new(8, 0xffff); + pub const CR_XIP_DUMCYC_CR_XIP_DUMCYC: crate::Field = crate::Field::new(16, 0, CR_XIP_DUMCYC); + + pub const CR_XIP_CFG: crate::Register = crate::Register::new(9, 0x7fff); + pub const CR_XIP_CFG_CR_XIP_CFG: crate::Field = crate::Field::new(15, 0, CR_XIP_CFG); + + pub const CR_AESKEY_AESKEYIN0: crate::Register = crate::Register::new(16, 0xffffffff); + pub const CR_AESKEY_AESKEYIN0_AESKEYIN0: crate::Field = crate::Field::new(32, 0, CR_AESKEY_AESKEYIN0); + + pub const CR_AESKEY_AESKEYIN1: crate::Register = crate::Register::new(17, 0xffffffff); + pub const CR_AESKEY_AESKEYIN1_AESKEYIN1: crate::Field = crate::Field::new(32, 0, CR_AESKEY_AESKEYIN1); + + pub const CR_AESKEY_AESKEYIN2: crate::Register = crate::Register::new(18, 0xffffffff); + pub const CR_AESKEY_AESKEYIN2_AESKEYIN2: crate::Field = crate::Field::new(32, 0, CR_AESKEY_AESKEYIN2); + + pub const CR_AESKEY_AESKEYIN3: crate::Register = crate::Register::new(19, 0xffffffff); + pub const CR_AESKEY_AESKEYIN3_AESKEYIN3: crate::Field = crate::Field::new(32, 0, CR_AESKEY_AESKEYIN3); + + pub const CR_AESENA: crate::Register = crate::Register::new(20, 0x1); + pub const CR_AESENA_CR_AESENA: crate::Field = crate::Field::new(1, 0, CR_AESENA); + + pub const HW_QFC_BASE: usize = 0x40010000; + } + + pub mod mbox_apb { + pub const MBOX_APB_NUMREGS: usize = 5; + + pub const SFR_WDATA: crate::Register = crate::Register::new(0, 0xffffffff); + pub const SFR_WDATA_SFR_WDATA: crate::Field = crate::Field::new(32, 0, SFR_WDATA); + + pub const SFR_RDATA: crate::Register = crate::Register::new(1, 0xffffffff); + pub const SFR_RDATA_SFR_RDATA: crate::Field = crate::Field::new(32, 0, SFR_RDATA); + + pub const SFR_STATUS: crate::Register = crate::Register::new(2, 0x3f); + pub const SFR_STATUS_RX_AVAIL: crate::Field = crate::Field::new(1, 0, SFR_STATUS); + pub const SFR_STATUS_TX_FREE: crate::Field = crate::Field::new(1, 1, SFR_STATUS); + pub const SFR_STATUS_ABORT_IN_PROGRESS: crate::Field = crate::Field::new(1, 2, SFR_STATUS); + pub const SFR_STATUS_ABORT_ACK: crate::Field = crate::Field::new(1, 3, SFR_STATUS); + pub const SFR_STATUS_TX_ERR: crate::Field = crate::Field::new(1, 4, SFR_STATUS); + pub const SFR_STATUS_RX_ERR: crate::Field = crate::Field::new(1, 5, SFR_STATUS); + + pub const SFR_ABORT: crate::Register = crate::Register::new(6, 0xffffffff); + pub const SFR_ABORT_SFR_ABORT: crate::Field = crate::Field::new(32, 0, SFR_ABORT); + + pub const SFR_DONE: crate::Register = crate::Register::new(7, 0xffffffff); + pub const SFR_DONE_SFR_DONE: crate::Field = crate::Field::new(32, 0, SFR_DONE); + + pub const HW_MBOX_APB_BASE: usize = 0x40013000; + } + + pub mod gluechain { + pub const GLUECHAIN_NUMREGS: usize = 4; + + pub const SFR_GCMASK: crate::Register = crate::Register::new(0, 0xffffffff); + pub const SFR_GCMASK_CR_GCMASK: crate::Field = crate::Field::new(32, 0, SFR_GCMASK); + + pub const SFR_GCSR: crate::Register = crate::Register::new(1, 0xffffffff); + pub const SFR_GCSR_GLUEREG: crate::Field = crate::Field::new(32, 0, SFR_GCSR); + + pub const SFR_GCRST: crate::Register = crate::Register::new(2, 0xffffffff); + pub const SFR_GCRST_GLUERST: crate::Field = crate::Field::new(32, 0, SFR_GCRST); + + pub const SFR_GCTEST: crate::Register = crate::Register::new(3, 0xffffffff); + pub const SFR_GCTEST_GLUETEST: crate::Field = crate::Field::new(32, 0, SFR_GCTEST); + + pub const HW_GLUECHAIN_BASE: usize = 0x40054000; + } + pub mod udma_ctrl { pub const UDMA_CTRL_NUMREGS: usize = 3; @@ -2420,11 +3816,12 @@ pub mod utra { pub const REG_RX_SIZE: crate::Register = crate::Register::new(1, 0xffff); pub const REG_RX_SIZE_R_RX_SIZE: crate::Field = crate::Field::new(16, 0, REG_RX_SIZE); - pub const REG_RX_CFG: crate::Register = crate::Register::new(2, 0x57); + pub const REG_RX_CFG: crate::Register = crate::Register::new(2, 0xd7); pub const REG_RX_CFG_R_RX_CONTINUOUS: crate::Field = crate::Field::new(1, 0, REG_RX_CFG); pub const REG_RX_CFG_R_RX_DATASIZE: crate::Field = crate::Field::new(2, 1, REG_RX_CFG); pub const REG_RX_CFG_R_RX_EN: crate::Field = crate::Field::new(1, 4, REG_RX_CFG); pub const REG_RX_CFG_R_RX_CLR: crate::Field = crate::Field::new(1, 6, REG_RX_CFG); + pub const REG_RX_CFG_R_RX_BACKPRESSURE: crate::Field = crate::Field::new(1, 7, REG_RX_CFG); pub const REG_TX_SADDR: crate::Register = crate::Register::new(4, 0xfff); pub const REG_TX_SADDR_R_TX_STARTADDR: crate::Field = crate::Field::new(12, 0, REG_TX_SADDR); @@ -2464,11 +3861,12 @@ pub mod utra { pub const REG_RX_SIZE: crate::Register = crate::Register::new(1, 0xffff); pub const REG_RX_SIZE_R_RX_SIZE: crate::Field = crate::Field::new(16, 0, REG_RX_SIZE); - pub const REG_RX_CFG: crate::Register = crate::Register::new(2, 0x57); + pub const REG_RX_CFG: crate::Register = crate::Register::new(2, 0xd7); pub const REG_RX_CFG_R_RX_CONTINUOUS: crate::Field = crate::Field::new(1, 0, REG_RX_CFG); pub const REG_RX_CFG_R_RX_DATASIZE: crate::Field = crate::Field::new(2, 1, REG_RX_CFG); pub const REG_RX_CFG_R_RX_EN: crate::Field = crate::Field::new(1, 4, REG_RX_CFG); pub const REG_RX_CFG_R_RX_CLR: crate::Field = crate::Field::new(1, 6, REG_RX_CFG); + pub const REG_RX_CFG_R_RX_BACKPRESSURE: crate::Field = crate::Field::new(1, 7, REG_RX_CFG); pub const REG_TX_SADDR: crate::Register = crate::Register::new(4, 0xfff); pub const REG_TX_SADDR_R_TX_STARTADDR: crate::Field = crate::Field::new(12, 0, REG_TX_SADDR); @@ -2508,11 +3906,12 @@ pub mod utra { pub const REG_RX_SIZE: crate::Register = crate::Register::new(1, 0xffff); pub const REG_RX_SIZE_R_RX_SIZE: crate::Field = crate::Field::new(16, 0, REG_RX_SIZE); - pub const REG_RX_CFG: crate::Register = crate::Register::new(2, 0x57); + pub const REG_RX_CFG: crate::Register = crate::Register::new(2, 0xd7); pub const REG_RX_CFG_R_RX_CONTINUOUS: crate::Field = crate::Field::new(1, 0, REG_RX_CFG); pub const REG_RX_CFG_R_RX_DATASIZE: crate::Field = crate::Field::new(2, 1, REG_RX_CFG); pub const REG_RX_CFG_R_RX_EN: crate::Field = crate::Field::new(1, 4, REG_RX_CFG); pub const REG_RX_CFG_R_RX_CLR: crate::Field = crate::Field::new(1, 6, REG_RX_CFG); + pub const REG_RX_CFG_R_RX_BACKPRESSURE: crate::Field = crate::Field::new(1, 7, REG_RX_CFG); pub const REG_TX_SADDR: crate::Register = crate::Register::new(4, 0xfff); pub const REG_TX_SADDR_R_TX_STARTADDR: crate::Field = crate::Field::new(12, 0, REG_TX_SADDR); @@ -2552,11 +3951,12 @@ pub mod utra { pub const REG_RX_SIZE: crate::Register = crate::Register::new(1, 0xffff); pub const REG_RX_SIZE_R_RX_SIZE: crate::Field = crate::Field::new(16, 0, REG_RX_SIZE); - pub const REG_RX_CFG: crate::Register = crate::Register::new(2, 0x57); + pub const REG_RX_CFG: crate::Register = crate::Register::new(2, 0xd7); pub const REG_RX_CFG_R_RX_CONTINUOUS: crate::Field = crate::Field::new(1, 0, REG_RX_CFG); pub const REG_RX_CFG_R_RX_DATASIZE: crate::Field = crate::Field::new(2, 1, REG_RX_CFG); pub const REG_RX_CFG_R_RX_EN: crate::Field = crate::Field::new(1, 4, REG_RX_CFG); pub const REG_RX_CFG_R_RX_CLR: crate::Field = crate::Field::new(1, 6, REG_RX_CFG); + pub const REG_RX_CFG_R_RX_BACKPRESSURE: crate::Field = crate::Field::new(1, 7, REG_RX_CFG); pub const REG_TX_SADDR: crate::Register = crate::Register::new(4, 0xfff); pub const REG_TX_SADDR_R_TX_STARTADDR: crate::Field = crate::Field::new(12, 0, REG_TX_SADDR); @@ -2783,8 +4183,8 @@ pub mod utra { pub const HW_UDMA_I2C_3_BASE: usize = 0x5010c000; } - pub mod udma_i2s_0 { - pub const UDMA_I2S_0_NUMREGS: usize = 10; + pub mod udma_sdio { + pub const UDMA_SDIO_NUMREGS: usize = 16; pub const REG_RX_SADDR: crate::Register = crate::Register::new(0, 0xfff); pub const REG_RX_SADDR_R_RX_STARTADDR: crate::Field = crate::Field::new(12, 0, REG_RX_SADDR); @@ -2792,9 +4192,8 @@ pub mod utra { pub const REG_RX_SIZE: crate::Register = crate::Register::new(1, 0xffff); pub const REG_RX_SIZE_R_RX_SIZE: crate::Field = crate::Field::new(16, 0, REG_RX_SIZE); - pub const REG_RX_CFG: crate::Register = crate::Register::new(2, 0x37); + pub const REG_RX_CFG: crate::Register = crate::Register::new(2, 0x31); pub const REG_RX_CFG_R_RX_CONTINUOUS: crate::Field = crate::Field::new(1, 0, REG_RX_CFG); - pub const REG_RX_CFG_R_RX_DATASIZE: crate::Field = crate::Field::new(2, 1, REG_RX_CFG); pub const REG_RX_CFG_R_RX_EN: crate::Field = crate::Field::new(1, 4, REG_RX_CFG); pub const REG_RX_CFG_R_RX_CLR: crate::Field = crate::Field::new(1, 5, REG_RX_CFG); @@ -2804,49 +4203,54 @@ pub mod utra { pub const REG_TX_SIZE: crate::Register = crate::Register::new(5, 0xffff); pub const REG_TX_SIZE_R_TX_SIZE: crate::Field = crate::Field::new(16, 0, REG_TX_SIZE); - pub const REG_TX_CFG: crate::Register = crate::Register::new(6, 0x37); + pub const REG_TX_CFG: crate::Register = crate::Register::new(6, 0x31); pub const REG_TX_CFG_R_TX_CONTINUOUS: crate::Field = crate::Field::new(1, 0, REG_TX_CFG); - pub const REG_TX_CFG_R_TX_DATASIZE: crate::Field = crate::Field::new(2, 1, REG_TX_CFG); pub const REG_TX_CFG_R_TX_EN: crate::Field = crate::Field::new(1, 4, REG_TX_CFG); pub const REG_TX_CFG_R_TX_CLR: crate::Field = crate::Field::new(1, 5, REG_TX_CFG); - pub const REG_I2S_CLKCFG_SETUP: crate::Register = crate::Register::new(8, 0xf7ffffff); - pub const REG_I2S_CLKCFG_SETUP_R_MASTER_GEN_CLK_DIV: crate::Field = crate::Field::new(8, 0, REG_I2S_CLKCFG_SETUP); - pub const REG_I2S_CLKCFG_SETUP_R_SLAVE_GEN_CLK_DIV: crate::Field = crate::Field::new(8, 8, REG_I2S_CLKCFG_SETUP); - pub const REG_I2S_CLKCFG_SETUP_R_COMMON_GEN_CLK_DIV: crate::Field = crate::Field::new(8, 16, REG_I2S_CLKCFG_SETUP); - pub const REG_I2S_CLKCFG_SETUP_R_SLAVE_CLK_EN: crate::Field = crate::Field::new(1, 24, REG_I2S_CLKCFG_SETUP); - pub const REG_I2S_CLKCFG_SETUP_R_MASTER_CLK_EN: crate::Field = crate::Field::new(1, 25, REG_I2S_CLKCFG_SETUP); - pub const REG_I2S_CLKCFG_SETUP_R_PDM_CLK_EN: crate::Field = crate::Field::new(1, 26, REG_I2S_CLKCFG_SETUP); - pub const REG_I2S_CLKCFG_SETUP_R_SLAVE_SEL_EXT: crate::Field = crate::Field::new(1, 28, REG_I2S_CLKCFG_SETUP); - pub const REG_I2S_CLKCFG_SETUP_R_SLAVE_SEL_NUM: crate::Field = crate::Field::new(1, 29, REG_I2S_CLKCFG_SETUP); - pub const REG_I2S_CLKCFG_SETUP_R_MASTER_SEL_EXT: crate::Field = crate::Field::new(1, 30, REG_I2S_CLKCFG_SETUP); - pub const REG_I2S_CLKCFG_SETUP_R_MASTER_SEL_NUM: crate::Field = crate::Field::new(1, 31, REG_I2S_CLKCFG_SETUP); + pub const REG_CMD_OP: crate::Register = crate::Register::new(8, 0x33f07); + pub const REG_CMD_OP_R_CMD_RSP_TYPE: crate::Field = crate::Field::new(3, 0, REG_CMD_OP); + pub const REG_CMD_OP_R_CMD_OP: crate::Field = crate::Field::new(6, 8, REG_CMD_OP); + pub const REG_CMD_OP_R_CMD_STOPOPT: crate::Field = crate::Field::new(2, 16, REG_CMD_OP); - pub const REG_I2S_SLV_SETUP: crate::Register = crate::Register::new(9, 0x80031f07); - pub const REG_I2S_SLV_SETUP_R_SLAVE_I2S_WORDS: crate::Field = crate::Field::new(3, 0, REG_I2S_SLV_SETUP); - pub const REG_I2S_SLV_SETUP_R_SLAVE_I2S_BITS_WORD: crate::Field = crate::Field::new(5, 8, REG_I2S_SLV_SETUP); - pub const REG_I2S_SLV_SETUP_R_SLAVE_I2S_LSB_FIRST: crate::Field = crate::Field::new(1, 16, REG_I2S_SLV_SETUP); - pub const REG_I2S_SLV_SETUP_R_SLAVE_I2S_2CH: crate::Field = crate::Field::new(1, 17, REG_I2S_SLV_SETUP); - pub const REG_I2S_SLV_SETUP_R_SLAVE_I2S_EN: crate::Field = crate::Field::new(1, 31, REG_I2S_SLV_SETUP); + pub const REG_DATA_SETUP: crate::Register = crate::Register::new(10, 0x3ffff07); + pub const REG_DATA_SETUP_R_DATA_EN: crate::Field = crate::Field::new(1, 0, REG_DATA_SETUP); + pub const REG_DATA_SETUP_R_DATA_RWN: crate::Field = crate::Field::new(1, 1, REG_DATA_SETUP); + pub const REG_DATA_SETUP_R_DATA_QUAD: crate::Field = crate::Field::new(1, 2, REG_DATA_SETUP); + pub const REG_DATA_SETUP_R_DATA_BLOCK_NUM: crate::Field = crate::Field::new(8, 8, REG_DATA_SETUP); + pub const REG_DATA_SETUP_R_DATA_BLOCK_SIZE: crate::Field = crate::Field::new(10, 16, REG_DATA_SETUP); - pub const REG_I2S_MST_SETUP: crate::Register = crate::Register::new(10, 0x80031f07); - pub const REG_I2S_MST_SETUP_R_MASTER_I2S_WORDS: crate::Field = crate::Field::new(3, 0, REG_I2S_MST_SETUP); - pub const REG_I2S_MST_SETUP_R_MASTER_I2S_BITS_WORD: crate::Field = crate::Field::new(5, 8, REG_I2S_MST_SETUP); - pub const REG_I2S_MST_SETUP_R_MASTER_I2S_LSB_FIRST: crate::Field = crate::Field::new(1, 16, REG_I2S_MST_SETUP); - pub const REG_I2S_MST_SETUP_R_MASTER_I2S_2CH: crate::Field = crate::Field::new(1, 17, REG_I2S_MST_SETUP); - pub const REG_I2S_MST_SETUP_R_MASTER_I2S_EN: crate::Field = crate::Field::new(1, 31, REG_I2S_MST_SETUP); + pub const REG_START: crate::Register = crate::Register::new(11, 0x1); + pub const REG_START_R_SDIO_START: crate::Field = crate::Field::new(1, 0, REG_START); - pub const REG_I2S_PDM_SETUP: crate::Register = crate::Register::new(11, 0x80007fff); - pub const REG_I2S_PDM_SETUP_R_SLAVE_PDM_SHIFT: crate::Field = crate::Field::new(3, 0, REG_I2S_PDM_SETUP); - pub const REG_I2S_PDM_SETUP_R_SLAVE_PDM_DECIMATION: crate::Field = crate::Field::new(10, 3, REG_I2S_PDM_SETUP); - pub const REG_I2S_PDM_SETUP_R_SLAVE_PDM_MODE: crate::Field = crate::Field::new(2, 13, REG_I2S_PDM_SETUP); - pub const REG_I2S_PDM_SETUP_R_SLAVE_PDM_EN: crate::Field = crate::Field::new(1, 31, REG_I2S_PDM_SETUP); + pub const REG_RSP0: crate::Register = crate::Register::new(12, 0xffffffff); + pub const REG_RSP0_CFG_RSP_DATA_I_31_0: crate::Field = crate::Field::new(32, 0, REG_RSP0); - pub const HW_UDMA_I2S_0_BASE: usize = 0x5010d000; + pub const REG_RSP1: crate::Register = crate::Register::new(13, 0xffffffff); + pub const REG_RSP1_CFG_RSP_DATA_I_63_32: crate::Field = crate::Field::new(32, 0, REG_RSP1); + + pub const REG_RSP2: crate::Register = crate::Register::new(14, 0xffffffff); + pub const REG_RSP2_CFG_RSP_DATA_I_95_64: crate::Field = crate::Field::new(32, 0, REG_RSP2); + + pub const REG_RSP3: crate::Register = crate::Register::new(15, 0xffffffff); + pub const REG_RSP3_CFG_RSP_DATA_I_127_96: crate::Field = crate::Field::new(32, 0, REG_RSP3); + + pub const REG_CLK_DIV: crate::Register = crate::Register::new(16, 0x1ff); + pub const REG_CLK_DIV_R_CLK_DIV_DATA: crate::Field = crate::Field::new(8, 0, REG_CLK_DIV); + pub const REG_CLK_DIV_R_CLK_DIV_VALID: crate::Field = crate::Field::new(1, 8, REG_CLK_DIV); + + pub const REG_STATUS: crate::Register = crate::Register::new(17, 0x3); + pub const REG_STATUS_R_EOT: crate::Field = crate::Field::new(1, 0, REG_STATUS); + pub const REG_STATUS_R_ERR: crate::Field = crate::Field::new(1, 1, REG_STATUS); + + pub const REG_DATA_TIMEOUT: crate::Register = crate::Register::new(18, 0xfffff); + pub const REG_DATA_TIMEOUT_R_DATA_TIMEOUT: crate::Field = crate::Field::new(20, 0, REG_DATA_TIMEOUT); + + pub const HW_UDMA_SDIO_BASE: usize = 0x5010d000; } - pub mod udma_i2s_1 { - pub const UDMA_I2S_1_NUMREGS: usize = 10; + pub mod udma_i2s { + pub const UDMA_I2S_NUMREGS: usize = 10; pub const REG_RX_SADDR: crate::Register = crate::Register::new(0, 0xfff); pub const REG_RX_SADDR_R_RX_STARTADDR: crate::Field = crate::Field::new(12, 0, REG_RX_SADDR); @@ -2904,7 +4308,7 @@ pub mod utra { pub const REG_I2S_PDM_SETUP_R_SLAVE_PDM_MODE: crate::Field = crate::Field::new(2, 13, REG_I2S_PDM_SETUP); pub const REG_I2S_PDM_SETUP_R_SLAVE_PDM_EN: crate::Field = crate::Field::new(1, 31, REG_I2S_PDM_SETUP); - pub const HW_UDMA_I2S_1_BASE: usize = 0x5010e000; + pub const HW_UDMA_I2S_BASE: usize = 0x5010e000; } pub mod udma_camera { @@ -3039,8 +4443,10 @@ pub mod utra { pub const REG_RX_SIZE: crate::Register = crate::Register::new(1, 0xffff); pub const REG_RX_SIZE_R_RX_SIZE: crate::Field = crate::Field::new(16, 0, REG_RX_SIZE); - pub const REG_RX_CFG: crate::Register = crate::Register::new(2, 0x1); + pub const REG_RX_CFG: crate::Register = crate::Register::new(2, 0x51); pub const REG_RX_CFG_R_RX_CONTINUOUS: crate::Field = crate::Field::new(1, 0, REG_RX_CFG); + pub const REG_RX_CFG_R_RX_EN: crate::Field = crate::Field::new(1, 4, REG_RX_CFG); + pub const REG_RX_CFG_R_RX_CLR: crate::Field = crate::Field::new(1, 6, REG_RX_CFG); pub const REG_TX_SADDR: crate::Register = crate::Register::new(4, 0xfff); pub const REG_TX_SADDR_R_TX_STARTADDR: crate::Field = crate::Field::new(12, 0, REG_TX_SADDR); @@ -3048,8 +4454,10 @@ pub mod utra { pub const REG_TX_SIZE: crate::Register = crate::Register::new(5, 0xffff); pub const REG_TX_SIZE_R_TX_SIZE: crate::Field = crate::Field::new(16, 0, REG_TX_SIZE); - pub const REG_TX_CFG: crate::Register = crate::Register::new(6, 0x1); + pub const REG_TX_CFG: crate::Register = crate::Register::new(6, 0x51); pub const REG_TX_CFG_R_TX_CONTINUOUS: crate::Field = crate::Field::new(1, 0, REG_TX_CFG); + pub const REG_TX_CFG_R_TX_EN: crate::Field = crate::Field::new(1, 4, REG_TX_CFG); + pub const REG_TX_CFG_R_TX_CLR: crate::Field = crate::Field::new(1, 6, REG_TX_CFG); pub const REG_STATUS: crate::Register = crate::Register::new(8, 0x1); pub const REG_STATUS_STATUS_I: crate::Field = crate::Field::new(1, 0, REG_STATUS); @@ -3180,1964 +4588,25 @@ pub mod utra { } pub mod udma_adc { - pub const UDMA_ADC_NUMREGS: usize = 0; + pub const UDMA_ADC_NUMREGS: usize = 4; + + pub const REG_RX_SADDR: crate::Register = crate::Register::new(0, 0xfff); + pub const REG_RX_SADDR_R_RX_STARTADDR: crate::Field = crate::Field::new(12, 0, REG_RX_SADDR); + + pub const REG_RX_SIZE: crate::Register = crate::Register::new(1, 0xffff); + pub const REG_RX_SIZE_R_RX_SIZE: crate::Field = crate::Field::new(16, 0, REG_RX_SIZE); + + pub const REG_RX_CFG: crate::Register = crate::Register::new(2, 0x31); + pub const REG_RX_CFG_R_RX_CONTINUOUS: crate::Field = crate::Field::new(1, 0, REG_RX_CFG); + pub const REG_RX_CFG_R_RX_EN: crate::Field = crate::Field::new(1, 4, REG_RX_CFG); + pub const REG_RX_CFG_R_RX_CLR: crate::Field = crate::Field::new(1, 5, REG_RX_CFG); + + pub const REG_CR_ADC: crate::Register = crate::Register::new(4, 0xfffffff); + pub const REG_CR_ADC_CR_ADC: crate::Field = crate::Field::new(28, 0, REG_CR_ADC); pub const HW_UDMA_ADC_BASE: usize = 0x50114000; } - pub mod aes { - pub const AES_NUMREGS: usize = 13; - - pub const SFR_CRFUNC: crate::Register = crate::Register::new(0, 0xff); - pub const SFR_CRFUNC_SFR_CRFUNC: crate::Field = crate::Field::new(8, 0, SFR_CRFUNC); - - pub const SFR_AR: crate::Register = crate::Register::new(1, 0xffffffff); - pub const SFR_AR_SFR_AR: crate::Field = crate::Field::new(32, 0, SFR_AR); - - pub const SFR_SRMFSM: crate::Register = crate::Register::new(2, 0xff); - pub const SFR_SRMFSM_SFR_SRMFSM: crate::Field = crate::Field::new(8, 0, SFR_SRMFSM); - - pub const SFR_FR: crate::Register = crate::Register::new(3, 0xf); - pub const SFR_FR_MFSM_DONE: crate::Field = crate::Field::new(1, 0, SFR_FR); - pub const SFR_FR_ACORE_DONE: crate::Field = crate::Field::new(1, 1, SFR_FR); - pub const SFR_FR_CHNLO_DONE: crate::Field = crate::Field::new(1, 2, SFR_FR); - pub const SFR_FR_CHNLI_DONE: crate::Field = crate::Field::new(1, 3, SFR_FR); - - pub const SFR_OPT: crate::Register = crate::Register::new(4, 0x1ff); - pub const SFR_OPT_OPT_KLEN0: crate::Field = crate::Field::new(4, 0, SFR_OPT); - pub const SFR_OPT_OPT_MODE0: crate::Field = crate::Field::new(4, 4, SFR_OPT); - pub const SFR_OPT_OPT_IFSTART0: crate::Field = crate::Field::new(1, 8, SFR_OPT); - - pub const SFR_OPT1: crate::Register = crate::Register::new(5, 0xffff); - pub const SFR_OPT1_SFR_OPT1: crate::Field = crate::Field::new(16, 0, SFR_OPT1); - - pub const SFR_OPTLTX: crate::Register = crate::Register::new(6, 0x3f); - pub const SFR_OPTLTX_SFR_OPTLTX: crate::Field = crate::Field::new(6, 0, SFR_OPTLTX); - - pub const SFR_MASKSEED: crate::Register = crate::Register::new(8, 0xffffffff); - pub const SFR_MASKSEED_SFR_MASKSEED: crate::Field = crate::Field::new(32, 0, SFR_MASKSEED); - - pub const SFR_MASKSEEDAR: crate::Register = crate::Register::new(9, 0xffffffff); - pub const SFR_MASKSEEDAR_SFR_MASKSEEDAR: crate::Field = crate::Field::new(32, 0, SFR_MASKSEEDAR); - - pub const SFR_SEGPTR_PTRID_IV: crate::Register = crate::Register::new(12, 0xfff); - pub const SFR_SEGPTR_PTRID_IV_PTRID_IV: crate::Field = crate::Field::new(12, 0, SFR_SEGPTR_PTRID_IV); - - pub const SFR_SEGPTR_PTRID_AKEY: crate::Register = crate::Register::new(13, 0xfff); - pub const SFR_SEGPTR_PTRID_AKEY_PTRID_AKEY: crate::Field = crate::Field::new(12, 0, SFR_SEGPTR_PTRID_AKEY); - - pub const SFR_SEGPTR_PTRID_AIB: crate::Register = crate::Register::new(14, 0xfff); - pub const SFR_SEGPTR_PTRID_AIB_PTRID_AIB: crate::Field = crate::Field::new(12, 0, SFR_SEGPTR_PTRID_AIB); - - pub const SFR_SEGPTR_PTRID_AOB: crate::Register = crate::Register::new(15, 0xfff); - pub const SFR_SEGPTR_PTRID_AOB_PTRID_AOB: crate::Field = crate::Field::new(12, 0, SFR_SEGPTR_PTRID_AOB); - - pub const HW_AES_BASE: usize = 0x4002d000; - } - - pub mod combohash { - pub const COMBOHASH_NUMREGS: usize = 14; - - pub const SFR_CRFUNC: crate::Register = crate::Register::new(0, 0xff); - pub const SFR_CRFUNC_CR_FUNC: crate::Field = crate::Field::new(8, 0, SFR_CRFUNC); - - pub const SFR_AR: crate::Register = crate::Register::new(1, 0xffffffff); - pub const SFR_AR_SFR_AR: crate::Field = crate::Field::new(32, 0, SFR_AR); - - pub const SFR_SRMFSM: crate::Register = crate::Register::new(2, 0xff); - pub const SFR_SRMFSM_MFSM: crate::Field = crate::Field::new(8, 0, SFR_SRMFSM); - - pub const SFR_FR: crate::Register = crate::Register::new(3, 0x3f); - pub const SFR_FR_MFSM_DONE: crate::Field = crate::Field::new(1, 0, SFR_FR); - pub const SFR_FR_HASH_DONE: crate::Field = crate::Field::new(1, 1, SFR_FR); - pub const SFR_FR_CHNLO_DONE: crate::Field = crate::Field::new(1, 2, SFR_FR); - pub const SFR_FR_CHNLI_DONE: crate::Field = crate::Field::new(1, 3, SFR_FR); - pub const SFR_FR_CHKDONE: crate::Field = crate::Field::new(1, 4, SFR_FR); - pub const SFR_FR_CHKPASS: crate::Field = crate::Field::new(1, 5, SFR_FR); - - pub const SFR_OPT1: crate::Register = crate::Register::new(4, 0xffff); - pub const SFR_OPT1_CR_OPT_HASHCNT: crate::Field = crate::Field::new(16, 0, SFR_OPT1); - - pub const SFR_OPT2: crate::Register = crate::Register::new(5, 0x7); - pub const SFR_OPT2_CR_OPT_SCRTCHK: crate::Field = crate::Field::new(1, 0, SFR_OPT2); - pub const SFR_OPT2_CR_OPT_IFSOB: crate::Field = crate::Field::new(1, 1, SFR_OPT2); - pub const SFR_OPT2_CR_OPT_IFSTART: crate::Field = crate::Field::new(1, 2, SFR_OPT2); - - pub const SFR_OPT3: crate::Register = crate::Register::new(6, 0xff); - pub const SFR_OPT3_SFR_OPT3: crate::Field = crate::Field::new(8, 0, SFR_OPT3); - - pub const SFR_BLKT0: crate::Register = crate::Register::new(7, 0xff); - pub const SFR_BLKT0_SFR_BLKT0: crate::Field = crate::Field::new(8, 0, SFR_BLKT0); - - pub const SFR_SEGPTR_SEGID_LKEY: crate::Register = crate::Register::new(8, 0xfff); - pub const SFR_SEGPTR_SEGID_LKEY_SEGID_LKEY: crate::Field = crate::Field::new(12, 0, SFR_SEGPTR_SEGID_LKEY); - - pub const SFR_SEGPTR_SEGID_KEY: crate::Register = crate::Register::new(9, 0xfff); - pub const SFR_SEGPTR_SEGID_KEY_SEGID_KEY: crate::Field = crate::Field::new(12, 0, SFR_SEGPTR_SEGID_KEY); - - pub const SFR_SEGPTR_SEGID_SCRT: crate::Register = crate::Register::new(11, 0xfff); - pub const SFR_SEGPTR_SEGID_SCRT_SEGID_SCRT: crate::Field = crate::Field::new(12, 0, SFR_SEGPTR_SEGID_SCRT); - - pub const SFR_SEGPTR_SEGID_MSG: crate::Register = crate::Register::new(12, 0xfff); - pub const SFR_SEGPTR_SEGID_MSG_SEGID_MSG: crate::Field = crate::Field::new(12, 0, SFR_SEGPTR_SEGID_MSG); - - pub const SFR_SEGPTR_SEGID_HOUT: crate::Register = crate::Register::new(13, 0xfff); - pub const SFR_SEGPTR_SEGID_HOUT_SEGID_HOUT: crate::Field = crate::Field::new(12, 0, SFR_SEGPTR_SEGID_HOUT); - - pub const SFR_SEGPTR_SEGID_HOUT2: crate::Register = crate::Register::new(15, 0xfff); - pub const SFR_SEGPTR_SEGID_HOUT2_SEGID_HOUT2: crate::Field = crate::Field::new(12, 0, SFR_SEGPTR_SEGID_HOUT2); - - pub const HW_COMBOHASH_BASE: usize = 0x4002b000; - } - - pub mod pke { - pub const PKE_NUMREGS: usize = 14; - - pub const SFR_CRFUNC: crate::Register = crate::Register::new(0, 0xffff); - pub const SFR_CRFUNC_CR_FUNC: crate::Field = crate::Field::new(8, 0, SFR_CRFUNC); - pub const SFR_CRFUNC_CR_PCOREIR: crate::Field = crate::Field::new(8, 8, SFR_CRFUNC); - - pub const SFR_AR: crate::Register = crate::Register::new(1, 0xffffffff); - pub const SFR_AR_SFR_AR: crate::Field = crate::Field::new(32, 0, SFR_AR); - - pub const SFR_SRMFSM: crate::Register = crate::Register::new(2, 0x1ff); - pub const SFR_SRMFSM_MFSM: crate::Field = crate::Field::new(8, 0, SFR_SRMFSM); - pub const SFR_SRMFSM_MODINVREADY: crate::Field = crate::Field::new(1, 8, SFR_SRMFSM); - - pub const SFR_FR: crate::Register = crate::Register::new(3, 0x1f); - pub const SFR_FR_MFSM_DONE: crate::Field = crate::Field::new(1, 0, SFR_FR); - pub const SFR_FR_PCORE_DONE: crate::Field = crate::Field::new(1, 1, SFR_FR); - pub const SFR_FR_CHNLO_DONE: crate::Field = crate::Field::new(1, 2, SFR_FR); - pub const SFR_FR_CHNLI_DONE: crate::Field = crate::Field::new(1, 3, SFR_FR); - pub const SFR_FR_CHNLX_DONE: crate::Field = crate::Field::new(1, 4, SFR_FR); - - pub const SFR_OPTNW: crate::Register = crate::Register::new(4, 0x1fff); - pub const SFR_OPTNW_SFR_OPTNW: crate::Field = crate::Field::new(13, 0, SFR_OPTNW); - - pub const SFR_OPTEW: crate::Register = crate::Register::new(5, 0x1fff); - pub const SFR_OPTEW_SFR_OPTEW: crate::Field = crate::Field::new(13, 0, SFR_OPTEW); - - pub const SFR_OPTRW: crate::Register = crate::Register::new(6, 0x3ff); - pub const SFR_OPTRW_SFR_OPTRW: crate::Field = crate::Field::new(10, 0, SFR_OPTRW); - - pub const SFR_OPTLTX: crate::Register = crate::Register::new(7, 0x1f); - pub const SFR_OPTLTX_SFR_OPTLTX: crate::Field = crate::Field::new(5, 0, SFR_OPTLTX); - - pub const SFR_OPTMASK: crate::Register = crate::Register::new(8, 0xffff); - pub const SFR_OPTMASK_SFR_OPTMASK: crate::Field = crate::Field::new(16, 0, SFR_OPTMASK); - - pub const SFR_SEGPTR_PTRID_PCON: crate::Register = crate::Register::new(12, 0xfff); - pub const SFR_SEGPTR_PTRID_PCON_PTRID_PCON: crate::Field = crate::Field::new(12, 0, SFR_SEGPTR_PTRID_PCON); - - pub const SFR_SEGPTR_PTRID_PIB0: crate::Register = crate::Register::new(13, 0xfff); - pub const SFR_SEGPTR_PTRID_PIB0_PTRID_PIB0: crate::Field = crate::Field::new(12, 0, SFR_SEGPTR_PTRID_PIB0); - - pub const SFR_SEGPTR_PTRID_PIB1: crate::Register = crate::Register::new(14, 0xfff); - pub const SFR_SEGPTR_PTRID_PIB1_PTRID_PIB1: crate::Field = crate::Field::new(12, 0, SFR_SEGPTR_PTRID_PIB1); - - pub const SFR_SEGPTR_PTRID_PKB: crate::Register = crate::Register::new(15, 0xfff); - pub const SFR_SEGPTR_PTRID_PKB_PTRID_PKB: crate::Field = crate::Field::new(12, 0, SFR_SEGPTR_PTRID_PKB); - - pub const SFR_SEGPTR_PTRID_POB: crate::Register = crate::Register::new(16, 0xfff); - pub const SFR_SEGPTR_PTRID_POB_PTRID_POB: crate::Field = crate::Field::new(12, 0, SFR_SEGPTR_PTRID_POB); - - pub const HW_PKE_BASE: usize = 0x4002c000; - } - - pub mod scedma { - pub const SCEDMA_NUMREGS: usize = 18; - - pub const SFR_SCHSTART_AR: crate::Register = crate::Register::new(0, 0xffffffff); - pub const SFR_SCHSTART_AR_SFR_SCHSTART_AR: crate::Field = crate::Field::new(32, 0, SFR_SCHSTART_AR); - - pub const SFR_XCH_FUNC: crate::Register = crate::Register::new(4, 0x1); - pub const SFR_XCH_FUNC_SFR_XCH_FUNC: crate::Field = crate::Field::new(1, 0, SFR_XCH_FUNC); - - pub const SFR_XCH_OPT: crate::Register = crate::Register::new(5, 0xff); - pub const SFR_XCH_OPT_SFR_XCH_OPT: crate::Field = crate::Field::new(8, 0, SFR_XCH_OPT); - - pub const SFR_XCH_AXSTART: crate::Register = crate::Register::new(6, 0xffffffff); - pub const SFR_XCH_AXSTART_SFR_XCH_AXSTART: crate::Field = crate::Field::new(32, 0, SFR_XCH_AXSTART); - - pub const SFR_XCH_SEGID: crate::Register = crate::Register::new(7, 0xff); - pub const SFR_XCH_SEGID_SFR_XCH_SEGID: crate::Field = crate::Field::new(8, 0, SFR_XCH_SEGID); - - pub const SFR_XCH_SEGSTART: crate::Register = crate::Register::new(8, 0xfff); - pub const SFR_XCH_SEGSTART_XCHCR_SEGSTART: crate::Field = crate::Field::new(12, 0, SFR_XCH_SEGSTART); - - pub const SFR_XCH_TRANSIZE: crate::Register = crate::Register::new(9, 0x3fffffff); - pub const SFR_XCH_TRANSIZE_XCHCR_TRANSIZE: crate::Field = crate::Field::new(30, 0, SFR_XCH_TRANSIZE); - - pub const SFR_SCH_FUNC: crate::Register = crate::Register::new(12, 0x1); - pub const SFR_SCH_FUNC_SFR_SCH_FUNC: crate::Field = crate::Field::new(1, 0, SFR_SCH_FUNC); - - pub const SFR_SCH_OPT: crate::Register = crate::Register::new(13, 0xff); - pub const SFR_SCH_OPT_SFR_SCH_OPT: crate::Field = crate::Field::new(8, 0, SFR_SCH_OPT); - - pub const SFR_SCH_AXSTART: crate::Register = crate::Register::new(14, 0xffffffff); - pub const SFR_SCH_AXSTART_SFR_SCH_AXSTART: crate::Field = crate::Field::new(32, 0, SFR_SCH_AXSTART); - - pub const SFR_SCH_SEGID: crate::Register = crate::Register::new(15, 0xff); - pub const SFR_SCH_SEGID_SFR_SCH_SEGID: crate::Field = crate::Field::new(8, 0, SFR_SCH_SEGID); - - pub const SFR_SCH_SEGSTART: crate::Register = crate::Register::new(16, 0xfff); - pub const SFR_SCH_SEGSTART_SCHCR_SEGSTART: crate::Field = crate::Field::new(12, 0, SFR_SCH_SEGSTART); - - pub const SFR_SCH_TRANSIZE: crate::Register = crate::Register::new(17, 0x3fffffff); - pub const SFR_SCH_TRANSIZE_SCHCR_TRANSIZE: crate::Field = crate::Field::new(30, 0, SFR_SCH_TRANSIZE); - - pub const SFR_ICH_OPT: crate::Register = crate::Register::new(20, 0xf); - pub const SFR_ICH_OPT_SFR_ICH_OPT: crate::Field = crate::Field::new(4, 0, SFR_ICH_OPT); - - pub const SFR_ICH_SEGID: crate::Register = crate::Register::new(21, 0xffff); - pub const SFR_ICH_SEGID_SFR_ICH_SEGID: crate::Field = crate::Field::new(16, 0, SFR_ICH_SEGID); - - pub const SFR_ICH_RPSTART: crate::Register = crate::Register::new(22, 0xfff); - pub const SFR_ICH_RPSTART_ICHCR_RPSTART: crate::Field = crate::Field::new(12, 0, SFR_ICH_RPSTART); - - pub const SFR_ICH_WPSTART: crate::Register = crate::Register::new(23, 0xfff); - pub const SFR_ICH_WPSTART_ICHCR_WPSTART: crate::Field = crate::Field::new(12, 0, SFR_ICH_WPSTART); - - pub const SFR_ICH_TRANSIZE: crate::Register = crate::Register::new(24, 0xfff); - pub const SFR_ICH_TRANSIZE_ICHCR_TRANSIZE: crate::Field = crate::Field::new(12, 0, SFR_ICH_TRANSIZE); - - pub const HW_SCEDMA_BASE: usize = 0x40029000; - } - - pub mod sce_glbsfr { - pub const SCE_GLBSFR_NUMREGS: usize = 18; - - pub const SFR_SCEMODE: crate::Register = crate::Register::new(0, 0x3); - pub const SFR_SCEMODE_CR_SCEMODE: crate::Field = crate::Field::new(2, 0, SFR_SCEMODE); - - pub const SFR_SUBEN: crate::Register = crate::Register::new(1, 0xffff); - pub const SFR_SUBEN_CR_SUBEN: crate::Field = crate::Field::new(16, 0, SFR_SUBEN); - - pub const SFR_AHBS: crate::Register = crate::Register::new(2, 0x1f); - pub const SFR_AHBS_CR_AHBSOPT: crate::Field = crate::Field::new(5, 0, SFR_AHBS); - - pub const SFR_SRBUSY: crate::Register = crate::Register::new(4, 0xffff); - pub const SFR_SRBUSY_SR_BUSY: crate::Field = crate::Field::new(16, 0, SFR_SRBUSY); - - pub const SFR_FRDONE: crate::Register = crate::Register::new(5, 0xffff); - pub const SFR_FRDONE_FR_DONE: crate::Field = crate::Field::new(16, 0, SFR_FRDONE); - - pub const SFR_FRERR: crate::Register = crate::Register::new(6, 0xffff); - pub const SFR_FRERR_FR_ERR: crate::Field = crate::Field::new(16, 0, SFR_FRERR); - - pub const SFR_ARCLR: crate::Register = crate::Register::new(7, 0xffffffff); - pub const SFR_ARCLR_AR_CLRRAM: crate::Field = crate::Field::new(32, 0, SFR_ARCLR); - - pub const SFR_FRACERR: crate::Register = crate::Register::new(8, 0xff); - pub const SFR_FRACERR_FR_ACERR: crate::Field = crate::Field::new(8, 0, SFR_FRACERR); - - pub const SFR_TICKCNT: crate::Register = crate::Register::new(9, 0xffffffff); - pub const SFR_TICKCNT_SFR_TICKCNT: crate::Field = crate::Field::new(32, 0, SFR_TICKCNT); - - pub const SFR_FFEN: crate::Register = crate::Register::new(12, 0x3f); - pub const SFR_FFEN_CR_FFEN: crate::Field = crate::Field::new(6, 0, SFR_FFEN); - - pub const SFR_FFCLR: crate::Register = crate::Register::new(13, 0xffffffff); - pub const SFR_FFCLR_AR_FFCLR: crate::Field = crate::Field::new(32, 0, SFR_FFCLR); - - pub const SFR_FFCNT_SR_FF0: crate::Register = crate::Register::new(16, 0xffff); - pub const SFR_FFCNT_SR_FF0_SR_FF0: crate::Field = crate::Field::new(16, 0, SFR_FFCNT_SR_FF0); - - pub const SFR_FFCNT_SR_FF1: crate::Register = crate::Register::new(17, 0xffff); - pub const SFR_FFCNT_SR_FF1_SR_FF1: crate::Field = crate::Field::new(16, 0, SFR_FFCNT_SR_FF1); - - pub const SFR_FFCNT_SR_FF2: crate::Register = crate::Register::new(18, 0xffff); - pub const SFR_FFCNT_SR_FF2_SR_FF2: crate::Field = crate::Field::new(16, 0, SFR_FFCNT_SR_FF2); - - pub const SFR_FFCNT_SR_FF3: crate::Register = crate::Register::new(19, 0xffff); - pub const SFR_FFCNT_SR_FF3_SR_FF3: crate::Field = crate::Field::new(16, 0, SFR_FFCNT_SR_FF3); - - pub const SFR_FFCNT_SR_FF4: crate::Register = crate::Register::new(20, 0xffff); - pub const SFR_FFCNT_SR_FF4_SR_FF4: crate::Field = crate::Field::new(16, 0, SFR_FFCNT_SR_FF4); - - pub const SFR_FFCNT_SR_FF5: crate::Register = crate::Register::new(21, 0xffff); - pub const SFR_FFCNT_SR_FF5_SR_FF5: crate::Field = crate::Field::new(16, 0, SFR_FFCNT_SR_FF5); - - pub const SFR_TS: crate::Register = crate::Register::new(63, 0xffff); - pub const SFR_TS_CR_TS: crate::Field = crate::Field::new(16, 0, SFR_TS); - - pub const HW_SCE_GLBSFR_BASE: usize = 0x40028000; - } - - pub mod trng { - pub const TRNG_NUMREGS: usize = 13; - - pub const SFR_CRSRC: crate::Register = crate::Register::new(0, 0xfff); - pub const SFR_CRSRC_SFR_CRSRC: crate::Field = crate::Field::new(12, 0, SFR_CRSRC); - - pub const SFR_CRANA: crate::Register = crate::Register::new(1, 0xffff); - pub const SFR_CRANA_SFR_CRANA: crate::Field = crate::Field::new(16, 0, SFR_CRANA); - - pub const SFR_PP: crate::Register = crate::Register::new(2, 0x1ffff); - pub const SFR_PP_SFR_PP: crate::Field = crate::Field::new(17, 0, SFR_PP); - - pub const SFR_OPT: crate::Register = crate::Register::new(3, 0x1ffff); - pub const SFR_OPT_SFR_OPT: crate::Field = crate::Field::new(17, 0, SFR_OPT); - - pub const SFR_SR: crate::Register = crate::Register::new(4, 0xffffffff); - pub const SFR_SR_SR_RNG: crate::Field = crate::Field::new(32, 0, SFR_SR); - - pub const SFR_AR_GEN: crate::Register = crate::Register::new(5, 0xffffffff); - pub const SFR_AR_GEN_SFR_AR_GEN: crate::Field = crate::Field::new(32, 0, SFR_AR_GEN); - - pub const SFR_FR: crate::Register = crate::Register::new(6, 0x3); - pub const SFR_FR_SFR_FR: crate::Field = crate::Field::new(2, 0, SFR_FR); - - pub const SFR_DRPSZ: crate::Register = crate::Register::new(8, 0xffffffff); - pub const SFR_DRPSZ_SFR_DRPSZ: crate::Field = crate::Field::new(32, 0, SFR_DRPSZ); - - pub const SFR_DRGEN: crate::Register = crate::Register::new(9, 0xffffffff); - pub const SFR_DRGEN_SFR_DRGEN: crate::Field = crate::Field::new(32, 0, SFR_DRGEN); - - pub const SFR_DRRESEED: crate::Register = crate::Register::new(10, 0xffffffff); - pub const SFR_DRRESEED_SFR_DRRESEED: crate::Field = crate::Field::new(32, 0, SFR_DRRESEED); - - pub const SFR_BUF: crate::Register = crate::Register::new(12, 0xffffffff); - pub const SFR_BUF_SFR_BUF: crate::Field = crate::Field::new(32, 0, SFR_BUF); - - pub const SFR_CHAIN_RNGCHAINEN0: crate::Register = crate::Register::new(16, 0xffffffff); - pub const SFR_CHAIN_RNGCHAINEN0_RNGCHAINEN0: crate::Field = crate::Field::new(32, 0, SFR_CHAIN_RNGCHAINEN0); - - pub const SFR_CHAIN_RNGCHAINEN1: crate::Register = crate::Register::new(17, 0xffffffff); - pub const SFR_CHAIN_RNGCHAINEN1_RNGCHAINEN1: crate::Field = crate::Field::new(32, 0, SFR_CHAIN_RNGCHAINEN1); - - pub const HW_TRNG_BASE: usize = 0x4002e000; - } - - pub mod alu { - pub const ALU_NUMREGS: usize = 0; - - pub const HW_ALU_BASE: usize = 0x4002f000; - } - - pub mod duart { - pub const DUART_NUMREGS: usize = 4; - - pub const SFR_TXD: crate::Register = crate::Register::new(0, 0xff); - pub const SFR_TXD_SFR_TXD: crate::Field = crate::Field::new(8, 0, SFR_TXD); - - pub const SFR_CR: crate::Register = crate::Register::new(1, 0x1); - pub const SFR_CR_SFR_CR: crate::Field = crate::Field::new(1, 0, SFR_CR); - - pub const SFR_SR: crate::Register = crate::Register::new(2, 0x1); - pub const SFR_SR_SFR_SR: crate::Field = crate::Field::new(1, 0, SFR_SR); - - pub const SFR_ETUC: crate::Register = crate::Register::new(3, 0xffff); - pub const SFR_ETUC_SFR_ETUC: crate::Field = crate::Field::new(16, 0, SFR_ETUC); - - pub const HW_DUART_BASE: usize = 0x40042000; - } - - pub mod wdg_intf { - pub const WDG_INTF_NUMREGS: usize = 0; - - pub const HW_WDG_INTF_BASE: usize = 0x40041000; - } - - pub mod timer_intf { - pub const TIMER_INTF_NUMREGS: usize = 0; - - pub const HW_TIMER_INTF_BASE: usize = 0x40043000; - } - - pub mod evc { - pub const EVC_NUMREGS: usize = 22; - - pub const SFR_CM7EVSEL_CM7EVSEL0: crate::Register = crate::Register::new(0, 0xff); - pub const SFR_CM7EVSEL_CM7EVSEL0_CM7EVSEL0: crate::Field = crate::Field::new(8, 0, SFR_CM7EVSEL_CM7EVSEL0); - - pub const SFR_CM7EVSEL_CM7EVSEL1: crate::Register = crate::Register::new(1, 0xff); - pub const SFR_CM7EVSEL_CM7EVSEL1_CM7EVSEL1: crate::Field = crate::Field::new(8, 0, SFR_CM7EVSEL_CM7EVSEL1); - - pub const SFR_CM7EVSEL_CM7EVSEL2: crate::Register = crate::Register::new(2, 0xff); - pub const SFR_CM7EVSEL_CM7EVSEL2_CM7EVSEL2: crate::Field = crate::Field::new(8, 0, SFR_CM7EVSEL_CM7EVSEL2); - - pub const SFR_CM7EVSEL_CM7EVSEL3: crate::Register = crate::Register::new(3, 0xff); - pub const SFR_CM7EVSEL_CM7EVSEL3_CM7EVSEL3: crate::Field = crate::Field::new(8, 0, SFR_CM7EVSEL_CM7EVSEL3); - - pub const SFR_CM7EVSEL_CM7EVSEL4: crate::Register = crate::Register::new(4, 0xff); - pub const SFR_CM7EVSEL_CM7EVSEL4_CM7EVSEL4: crate::Field = crate::Field::new(8, 0, SFR_CM7EVSEL_CM7EVSEL4); - - pub const SFR_CM7EVSEL_CM7EVSEL5: crate::Register = crate::Register::new(5, 0xff); - pub const SFR_CM7EVSEL_CM7EVSEL5_CM7EVSEL5: crate::Field = crate::Field::new(8, 0, SFR_CM7EVSEL_CM7EVSEL5); - - pub const SFR_CM7EVSEL_CM7EVSEL6: crate::Register = crate::Register::new(6, 0xff); - pub const SFR_CM7EVSEL_CM7EVSEL6_CM7EVSEL6: crate::Field = crate::Field::new(8, 0, SFR_CM7EVSEL_CM7EVSEL6); - - pub const SFR_CM7EVSEL_CM7EVSEL7: crate::Register = crate::Register::new(7, 0xff); - pub const SFR_CM7EVSEL_CM7EVSEL7_CM7EVSEL7: crate::Field = crate::Field::new(8, 0, SFR_CM7EVSEL_CM7EVSEL7); - - pub const SFR_CM7EVEN: crate::Register = crate::Register::new(8, 0xff); - pub const SFR_CM7EVEN_CM7EVEN: crate::Field = crate::Field::new(8, 0, SFR_CM7EVEN); - - pub const SFR_CM7EVFR: crate::Register = crate::Register::new(9, 0xff); - pub const SFR_CM7EVFR_CM7EVS: crate::Field = crate::Field::new(8, 0, SFR_CM7EVFR); - - pub const SFR_TMREVSEL: crate::Register = crate::Register::new(12, 0xffff); - pub const SFR_TMREVSEL_TMR_EVSEL: crate::Field = crate::Field::new(16, 0, SFR_TMREVSEL); - - pub const SFR_PWMEVSEL: crate::Register = crate::Register::new(13, 0xffffffff); - pub const SFR_PWMEVSEL_PWM_EVSEL: crate::Field = crate::Field::new(32, 0, SFR_PWMEVSEL); - - pub const SFR_IFEVEN_IFEVEN0: crate::Register = crate::Register::new(16, 0xffffffff); - pub const SFR_IFEVEN_IFEVEN0_IFEVEN0: crate::Field = crate::Field::new(32, 0, SFR_IFEVEN_IFEVEN0); - - pub const SFR_IFEVEN_IFEVEN1: crate::Register = crate::Register::new(17, 0xffffffff); - pub const SFR_IFEVEN_IFEVEN1_IFEVEN1: crate::Field = crate::Field::new(32, 0, SFR_IFEVEN_IFEVEN1); - - pub const SFR_IFEVEN_IFEVEN2: crate::Register = crate::Register::new(18, 0xffffffff); - pub const SFR_IFEVEN_IFEVEN2_IFEVEN2: crate::Field = crate::Field::new(32, 0, SFR_IFEVEN_IFEVEN2); - - pub const SFR_IFEVEN_IFEVEN3: crate::Register = crate::Register::new(19, 0xffffffff); - pub const SFR_IFEVEN_IFEVEN3_IFEVEN3: crate::Field = crate::Field::new(32, 0, SFR_IFEVEN_IFEVEN3); - - pub const SFR_IFEVEN_IFEVEN4: crate::Register = crate::Register::new(20, 0xffffffff); - pub const SFR_IFEVEN_IFEVEN4_IFEVEN4: crate::Field = crate::Field::new(32, 0, SFR_IFEVEN_IFEVEN4); - - pub const SFR_IFEVEN_IFEVEN5: crate::Register = crate::Register::new(21, 0xffffffff); - pub const SFR_IFEVEN_IFEVEN5_IFEVEN5: crate::Field = crate::Field::new(32, 0, SFR_IFEVEN_IFEVEN5); - - pub const SFR_IFEVEN_IFEVEN6: crate::Register = crate::Register::new(22, 0xffffffff); - pub const SFR_IFEVEN_IFEVEN6_IFEVEN6: crate::Field = crate::Field::new(32, 0, SFR_IFEVEN_IFEVEN6); - - pub const SFR_IFEVEN_IFEVEN7: crate::Register = crate::Register::new(23, 0xffffffff); - pub const SFR_IFEVEN_IFEVEN7_IFEVEN7: crate::Field = crate::Field::new(32, 0, SFR_IFEVEN_IFEVEN7); - - pub const SFR_IFEVERRFR: crate::Register = crate::Register::new(24, 0xffffffff); - pub const SFR_IFEVERRFR_IFEV_ERRS: crate::Field = crate::Field::new(32, 0, SFR_IFEVERRFR); - - pub const SFR_CM7ERRFR: crate::Register = crate::Register::new(32, 0xffffffff); - pub const SFR_CM7ERRFR_ERRIN: crate::Field = crate::Field::new(32, 0, SFR_CM7ERRFR); - - pub const HW_EVC_BASE: usize = 0x40044000; - } - - pub mod sysctrl { - pub const SYSCTRL_NUMREGS: usize = 35; - - pub const SFR_CGUSEC: crate::Register = crate::Register::new(0, 0xffff); - pub const SFR_CGUSEC_SFR_CGUSEC: crate::Field = crate::Field::new(16, 0, SFR_CGUSEC); - - pub const SFR_CGULP: crate::Register = crate::Register::new(1, 0xffff); - pub const SFR_CGULP_SFR_CGULP: crate::Field = crate::Field::new(16, 0, SFR_CGULP); - - pub const SFR_SEED: crate::Register = crate::Register::new(2, 0xffffffff); - pub const SFR_SEED_SFR_SEED: crate::Field = crate::Field::new(32, 0, SFR_SEED); - - pub const SFR_SEEDAR: crate::Register = crate::Register::new(3, 0xffffffff); - pub const SFR_SEEDAR_SFR_SEEDAR: crate::Field = crate::Field::new(32, 0, SFR_SEEDAR); - - pub const SFR_CGUSEL0: crate::Register = crate::Register::new(4, 0x3); - pub const SFR_CGUSEL0_SFR_CGUSEL0: crate::Field = crate::Field::new(2, 0, SFR_CGUSEL0); - - pub const SFR_CGUFD_CFGFDCR_0_4_0: crate::Register = crate::Register::new(5, 0xffff); - pub const SFR_CGUFD_CFGFDCR_0_4_0_CFGFDCR_0_4_0: crate::Field = crate::Field::new(16, 0, SFR_CGUFD_CFGFDCR_0_4_0); - - pub const SFR_CGUFD_CFGFDCR_0_4_1: crate::Register = crate::Register::new(6, 0xffff); - pub const SFR_CGUFD_CFGFDCR_0_4_1_CFGFDCR_0_4_1: crate::Field = crate::Field::new(16, 0, SFR_CGUFD_CFGFDCR_0_4_1); - - pub const SFR_CGUFD_CFGFDCR_0_4_2: crate::Register = crate::Register::new(7, 0xffff); - pub const SFR_CGUFD_CFGFDCR_0_4_2_CFGFDCR_0_4_2: crate::Field = crate::Field::new(16, 0, SFR_CGUFD_CFGFDCR_0_4_2); - - pub const SFR_CGUFD_CFGFDCR_0_4_3: crate::Register = crate::Register::new(8, 0xffff); - pub const SFR_CGUFD_CFGFDCR_0_4_3_CFGFDCR_0_4_3: crate::Field = crate::Field::new(16, 0, SFR_CGUFD_CFGFDCR_0_4_3); - - pub const SFR_CGUFD_CFGFDCR_0_4_4: crate::Register = crate::Register::new(9, 0xffff); - pub const SFR_CGUFD_CFGFDCR_0_4_4_CFGFDCR_0_4_4: crate::Field = crate::Field::new(16, 0, SFR_CGUFD_CFGFDCR_0_4_4); - - pub const SFR_CGUFDAO: crate::Register = crate::Register::new(10, 0xffff); - pub const SFR_CGUFDAO_CFGFDCR: crate::Field = crate::Field::new(16, 0, SFR_CGUFDAO); - - pub const SFR_CGUSET: crate::Register = crate::Register::new(11, 0xffffffff); - pub const SFR_CGUSET_SFR_CGUSET: crate::Field = crate::Field::new(32, 0, SFR_CGUSET); - - pub const SFR_CGUSEL1: crate::Register = crate::Register::new(12, 0x1); - pub const SFR_CGUSEL1_SFR_CGUSEL1: crate::Field = crate::Field::new(1, 0, SFR_CGUSEL1); - - pub const SFR_CGUFDPKE: crate::Register = crate::Register::new(13, 0x1ff); - pub const SFR_CGUFDPKE_SFR_CGUFDPKE: crate::Field = crate::Field::new(9, 0, SFR_CGUFDPKE); - - pub const SFR_CGUFSSR_FSFREQ0: crate::Register = crate::Register::new(16, 0xffff); - pub const SFR_CGUFSSR_FSFREQ0_FSFREQ0: crate::Field = crate::Field::new(16, 0, SFR_CGUFSSR_FSFREQ0); - - pub const SFR_CGUFSSR_FSFREQ1: crate::Register = crate::Register::new(17, 0xffff); - pub const SFR_CGUFSSR_FSFREQ1_FSFREQ1: crate::Field = crate::Field::new(16, 0, SFR_CGUFSSR_FSFREQ1); - - pub const SFR_CGUFSSR_FSFREQ2: crate::Register = crate::Register::new(18, 0xffff); - pub const SFR_CGUFSSR_FSFREQ2_FSFREQ2: crate::Field = crate::Field::new(16, 0, SFR_CGUFSSR_FSFREQ2); - - pub const SFR_CGUFSSR_FSFREQ3: crate::Register = crate::Register::new(19, 0xffff); - pub const SFR_CGUFSSR_FSFREQ3_FSFREQ3: crate::Field = crate::Field::new(16, 0, SFR_CGUFSSR_FSFREQ3); - - pub const SFR_CGUFSVLD: crate::Register = crate::Register::new(20, 0xf); - pub const SFR_CGUFSVLD_SFR_CGUFSVLD: crate::Field = crate::Field::new(4, 0, SFR_CGUFSVLD); - - pub const SFR_CGUFSCR: crate::Register = crate::Register::new(21, 0xffff); - pub const SFR_CGUFSCR_SFR_CGUFSCR: crate::Field = crate::Field::new(16, 0, SFR_CGUFSCR); - - pub const SFR_ACLKGR: crate::Register = crate::Register::new(24, 0xff); - pub const SFR_ACLKGR_SFR_ACLKGR: crate::Field = crate::Field::new(8, 0, SFR_ACLKGR); - - pub const SFR_HCLKGR: crate::Register = crate::Register::new(25, 0xff); - pub const SFR_HCLKGR_SFR_HCLKGR: crate::Field = crate::Field::new(8, 0, SFR_HCLKGR); - - pub const SFR_ICLKGR: crate::Register = crate::Register::new(26, 0xff); - pub const SFR_ICLKGR_SFR_ICLKGR: crate::Field = crate::Field::new(8, 0, SFR_ICLKGR); - - pub const SFR_PCLKGR: crate::Register = crate::Register::new(27, 0xff); - pub const SFR_PCLKGR_SFR_PCLKGR: crate::Field = crate::Field::new(8, 0, SFR_PCLKGR); - - pub const SFR_RCURST0: crate::Register = crate::Register::new(32, 0xffffffff); - pub const SFR_RCURST0_SFR_RCURST0: crate::Field = crate::Field::new(32, 0, SFR_RCURST0); - - pub const SFR_RCURST1: crate::Register = crate::Register::new(33, 0xffffffff); - pub const SFR_RCURST1_SFR_RCURST1: crate::Field = crate::Field::new(32, 0, SFR_RCURST1); - - pub const SFR_RCUSRCFR: crate::Register = crate::Register::new(34, 0xffff); - pub const SFR_RCUSRCFR_SFR_RCUSRCFR: crate::Field = crate::Field::new(16, 0, SFR_RCUSRCFR); - - pub const SFR_IPCARIPFLOW: crate::Register = crate::Register::new(36, 0xffffffff); - pub const SFR_IPCARIPFLOW_SFR_IPCARIPFLOW: crate::Field = crate::Field::new(32, 0, SFR_IPCARIPFLOW); - - pub const SFR_IPCEN: crate::Register = crate::Register::new(37, 0xffff); - pub const SFR_IPCEN_SFR_IPCEN: crate::Field = crate::Field::new(16, 0, SFR_IPCEN); - - pub const SFR_IPCLPEN: crate::Register = crate::Register::new(38, 0xffff); - pub const SFR_IPCLPEN_SFR_IPCLPEN: crate::Field = crate::Field::new(16, 0, SFR_IPCLPEN); - - pub const SFR_IPCOSC: crate::Register = crate::Register::new(39, 0x7f); - pub const SFR_IPCOSC_SFR_IPCOSC: crate::Field = crate::Field::new(7, 0, SFR_IPCOSC); - - pub const SFR_IPCPLLMN: crate::Register = crate::Register::new(40, 0x1ffff); - pub const SFR_IPCPLLMN_SFR_IPCPLLMN: crate::Field = crate::Field::new(17, 0, SFR_IPCPLLMN); - - pub const SFR_IPCPLLF: crate::Register = crate::Register::new(41, 0x1ffffff); - pub const SFR_IPCPLLF_SFR_IPCPLLF: crate::Field = crate::Field::new(25, 0, SFR_IPCPLLF); - - pub const SFR_IPCPLLQ: crate::Register = crate::Register::new(42, 0x7fff); - pub const SFR_IPCPLLQ_SFR_IPCPLLQ: crate::Field = crate::Field::new(15, 0, SFR_IPCPLLQ); - - pub const SFR_IPCCR: crate::Register = crate::Register::new(43, 0xffff); - pub const SFR_IPCCR_SFR_IPCCR: crate::Field = crate::Field::new(16, 0, SFR_IPCCR); - - pub const HW_SYSCTRL_BASE: usize = 0x40040000; - } - - pub mod apb_thru { - pub const APB_THRU_NUMREGS: usize = 0; - - pub const HW_APB_THRU_BASE: usize = 0x50122000; - } - - pub mod iox { - pub const IOX_NUMREGS: usize = 64; - - pub const SFR_AFSEL_CRAFSEL0: crate::Register = crate::Register::new(0, 0xffff); - pub const SFR_AFSEL_CRAFSEL0_CRAFSEL0: crate::Field = crate::Field::new(16, 0, SFR_AFSEL_CRAFSEL0); - - pub const SFR_AFSEL_CRAFSEL1: crate::Register = crate::Register::new(1, 0xffff); - pub const SFR_AFSEL_CRAFSEL1_CRAFSEL1: crate::Field = crate::Field::new(16, 0, SFR_AFSEL_CRAFSEL1); - - pub const SFR_AFSEL_CRAFSEL2: crate::Register = crate::Register::new(2, 0xffff); - pub const SFR_AFSEL_CRAFSEL2_CRAFSEL2: crate::Field = crate::Field::new(16, 0, SFR_AFSEL_CRAFSEL2); - - pub const SFR_AFSEL_CRAFSEL3: crate::Register = crate::Register::new(3, 0xffff); - pub const SFR_AFSEL_CRAFSEL3_CRAFSEL3: crate::Field = crate::Field::new(16, 0, SFR_AFSEL_CRAFSEL3); - - pub const SFR_AFSEL_CRAFSEL4: crate::Register = crate::Register::new(4, 0xffff); - pub const SFR_AFSEL_CRAFSEL4_CRAFSEL4: crate::Field = crate::Field::new(16, 0, SFR_AFSEL_CRAFSEL4); - - pub const SFR_AFSEL_CRAFSEL5: crate::Register = crate::Register::new(5, 0xffff); - pub const SFR_AFSEL_CRAFSEL5_CRAFSEL5: crate::Field = crate::Field::new(16, 0, SFR_AFSEL_CRAFSEL5); - - pub const SFR_AFSEL_CRAFSEL6: crate::Register = crate::Register::new(6, 0xffff); - pub const SFR_AFSEL_CRAFSEL6_CRAFSEL6: crate::Field = crate::Field::new(16, 0, SFR_AFSEL_CRAFSEL6); - - pub const SFR_AFSEL_CRAFSEL7: crate::Register = crate::Register::new(7, 0xffff); - pub const SFR_AFSEL_CRAFSEL7_CRAFSEL7: crate::Field = crate::Field::new(16, 0, SFR_AFSEL_CRAFSEL7); - - pub const SFR_AFSEL_CRAFSEL8: crate::Register = crate::Register::new(8, 0xffff); - pub const SFR_AFSEL_CRAFSEL8_CRAFSEL8: crate::Field = crate::Field::new(16, 0, SFR_AFSEL_CRAFSEL8); - - pub const SFR_AFSEL_CRAFSEL9: crate::Register = crate::Register::new(9, 0xffff); - pub const SFR_AFSEL_CRAFSEL9_CRAFSEL9: crate::Field = crate::Field::new(16, 0, SFR_AFSEL_CRAFSEL9); - - pub const SFR_AFSEL_CRAFSEL10: crate::Register = crate::Register::new(10, 0xffff); - pub const SFR_AFSEL_CRAFSEL10_CRAFSEL10: crate::Field = crate::Field::new(16, 0, SFR_AFSEL_CRAFSEL10); - - pub const SFR_AFSEL_CRAFSEL11: crate::Register = crate::Register::new(11, 0xffff); - pub const SFR_AFSEL_CRAFSEL11_CRAFSEL11: crate::Field = crate::Field::new(16, 0, SFR_AFSEL_CRAFSEL11); - - pub const SFR_INTCR_CRINT0: crate::Register = crate::Register::new(64, 0x3ff); - pub const SFR_INTCR_CRINT0_CRINT0: crate::Field = crate::Field::new(10, 0, SFR_INTCR_CRINT0); - - pub const SFR_INTCR_CRINT1: crate::Register = crate::Register::new(65, 0x3ff); - pub const SFR_INTCR_CRINT1_CRINT1: crate::Field = crate::Field::new(10, 0, SFR_INTCR_CRINT1); - - pub const SFR_INTCR_CRINT2: crate::Register = crate::Register::new(66, 0x3ff); - pub const SFR_INTCR_CRINT2_CRINT2: crate::Field = crate::Field::new(10, 0, SFR_INTCR_CRINT2); - - pub const SFR_INTCR_CRINT3: crate::Register = crate::Register::new(67, 0x3ff); - pub const SFR_INTCR_CRINT3_CRINT3: crate::Field = crate::Field::new(10, 0, SFR_INTCR_CRINT3); - - pub const SFR_INTCR_CRINT4: crate::Register = crate::Register::new(68, 0x3ff); - pub const SFR_INTCR_CRINT4_CRINT4: crate::Field = crate::Field::new(10, 0, SFR_INTCR_CRINT4); - - pub const SFR_INTCR_CRINT5: crate::Register = crate::Register::new(69, 0x3ff); - pub const SFR_INTCR_CRINT5_CRINT5: crate::Field = crate::Field::new(10, 0, SFR_INTCR_CRINT5); - - pub const SFR_INTCR_CRINT6: crate::Register = crate::Register::new(70, 0x3ff); - pub const SFR_INTCR_CRINT6_CRINT6: crate::Field = crate::Field::new(10, 0, SFR_INTCR_CRINT6); - - pub const SFR_INTCR_CRINT7: crate::Register = crate::Register::new(71, 0x3ff); - pub const SFR_INTCR_CRINT7_CRINT7: crate::Field = crate::Field::new(10, 0, SFR_INTCR_CRINT7); - - pub const SFR_INTFR: crate::Register = crate::Register::new(72, 0xff); - pub const SFR_INTFR_FRINT: crate::Field = crate::Field::new(8, 0, SFR_INTFR); - - pub const SFR_GPIOOUT_CRGO0: crate::Register = crate::Register::new(76, 0xffff); - pub const SFR_GPIOOUT_CRGO0_CRGO0: crate::Field = crate::Field::new(16, 0, SFR_GPIOOUT_CRGO0); - - pub const SFR_GPIOOUT_CRGO1: crate::Register = crate::Register::new(77, 0xffff); - pub const SFR_GPIOOUT_CRGO1_CRGO1: crate::Field = crate::Field::new(16, 0, SFR_GPIOOUT_CRGO1); - - pub const SFR_GPIOOUT_CRGO2: crate::Register = crate::Register::new(78, 0xffff); - pub const SFR_GPIOOUT_CRGO2_CRGO2: crate::Field = crate::Field::new(16, 0, SFR_GPIOOUT_CRGO2); - - pub const SFR_GPIOOUT_CRGO3: crate::Register = crate::Register::new(79, 0xffff); - pub const SFR_GPIOOUT_CRGO3_CRGO3: crate::Field = crate::Field::new(16, 0, SFR_GPIOOUT_CRGO3); - - pub const SFR_GPIOOUT_CRGO4: crate::Register = crate::Register::new(80, 0xffff); - pub const SFR_GPIOOUT_CRGO4_CRGO4: crate::Field = crate::Field::new(16, 0, SFR_GPIOOUT_CRGO4); - - pub const SFR_GPIOOUT_CRGO5: crate::Register = crate::Register::new(81, 0xffff); - pub const SFR_GPIOOUT_CRGO5_CRGO5: crate::Field = crate::Field::new(16, 0, SFR_GPIOOUT_CRGO5); - - pub const SFR_GPIOOE_CRGOE0: crate::Register = crate::Register::new(82, 0xffff); - pub const SFR_GPIOOE_CRGOE0_CRGOE0: crate::Field = crate::Field::new(16, 0, SFR_GPIOOE_CRGOE0); - - pub const SFR_GPIOOE_CRGOE1: crate::Register = crate::Register::new(83, 0xffff); - pub const SFR_GPIOOE_CRGOE1_CRGOE1: crate::Field = crate::Field::new(16, 0, SFR_GPIOOE_CRGOE1); - - pub const SFR_GPIOOE_CRGOE2: crate::Register = crate::Register::new(84, 0xffff); - pub const SFR_GPIOOE_CRGOE2_CRGOE2: crate::Field = crate::Field::new(16, 0, SFR_GPIOOE_CRGOE2); - - pub const SFR_GPIOOE_CRGOE3: crate::Register = crate::Register::new(85, 0xffff); - pub const SFR_GPIOOE_CRGOE3_CRGOE3: crate::Field = crate::Field::new(16, 0, SFR_GPIOOE_CRGOE3); - - pub const SFR_GPIOOE_CRGOE4: crate::Register = crate::Register::new(86, 0xffff); - pub const SFR_GPIOOE_CRGOE4_CRGOE4: crate::Field = crate::Field::new(16, 0, SFR_GPIOOE_CRGOE4); - - pub const SFR_GPIOOE_CRGOE5: crate::Register = crate::Register::new(87, 0xffff); - pub const SFR_GPIOOE_CRGOE5_CRGOE5: crate::Field = crate::Field::new(16, 0, SFR_GPIOOE_CRGOE5); - - pub const SFR_GPIOPU_CRGPU0: crate::Register = crate::Register::new(88, 0xffff); - pub const SFR_GPIOPU_CRGPU0_CRGPU0: crate::Field = crate::Field::new(16, 0, SFR_GPIOPU_CRGPU0); - - pub const SFR_GPIOPU_CRGPU1: crate::Register = crate::Register::new(89, 0xffff); - pub const SFR_GPIOPU_CRGPU1_CRGPU1: crate::Field = crate::Field::new(16, 0, SFR_GPIOPU_CRGPU1); - - pub const SFR_GPIOPU_CRGPU2: crate::Register = crate::Register::new(90, 0xffff); - pub const SFR_GPIOPU_CRGPU2_CRGPU2: crate::Field = crate::Field::new(16, 0, SFR_GPIOPU_CRGPU2); - - pub const SFR_GPIOPU_CRGPU3: crate::Register = crate::Register::new(91, 0xffff); - pub const SFR_GPIOPU_CRGPU3_CRGPU3: crate::Field = crate::Field::new(16, 0, SFR_GPIOPU_CRGPU3); - - pub const SFR_GPIOPU_CRGPU4: crate::Register = crate::Register::new(92, 0xffff); - pub const SFR_GPIOPU_CRGPU4_CRGPU4: crate::Field = crate::Field::new(16, 0, SFR_GPIOPU_CRGPU4); - - pub const SFR_GPIOPU_CRGPU5: crate::Register = crate::Register::new(93, 0xffff); - pub const SFR_GPIOPU_CRGPU5_CRGPU5: crate::Field = crate::Field::new(16, 0, SFR_GPIOPU_CRGPU5); - - pub const SFR_GPIOIN_SRGI0: crate::Register = crate::Register::new(94, 0xffff); - pub const SFR_GPIOIN_SRGI0_SRGI0: crate::Field = crate::Field::new(16, 0, SFR_GPIOIN_SRGI0); - - pub const SFR_GPIOIN_SRGI1: crate::Register = crate::Register::new(95, 0xffff); - pub const SFR_GPIOIN_SRGI1_SRGI1: crate::Field = crate::Field::new(16, 0, SFR_GPIOIN_SRGI1); - - pub const SFR_GPIOIN_SRGI2: crate::Register = crate::Register::new(96, 0xffff); - pub const SFR_GPIOIN_SRGI2_SRGI2: crate::Field = crate::Field::new(16, 0, SFR_GPIOIN_SRGI2); - - pub const SFR_GPIOIN_SRGI3: crate::Register = crate::Register::new(97, 0xffff); - pub const SFR_GPIOIN_SRGI3_SRGI3: crate::Field = crate::Field::new(16, 0, SFR_GPIOIN_SRGI3); - - pub const SFR_GPIOIN_SRGI4: crate::Register = crate::Register::new(98, 0xffff); - pub const SFR_GPIOIN_SRGI4_SRGI4: crate::Field = crate::Field::new(16, 0, SFR_GPIOIN_SRGI4); - - pub const SFR_GPIOIN_SRGI5: crate::Register = crate::Register::new(99, 0xffff); - pub const SFR_GPIOIN_SRGI5_SRGI5: crate::Field = crate::Field::new(16, 0, SFR_GPIOIN_SRGI5); - - pub const SFR_PIOSEL: crate::Register = crate::Register::new(128, 0xffffffff); - pub const SFR_PIOSEL_PIOSEL: crate::Field = crate::Field::new(32, 0, SFR_PIOSEL); - - pub const SFR_CFG_SCHM_CR_CFG_SCHMSEL0: crate::Register = crate::Register::new(140, 0xffff); - pub const SFR_CFG_SCHM_CR_CFG_SCHMSEL0_CR_CFG_SCHMSEL0: crate::Field = crate::Field::new(16, 0, SFR_CFG_SCHM_CR_CFG_SCHMSEL0); - - pub const SFR_CFG_SCHM_CR_CFG_SCHMSEL1: crate::Register = crate::Register::new(141, 0xffff); - pub const SFR_CFG_SCHM_CR_CFG_SCHMSEL1_CR_CFG_SCHMSEL1: crate::Field = crate::Field::new(16, 0, SFR_CFG_SCHM_CR_CFG_SCHMSEL1); - - pub const SFR_CFG_SCHM_CR_CFG_SCHMSEL2: crate::Register = crate::Register::new(142, 0xffff); - pub const SFR_CFG_SCHM_CR_CFG_SCHMSEL2_CR_CFG_SCHMSEL2: crate::Field = crate::Field::new(16, 0, SFR_CFG_SCHM_CR_CFG_SCHMSEL2); - - pub const SFR_CFG_SCHM_CR_CFG_SCHMSEL3: crate::Register = crate::Register::new(143, 0xffff); - pub const SFR_CFG_SCHM_CR_CFG_SCHMSEL3_CR_CFG_SCHMSEL3: crate::Field = crate::Field::new(16, 0, SFR_CFG_SCHM_CR_CFG_SCHMSEL3); - - pub const SFR_CFG_SCHM_CR_CFG_SCHMSEL4: crate::Register = crate::Register::new(144, 0xffff); - pub const SFR_CFG_SCHM_CR_CFG_SCHMSEL4_CR_CFG_SCHMSEL4: crate::Field = crate::Field::new(16, 0, SFR_CFG_SCHM_CR_CFG_SCHMSEL4); - - pub const SFR_CFG_SCHM_CR_CFG_SCHMSEL5: crate::Register = crate::Register::new(145, 0xffff); - pub const SFR_CFG_SCHM_CR_CFG_SCHMSEL5_CR_CFG_SCHMSEL5: crate::Field = crate::Field::new(16, 0, SFR_CFG_SCHM_CR_CFG_SCHMSEL5); - - pub const SFR_CFG_SLEW_CR_CFG_SLEWSLOW0: crate::Register = crate::Register::new(146, 0xffff); - pub const SFR_CFG_SLEW_CR_CFG_SLEWSLOW0_CR_CFG_SLEWSLOW0: crate::Field = crate::Field::new(16, 0, SFR_CFG_SLEW_CR_CFG_SLEWSLOW0); - - pub const SFR_CFG_SLEW_CR_CFG_SLEWSLOW1: crate::Register = crate::Register::new(147, 0xffff); - pub const SFR_CFG_SLEW_CR_CFG_SLEWSLOW1_CR_CFG_SLEWSLOW1: crate::Field = crate::Field::new(16, 0, SFR_CFG_SLEW_CR_CFG_SLEWSLOW1); - - pub const SFR_CFG_SLEW_CR_CFG_SLEWSLOW2: crate::Register = crate::Register::new(148, 0xffff); - pub const SFR_CFG_SLEW_CR_CFG_SLEWSLOW2_CR_CFG_SLEWSLOW2: crate::Field = crate::Field::new(16, 0, SFR_CFG_SLEW_CR_CFG_SLEWSLOW2); - - pub const SFR_CFG_SLEW_CR_CFG_SLEWSLOW3: crate::Register = crate::Register::new(149, 0xffff); - pub const SFR_CFG_SLEW_CR_CFG_SLEWSLOW3_CR_CFG_SLEWSLOW3: crate::Field = crate::Field::new(16, 0, SFR_CFG_SLEW_CR_CFG_SLEWSLOW3); - - pub const SFR_CFG_SLEW_CR_CFG_SLEWSLOW4: crate::Register = crate::Register::new(150, 0xffff); - pub const SFR_CFG_SLEW_CR_CFG_SLEWSLOW4_CR_CFG_SLEWSLOW4: crate::Field = crate::Field::new(16, 0, SFR_CFG_SLEW_CR_CFG_SLEWSLOW4); - - pub const SFR_CFG_SLEW_CR_CFG_SLEWSLOW5: crate::Register = crate::Register::new(151, 0xffff); - pub const SFR_CFG_SLEW_CR_CFG_SLEWSLOW5_CR_CFG_SLEWSLOW5: crate::Field = crate::Field::new(16, 0, SFR_CFG_SLEW_CR_CFG_SLEWSLOW5); - - pub const SFR_CFG_DRVSEL_CR_CFG_DRVSEL0: crate::Register = crate::Register::new(152, 0xffffffff); - pub const SFR_CFG_DRVSEL_CR_CFG_DRVSEL0_CR_CFG_DRVSEL0: crate::Field = crate::Field::new(32, 0, SFR_CFG_DRVSEL_CR_CFG_DRVSEL0); - - pub const SFR_CFG_DRVSEL_CR_CFG_DRVSEL1: crate::Register = crate::Register::new(153, 0xffffffff); - pub const SFR_CFG_DRVSEL_CR_CFG_DRVSEL1_CR_CFG_DRVSEL1: crate::Field = crate::Field::new(32, 0, SFR_CFG_DRVSEL_CR_CFG_DRVSEL1); - - pub const SFR_CFG_DRVSEL_CR_CFG_DRVSEL2: crate::Register = crate::Register::new(154, 0xffffffff); - pub const SFR_CFG_DRVSEL_CR_CFG_DRVSEL2_CR_CFG_DRVSEL2: crate::Field = crate::Field::new(32, 0, SFR_CFG_DRVSEL_CR_CFG_DRVSEL2); - - pub const SFR_CFG_DRVSEL_CR_CFG_DRVSEL3: crate::Register = crate::Register::new(155, 0xffffffff); - pub const SFR_CFG_DRVSEL_CR_CFG_DRVSEL3_CR_CFG_DRVSEL3: crate::Field = crate::Field::new(32, 0, SFR_CFG_DRVSEL_CR_CFG_DRVSEL3); - - pub const SFR_CFG_DRVSEL_CR_CFG_DRVSEL4: crate::Register = crate::Register::new(156, 0xffffffff); - pub const SFR_CFG_DRVSEL_CR_CFG_DRVSEL4_CR_CFG_DRVSEL4: crate::Field = crate::Field::new(32, 0, SFR_CFG_DRVSEL_CR_CFG_DRVSEL4); - - pub const SFR_CFG_DRVSEL_CR_CFG_DRVSEL5: crate::Register = crate::Register::new(157, 0xffffffff); - pub const SFR_CFG_DRVSEL_CR_CFG_DRVSEL5_CR_CFG_DRVSEL5: crate::Field = crate::Field::new(32, 0, SFR_CFG_DRVSEL_CR_CFG_DRVSEL5); - - pub const HW_IOX_BASE: usize = 0x5012f000; - } - - pub mod pwm { - pub const PWM_NUMREGS: usize = 0; - - pub const HW_PWM_BASE: usize = 0x50120000; - } - - pub mod sddc { - pub const SDDC_NUMREGS: usize = 112; - - pub const SFR_IO: crate::Register = crate::Register::new(0, 0x3); - pub const SFR_IO_SFR_IO: crate::Field = crate::Field::new(2, 0, SFR_IO); - - pub const SFR_AR: crate::Register = crate::Register::new(1, 0xffffffff); - pub const SFR_AR_SFR_AR: crate::Field = crate::Field::new(32, 0, SFR_AR); - - pub const CR_OCR: crate::Register = crate::Register::new(4, 0xffffff); - pub const CR_OCR_CR_OCR: crate::Field = crate::Field::new(24, 0, CR_OCR); - - pub const CR_RDFFTHRES: crate::Register = crate::Register::new(5, 0xff); - pub const CR_RDFFTHRES_CR_RDFFTHRES: crate::Field = crate::Field::new(8, 0, CR_RDFFTHRES); - - pub const CR_REV: crate::Register = crate::Register::new(6, 0xffff); - pub const CR_REV_CFG_REG_SD_SPEC_REVISION: crate::Field = crate::Field::new(8, 0, CR_REV); - pub const CR_REV_CFG_REG_CCCR_SDIO_REVISION: crate::Field = crate::Field::new(8, 8, CR_REV); - - pub const CR_BACSA: crate::Register = crate::Register::new(7, 0x3ffff); - pub const CR_BACSA_CFG_BASE_ADDR_CSA: crate::Field = crate::Field::new(18, 0, CR_BACSA); - - pub const CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC0: crate::Register = crate::Register::new(8, 0x3ffff); - pub const CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC0_CFG_BASE_ADDR_IO_FUNC0: crate::Field = crate::Field::new(18, 0, CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC0); - - pub const CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC1: crate::Register = crate::Register::new(9, 0x3ffff); - pub const CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC1_CFG_BASE_ADDR_IO_FUNC1: crate::Field = crate::Field::new(18, 0, CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC1); - - pub const CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC2: crate::Register = crate::Register::new(10, 0x3ffff); - pub const CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC2_CFG_BASE_ADDR_IO_FUNC2: crate::Field = crate::Field::new(18, 0, CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC2); - - pub const CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC3: crate::Register = crate::Register::new(11, 0x3ffff); - pub const CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC3_CFG_BASE_ADDR_IO_FUNC3: crate::Field = crate::Field::new(18, 0, CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC3); - - pub const CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC4: crate::Register = crate::Register::new(12, 0x3ffff); - pub const CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC4_CFG_BASE_ADDR_IO_FUNC4: crate::Field = crate::Field::new(18, 0, CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC4); - - pub const CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC5: crate::Register = crate::Register::new(13, 0x3ffff); - pub const CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC5_CFG_BASE_ADDR_IO_FUNC5: crate::Field = crate::Field::new(18, 0, CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC5); - - pub const CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC6: crate::Register = crate::Register::new(14, 0x3ffff); - pub const CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC6_CFG_BASE_ADDR_IO_FUNC6: crate::Field = crate::Field::new(18, 0, CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC6); - - pub const CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC7: crate::Register = crate::Register::new(15, 0x3ffff); - pub const CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC7_CFG_BASE_ADDR_IO_FUNC7: crate::Field = crate::Field::new(18, 0, CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC7); - - pub const CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR0: crate::Register = crate::Register::new(16, 0x1ffff); - pub const CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR0_CFG_REG_FUNC_CIS_PTR0: crate::Field = crate::Field::new(17, 0, CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR0); - - pub const CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR1: crate::Register = crate::Register::new(17, 0x1ffff); - pub const CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR1_CFG_REG_FUNC_CIS_PTR1: crate::Field = crate::Field::new(17, 0, CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR1); - - pub const CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR2: crate::Register = crate::Register::new(18, 0x1ffff); - pub const CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR2_CFG_REG_FUNC_CIS_PTR2: crate::Field = crate::Field::new(17, 0, CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR2); - - pub const CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR3: crate::Register = crate::Register::new(19, 0x1ffff); - pub const CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR3_CFG_REG_FUNC_CIS_PTR3: crate::Field = crate::Field::new(17, 0, CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR3); - - pub const CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR4: crate::Register = crate::Register::new(20, 0x1ffff); - pub const CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR4_CFG_REG_FUNC_CIS_PTR4: crate::Field = crate::Field::new(17, 0, CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR4); - - pub const CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR5: crate::Register = crate::Register::new(21, 0x1ffff); - pub const CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR5_CFG_REG_FUNC_CIS_PTR5: crate::Field = crate::Field::new(17, 0, CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR5); - - pub const CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR6: crate::Register = crate::Register::new(22, 0x1ffff); - pub const CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR6_CFG_REG_FUNC_CIS_PTR6: crate::Field = crate::Field::new(17, 0, CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR6); - - pub const CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR7: crate::Register = crate::Register::new(23, 0x1ffff); - pub const CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR7_CFG_REG_FUNC_CIS_PTR7: crate::Field = crate::Field::new(17, 0, CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR7); - - pub const CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE0: crate::Register = crate::Register::new(24, 0xff); - pub const CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE0_CFG_REG_FUNC_EXT_STD_CODE0: crate::Field = crate::Field::new(8, 0, CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE0); - - pub const CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE1: crate::Register = crate::Register::new(25, 0xff); - pub const CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE1_CFG_REG_FUNC_EXT_STD_CODE1: crate::Field = crate::Field::new(8, 0, CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE1); - - pub const CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE2: crate::Register = crate::Register::new(26, 0xff); - pub const CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE2_CFG_REG_FUNC_EXT_STD_CODE2: crate::Field = crate::Field::new(8, 0, CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE2); - - pub const CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE3: crate::Register = crate::Register::new(27, 0xff); - pub const CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE3_CFG_REG_FUNC_EXT_STD_CODE3: crate::Field = crate::Field::new(8, 0, CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE3); - - pub const CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE4: crate::Register = crate::Register::new(28, 0xff); - pub const CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE4_CFG_REG_FUNC_EXT_STD_CODE4: crate::Field = crate::Field::new(8, 0, CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE4); - - pub const CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE5: crate::Register = crate::Register::new(29, 0xff); - pub const CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE5_CFG_REG_FUNC_EXT_STD_CODE5: crate::Field = crate::Field::new(8, 0, CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE5); - - pub const CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE6: crate::Register = crate::Register::new(30, 0xff); - pub const CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE6_CFG_REG_FUNC_EXT_STD_CODE6: crate::Field = crate::Field::new(8, 0, CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE6); - - pub const CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE7: crate::Register = crate::Register::new(31, 0xff); - pub const CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE7_CFG_REG_FUNC_EXT_STD_CODE7: crate::Field = crate::Field::new(8, 0, CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE7); - - pub const CR_WRITE_PROTECT: crate::Register = crate::Register::new(32, 0x1); - pub const CR_WRITE_PROTECT_CR_WRITE_PROTECT: crate::Field = crate::Field::new(1, 0, CR_WRITE_PROTECT); - - pub const CR_REG_DSR: crate::Register = crate::Register::new(33, 0xffff); - pub const CR_REG_DSR_CR_REG_DSR: crate::Field = crate::Field::new(16, 0, CR_REG_DSR); - - pub const CR_REG_CID_CFG_REG_CID0: crate::Register = crate::Register::new(34, 0xffffffff); - pub const CR_REG_CID_CFG_REG_CID0_CFG_REG_CID0: crate::Field = crate::Field::new(32, 0, CR_REG_CID_CFG_REG_CID0); - - pub const CR_REG_CID_CFG_REG_CID1: crate::Register = crate::Register::new(35, 0xffffffff); - pub const CR_REG_CID_CFG_REG_CID1_CFG_REG_CID1: crate::Field = crate::Field::new(32, 0, CR_REG_CID_CFG_REG_CID1); - - pub const CR_REG_CID_CFG_REG_CID2: crate::Register = crate::Register::new(36, 0xffffffff); - pub const CR_REG_CID_CFG_REG_CID2_CFG_REG_CID2: crate::Field = crate::Field::new(32, 0, CR_REG_CID_CFG_REG_CID2); - - pub const CR_REG_CID_CFG_REG_CID3: crate::Register = crate::Register::new(37, 0xffffffff); - pub const CR_REG_CID_CFG_REG_CID3_CFG_REG_CID3: crate::Field = crate::Field::new(32, 0, CR_REG_CID_CFG_REG_CID3); - - pub const CR_REG_CSD_CFG_REG_CSD0: crate::Register = crate::Register::new(38, 0xffffffff); - pub const CR_REG_CSD_CFG_REG_CSD0_CFG_REG_CSD0: crate::Field = crate::Field::new(32, 0, CR_REG_CSD_CFG_REG_CSD0); - - pub const CR_REG_CSD_CFG_REG_CSD1: crate::Register = crate::Register::new(39, 0xffffffff); - pub const CR_REG_CSD_CFG_REG_CSD1_CFG_REG_CSD1: crate::Field = crate::Field::new(32, 0, CR_REG_CSD_CFG_REG_CSD1); - - pub const CR_REG_CSD_CFG_REG_CSD2: crate::Register = crate::Register::new(40, 0xffffffff); - pub const CR_REG_CSD_CFG_REG_CSD2_CFG_REG_CSD2: crate::Field = crate::Field::new(32, 0, CR_REG_CSD_CFG_REG_CSD2); - - pub const CR_REG_CSD_CFG_REG_CSD3: crate::Register = crate::Register::new(41, 0xffffffff); - pub const CR_REG_CSD_CFG_REG_CSD3_CFG_REG_CSD3: crate::Field = crate::Field::new(32, 0, CR_REG_CSD_CFG_REG_CSD3); - - pub const CR_REG_SCR_CFG_REG_SCR0: crate::Register = crate::Register::new(42, 0xffffffff); - pub const CR_REG_SCR_CFG_REG_SCR0_CFG_REG_SCR0: crate::Field = crate::Field::new(32, 0, CR_REG_SCR_CFG_REG_SCR0); - - pub const CR_REG_SCR_CFG_REG_SCR1: crate::Register = crate::Register::new(43, 0xffffffff); - pub const CR_REG_SCR_CFG_REG_SCR1_CFG_REG_SCR1: crate::Field = crate::Field::new(32, 0, CR_REG_SCR_CFG_REG_SCR1); - - pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS0: crate::Register = crate::Register::new(44, 0xffffffff); - pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS0_CFG_REG_SD_STATUS0: crate::Field = crate::Field::new(32, 0, CR_REG_SD_STATUS_CFG_REG_SD_STATUS0); - - pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS1: crate::Register = crate::Register::new(45, 0xffffffff); - pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS1_CFG_REG_SD_STATUS1: crate::Field = crate::Field::new(32, 0, CR_REG_SD_STATUS_CFG_REG_SD_STATUS1); - - pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS2: crate::Register = crate::Register::new(46, 0xffffffff); - pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS2_CFG_REG_SD_STATUS2: crate::Field = crate::Field::new(32, 0, CR_REG_SD_STATUS_CFG_REG_SD_STATUS2); - - pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS3: crate::Register = crate::Register::new(47, 0xffffffff); - pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS3_CFG_REG_SD_STATUS3: crate::Field = crate::Field::new(32, 0, CR_REG_SD_STATUS_CFG_REG_SD_STATUS3); - - pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS4: crate::Register = crate::Register::new(48, 0xffffffff); - pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS4_CFG_REG_SD_STATUS4: crate::Field = crate::Field::new(32, 0, CR_REG_SD_STATUS_CFG_REG_SD_STATUS4); - - pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS5: crate::Register = crate::Register::new(49, 0xffffffff); - pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS5_CFG_REG_SD_STATUS5: crate::Field = crate::Field::new(32, 0, CR_REG_SD_STATUS_CFG_REG_SD_STATUS5); - - pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS6: crate::Register = crate::Register::new(50, 0xffffffff); - pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS6_CFG_REG_SD_STATUS6: crate::Field = crate::Field::new(32, 0, CR_REG_SD_STATUS_CFG_REG_SD_STATUS6); - - pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS7: crate::Register = crate::Register::new(51, 0xffffffff); - pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS7_CFG_REG_SD_STATUS7: crate::Field = crate::Field::new(32, 0, CR_REG_SD_STATUS_CFG_REG_SD_STATUS7); - - pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS8: crate::Register = crate::Register::new(52, 0xffffffff); - pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS8_CFG_REG_SD_STATUS8: crate::Field = crate::Field::new(32, 0, CR_REG_SD_STATUS_CFG_REG_SD_STATUS8); - - pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS9: crate::Register = crate::Register::new(53, 0xffffffff); - pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS9_CFG_REG_SD_STATUS9: crate::Field = crate::Field::new(32, 0, CR_REG_SD_STATUS_CFG_REG_SD_STATUS9); - - pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS10: crate::Register = crate::Register::new(54, 0xffffffff); - pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS10_CFG_REG_SD_STATUS10: crate::Field = crate::Field::new(32, 0, CR_REG_SD_STATUS_CFG_REG_SD_STATUS10); - - pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS11: crate::Register = crate::Register::new(55, 0xffffffff); - pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS11_CFG_REG_SD_STATUS11: crate::Field = crate::Field::new(32, 0, CR_REG_SD_STATUS_CFG_REG_SD_STATUS11); - - pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS12: crate::Register = crate::Register::new(56, 0xffffffff); - pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS12_CFG_REG_SD_STATUS12: crate::Field = crate::Field::new(32, 0, CR_REG_SD_STATUS_CFG_REG_SD_STATUS12); - - pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS13: crate::Register = crate::Register::new(57, 0xffffffff); - pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS13_CFG_REG_SD_STATUS13: crate::Field = crate::Field::new(32, 0, CR_REG_SD_STATUS_CFG_REG_SD_STATUS13); - - pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS14: crate::Register = crate::Register::new(58, 0xffffffff); - pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS14_CFG_REG_SD_STATUS14: crate::Field = crate::Field::new(32, 0, CR_REG_SD_STATUS_CFG_REG_SD_STATUS14); - - pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS15: crate::Register = crate::Register::new(59, 0xffffffff); - pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS15_CFG_REG_SD_STATUS15: crate::Field = crate::Field::new(32, 0, CR_REG_SD_STATUS_CFG_REG_SD_STATUS15); - - pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC0: crate::Register = crate::Register::new(64, 0x3ffff); - pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC0_CFG_BASE_ADDR_MEM_FUNC0: crate::Field = crate::Field::new(18, 0, CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC0); - - pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC1: crate::Register = crate::Register::new(65, 0x3ffff); - pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC1_CFG_BASE_ADDR_MEM_FUNC1: crate::Field = crate::Field::new(18, 0, CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC1); - - pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC2: crate::Register = crate::Register::new(66, 0x3ffff); - pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC2_CFG_BASE_ADDR_MEM_FUNC2: crate::Field = crate::Field::new(18, 0, CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC2); - - pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC3: crate::Register = crate::Register::new(67, 0x3ffff); - pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC3_CFG_BASE_ADDR_MEM_FUNC3: crate::Field = crate::Field::new(18, 0, CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC3); - - pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC4: crate::Register = crate::Register::new(68, 0x3ffff); - pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC4_CFG_BASE_ADDR_MEM_FUNC4: crate::Field = crate::Field::new(18, 0, CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC4); - - pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC5: crate::Register = crate::Register::new(69, 0x3ffff); - pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC5_CFG_BASE_ADDR_MEM_FUNC5: crate::Field = crate::Field::new(18, 0, CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC5); - - pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC6: crate::Register = crate::Register::new(70, 0x3ffff); - pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC6_CFG_BASE_ADDR_MEM_FUNC6: crate::Field = crate::Field::new(18, 0, CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC6); - - pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC7: crate::Register = crate::Register::new(71, 0x3ffff); - pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC7_CFG_BASE_ADDR_MEM_FUNC7: crate::Field = crate::Field::new(18, 0, CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC7); - - pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC8: crate::Register = crate::Register::new(72, 0x3ffff); - pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC8_CFG_BASE_ADDR_MEM_FUNC8: crate::Field = crate::Field::new(18, 0, CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC8); - - pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC9: crate::Register = crate::Register::new(73, 0x3ffff); - pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC9_CFG_BASE_ADDR_MEM_FUNC9: crate::Field = crate::Field::new(18, 0, CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC9); - - pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC10: crate::Register = crate::Register::new(74, 0x3ffff); - pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC10_CFG_BASE_ADDR_MEM_FUNC10: crate::Field = crate::Field::new(18, 0, CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC10); - - pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC11: crate::Register = crate::Register::new(75, 0x3ffff); - pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC11_CFG_BASE_ADDR_MEM_FUNC11: crate::Field = crate::Field::new(18, 0, CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC11); - - pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC12: crate::Register = crate::Register::new(76, 0x3ffff); - pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC12_CFG_BASE_ADDR_MEM_FUNC12: crate::Field = crate::Field::new(18, 0, CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC12); - - pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC13: crate::Register = crate::Register::new(77, 0x3ffff); - pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC13_CFG_BASE_ADDR_MEM_FUNC13: crate::Field = crate::Field::new(18, 0, CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC13); - - pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC14: crate::Register = crate::Register::new(78, 0x3ffff); - pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC14_CFG_BASE_ADDR_MEM_FUNC14: crate::Field = crate::Field::new(18, 0, CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC14); - - pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC15: crate::Register = crate::Register::new(79, 0x3ffff); - pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC15_CFG_BASE_ADDR_MEM_FUNC15: crate::Field = crate::Field::new(18, 0, CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC15); - - pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC16: crate::Register = crate::Register::new(80, 0x3ffff); - pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC16_CFG_BASE_ADDR_MEM_FUNC16: crate::Field = crate::Field::new(18, 0, CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC16); - - pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC17: crate::Register = crate::Register::new(81, 0x3ffff); - pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC17_CFG_BASE_ADDR_MEM_FUNC17: crate::Field = crate::Field::new(18, 0, CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC17); - - pub const CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE0: crate::Register = crate::Register::new(82, 0xff); - pub const CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE0_CFG_REG_FUNC_ISDIO_INTERFACE_CODE0: crate::Field = crate::Field::new(8, 0, CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE0); - - pub const CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE1: crate::Register = crate::Register::new(83, 0xff); - pub const CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE1_CFG_REG_FUNC_ISDIO_INTERFACE_CODE1: crate::Field = crate::Field::new(8, 0, CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE1); - - pub const CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE2: crate::Register = crate::Register::new(84, 0xff); - pub const CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE2_CFG_REG_FUNC_ISDIO_INTERFACE_CODE2: crate::Field = crate::Field::new(8, 0, CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE2); - - pub const CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE3: crate::Register = crate::Register::new(85, 0xff); - pub const CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE3_CFG_REG_FUNC_ISDIO_INTERFACE_CODE3: crate::Field = crate::Field::new(8, 0, CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE3); - - pub const CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE4: crate::Register = crate::Register::new(86, 0xff); - pub const CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE4_CFG_REG_FUNC_ISDIO_INTERFACE_CODE4: crate::Field = crate::Field::new(8, 0, CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE4); - - pub const CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE5: crate::Register = crate::Register::new(87, 0xff); - pub const CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE5_CFG_REG_FUNC_ISDIO_INTERFACE_CODE5: crate::Field = crate::Field::new(8, 0, CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE5); - - pub const CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE6: crate::Register = crate::Register::new(88, 0xff); - pub const CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE6_CFG_REG_FUNC_ISDIO_INTERFACE_CODE6: crate::Field = crate::Field::new(8, 0, CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE6); - - pub const CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE0: crate::Register = crate::Register::new(90, 0xffff); - pub const CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE0_CFG_REG_FUNC_MANUFACT_CODE0: crate::Field = crate::Field::new(16, 0, CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE0); - - pub const CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE1: crate::Register = crate::Register::new(91, 0xffff); - pub const CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE1_CFG_REG_FUNC_MANUFACT_CODE1: crate::Field = crate::Field::new(16, 0, CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE1); - - pub const CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE2: crate::Register = crate::Register::new(92, 0xffff); - pub const CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE2_CFG_REG_FUNC_MANUFACT_CODE2: crate::Field = crate::Field::new(16, 0, CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE2); - - pub const CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE3: crate::Register = crate::Register::new(93, 0xffff); - pub const CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE3_CFG_REG_FUNC_MANUFACT_CODE3: crate::Field = crate::Field::new(16, 0, CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE3); - - pub const CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE4: crate::Register = crate::Register::new(94, 0xffff); - pub const CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE4_CFG_REG_FUNC_MANUFACT_CODE4: crate::Field = crate::Field::new(16, 0, CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE4); - - pub const CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE5: crate::Register = crate::Register::new(95, 0xffff); - pub const CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE5_CFG_REG_FUNC_MANUFACT_CODE5: crate::Field = crate::Field::new(16, 0, CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE5); - - pub const CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE6: crate::Register = crate::Register::new(96, 0xffff); - pub const CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE6_CFG_REG_FUNC_MANUFACT_CODE6: crate::Field = crate::Field::new(16, 0, CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE6); - - pub const CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO0: crate::Register = crate::Register::new(98, 0xffff); - pub const CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO0_CFG_REG_FUNC_MANUFACT_INFO0: crate::Field = crate::Field::new(16, 0, CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO0); - - pub const CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO1: crate::Register = crate::Register::new(99, 0xffff); - pub const CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO1_CFG_REG_FUNC_MANUFACT_INFO1: crate::Field = crate::Field::new(16, 0, CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO1); - - pub const CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO2: crate::Register = crate::Register::new(100, 0xffff); - pub const CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO2_CFG_REG_FUNC_MANUFACT_INFO2: crate::Field = crate::Field::new(16, 0, CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO2); - - pub const CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO3: crate::Register = crate::Register::new(101, 0xffff); - pub const CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO3_CFG_REG_FUNC_MANUFACT_INFO3: crate::Field = crate::Field::new(16, 0, CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO3); - - pub const CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO4: crate::Register = crate::Register::new(102, 0xffff); - pub const CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO4_CFG_REG_FUNC_MANUFACT_INFO4: crate::Field = crate::Field::new(16, 0, CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO4); - - pub const CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO5: crate::Register = crate::Register::new(103, 0xffff); - pub const CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO5_CFG_REG_FUNC_MANUFACT_INFO5: crate::Field = crate::Field::new(16, 0, CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO5); - - pub const CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO6: crate::Register = crate::Register::new(104, 0xffff); - pub const CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO6_CFG_REG_FUNC_MANUFACT_INFO6: crate::Field = crate::Field::new(16, 0, CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO6); - - pub const CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE0: crate::Register = crate::Register::new(106, 0xff); - pub const CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE0_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE0: crate::Field = crate::Field::new(8, 0, CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE0); - - pub const CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE1: crate::Register = crate::Register::new(107, 0xff); - pub const CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE1_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE1: crate::Field = crate::Field::new(8, 0, CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE1); - - pub const CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE2: crate::Register = crate::Register::new(108, 0xff); - pub const CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE2_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE2: crate::Field = crate::Field::new(8, 0, CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE2); - - pub const CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE3: crate::Register = crate::Register::new(109, 0xff); - pub const CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE3_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE3: crate::Field = crate::Field::new(8, 0, CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE3); - - pub const CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE4: crate::Register = crate::Register::new(110, 0xff); - pub const CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE4_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE4: crate::Field = crate::Field::new(8, 0, CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE4); - - pub const CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE5: crate::Register = crate::Register::new(111, 0xff); - pub const CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE5_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE5: crate::Field = crate::Field::new(8, 0, CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE5); - - pub const CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE6: crate::Register = crate::Register::new(112, 0xff); - pub const CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE6_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE6: crate::Field = crate::Field::new(8, 0, CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE6); - - pub const CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO0: crate::Register = crate::Register::new(114, 0xffff); - pub const CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO0_CFG_REG_FUNC_INFO0: crate::Field = crate::Field::new(16, 0, CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO0); - - pub const CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO1: crate::Register = crate::Register::new(115, 0xffff); - pub const CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO1_CFG_REG_FUNC_INFO1: crate::Field = crate::Field::new(16, 0, CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO1); - - pub const CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO2: crate::Register = crate::Register::new(116, 0xffff); - pub const CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO2_CFG_REG_FUNC_INFO2: crate::Field = crate::Field::new(16, 0, CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO2); - - pub const CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO3: crate::Register = crate::Register::new(117, 0xffff); - pub const CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO3_CFG_REG_FUNC_INFO3: crate::Field = crate::Field::new(16, 0, CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO3); - - pub const CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO4: crate::Register = crate::Register::new(118, 0xffff); - pub const CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO4_CFG_REG_FUNC_INFO4: crate::Field = crate::Field::new(16, 0, CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO4); - - pub const CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO5: crate::Register = crate::Register::new(119, 0xffff); - pub const CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO5_CFG_REG_FUNC_INFO5: crate::Field = crate::Field::new(16, 0, CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO5); - - pub const CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO6: crate::Register = crate::Register::new(120, 0xffff); - pub const CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO6_CFG_REG_FUNC_INFO6: crate::Field = crate::Field::new(16, 0, CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO6); - - pub const CR_REG_UHS_1_SUPPORT: crate::Register = crate::Register::new(124, 0xffffffff); - pub const CR_REG_UHS_1_SUPPORT_CFG_REG_MAX_CURRENT: crate::Field = crate::Field::new(16, 0, CR_REG_UHS_1_SUPPORT); - pub const CR_REG_UHS_1_SUPPORT_CFG_REG_DATA_STRC_VERSION: crate::Field = crate::Field::new(8, 16, CR_REG_UHS_1_SUPPORT); - pub const CR_REG_UHS_1_SUPPORT_CFG_REG_UHS_1_SUPPORT: crate::Field = crate::Field::new(8, 24, CR_REG_UHS_1_SUPPORT); - - pub const HW_SDDC_BASE: usize = 0x50121000; - } - - pub mod rp_pio { - pub const RP_PIO_NUMREGS: usize = 89; - - pub const SFR_CTRL: crate::Register = crate::Register::new(0, 0xfff); - pub const SFR_CTRL_EN: crate::Field = crate::Field::new(4, 0, SFR_CTRL); - pub const SFR_CTRL_RESTART: crate::Field = crate::Field::new(4, 4, SFR_CTRL); - pub const SFR_CTRL_CLKDIV_RESTART: crate::Field = crate::Field::new(4, 8, SFR_CTRL); - - pub const SFR_FSTAT: crate::Register = crate::Register::new(1, 0xffffffff); - pub const SFR_FSTAT_RX_FULL: crate::Field = crate::Field::new(4, 0, SFR_FSTAT); - pub const SFR_FSTAT_CONSTANT0: crate::Field = crate::Field::new(4, 4, SFR_FSTAT); - pub const SFR_FSTAT_RX_EMPTY: crate::Field = crate::Field::new(4, 8, SFR_FSTAT); - pub const SFR_FSTAT_CONSTANT1: crate::Field = crate::Field::new(4, 12, SFR_FSTAT); - pub const SFR_FSTAT_TX_FULL: crate::Field = crate::Field::new(4, 16, SFR_FSTAT); - pub const SFR_FSTAT_CONSTANT2: crate::Field = crate::Field::new(4, 20, SFR_FSTAT); - pub const SFR_FSTAT_TX_EMPTY: crate::Field = crate::Field::new(4, 24, SFR_FSTAT); - pub const SFR_FSTAT_CONSTANT3: crate::Field = crate::Field::new(4, 28, SFR_FSTAT); - - pub const SFR_FDEBUG: crate::Register = crate::Register::new(2, 0xffffffff); - pub const SFR_FDEBUG_RXSTALL: crate::Field = crate::Field::new(4, 0, SFR_FDEBUG); - pub const SFR_FDEBUG_NC_DBG3: crate::Field = crate::Field::new(4, 4, SFR_FDEBUG); - pub const SFR_FDEBUG_RXUNDER: crate::Field = crate::Field::new(4, 8, SFR_FDEBUG); - pub const SFR_FDEBUG_NC_DBG2: crate::Field = crate::Field::new(4, 12, SFR_FDEBUG); - pub const SFR_FDEBUG_TXOVER: crate::Field = crate::Field::new(4, 16, SFR_FDEBUG); - pub const SFR_FDEBUG_NC_DBG1: crate::Field = crate::Field::new(4, 20, SFR_FDEBUG); - pub const SFR_FDEBUG_TXSTALL: crate::Field = crate::Field::new(4, 24, SFR_FDEBUG); - pub const SFR_FDEBUG_NC_DBG0: crate::Field = crate::Field::new(4, 28, SFR_FDEBUG); - - pub const SFR_FLEVEL: crate::Register = crate::Register::new(3, 0xffffffff); - pub const SFR_FLEVEL_TX_LEVEL0: crate::Field = crate::Field::new(3, 0, SFR_FLEVEL); - pub const SFR_FLEVEL_CONSTANT0: crate::Field = crate::Field::new(1, 3, SFR_FLEVEL); - pub const SFR_FLEVEL_RX_LEVEL0: crate::Field = crate::Field::new(3, 4, SFR_FLEVEL); - pub const SFR_FLEVEL_CONSTANT1: crate::Field = crate::Field::new(1, 7, SFR_FLEVEL); - pub const SFR_FLEVEL_TX_LEVEL1: crate::Field = crate::Field::new(3, 8, SFR_FLEVEL); - pub const SFR_FLEVEL_CONSTANT2: crate::Field = crate::Field::new(1, 11, SFR_FLEVEL); - pub const SFR_FLEVEL_RX_LEVEL1: crate::Field = crate::Field::new(3, 12, SFR_FLEVEL); - pub const SFR_FLEVEL_CONSTANT3: crate::Field = crate::Field::new(1, 15, SFR_FLEVEL); - pub const SFR_FLEVEL_TX_LEVEL2: crate::Field = crate::Field::new(3, 16, SFR_FLEVEL); - pub const SFR_FLEVEL_CONSTANT4: crate::Field = crate::Field::new(1, 19, SFR_FLEVEL); - pub const SFR_FLEVEL_RX_LEVEL2: crate::Field = crate::Field::new(3, 20, SFR_FLEVEL); - pub const SFR_FLEVEL_CONSTANT5: crate::Field = crate::Field::new(1, 23, SFR_FLEVEL); - pub const SFR_FLEVEL_TX_LEVEL3: crate::Field = crate::Field::new(3, 24, SFR_FLEVEL); - pub const SFR_FLEVEL_CONSTANT6: crate::Field = crate::Field::new(1, 27, SFR_FLEVEL); - pub const SFR_FLEVEL_RX_LEVEL3: crate::Field = crate::Field::new(3, 28, SFR_FLEVEL); - pub const SFR_FLEVEL_CONSTANT7: crate::Field = crate::Field::new(1, 31, SFR_FLEVEL); - - pub const SFR_TXF0: crate::Register = crate::Register::new(4, 0xffffffff); - pub const SFR_TXF0_FDIN: crate::Field = crate::Field::new(32, 0, SFR_TXF0); - - pub const SFR_TXF1: crate::Register = crate::Register::new(5, 0xffffffff); - pub const SFR_TXF1_FDIN: crate::Field = crate::Field::new(32, 0, SFR_TXF1); - - pub const SFR_TXF2: crate::Register = crate::Register::new(6, 0xffffffff); - pub const SFR_TXF2_FDIN: crate::Field = crate::Field::new(32, 0, SFR_TXF2); - - pub const SFR_TXF3: crate::Register = crate::Register::new(7, 0xffffffff); - pub const SFR_TXF3_FDIN: crate::Field = crate::Field::new(32, 0, SFR_TXF3); - - pub const SFR_RXF0: crate::Register = crate::Register::new(8, 0xffffffff); - pub const SFR_RXF0_PDOUT: crate::Field = crate::Field::new(32, 0, SFR_RXF0); - - pub const SFR_RXF1: crate::Register = crate::Register::new(9, 0xffffffff); - pub const SFR_RXF1_PDOUT: crate::Field = crate::Field::new(32, 0, SFR_RXF1); - - pub const SFR_RXF2: crate::Register = crate::Register::new(10, 0xffffffff); - pub const SFR_RXF2_PDOUT: crate::Field = crate::Field::new(32, 0, SFR_RXF2); - - pub const SFR_RXF3: crate::Register = crate::Register::new(11, 0xffffffff); - pub const SFR_RXF3_PDOUT: crate::Field = crate::Field::new(32, 0, SFR_RXF3); - - pub const SFR_IRQ: crate::Register = crate::Register::new(12, 0xff); - pub const SFR_IRQ_SFR_IRQ: crate::Field = crate::Field::new(8, 0, SFR_IRQ); - - pub const SFR_IRQ_FORCE: crate::Register = crate::Register::new(13, 0xff); - pub const SFR_IRQ_FORCE_SFR_IRQ_FORCE: crate::Field = crate::Field::new(8, 0, SFR_IRQ_FORCE); - - pub const SFR_SYNC_BYPASS: crate::Register = crate::Register::new(14, 0xffffffff); - pub const SFR_SYNC_BYPASS_SFR_SYNC_BYPASS: crate::Field = crate::Field::new(32, 0, SFR_SYNC_BYPASS); - - pub const SFR_DBG_PADOUT: crate::Register = crate::Register::new(15, 0xffffffff); - pub const SFR_DBG_PADOUT_SFR_DBG_PADOUT: crate::Field = crate::Field::new(32, 0, SFR_DBG_PADOUT); - - pub const SFR_DBG_PADOE: crate::Register = crate::Register::new(16, 0xffffffff); - pub const SFR_DBG_PADOE_SFR_DBG_PADOE: crate::Field = crate::Field::new(32, 0, SFR_DBG_PADOE); - - pub const SFR_DBG_CFGINFO: crate::Register = crate::Register::new(17, 0xffffffff); - pub const SFR_DBG_CFGINFO_CONSTANT0: crate::Field = crate::Field::new(8, 0, SFR_DBG_CFGINFO); - pub const SFR_DBG_CFGINFO_CONSTANT1: crate::Field = crate::Field::new(8, 8, SFR_DBG_CFGINFO); - pub const SFR_DBG_CFGINFO_CONSTANT2: crate::Field = crate::Field::new(16, 16, SFR_DBG_CFGINFO); - - pub const SFR_INSTR_MEM0: crate::Register = crate::Register::new(18, 0xffff); - pub const SFR_INSTR_MEM0_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM0); - - pub const SFR_INSTR_MEM1: crate::Register = crate::Register::new(19, 0xffff); - pub const SFR_INSTR_MEM1_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM1); - - pub const SFR_INSTR_MEM2: crate::Register = crate::Register::new(20, 0xffff); - pub const SFR_INSTR_MEM2_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM2); - - pub const SFR_INSTR_MEM3: crate::Register = crate::Register::new(21, 0xffff); - pub const SFR_INSTR_MEM3_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM3); - - pub const SFR_INSTR_MEM4: crate::Register = crate::Register::new(22, 0xffff); - pub const SFR_INSTR_MEM4_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM4); - - pub const SFR_INSTR_MEM5: crate::Register = crate::Register::new(23, 0xffff); - pub const SFR_INSTR_MEM5_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM5); - - pub const SFR_INSTR_MEM6: crate::Register = crate::Register::new(24, 0xffff); - pub const SFR_INSTR_MEM6_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM6); - - pub const SFR_INSTR_MEM7: crate::Register = crate::Register::new(25, 0xffff); - pub const SFR_INSTR_MEM7_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM7); - - pub const SFR_INSTR_MEM8: crate::Register = crate::Register::new(26, 0xffff); - pub const SFR_INSTR_MEM8_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM8); - - pub const SFR_INSTR_MEM9: crate::Register = crate::Register::new(27, 0xffff); - pub const SFR_INSTR_MEM9_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM9); - - pub const SFR_INSTR_MEM10: crate::Register = crate::Register::new(28, 0xffff); - pub const SFR_INSTR_MEM10_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM10); - - pub const SFR_INSTR_MEM11: crate::Register = crate::Register::new(29, 0xffff); - pub const SFR_INSTR_MEM11_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM11); - - pub const SFR_INSTR_MEM12: crate::Register = crate::Register::new(30, 0xffff); - pub const SFR_INSTR_MEM12_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM12); - - pub const SFR_INSTR_MEM13: crate::Register = crate::Register::new(31, 0xffff); - pub const SFR_INSTR_MEM13_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM13); - - pub const SFR_INSTR_MEM14: crate::Register = crate::Register::new(32, 0xffff); - pub const SFR_INSTR_MEM14_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM14); - - pub const SFR_INSTR_MEM15: crate::Register = crate::Register::new(33, 0xffff); - pub const SFR_INSTR_MEM15_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM15); - - pub const SFR_INSTR_MEM16: crate::Register = crate::Register::new(34, 0xffff); - pub const SFR_INSTR_MEM16_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM16); - - pub const SFR_INSTR_MEM17: crate::Register = crate::Register::new(35, 0xffff); - pub const SFR_INSTR_MEM17_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM17); - - pub const SFR_INSTR_MEM18: crate::Register = crate::Register::new(36, 0xffff); - pub const SFR_INSTR_MEM18_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM18); - - pub const SFR_INSTR_MEM19: crate::Register = crate::Register::new(37, 0xffff); - pub const SFR_INSTR_MEM19_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM19); - - pub const SFR_INSTR_MEM20: crate::Register = crate::Register::new(38, 0xffff); - pub const SFR_INSTR_MEM20_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM20); - - pub const SFR_INSTR_MEM21: crate::Register = crate::Register::new(39, 0xffff); - pub const SFR_INSTR_MEM21_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM21); - - pub const SFR_INSTR_MEM22: crate::Register = crate::Register::new(40, 0xffff); - pub const SFR_INSTR_MEM22_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM22); - - pub const SFR_INSTR_MEM23: crate::Register = crate::Register::new(41, 0xffff); - pub const SFR_INSTR_MEM23_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM23); - - pub const SFR_INSTR_MEM24: crate::Register = crate::Register::new(42, 0xffff); - pub const SFR_INSTR_MEM24_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM24); - - pub const SFR_INSTR_MEM25: crate::Register = crate::Register::new(43, 0xffff); - pub const SFR_INSTR_MEM25_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM25); - - pub const SFR_INSTR_MEM26: crate::Register = crate::Register::new(44, 0xffff); - pub const SFR_INSTR_MEM26_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM26); - - pub const SFR_INSTR_MEM27: crate::Register = crate::Register::new(45, 0xffff); - pub const SFR_INSTR_MEM27_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM27); - - pub const SFR_INSTR_MEM28: crate::Register = crate::Register::new(46, 0xffff); - pub const SFR_INSTR_MEM28_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM28); - - pub const SFR_INSTR_MEM29: crate::Register = crate::Register::new(47, 0xffff); - pub const SFR_INSTR_MEM29_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM29); - - pub const SFR_INSTR_MEM30: crate::Register = crate::Register::new(48, 0xffff); - pub const SFR_INSTR_MEM30_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM30); - - pub const SFR_INSTR_MEM31: crate::Register = crate::Register::new(49, 0xffff); - pub const SFR_INSTR_MEM31_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM31); - - pub const SFR_SM0_CLKDIV: crate::Register = crate::Register::new(50, 0xffffffff); - pub const SFR_SM0_CLKDIV_UNUSED_DIV: crate::Field = crate::Field::new(8, 0, SFR_SM0_CLKDIV); - pub const SFR_SM0_CLKDIV_DIV_FRAC: crate::Field = crate::Field::new(8, 8, SFR_SM0_CLKDIV); - pub const SFR_SM0_CLKDIV_DIV_INT: crate::Field = crate::Field::new(16, 16, SFR_SM0_CLKDIV); - - pub const SFR_SM0_EXECCTRL: crate::Register = crate::Register::new(51, 0xffffffff); - pub const SFR_SM0_EXECCTRL_STATUS_N: crate::Field = crate::Field::new(4, 0, SFR_SM0_EXECCTRL); - pub const SFR_SM0_EXECCTRL_STATUS_SEL: crate::Field = crate::Field::new(1, 4, SFR_SM0_EXECCTRL); - pub const SFR_SM0_EXECCTRL_RESVD_EXEC: crate::Field = crate::Field::new(2, 5, SFR_SM0_EXECCTRL); - pub const SFR_SM0_EXECCTRL_WRAP_TARGET: crate::Field = crate::Field::new(5, 7, SFR_SM0_EXECCTRL); - pub const SFR_SM0_EXECCTRL_PEND: crate::Field = crate::Field::new(5, 12, SFR_SM0_EXECCTRL); - pub const SFR_SM0_EXECCTRL_OUT_STICKY: crate::Field = crate::Field::new(1, 17, SFR_SM0_EXECCTRL); - pub const SFR_SM0_EXECCTRL_INLINE_OUT_EN: crate::Field = crate::Field::new(1, 18, SFR_SM0_EXECCTRL); - pub const SFR_SM0_EXECCTRL_OUT_EN_SEL: crate::Field = crate::Field::new(5, 19, SFR_SM0_EXECCTRL); - pub const SFR_SM0_EXECCTRL_JMP_PIN: crate::Field = crate::Field::new(5, 24, SFR_SM0_EXECCTRL); - pub const SFR_SM0_EXECCTRL_SIDE_PINDIR: crate::Field = crate::Field::new(1, 29, SFR_SM0_EXECCTRL); - pub const SFR_SM0_EXECCTRL_SIDESET_ENABLE_BIT: crate::Field = crate::Field::new(1, 30, SFR_SM0_EXECCTRL); - pub const SFR_SM0_EXECCTRL_EXEC_STALLED_RO0: crate::Field = crate::Field::new(1, 31, SFR_SM0_EXECCTRL); - - pub const SFR_SM0_SHIFTCTRL: crate::Register = crate::Register::new(52, 0xffffffff); - pub const SFR_SM0_SHIFTCTRL_RESVD_SHIFT: crate::Field = crate::Field::new(16, 0, SFR_SM0_SHIFTCTRL); - pub const SFR_SM0_SHIFTCTRL_AUTO_PUSH: crate::Field = crate::Field::new(1, 16, SFR_SM0_SHIFTCTRL); - pub const SFR_SM0_SHIFTCTRL_AUTO_PULL: crate::Field = crate::Field::new(1, 17, SFR_SM0_SHIFTCTRL); - pub const SFR_SM0_SHIFTCTRL_IN_SHIFT_DIR: crate::Field = crate::Field::new(1, 18, SFR_SM0_SHIFTCTRL); - pub const SFR_SM0_SHIFTCTRL_OUT_SHIFT_DIR: crate::Field = crate::Field::new(1, 19, SFR_SM0_SHIFTCTRL); - pub const SFR_SM0_SHIFTCTRL_ISR_THRESHOLD: crate::Field = crate::Field::new(5, 20, SFR_SM0_SHIFTCTRL); - pub const SFR_SM0_SHIFTCTRL_OSR_THRESHOLD: crate::Field = crate::Field::new(5, 25, SFR_SM0_SHIFTCTRL); - pub const SFR_SM0_SHIFTCTRL_JOIN_TX: crate::Field = crate::Field::new(1, 30, SFR_SM0_SHIFTCTRL); - pub const SFR_SM0_SHIFTCTRL_JOIN_RX: crate::Field = crate::Field::new(1, 31, SFR_SM0_SHIFTCTRL); - - pub const SFR_SM0_ADDR: crate::Register = crate::Register::new(53, 0x1f); - pub const SFR_SM0_ADDR_PC: crate::Field = crate::Field::new(5, 0, SFR_SM0_ADDR); - - pub const SFR_SM0_INSTR: crate::Register = crate::Register::new(54, 0xffff); - pub const SFR_SM0_INSTR_IMM_INSTR: crate::Field = crate::Field::new(16, 0, SFR_SM0_INSTR); - - pub const SFR_SM0_PINCTRL: crate::Register = crate::Register::new(55, 0xffffffff); - pub const SFR_SM0_PINCTRL_PINS_OUT_BASE: crate::Field = crate::Field::new(5, 0, SFR_SM0_PINCTRL); - pub const SFR_SM0_PINCTRL_PINS_SET_BASE: crate::Field = crate::Field::new(5, 5, SFR_SM0_PINCTRL); - pub const SFR_SM0_PINCTRL_PINS_SIDE_BASE: crate::Field = crate::Field::new(5, 10, SFR_SM0_PINCTRL); - pub const SFR_SM0_PINCTRL_PINS_IN_BASE: crate::Field = crate::Field::new(5, 15, SFR_SM0_PINCTRL); - pub const SFR_SM0_PINCTRL_PINS_OUT_COUNT: crate::Field = crate::Field::new(6, 20, SFR_SM0_PINCTRL); - pub const SFR_SM0_PINCTRL_PINS_SET_COUNT: crate::Field = crate::Field::new(3, 26, SFR_SM0_PINCTRL); - pub const SFR_SM0_PINCTRL_PINS_SIDE_COUNT: crate::Field = crate::Field::new(3, 29, SFR_SM0_PINCTRL); - - pub const SFR_SM1_CLKDIV: crate::Register = crate::Register::new(56, 0xffffffff); - pub const SFR_SM1_CLKDIV_UNUSED_DIV: crate::Field = crate::Field::new(8, 0, SFR_SM1_CLKDIV); - pub const SFR_SM1_CLKDIV_DIV_FRAC: crate::Field = crate::Field::new(8, 8, SFR_SM1_CLKDIV); - pub const SFR_SM1_CLKDIV_DIV_INT: crate::Field = crate::Field::new(16, 16, SFR_SM1_CLKDIV); - - pub const SFR_SM1_EXECCTRL: crate::Register = crate::Register::new(57, 0xffffffff); - pub const SFR_SM1_EXECCTRL_STATUS_N: crate::Field = crate::Field::new(4, 0, SFR_SM1_EXECCTRL); - pub const SFR_SM1_EXECCTRL_STATUS_SEL: crate::Field = crate::Field::new(1, 4, SFR_SM1_EXECCTRL); - pub const SFR_SM1_EXECCTRL_RESVD_EXEC: crate::Field = crate::Field::new(2, 5, SFR_SM1_EXECCTRL); - pub const SFR_SM1_EXECCTRL_WRAP_TARGET: crate::Field = crate::Field::new(5, 7, SFR_SM1_EXECCTRL); - pub const SFR_SM1_EXECCTRL_PEND: crate::Field = crate::Field::new(5, 12, SFR_SM1_EXECCTRL); - pub const SFR_SM1_EXECCTRL_OUT_STICKY: crate::Field = crate::Field::new(1, 17, SFR_SM1_EXECCTRL); - pub const SFR_SM1_EXECCTRL_INLINE_OUT_EN: crate::Field = crate::Field::new(1, 18, SFR_SM1_EXECCTRL); - pub const SFR_SM1_EXECCTRL_OUT_EN_SEL: crate::Field = crate::Field::new(5, 19, SFR_SM1_EXECCTRL); - pub const SFR_SM1_EXECCTRL_JMP_PIN: crate::Field = crate::Field::new(5, 24, SFR_SM1_EXECCTRL); - pub const SFR_SM1_EXECCTRL_SIDE_PINDIR: crate::Field = crate::Field::new(1, 29, SFR_SM1_EXECCTRL); - pub const SFR_SM1_EXECCTRL_SIDESET_ENABLE_BIT: crate::Field = crate::Field::new(1, 30, SFR_SM1_EXECCTRL); - pub const SFR_SM1_EXECCTRL_EXEC_STALLED_RO1: crate::Field = crate::Field::new(1, 31, SFR_SM1_EXECCTRL); - - pub const SFR_SM1_SHIFTCTRL: crate::Register = crate::Register::new(58, 0xffffffff); - pub const SFR_SM1_SHIFTCTRL_RESVD_SHIFT: crate::Field = crate::Field::new(16, 0, SFR_SM1_SHIFTCTRL); - pub const SFR_SM1_SHIFTCTRL_AUTO_PUSH: crate::Field = crate::Field::new(1, 16, SFR_SM1_SHIFTCTRL); - pub const SFR_SM1_SHIFTCTRL_AUTO_PULL: crate::Field = crate::Field::new(1, 17, SFR_SM1_SHIFTCTRL); - pub const SFR_SM1_SHIFTCTRL_IN_SHIFT_DIR: crate::Field = crate::Field::new(1, 18, SFR_SM1_SHIFTCTRL); - pub const SFR_SM1_SHIFTCTRL_OUT_SHIFT_DIR: crate::Field = crate::Field::new(1, 19, SFR_SM1_SHIFTCTRL); - pub const SFR_SM1_SHIFTCTRL_ISR_THRESHOLD: crate::Field = crate::Field::new(5, 20, SFR_SM1_SHIFTCTRL); - pub const SFR_SM1_SHIFTCTRL_OSR_THRESHOLD: crate::Field = crate::Field::new(5, 25, SFR_SM1_SHIFTCTRL); - pub const SFR_SM1_SHIFTCTRL_JOIN_TX: crate::Field = crate::Field::new(1, 30, SFR_SM1_SHIFTCTRL); - pub const SFR_SM1_SHIFTCTRL_JOIN_RX: crate::Field = crate::Field::new(1, 31, SFR_SM1_SHIFTCTRL); - - pub const SFR_SM1_ADDR: crate::Register = crate::Register::new(59, 0x1f); - pub const SFR_SM1_ADDR_PC: crate::Field = crate::Field::new(5, 0, SFR_SM1_ADDR); - - pub const SFR_SM1_INSTR: crate::Register = crate::Register::new(60, 0xffff); - pub const SFR_SM1_INSTR_IMM_INSTR: crate::Field = crate::Field::new(16, 0, SFR_SM1_INSTR); - - pub const SFR_SM1_PINCTRL: crate::Register = crate::Register::new(61, 0xffffffff); - pub const SFR_SM1_PINCTRL_PINS_OUT_BASE: crate::Field = crate::Field::new(5, 0, SFR_SM1_PINCTRL); - pub const SFR_SM1_PINCTRL_PINS_SET_BASE: crate::Field = crate::Field::new(5, 5, SFR_SM1_PINCTRL); - pub const SFR_SM1_PINCTRL_PINS_SIDE_BASE: crate::Field = crate::Field::new(5, 10, SFR_SM1_PINCTRL); - pub const SFR_SM1_PINCTRL_PINS_IN_BASE: crate::Field = crate::Field::new(5, 15, SFR_SM1_PINCTRL); - pub const SFR_SM1_PINCTRL_PINS_OUT_COUNT: crate::Field = crate::Field::new(6, 20, SFR_SM1_PINCTRL); - pub const SFR_SM1_PINCTRL_PINS_SET_COUNT: crate::Field = crate::Field::new(3, 26, SFR_SM1_PINCTRL); - pub const SFR_SM1_PINCTRL_PINS_SIDE_COUNT: crate::Field = crate::Field::new(3, 29, SFR_SM1_PINCTRL); - - pub const SFR_SM2_CLKDIV: crate::Register = crate::Register::new(62, 0xffffffff); - pub const SFR_SM2_CLKDIV_UNUSED_DIV: crate::Field = crate::Field::new(8, 0, SFR_SM2_CLKDIV); - pub const SFR_SM2_CLKDIV_DIV_FRAC: crate::Field = crate::Field::new(8, 8, SFR_SM2_CLKDIV); - pub const SFR_SM2_CLKDIV_DIV_INT: crate::Field = crate::Field::new(16, 16, SFR_SM2_CLKDIV); - - pub const SFR_SM2_EXECCTRL: crate::Register = crate::Register::new(63, 0xffffffff); - pub const SFR_SM2_EXECCTRL_STATUS_N: crate::Field = crate::Field::new(4, 0, SFR_SM2_EXECCTRL); - pub const SFR_SM2_EXECCTRL_STATUS_SEL: crate::Field = crate::Field::new(1, 4, SFR_SM2_EXECCTRL); - pub const SFR_SM2_EXECCTRL_RESVD_EXEC: crate::Field = crate::Field::new(2, 5, SFR_SM2_EXECCTRL); - pub const SFR_SM2_EXECCTRL_WRAP_TARGET: crate::Field = crate::Field::new(5, 7, SFR_SM2_EXECCTRL); - pub const SFR_SM2_EXECCTRL_PEND: crate::Field = crate::Field::new(5, 12, SFR_SM2_EXECCTRL); - pub const SFR_SM2_EXECCTRL_OUT_STICKY: crate::Field = crate::Field::new(1, 17, SFR_SM2_EXECCTRL); - pub const SFR_SM2_EXECCTRL_INLINE_OUT_EN: crate::Field = crate::Field::new(1, 18, SFR_SM2_EXECCTRL); - pub const SFR_SM2_EXECCTRL_OUT_EN_SEL: crate::Field = crate::Field::new(5, 19, SFR_SM2_EXECCTRL); - pub const SFR_SM2_EXECCTRL_JMP_PIN: crate::Field = crate::Field::new(5, 24, SFR_SM2_EXECCTRL); - pub const SFR_SM2_EXECCTRL_SIDE_PINDIR: crate::Field = crate::Field::new(1, 29, SFR_SM2_EXECCTRL); - pub const SFR_SM2_EXECCTRL_SIDESET_ENABLE_BIT: crate::Field = crate::Field::new(1, 30, SFR_SM2_EXECCTRL); - pub const SFR_SM2_EXECCTRL_EXEC_STALLED_RO2: crate::Field = crate::Field::new(1, 31, SFR_SM2_EXECCTRL); - - pub const SFR_SM2_SHIFTCTRL: crate::Register = crate::Register::new(64, 0xffffffff); - pub const SFR_SM2_SHIFTCTRL_RESVD_SHIFT: crate::Field = crate::Field::new(16, 0, SFR_SM2_SHIFTCTRL); - pub const SFR_SM2_SHIFTCTRL_AUTO_PUSH: crate::Field = crate::Field::new(1, 16, SFR_SM2_SHIFTCTRL); - pub const SFR_SM2_SHIFTCTRL_AUTO_PULL: crate::Field = crate::Field::new(1, 17, SFR_SM2_SHIFTCTRL); - pub const SFR_SM2_SHIFTCTRL_IN_SHIFT_DIR: crate::Field = crate::Field::new(1, 18, SFR_SM2_SHIFTCTRL); - pub const SFR_SM2_SHIFTCTRL_OUT_SHIFT_DIR: crate::Field = crate::Field::new(1, 19, SFR_SM2_SHIFTCTRL); - pub const SFR_SM2_SHIFTCTRL_ISR_THRESHOLD: crate::Field = crate::Field::new(5, 20, SFR_SM2_SHIFTCTRL); - pub const SFR_SM2_SHIFTCTRL_OSR_THRESHOLD: crate::Field = crate::Field::new(5, 25, SFR_SM2_SHIFTCTRL); - pub const SFR_SM2_SHIFTCTRL_JOIN_TX: crate::Field = crate::Field::new(1, 30, SFR_SM2_SHIFTCTRL); - pub const SFR_SM2_SHIFTCTRL_JOIN_RX: crate::Field = crate::Field::new(1, 31, SFR_SM2_SHIFTCTRL); - - pub const SFR_SM2_ADDR: crate::Register = crate::Register::new(65, 0x1f); - pub const SFR_SM2_ADDR_PC: crate::Field = crate::Field::new(5, 0, SFR_SM2_ADDR); - - pub const SFR_SM2_INSTR: crate::Register = crate::Register::new(66, 0xffff); - pub const SFR_SM2_INSTR_IMM_INSTR: crate::Field = crate::Field::new(16, 0, SFR_SM2_INSTR); - - pub const SFR_SM2_PINCTRL: crate::Register = crate::Register::new(67, 0xffffffff); - pub const SFR_SM2_PINCTRL_PINS_OUT_BASE: crate::Field = crate::Field::new(5, 0, SFR_SM2_PINCTRL); - pub const SFR_SM2_PINCTRL_PINS_SET_BASE: crate::Field = crate::Field::new(5, 5, SFR_SM2_PINCTRL); - pub const SFR_SM2_PINCTRL_PINS_SIDE_BASE: crate::Field = crate::Field::new(5, 10, SFR_SM2_PINCTRL); - pub const SFR_SM2_PINCTRL_PINS_IN_BASE: crate::Field = crate::Field::new(5, 15, SFR_SM2_PINCTRL); - pub const SFR_SM2_PINCTRL_PINS_OUT_COUNT: crate::Field = crate::Field::new(6, 20, SFR_SM2_PINCTRL); - pub const SFR_SM2_PINCTRL_PINS_SET_COUNT: crate::Field = crate::Field::new(3, 26, SFR_SM2_PINCTRL); - pub const SFR_SM2_PINCTRL_PINS_SIDE_COUNT: crate::Field = crate::Field::new(3, 29, SFR_SM2_PINCTRL); - - pub const SFR_SM3_CLKDIV: crate::Register = crate::Register::new(68, 0xffffffff); - pub const SFR_SM3_CLKDIV_UNUSED_DIV: crate::Field = crate::Field::new(8, 0, SFR_SM3_CLKDIV); - pub const SFR_SM3_CLKDIV_DIV_FRAC: crate::Field = crate::Field::new(8, 8, SFR_SM3_CLKDIV); - pub const SFR_SM3_CLKDIV_DIV_INT: crate::Field = crate::Field::new(16, 16, SFR_SM3_CLKDIV); - - pub const SFR_SM3_EXECCTRL: crate::Register = crate::Register::new(69, 0xffffffff); - pub const SFR_SM3_EXECCTRL_STATUS_N: crate::Field = crate::Field::new(4, 0, SFR_SM3_EXECCTRL); - pub const SFR_SM3_EXECCTRL_STATUS_SEL: crate::Field = crate::Field::new(1, 4, SFR_SM3_EXECCTRL); - pub const SFR_SM3_EXECCTRL_RESVD_EXEC: crate::Field = crate::Field::new(2, 5, SFR_SM3_EXECCTRL); - pub const SFR_SM3_EXECCTRL_WRAP_TARGET: crate::Field = crate::Field::new(5, 7, SFR_SM3_EXECCTRL); - pub const SFR_SM3_EXECCTRL_PEND: crate::Field = crate::Field::new(5, 12, SFR_SM3_EXECCTRL); - pub const SFR_SM3_EXECCTRL_OUT_STICKY: crate::Field = crate::Field::new(1, 17, SFR_SM3_EXECCTRL); - pub const SFR_SM3_EXECCTRL_INLINE_OUT_EN: crate::Field = crate::Field::new(1, 18, SFR_SM3_EXECCTRL); - pub const SFR_SM3_EXECCTRL_OUT_EN_SEL: crate::Field = crate::Field::new(5, 19, SFR_SM3_EXECCTRL); - pub const SFR_SM3_EXECCTRL_JMP_PIN: crate::Field = crate::Field::new(5, 24, SFR_SM3_EXECCTRL); - pub const SFR_SM3_EXECCTRL_SIDE_PINDIR: crate::Field = crate::Field::new(1, 29, SFR_SM3_EXECCTRL); - pub const SFR_SM3_EXECCTRL_SIDESET_ENABLE_BIT: crate::Field = crate::Field::new(1, 30, SFR_SM3_EXECCTRL); - pub const SFR_SM3_EXECCTRL_EXEC_STALLED_RO3: crate::Field = crate::Field::new(1, 31, SFR_SM3_EXECCTRL); - - pub const SFR_SM3_SHIFTCTRL: crate::Register = crate::Register::new(70, 0xffffffff); - pub const SFR_SM3_SHIFTCTRL_RESVD_SHIFT: crate::Field = crate::Field::new(16, 0, SFR_SM3_SHIFTCTRL); - pub const SFR_SM3_SHIFTCTRL_AUTO_PUSH: crate::Field = crate::Field::new(1, 16, SFR_SM3_SHIFTCTRL); - pub const SFR_SM3_SHIFTCTRL_AUTO_PULL: crate::Field = crate::Field::new(1, 17, SFR_SM3_SHIFTCTRL); - pub const SFR_SM3_SHIFTCTRL_IN_SHIFT_DIR: crate::Field = crate::Field::new(1, 18, SFR_SM3_SHIFTCTRL); - pub const SFR_SM3_SHIFTCTRL_OUT_SHIFT_DIR: crate::Field = crate::Field::new(1, 19, SFR_SM3_SHIFTCTRL); - pub const SFR_SM3_SHIFTCTRL_ISR_THRESHOLD: crate::Field = crate::Field::new(5, 20, SFR_SM3_SHIFTCTRL); - pub const SFR_SM3_SHIFTCTRL_OSR_THRESHOLD: crate::Field = crate::Field::new(5, 25, SFR_SM3_SHIFTCTRL); - pub const SFR_SM3_SHIFTCTRL_JOIN_TX: crate::Field = crate::Field::new(1, 30, SFR_SM3_SHIFTCTRL); - pub const SFR_SM3_SHIFTCTRL_JOIN_RX: crate::Field = crate::Field::new(1, 31, SFR_SM3_SHIFTCTRL); - - pub const SFR_SM3_ADDR: crate::Register = crate::Register::new(71, 0x1f); - pub const SFR_SM3_ADDR_PC: crate::Field = crate::Field::new(5, 0, SFR_SM3_ADDR); - - pub const SFR_SM3_INSTR: crate::Register = crate::Register::new(72, 0xffff); - pub const SFR_SM3_INSTR_IMM_INSTR: crate::Field = crate::Field::new(16, 0, SFR_SM3_INSTR); - - pub const SFR_SM3_PINCTRL: crate::Register = crate::Register::new(73, 0xffffffff); - pub const SFR_SM3_PINCTRL_PINS_OUT_BASE: crate::Field = crate::Field::new(5, 0, SFR_SM3_PINCTRL); - pub const SFR_SM3_PINCTRL_PINS_SET_BASE: crate::Field = crate::Field::new(5, 5, SFR_SM3_PINCTRL); - pub const SFR_SM3_PINCTRL_PINS_SIDE_BASE: crate::Field = crate::Field::new(5, 10, SFR_SM3_PINCTRL); - pub const SFR_SM3_PINCTRL_PINS_IN_BASE: crate::Field = crate::Field::new(5, 15, SFR_SM3_PINCTRL); - pub const SFR_SM3_PINCTRL_PINS_OUT_COUNT: crate::Field = crate::Field::new(6, 20, SFR_SM3_PINCTRL); - pub const SFR_SM3_PINCTRL_PINS_SET_COUNT: crate::Field = crate::Field::new(3, 26, SFR_SM3_PINCTRL); - pub const SFR_SM3_PINCTRL_PINS_SIDE_COUNT: crate::Field = crate::Field::new(3, 29, SFR_SM3_PINCTRL); - - pub const SFR_INTR: crate::Register = crate::Register::new(74, 0xfff); - pub const SFR_INTR_INTR_RXNEMPTY: crate::Field = crate::Field::new(4, 0, SFR_INTR); - pub const SFR_INTR_INTR_TXNFULL: crate::Field = crate::Field::new(4, 4, SFR_INTR); - pub const SFR_INTR_INTR_SM: crate::Field = crate::Field::new(4, 8, SFR_INTR); - - pub const SFR_IRQ0_INTE: crate::Register = crate::Register::new(75, 0xfff); - pub const SFR_IRQ0_INTE_IRQ0_INTE_RXNEMPTY: crate::Field = crate::Field::new(4, 0, SFR_IRQ0_INTE); - pub const SFR_IRQ0_INTE_IRQ0_INTE_TXNFULL: crate::Field = crate::Field::new(4, 4, SFR_IRQ0_INTE); - pub const SFR_IRQ0_INTE_IRQ0_INTE_SM: crate::Field = crate::Field::new(4, 8, SFR_IRQ0_INTE); - - pub const SFR_IRQ0_INTF: crate::Register = crate::Register::new(76, 0xfff); - pub const SFR_IRQ0_INTF_IRQ0_INTF_RXNEMPTY: crate::Field = crate::Field::new(4, 0, SFR_IRQ0_INTF); - pub const SFR_IRQ0_INTF_IRQ0_INTF_TXNFULL: crate::Field = crate::Field::new(4, 4, SFR_IRQ0_INTF); - pub const SFR_IRQ0_INTF_IRQ0_INTF_SM: crate::Field = crate::Field::new(4, 8, SFR_IRQ0_INTF); - - pub const SFR_IRQ0_INTS: crate::Register = crate::Register::new(77, 0xfff); - pub const SFR_IRQ0_INTS_IRQ0_INTS_RXNEMPTY: crate::Field = crate::Field::new(4, 0, SFR_IRQ0_INTS); - pub const SFR_IRQ0_INTS_IRQ0_INTS_TXNFULL: crate::Field = crate::Field::new(4, 4, SFR_IRQ0_INTS); - pub const SFR_IRQ0_INTS_IRQ0_INTS_SM: crate::Field = crate::Field::new(4, 8, SFR_IRQ0_INTS); - - pub const SFR_IRQ1_INTE: crate::Register = crate::Register::new(78, 0xfff); - pub const SFR_IRQ1_INTE_IRQ1_INTE_RXNEMPTY: crate::Field = crate::Field::new(4, 0, SFR_IRQ1_INTE); - pub const SFR_IRQ1_INTE_IRQ1_INTE_TXNFULL: crate::Field = crate::Field::new(4, 4, SFR_IRQ1_INTE); - pub const SFR_IRQ1_INTE_IRQ1_INTE_SM: crate::Field = crate::Field::new(4, 8, SFR_IRQ1_INTE); - - pub const SFR_IRQ1_INTF: crate::Register = crate::Register::new(79, 0xfff); - pub const SFR_IRQ1_INTF_IRQ1_INTF_RXNEMPTY: crate::Field = crate::Field::new(4, 0, SFR_IRQ1_INTF); - pub const SFR_IRQ1_INTF_IRQ1_INTF_TXNFULL: crate::Field = crate::Field::new(4, 4, SFR_IRQ1_INTF); - pub const SFR_IRQ1_INTF_IRQ1_INTF_SM: crate::Field = crate::Field::new(4, 8, SFR_IRQ1_INTF); - - pub const SFR_IRQ1_INTS: crate::Register = crate::Register::new(80, 0xfff); - pub const SFR_IRQ1_INTS_IRQ1_INTS_RXNEMPTY: crate::Field = crate::Field::new(4, 0, SFR_IRQ1_INTS); - pub const SFR_IRQ1_INTS_IRQ1_INTS_TXNFULL: crate::Field = crate::Field::new(4, 4, SFR_IRQ1_INTS); - pub const SFR_IRQ1_INTS_IRQ1_INTS_SM: crate::Field = crate::Field::new(4, 8, SFR_IRQ1_INTS); - - pub const SFR_IO_OE_INV: crate::Register = crate::Register::new(96, 0xffffffff); - pub const SFR_IO_OE_INV_SFR_IO_OE_INV: crate::Field = crate::Field::new(32, 0, SFR_IO_OE_INV); - - pub const SFR_IO_O_INV: crate::Register = crate::Register::new(97, 0xffffffff); - pub const SFR_IO_O_INV_SFR_IO_O_INV: crate::Field = crate::Field::new(32, 0, SFR_IO_O_INV); - - pub const SFR_IO_I_INV: crate::Register = crate::Register::new(98, 0xffffffff); - pub const SFR_IO_I_INV_SFR_IO_I_INV: crate::Field = crate::Field::new(32, 0, SFR_IO_I_INV); - - pub const SFR_FIFO_MARGIN: crate::Register = crate::Register::new(99, 0xffff); - pub const SFR_FIFO_MARGIN_FIFO_TX_MARGIN0: crate::Field = crate::Field::new(2, 0, SFR_FIFO_MARGIN); - pub const SFR_FIFO_MARGIN_FIFO_RX_MARGIN0: crate::Field = crate::Field::new(2, 2, SFR_FIFO_MARGIN); - pub const SFR_FIFO_MARGIN_FIFO_TX_MARGIN1: crate::Field = crate::Field::new(2, 4, SFR_FIFO_MARGIN); - pub const SFR_FIFO_MARGIN_FIFO_RX_MARGIN1: crate::Field = crate::Field::new(2, 6, SFR_FIFO_MARGIN); - pub const SFR_FIFO_MARGIN_FIFO_TX_MARGIN2: crate::Field = crate::Field::new(2, 8, SFR_FIFO_MARGIN); - pub const SFR_FIFO_MARGIN_FIFO_RX_MARGIN2: crate::Field = crate::Field::new(2, 10, SFR_FIFO_MARGIN); - pub const SFR_FIFO_MARGIN_FIFO_TX_MARGIN3: crate::Field = crate::Field::new(2, 12, SFR_FIFO_MARGIN); - pub const SFR_FIFO_MARGIN_FIFO_RX_MARGIN3: crate::Field = crate::Field::new(2, 14, SFR_FIFO_MARGIN); - - pub const SFR_ZERO0: crate::Register = crate::Register::new(100, 0xffffffff); - pub const SFR_ZERO0_SFR_ZERO0: crate::Field = crate::Field::new(32, 0, SFR_ZERO0); - - pub const SFR_ZERO1: crate::Register = crate::Register::new(101, 0xffffffff); - pub const SFR_ZERO1_SFR_ZERO1: crate::Field = crate::Field::new(32, 0, SFR_ZERO1); - - pub const SFR_ZERO2: crate::Register = crate::Register::new(102, 0xffffffff); - pub const SFR_ZERO2_SFR_ZERO2: crate::Field = crate::Field::new(32, 0, SFR_ZERO2); - - pub const SFR_ZERO3: crate::Register = crate::Register::new(103, 0xffffffff); - pub const SFR_ZERO3_SFR_ZERO3: crate::Field = crate::Field::new(32, 0, SFR_ZERO3); - - pub const HW_RP_PIO_BASE: usize = 0x50123000; - } - - pub mod bio_bdma { - pub const BIO_BDMA_NUMREGS: usize = 60; - - pub const SFR_CTRL: crate::Register = crate::Register::new(0, 0xfff); - pub const SFR_CTRL_EN: crate::Field = crate::Field::new(4, 0, SFR_CTRL); - pub const SFR_CTRL_RESTART: crate::Field = crate::Field::new(4, 4, SFR_CTRL); - pub const SFR_CTRL_CLKDIV_RESTART: crate::Field = crate::Field::new(4, 8, SFR_CTRL); - - pub const SFR_CFGINFO: crate::Register = crate::Register::new(1, 0xffffffff); - pub const SFR_CFGINFO_CONSTANT0: crate::Field = crate::Field::new(8, 0, SFR_CFGINFO); - pub const SFR_CFGINFO_CONSTANT1: crate::Field = crate::Field::new(8, 8, SFR_CFGINFO); - pub const SFR_CFGINFO_CONSTANT2: crate::Field = crate::Field::new(16, 16, SFR_CFGINFO); - - pub const SFR_CONFIG: crate::Register = crate::Register::new(2, 0xff); - pub const SFR_CONFIG_SNAP_OUTPUT_TO_WHICH: crate::Field = crate::Field::new(2, 0, SFR_CONFIG); - pub const SFR_CONFIG_SNAP_OUTPUT_TO_QUANTUM: crate::Field = crate::Field::new(1, 2, SFR_CONFIG); - pub const SFR_CONFIG_SNAP_INPUT_TO_WHICH: crate::Field = crate::Field::new(2, 3, SFR_CONFIG); - pub const SFR_CONFIG_SNAP_INPUT_TO_QUANTUM: crate::Field = crate::Field::new(1, 5, SFR_CONFIG); - pub const SFR_CONFIG_DISABLE_FILTER_PERI: crate::Field = crate::Field::new(1, 6, SFR_CONFIG); - pub const SFR_CONFIG_DISABLE_FILTER_MEM: crate::Field = crate::Field::new(1, 7, SFR_CONFIG); - - pub const SFR_FLEVEL: crate::Register = crate::Register::new(3, 0xffff); - pub const SFR_FLEVEL_PCLK_REGFIFO_LEVEL0: crate::Field = crate::Field::new(4, 0, SFR_FLEVEL); - pub const SFR_FLEVEL_PCLK_REGFIFO_LEVEL1: crate::Field = crate::Field::new(4, 4, SFR_FLEVEL); - pub const SFR_FLEVEL_PCLK_REGFIFO_LEVEL2: crate::Field = crate::Field::new(4, 8, SFR_FLEVEL); - pub const SFR_FLEVEL_PCLK_REGFIFO_LEVEL3: crate::Field = crate::Field::new(4, 12, SFR_FLEVEL); - - pub const SFR_TXF0: crate::Register = crate::Register::new(4, 0xffffffff); - pub const SFR_TXF0_FDIN: crate::Field = crate::Field::new(32, 0, SFR_TXF0); - - pub const SFR_TXF1: crate::Register = crate::Register::new(5, 0xffffffff); - pub const SFR_TXF1_FDIN: crate::Field = crate::Field::new(32, 0, SFR_TXF1); - - pub const SFR_TXF2: crate::Register = crate::Register::new(6, 0xffffffff); - pub const SFR_TXF2_FDIN: crate::Field = crate::Field::new(32, 0, SFR_TXF2); - - pub const SFR_TXF3: crate::Register = crate::Register::new(7, 0xffffffff); - pub const SFR_TXF3_FDIN: crate::Field = crate::Field::new(32, 0, SFR_TXF3); - - pub const SFR_RXF0: crate::Register = crate::Register::new(8, 0xffffffff); - pub const SFR_RXF0_FDOUT: crate::Field = crate::Field::new(32, 0, SFR_RXF0); - - pub const SFR_RXF1: crate::Register = crate::Register::new(9, 0xffffffff); - pub const SFR_RXF1_FDOUT: crate::Field = crate::Field::new(32, 0, SFR_RXF1); - - pub const SFR_RXF2: crate::Register = crate::Register::new(10, 0xffffffff); - pub const SFR_RXF2_FDOUT: crate::Field = crate::Field::new(32, 0, SFR_RXF2); - - pub const SFR_RXF3: crate::Register = crate::Register::new(11, 0xffffffff); - pub const SFR_RXF3_FDOUT: crate::Field = crate::Field::new(32, 0, SFR_RXF3); - - pub const SFR_ELEVEL: crate::Register = crate::Register::new(12, 0xffffffff); - pub const SFR_ELEVEL_FIFO_EVENT_LEVEL0: crate::Field = crate::Field::new(4, 0, SFR_ELEVEL); - pub const SFR_ELEVEL_FIFO_EVENT_LEVEL1: crate::Field = crate::Field::new(4, 4, SFR_ELEVEL); - pub const SFR_ELEVEL_FIFO_EVENT_LEVEL2: crate::Field = crate::Field::new(4, 8, SFR_ELEVEL); - pub const SFR_ELEVEL_FIFO_EVENT_LEVEL3: crate::Field = crate::Field::new(4, 12, SFR_ELEVEL); - pub const SFR_ELEVEL_FIFO_EVENT_LEVEL4: crate::Field = crate::Field::new(4, 16, SFR_ELEVEL); - pub const SFR_ELEVEL_FIFO_EVENT_LEVEL5: crate::Field = crate::Field::new(4, 20, SFR_ELEVEL); - pub const SFR_ELEVEL_FIFO_EVENT_LEVEL6: crate::Field = crate::Field::new(4, 24, SFR_ELEVEL); - pub const SFR_ELEVEL_FIFO_EVENT_LEVEL7: crate::Field = crate::Field::new(4, 28, SFR_ELEVEL); - - pub const SFR_ETYPE: crate::Register = crate::Register::new(13, 0xffffff); - pub const SFR_ETYPE_FIFO_EVENT_LT_MASK: crate::Field = crate::Field::new(8, 0, SFR_ETYPE); - pub const SFR_ETYPE_FIFO_EVENT_EQ_MASK: crate::Field = crate::Field::new(8, 8, SFR_ETYPE); - pub const SFR_ETYPE_FIFO_EVENT_GT_MASK: crate::Field = crate::Field::new(8, 16, SFR_ETYPE); - - pub const SFR_EVENT_SET: crate::Register = crate::Register::new(14, 0xffffff); - pub const SFR_EVENT_SET_SFR_EVENT_SET: crate::Field = crate::Field::new(24, 0, SFR_EVENT_SET); - - pub const SFR_EVENT_CLR: crate::Register = crate::Register::new(15, 0xffffff); - pub const SFR_EVENT_CLR_SFR_EVENT_CLR: crate::Field = crate::Field::new(24, 0, SFR_EVENT_CLR); - - pub const SFR_EVENT_STATUS: crate::Register = crate::Register::new(16, 0xffffffff); - pub const SFR_EVENT_STATUS_SFR_EVENT_STATUS: crate::Field = crate::Field::new(32, 0, SFR_EVENT_STATUS); - - pub const SFR_EXTCLOCK: crate::Register = crate::Register::new(17, 0xffffff); - pub const SFR_EXTCLOCK_USE_EXTCLK: crate::Field = crate::Field::new(4, 0, SFR_EXTCLOCK); - pub const SFR_EXTCLOCK_EXTCLK_GPIO_0: crate::Field = crate::Field::new(5, 4, SFR_EXTCLOCK); - pub const SFR_EXTCLOCK_EXTCLK_GPIO_1: crate::Field = crate::Field::new(5, 9, SFR_EXTCLOCK); - pub const SFR_EXTCLOCK_EXTCLK_GPIO_2: crate::Field = crate::Field::new(5, 14, SFR_EXTCLOCK); - pub const SFR_EXTCLOCK_EXTCLK_GPIO_3: crate::Field = crate::Field::new(5, 19, SFR_EXTCLOCK); - - pub const SFR_FIFO_CLR: crate::Register = crate::Register::new(18, 0xf); - pub const SFR_FIFO_CLR_SFR_FIFO_CLR: crate::Field = crate::Field::new(4, 0, SFR_FIFO_CLR); - - pub const SFR_QDIV0: crate::Register = crate::Register::new(20, 0x7); - pub const SFR_QDIV0_UNUSED_DIV: crate::Field = crate::Field::new(1, 0, SFR_QDIV0); - pub const SFR_QDIV0_DIV_FRAC: crate::Field = crate::Field::new(1, 1, SFR_QDIV0); - pub const SFR_QDIV0_DIV_INT: crate::Field = crate::Field::new(1, 2, SFR_QDIV0); - - pub const SFR_QDIV1: crate::Register = crate::Register::new(21, 0x7); - pub const SFR_QDIV1_UNUSED_DIV: crate::Field = crate::Field::new(1, 0, SFR_QDIV1); - pub const SFR_QDIV1_DIV_FRAC: crate::Field = crate::Field::new(1, 1, SFR_QDIV1); - pub const SFR_QDIV1_DIV_INT: crate::Field = crate::Field::new(1, 2, SFR_QDIV1); - - pub const SFR_QDIV2: crate::Register = crate::Register::new(22, 0x7); - pub const SFR_QDIV2_UNUSED_DIV: crate::Field = crate::Field::new(1, 0, SFR_QDIV2); - pub const SFR_QDIV2_DIV_FRAC: crate::Field = crate::Field::new(1, 1, SFR_QDIV2); - pub const SFR_QDIV2_DIV_INT: crate::Field = crate::Field::new(1, 2, SFR_QDIV2); - - pub const SFR_QDIV3: crate::Register = crate::Register::new(23, 0x7); - pub const SFR_QDIV3_UNUSED_DIV: crate::Field = crate::Field::new(1, 0, SFR_QDIV3); - pub const SFR_QDIV3_DIV_FRAC: crate::Field = crate::Field::new(1, 1, SFR_QDIV3); - pub const SFR_QDIV3_DIV_INT: crate::Field = crate::Field::new(1, 2, SFR_QDIV3); - - pub const SFR_SYNC_BYPASS: crate::Register = crate::Register::new(24, 0xffffffff); - pub const SFR_SYNC_BYPASS_SFR_SYNC_BYPASS: crate::Field = crate::Field::new(32, 0, SFR_SYNC_BYPASS); - - pub const SFR_IO_OE_INV: crate::Register = crate::Register::new(25, 0xffffffff); - pub const SFR_IO_OE_INV_SFR_IO_OE_INV: crate::Field = crate::Field::new(32, 0, SFR_IO_OE_INV); - - pub const SFR_IO_O_INV: crate::Register = crate::Register::new(26, 0xffffffff); - pub const SFR_IO_O_INV_SFR_IO_O_INV: crate::Field = crate::Field::new(32, 0, SFR_IO_O_INV); - - pub const SFR_IO_I_INV: crate::Register = crate::Register::new(27, 0xffffffff); - pub const SFR_IO_I_INV_SFR_IO_I_INV: crate::Field = crate::Field::new(32, 0, SFR_IO_I_INV); - - pub const SFR_IRQMASK_0: crate::Register = crate::Register::new(28, 0xffffffff); - pub const SFR_IRQMASK_0_SFR_IRQMASK_0: crate::Field = crate::Field::new(32, 0, SFR_IRQMASK_0); - - pub const SFR_IRQMASK_1: crate::Register = crate::Register::new(29, 0xffffffff); - pub const SFR_IRQMASK_1_SFR_IRQMASK_1: crate::Field = crate::Field::new(32, 0, SFR_IRQMASK_1); - - pub const SFR_IRQMASK_2: crate::Register = crate::Register::new(30, 0xffffffff); - pub const SFR_IRQMASK_2_SFR_IRQMASK_2: crate::Field = crate::Field::new(32, 0, SFR_IRQMASK_2); - - pub const SFR_IRQMASK_3: crate::Register = crate::Register::new(31, 0xffffffff); - pub const SFR_IRQMASK_3_SFR_IRQMASK_3: crate::Field = crate::Field::new(32, 0, SFR_IRQMASK_3); - - pub const SFR_IRQ_EDGE: crate::Register = crate::Register::new(32, 0xf); - pub const SFR_IRQ_EDGE_SFR_IRQ_EDGE: crate::Field = crate::Field::new(4, 0, SFR_IRQ_EDGE); - - pub const SFR_DBG_PADOUT: crate::Register = crate::Register::new(33, 0xffffffff); - pub const SFR_DBG_PADOUT_SFR_DBG_PADOUT: crate::Field = crate::Field::new(32, 0, SFR_DBG_PADOUT); - - pub const SFR_DBG_PADOE: crate::Register = crate::Register::new(34, 0xffffffff); - pub const SFR_DBG_PADOE_SFR_DBG_PADOE: crate::Field = crate::Field::new(32, 0, SFR_DBG_PADOE); - - pub const SFR_DBG0: crate::Register = crate::Register::new(36, 0x3); - pub const SFR_DBG0_DBG_PC: crate::Field = crate::Field::new(1, 0, SFR_DBG0); - pub const SFR_DBG0_TRAP: crate::Field = crate::Field::new(1, 1, SFR_DBG0); - - pub const SFR_DBG1: crate::Register = crate::Register::new(37, 0x3); - pub const SFR_DBG1_DBG_PC: crate::Field = crate::Field::new(1, 0, SFR_DBG1); - pub const SFR_DBG1_TRAP: crate::Field = crate::Field::new(1, 1, SFR_DBG1); - - pub const SFR_DBG2: crate::Register = crate::Register::new(38, 0x3); - pub const SFR_DBG2_DBG_PC: crate::Field = crate::Field::new(1, 0, SFR_DBG2); - pub const SFR_DBG2_TRAP: crate::Field = crate::Field::new(1, 1, SFR_DBG2); - - pub const SFR_DBG3: crate::Register = crate::Register::new(39, 0x3); - pub const SFR_DBG3_DBG_PC: crate::Field = crate::Field::new(1, 0, SFR_DBG3); - pub const SFR_DBG3_TRAP: crate::Field = crate::Field::new(1, 1, SFR_DBG3); - - pub const SFR_MEM_GUTTER: crate::Register = crate::Register::new(40, 0xfffff); - pub const SFR_MEM_GUTTER_SFR_MEM_GUTTER: crate::Field = crate::Field::new(20, 0, SFR_MEM_GUTTER); - - pub const SFR_PERI_GUTTER: crate::Register = crate::Register::new(41, 0xfffff); - pub const SFR_PERI_GUTTER_SFR_PERI_GUTTER: crate::Field = crate::Field::new(20, 0, SFR_PERI_GUTTER); - - pub const SFR_DMAREQ_MAP_CR_EVMAP0: crate::Register = crate::Register::new(44, 0xffffffff); - pub const SFR_DMAREQ_MAP_CR_EVMAP0_CR_EVMAP0: crate::Field = crate::Field::new(32, 0, SFR_DMAREQ_MAP_CR_EVMAP0); - - pub const SFR_DMAREQ_MAP_CR_EVMAP1: crate::Register = crate::Register::new(45, 0xffffffff); - pub const SFR_DMAREQ_MAP_CR_EVMAP1_CR_EVMAP1: crate::Field = crate::Field::new(32, 0, SFR_DMAREQ_MAP_CR_EVMAP1); - - pub const SFR_DMAREQ_MAP_CR_EVMAP2: crate::Register = crate::Register::new(46, 0xffffffff); - pub const SFR_DMAREQ_MAP_CR_EVMAP2_CR_EVMAP2: crate::Field = crate::Field::new(32, 0, SFR_DMAREQ_MAP_CR_EVMAP2); - - pub const SFR_DMAREQ_MAP_CR_EVMAP3: crate::Register = crate::Register::new(47, 0xffffffff); - pub const SFR_DMAREQ_MAP_CR_EVMAP3_CR_EVMAP3: crate::Field = crate::Field::new(32, 0, SFR_DMAREQ_MAP_CR_EVMAP3); - - pub const SFR_DMAREQ_MAP_CR_EVMAP4: crate::Register = crate::Register::new(48, 0xffffffff); - pub const SFR_DMAREQ_MAP_CR_EVMAP4_CR_EVMAP4: crate::Field = crate::Field::new(32, 0, SFR_DMAREQ_MAP_CR_EVMAP4); - - pub const SFR_DMAREQ_MAP_CR_EVMAP5: crate::Register = crate::Register::new(49, 0xffffffff); - pub const SFR_DMAREQ_MAP_CR_EVMAP5_CR_EVMAP5: crate::Field = crate::Field::new(32, 0, SFR_DMAREQ_MAP_CR_EVMAP5); - - pub const SFR_DMAREQ_STAT_SR_EVSTAT0: crate::Register = crate::Register::new(50, 0xffffffff); - pub const SFR_DMAREQ_STAT_SR_EVSTAT0_SR_EVSTAT0: crate::Field = crate::Field::new(32, 0, SFR_DMAREQ_STAT_SR_EVSTAT0); - - pub const SFR_DMAREQ_STAT_SR_EVSTAT1: crate::Register = crate::Register::new(51, 0xffffffff); - pub const SFR_DMAREQ_STAT_SR_EVSTAT1_SR_EVSTAT1: crate::Field = crate::Field::new(32, 0, SFR_DMAREQ_STAT_SR_EVSTAT1); - - pub const SFR_DMAREQ_STAT_SR_EVSTAT2: crate::Register = crate::Register::new(52, 0xffffffff); - pub const SFR_DMAREQ_STAT_SR_EVSTAT2_SR_EVSTAT2: crate::Field = crate::Field::new(32, 0, SFR_DMAREQ_STAT_SR_EVSTAT2); - - pub const SFR_DMAREQ_STAT_SR_EVSTAT3: crate::Register = crate::Register::new(53, 0xffffffff); - pub const SFR_DMAREQ_STAT_SR_EVSTAT3_SR_EVSTAT3: crate::Field = crate::Field::new(32, 0, SFR_DMAREQ_STAT_SR_EVSTAT3); - - pub const SFR_DMAREQ_STAT_SR_EVSTAT4: crate::Register = crate::Register::new(54, 0xffffffff); - pub const SFR_DMAREQ_STAT_SR_EVSTAT4_SR_EVSTAT4: crate::Field = crate::Field::new(32, 0, SFR_DMAREQ_STAT_SR_EVSTAT4); - - pub const SFR_DMAREQ_STAT_SR_EVSTAT5: crate::Register = crate::Register::new(55, 0xffffffff); - pub const SFR_DMAREQ_STAT_SR_EVSTAT5_SR_EVSTAT5: crate::Field = crate::Field::new(32, 0, SFR_DMAREQ_STAT_SR_EVSTAT5); - - pub const SFR_FILTER_BASE_0: crate::Register = crate::Register::new(56, 0xfffff); - pub const SFR_FILTER_BASE_0_FILTER_BASE: crate::Field = crate::Field::new(20, 0, SFR_FILTER_BASE_0); - - pub const SFR_FILTER_BOUNDS_0: crate::Register = crate::Register::new(57, 0xfffff); - pub const SFR_FILTER_BOUNDS_0_FILTER_BOUNDS: crate::Field = crate::Field::new(20, 0, SFR_FILTER_BOUNDS_0); - - pub const SFR_FILTER_BASE_1: crate::Register = crate::Register::new(58, 0xfffff); - pub const SFR_FILTER_BASE_1_FILTER_BASE: crate::Field = crate::Field::new(20, 0, SFR_FILTER_BASE_1); - - pub const SFR_FILTER_BOUNDS_1: crate::Register = crate::Register::new(59, 0xfffff); - pub const SFR_FILTER_BOUNDS_1_FILTER_BOUNDS: crate::Field = crate::Field::new(20, 0, SFR_FILTER_BOUNDS_1); - - pub const SFR_FILTER_BASE_2: crate::Register = crate::Register::new(60, 0xfffff); - pub const SFR_FILTER_BASE_2_FILTER_BASE: crate::Field = crate::Field::new(20, 0, SFR_FILTER_BASE_2); - - pub const SFR_FILTER_BOUNDS_2: crate::Register = crate::Register::new(61, 0xfffff); - pub const SFR_FILTER_BOUNDS_2_FILTER_BOUNDS: crate::Field = crate::Field::new(20, 0, SFR_FILTER_BOUNDS_2); - - pub const SFR_FILTER_BASE_3: crate::Register = crate::Register::new(62, 0xfffff); - pub const SFR_FILTER_BASE_3_FILTER_BASE: crate::Field = crate::Field::new(20, 0, SFR_FILTER_BASE_3); - - pub const SFR_FILTER_BOUNDS_3: crate::Register = crate::Register::new(63, 0xfffff); - pub const SFR_FILTER_BOUNDS_3_FILTER_BOUNDS: crate::Field = crate::Field::new(20, 0, SFR_FILTER_BOUNDS_3); - - pub const HW_BIO_BDMA_BASE: usize = 0x50124000; - } - - pub mod coresub_sramtrm { - pub const CORESUB_SRAMTRM_NUMREGS: usize = 7; - - pub const SFR_CACHE: crate::Register = crate::Register::new(0, 0x7); - pub const SFR_CACHE_SFR_CACHE: crate::Field = crate::Field::new(3, 0, SFR_CACHE); - - pub const SFR_ITCM: crate::Register = crate::Register::new(1, 0x1f); - pub const SFR_ITCM_SFR_ITCM: crate::Field = crate::Field::new(5, 0, SFR_ITCM); - - pub const SFR_DTCM: crate::Register = crate::Register::new(2, 0x1f); - pub const SFR_DTCM_SFR_DTCM: crate::Field = crate::Field::new(5, 0, SFR_DTCM); - - pub const SFR_SRAM0: crate::Register = crate::Register::new(3, 0x1f); - pub const SFR_SRAM0_SFR_SRAM0: crate::Field = crate::Field::new(5, 0, SFR_SRAM0); - - pub const SFR_SRAM1: crate::Register = crate::Register::new(4, 0x1f); - pub const SFR_SRAM1_SFR_SRAM1: crate::Field = crate::Field::new(5, 0, SFR_SRAM1); - - pub const SFR_VEXRAM: crate::Register = crate::Register::new(5, 0x7); - pub const SFR_VEXRAM_SFR_VEXRAM: crate::Field = crate::Field::new(3, 0, SFR_VEXRAM); - - pub const SFR_SRAMERR: crate::Register = crate::Register::new(8, 0xf); - pub const SFR_SRAMERR_SRAMBANKERR: crate::Field = crate::Field::new(4, 0, SFR_SRAMERR); - - pub const HW_CORESUB_SRAMTRM_BASE: usize = 0x40014000; - } - - pub mod mdma { - pub const MDMA_NUMREGS: usize = 24; - - pub const SFR_EVSEL_CR_EVSEL0: crate::Register = crate::Register::new(0, 0xff); - pub const SFR_EVSEL_CR_EVSEL0_CR_EVSEL0: crate::Field = crate::Field::new(8, 0, SFR_EVSEL_CR_EVSEL0); - - pub const SFR_EVSEL_CR_EVSEL1: crate::Register = crate::Register::new(1, 0xff); - pub const SFR_EVSEL_CR_EVSEL1_CR_EVSEL1: crate::Field = crate::Field::new(8, 0, SFR_EVSEL_CR_EVSEL1); - - pub const SFR_EVSEL_CR_EVSEL2: crate::Register = crate::Register::new(2, 0xff); - pub const SFR_EVSEL_CR_EVSEL2_CR_EVSEL2: crate::Field = crate::Field::new(8, 0, SFR_EVSEL_CR_EVSEL2); - - pub const SFR_EVSEL_CR_EVSEL3: crate::Register = crate::Register::new(3, 0xff); - pub const SFR_EVSEL_CR_EVSEL3_CR_EVSEL3: crate::Field = crate::Field::new(8, 0, SFR_EVSEL_CR_EVSEL3); - - pub const SFR_EVSEL_CR_EVSEL4: crate::Register = crate::Register::new(4, 0xff); - pub const SFR_EVSEL_CR_EVSEL4_CR_EVSEL4: crate::Field = crate::Field::new(8, 0, SFR_EVSEL_CR_EVSEL4); - - pub const SFR_EVSEL_CR_EVSEL5: crate::Register = crate::Register::new(5, 0xff); - pub const SFR_EVSEL_CR_EVSEL5_CR_EVSEL5: crate::Field = crate::Field::new(8, 0, SFR_EVSEL_CR_EVSEL5); - - pub const SFR_EVSEL_CR_EVSEL6: crate::Register = crate::Register::new(6, 0xff); - pub const SFR_EVSEL_CR_EVSEL6_CR_EVSEL6: crate::Field = crate::Field::new(8, 0, SFR_EVSEL_CR_EVSEL6); - - pub const SFR_EVSEL_CR_EVSEL7: crate::Register = crate::Register::new(7, 0xff); - pub const SFR_EVSEL_CR_EVSEL7_CR_EVSEL7: crate::Field = crate::Field::new(8, 0, SFR_EVSEL_CR_EVSEL7); - - pub const SFR_CR_CR_MDMAREQ0: crate::Register = crate::Register::new(8, 0x1f); - pub const SFR_CR_CR_MDMAREQ0_CR_MDMAREQ0: crate::Field = crate::Field::new(5, 0, SFR_CR_CR_MDMAREQ0); - - pub const SFR_CR_CR_MDMAREQ1: crate::Register = crate::Register::new(9, 0x1f); - pub const SFR_CR_CR_MDMAREQ1_CR_MDMAREQ1: crate::Field = crate::Field::new(5, 0, SFR_CR_CR_MDMAREQ1); - - pub const SFR_CR_CR_MDMAREQ2: crate::Register = crate::Register::new(10, 0x1f); - pub const SFR_CR_CR_MDMAREQ2_CR_MDMAREQ2: crate::Field = crate::Field::new(5, 0, SFR_CR_CR_MDMAREQ2); - - pub const SFR_CR_CR_MDMAREQ3: crate::Register = crate::Register::new(11, 0x1f); - pub const SFR_CR_CR_MDMAREQ3_CR_MDMAREQ3: crate::Field = crate::Field::new(5, 0, SFR_CR_CR_MDMAREQ3); - - pub const SFR_CR_CR_MDMAREQ4: crate::Register = crate::Register::new(12, 0x1f); - pub const SFR_CR_CR_MDMAREQ4_CR_MDMAREQ4: crate::Field = crate::Field::new(5, 0, SFR_CR_CR_MDMAREQ4); - - pub const SFR_CR_CR_MDMAREQ5: crate::Register = crate::Register::new(13, 0x1f); - pub const SFR_CR_CR_MDMAREQ5_CR_MDMAREQ5: crate::Field = crate::Field::new(5, 0, SFR_CR_CR_MDMAREQ5); - - pub const SFR_CR_CR_MDMAREQ6: crate::Register = crate::Register::new(14, 0x1f); - pub const SFR_CR_CR_MDMAREQ6_CR_MDMAREQ6: crate::Field = crate::Field::new(5, 0, SFR_CR_CR_MDMAREQ6); - - pub const SFR_CR_CR_MDMAREQ7: crate::Register = crate::Register::new(15, 0x1f); - pub const SFR_CR_CR_MDMAREQ7_CR_MDMAREQ7: crate::Field = crate::Field::new(5, 0, SFR_CR_CR_MDMAREQ7); - - pub const SFR_SR_SR_MDMAREQ0: crate::Register = crate::Register::new(16, 0x1f); - pub const SFR_SR_SR_MDMAREQ0_SR_MDMAREQ0: crate::Field = crate::Field::new(5, 0, SFR_SR_SR_MDMAREQ0); - - pub const SFR_SR_SR_MDMAREQ1: crate::Register = crate::Register::new(17, 0x1f); - pub const SFR_SR_SR_MDMAREQ1_SR_MDMAREQ1: crate::Field = crate::Field::new(5, 0, SFR_SR_SR_MDMAREQ1); - - pub const SFR_SR_SR_MDMAREQ2: crate::Register = crate::Register::new(18, 0x1f); - pub const SFR_SR_SR_MDMAREQ2_SR_MDMAREQ2: crate::Field = crate::Field::new(5, 0, SFR_SR_SR_MDMAREQ2); - - pub const SFR_SR_SR_MDMAREQ3: crate::Register = crate::Register::new(19, 0x1f); - pub const SFR_SR_SR_MDMAREQ3_SR_MDMAREQ3: crate::Field = crate::Field::new(5, 0, SFR_SR_SR_MDMAREQ3); - - pub const SFR_SR_SR_MDMAREQ4: crate::Register = crate::Register::new(20, 0x1f); - pub const SFR_SR_SR_MDMAREQ4_SR_MDMAREQ4: crate::Field = crate::Field::new(5, 0, SFR_SR_SR_MDMAREQ4); - - pub const SFR_SR_SR_MDMAREQ5: crate::Register = crate::Register::new(21, 0x1f); - pub const SFR_SR_SR_MDMAREQ5_SR_MDMAREQ5: crate::Field = crate::Field::new(5, 0, SFR_SR_SR_MDMAREQ5); - - pub const SFR_SR_SR_MDMAREQ6: crate::Register = crate::Register::new(22, 0x1f); - pub const SFR_SR_SR_MDMAREQ6_SR_MDMAREQ6: crate::Field = crate::Field::new(5, 0, SFR_SR_SR_MDMAREQ6); - - pub const SFR_SR_SR_MDMAREQ7: crate::Register = crate::Register::new(23, 0x1f); - pub const SFR_SR_SR_MDMAREQ7_SR_MDMAREQ7: crate::Field = crate::Field::new(5, 0, SFR_SR_SR_MDMAREQ7); - - pub const HW_MDMA_BASE: usize = 0x40012000; - } - - pub mod qfc { - pub const QFC_NUMREGS: usize = 14; - - pub const SFR_IO: crate::Register = crate::Register::new(0, 0xff); - pub const SFR_IO_SFR_IO: crate::Field = crate::Field::new(8, 0, SFR_IO); - - pub const SFR_AR: crate::Register = crate::Register::new(1, 0xffffffff); - pub const SFR_AR_SFR_AR: crate::Field = crate::Field::new(32, 0, SFR_AR); - - pub const SFR_IODRV: crate::Register = crate::Register::new(2, 0xfff); - pub const SFR_IODRV_PADDRVSEL: crate::Field = crate::Field::new(12, 0, SFR_IODRV); - - pub const CR_XIP_ADDRMODE: crate::Register = crate::Register::new(4, 0x3); - pub const CR_XIP_ADDRMODE_CR_XIP_ADDRMODE: crate::Field = crate::Field::new(2, 0, CR_XIP_ADDRMODE); - - pub const CR_XIP_OPCODE: crate::Register = crate::Register::new(5, 0xffffffff); - pub const CR_XIP_OPCODE_CR_XIP_OPCODE: crate::Field = crate::Field::new(32, 0, CR_XIP_OPCODE); - - pub const CR_XIP_WIDTH: crate::Register = crate::Register::new(6, 0x3f); - pub const CR_XIP_WIDTH_CR_XIP_WIDTH: crate::Field = crate::Field::new(6, 0, CR_XIP_WIDTH); - - pub const CR_XIP_SSEL: crate::Register = crate::Register::new(7, 0x7f); - pub const CR_XIP_SSEL_CR_XIP_SSEL: crate::Field = crate::Field::new(7, 0, CR_XIP_SSEL); - - pub const CR_XIP_DUMCYC: crate::Register = crate::Register::new(8, 0xffff); - pub const CR_XIP_DUMCYC_CR_XIP_DUMCYC: crate::Field = crate::Field::new(16, 0, CR_XIP_DUMCYC); - - pub const CR_XIP_CFG: crate::Register = crate::Register::new(9, 0x3fff); - pub const CR_XIP_CFG_CR_XIP_CFG: crate::Field = crate::Field::new(14, 0, CR_XIP_CFG); - - pub const CR_AESKEY_AESKEYIN0: crate::Register = crate::Register::new(16, 0xffffffff); - pub const CR_AESKEY_AESKEYIN0_AESKEYIN0: crate::Field = crate::Field::new(32, 0, CR_AESKEY_AESKEYIN0); - - pub const CR_AESKEY_AESKEYIN1: crate::Register = crate::Register::new(17, 0xffffffff); - pub const CR_AESKEY_AESKEYIN1_AESKEYIN1: crate::Field = crate::Field::new(32, 0, CR_AESKEY_AESKEYIN1); - - pub const CR_AESKEY_AESKEYIN2: crate::Register = crate::Register::new(18, 0xffffffff); - pub const CR_AESKEY_AESKEYIN2_AESKEYIN2: crate::Field = crate::Field::new(32, 0, CR_AESKEY_AESKEYIN2); - - pub const CR_AESKEY_AESKEYIN3: crate::Register = crate::Register::new(19, 0xffffffff); - pub const CR_AESKEY_AESKEYIN3_AESKEYIN3: crate::Field = crate::Field::new(32, 0, CR_AESKEY_AESKEYIN3); - - pub const CR_AESENA: crate::Register = crate::Register::new(20, 0x1); - pub const CR_AESENA_CR_AESENA: crate::Field = crate::Field::new(1, 0, CR_AESENA); - - pub const HW_QFC_BASE: usize = 0x40010000; - } - - pub mod mbox_apb { - pub const MBOX_APB_NUMREGS: usize = 5; - - pub const SFR_WDATA: crate::Register = crate::Register::new(0, 0xffffffff); - pub const SFR_WDATA_SFR_WDATA: crate::Field = crate::Field::new(32, 0, SFR_WDATA); - - pub const SFR_RDATA: crate::Register = crate::Register::new(1, 0xffffffff); - pub const SFR_RDATA_SFR_RDATA: crate::Field = crate::Field::new(32, 0, SFR_RDATA); - - pub const SFR_STATUS: crate::Register = crate::Register::new(2, 0x3f); - pub const SFR_STATUS_RX_AVAIL: crate::Field = crate::Field::new(1, 0, SFR_STATUS); - pub const SFR_STATUS_TX_FREE: crate::Field = crate::Field::new(1, 1, SFR_STATUS); - pub const SFR_STATUS_ABORT_IN_PROGRESS: crate::Field = crate::Field::new(1, 2, SFR_STATUS); - pub const SFR_STATUS_ABORT_ACK: crate::Field = crate::Field::new(1, 3, SFR_STATUS); - pub const SFR_STATUS_TX_ERR: crate::Field = crate::Field::new(1, 4, SFR_STATUS); - pub const SFR_STATUS_RX_ERR: crate::Field = crate::Field::new(1, 5, SFR_STATUS); - - pub const SFR_ABORT: crate::Register = crate::Register::new(6, 0xffffffff); - pub const SFR_ABORT_SFR_ABORT: crate::Field = crate::Field::new(32, 0, SFR_ABORT); - - pub const SFR_DONE: crate::Register = crate::Register::new(7, 0xffffffff); - pub const SFR_DONE_SFR_DONE: crate::Field = crate::Field::new(32, 0, SFR_DONE); - - pub const HW_MBOX_APB_BASE: usize = 0x40013000; - } - - pub mod gluechain { - pub const GLUECHAIN_NUMREGS: usize = 4; - - pub const SFR_GCMASK: crate::Register = crate::Register::new(0, 0xffffffff); - pub const SFR_GCMASK_CR_GCMASK: crate::Field = crate::Field::new(32, 0, SFR_GCMASK); - - pub const SFR_GCSR: crate::Register = crate::Register::new(1, 0xffffffff); - pub const SFR_GCSR_GLUEREG: crate::Field = crate::Field::new(32, 0, SFR_GCSR); - - pub const SFR_GCRST: crate::Register = crate::Register::new(2, 0xffffffff); - pub const SFR_GCRST_GLUERST: crate::Field = crate::Field::new(32, 0, SFR_GCRST); - - pub const SFR_GCTEST: crate::Register = crate::Register::new(3, 0xffffffff); - pub const SFR_GCTEST_GLUETEST: crate::Field = crate::Field::new(32, 0, SFR_GCTEST); - - pub const HW_GLUECHAIN_BASE: usize = 0x40054000; - } - pub mod bio_fifo0 { pub const BIO_FIFO0_NUMREGS: usize = 6; @@ -5527,118 +4996,6 @@ mod tests { susres_csr.wfo(utra::susres::EV_ENABLE_SOFT_INT, baz); } - #[test] - #[ignore] - fn compile_check_coreuser_csr() { - use super::*; - let mut coreuser_csr = CSR::new(HW_COREUSER_BASE as *mut u32); - - let foo = coreuser_csr.r(utra::coreuser::SET_ASID); - coreuser_csr.wo(utra::coreuser::SET_ASID, foo); - let bar = coreuser_csr.rf(utra::coreuser::SET_ASID_ASID); - coreuser_csr.rmwf(utra::coreuser::SET_ASID_ASID, bar); - let mut baz = coreuser_csr.zf(utra::coreuser::SET_ASID_ASID, bar); - baz |= coreuser_csr.ms(utra::coreuser::SET_ASID_ASID, 1); - coreuser_csr.wfo(utra::coreuser::SET_ASID_ASID, baz); - let bar = coreuser_csr.rf(utra::coreuser::SET_ASID_TRUSTED); - coreuser_csr.rmwf(utra::coreuser::SET_ASID_TRUSTED, bar); - let mut baz = coreuser_csr.zf(utra::coreuser::SET_ASID_TRUSTED, bar); - baz |= coreuser_csr.ms(utra::coreuser::SET_ASID_TRUSTED, 1); - coreuser_csr.wfo(utra::coreuser::SET_ASID_TRUSTED, baz); - - let foo = coreuser_csr.r(utra::coreuser::GET_ASID_ADDR); - coreuser_csr.wo(utra::coreuser::GET_ASID_ADDR, foo); - let bar = coreuser_csr.rf(utra::coreuser::GET_ASID_ADDR_ASID); - coreuser_csr.rmwf(utra::coreuser::GET_ASID_ADDR_ASID, bar); - let mut baz = coreuser_csr.zf(utra::coreuser::GET_ASID_ADDR_ASID, bar); - baz |= coreuser_csr.ms(utra::coreuser::GET_ASID_ADDR_ASID, 1); - coreuser_csr.wfo(utra::coreuser::GET_ASID_ADDR_ASID, baz); - - let foo = coreuser_csr.r(utra::coreuser::GET_ASID_VALUE); - coreuser_csr.wo(utra::coreuser::GET_ASID_VALUE, foo); - let bar = coreuser_csr.rf(utra::coreuser::GET_ASID_VALUE_VALUE); - coreuser_csr.rmwf(utra::coreuser::GET_ASID_VALUE_VALUE, bar); - let mut baz = coreuser_csr.zf(utra::coreuser::GET_ASID_VALUE_VALUE, bar); - baz |= coreuser_csr.ms(utra::coreuser::GET_ASID_VALUE_VALUE, 1); - coreuser_csr.wfo(utra::coreuser::GET_ASID_VALUE_VALUE, baz); - - let foo = coreuser_csr.r(utra::coreuser::SET_PRIVILEGE); - coreuser_csr.wo(utra::coreuser::SET_PRIVILEGE, foo); - let bar = coreuser_csr.rf(utra::coreuser::SET_PRIVILEGE_MPP); - coreuser_csr.rmwf(utra::coreuser::SET_PRIVILEGE_MPP, bar); - let mut baz = coreuser_csr.zf(utra::coreuser::SET_PRIVILEGE_MPP, bar); - baz |= coreuser_csr.ms(utra::coreuser::SET_PRIVILEGE_MPP, 1); - coreuser_csr.wfo(utra::coreuser::SET_PRIVILEGE_MPP, baz); - - let foo = coreuser_csr.r(utra::coreuser::CONTROL); - coreuser_csr.wo(utra::coreuser::CONTROL, foo); - let bar = coreuser_csr.rf(utra::coreuser::CONTROL_ENABLE); - coreuser_csr.rmwf(utra::coreuser::CONTROL_ENABLE, bar); - let mut baz = coreuser_csr.zf(utra::coreuser::CONTROL_ENABLE, bar); - baz |= coreuser_csr.ms(utra::coreuser::CONTROL_ENABLE, 1); - coreuser_csr.wfo(utra::coreuser::CONTROL_ENABLE, baz); - let bar = coreuser_csr.rf(utra::coreuser::CONTROL_ASID); - coreuser_csr.rmwf(utra::coreuser::CONTROL_ASID, bar); - let mut baz = coreuser_csr.zf(utra::coreuser::CONTROL_ASID, bar); - baz |= coreuser_csr.ms(utra::coreuser::CONTROL_ASID, 1); - coreuser_csr.wfo(utra::coreuser::CONTROL_ASID, baz); - let bar = coreuser_csr.rf(utra::coreuser::CONTROL_PPN_A); - coreuser_csr.rmwf(utra::coreuser::CONTROL_PPN_A, bar); - let mut baz = coreuser_csr.zf(utra::coreuser::CONTROL_PPN_A, bar); - baz |= coreuser_csr.ms(utra::coreuser::CONTROL_PPN_A, 1); - coreuser_csr.wfo(utra::coreuser::CONTROL_PPN_A, baz); - let bar = coreuser_csr.rf(utra::coreuser::CONTROL_PPN_B); - coreuser_csr.rmwf(utra::coreuser::CONTROL_PPN_B, bar); - let mut baz = coreuser_csr.zf(utra::coreuser::CONTROL_PPN_B, bar); - baz |= coreuser_csr.ms(utra::coreuser::CONTROL_PPN_B, 1); - coreuser_csr.wfo(utra::coreuser::CONTROL_PPN_B, baz); - let bar = coreuser_csr.rf(utra::coreuser::CONTROL_PRIVILEGE); - coreuser_csr.rmwf(utra::coreuser::CONTROL_PRIVILEGE, bar); - let mut baz = coreuser_csr.zf(utra::coreuser::CONTROL_PRIVILEGE, bar); - baz |= coreuser_csr.ms(utra::coreuser::CONTROL_PRIVILEGE, 1); - coreuser_csr.wfo(utra::coreuser::CONTROL_PRIVILEGE, baz); - - let foo = coreuser_csr.r(utra::coreuser::PROTECT); - coreuser_csr.wo(utra::coreuser::PROTECT, foo); - let bar = coreuser_csr.rf(utra::coreuser::PROTECT_PROTECT); - coreuser_csr.rmwf(utra::coreuser::PROTECT_PROTECT, bar); - let mut baz = coreuser_csr.zf(utra::coreuser::PROTECT_PROTECT, bar); - baz |= coreuser_csr.ms(utra::coreuser::PROTECT_PROTECT, 1); - coreuser_csr.wfo(utra::coreuser::PROTECT_PROTECT, baz); - - let foo = coreuser_csr.r(utra::coreuser::WINDOW_AL); - coreuser_csr.wo(utra::coreuser::WINDOW_AL, foo); - let bar = coreuser_csr.rf(utra::coreuser::WINDOW_AL_PPN); - coreuser_csr.rmwf(utra::coreuser::WINDOW_AL_PPN, bar); - let mut baz = coreuser_csr.zf(utra::coreuser::WINDOW_AL_PPN, bar); - baz |= coreuser_csr.ms(utra::coreuser::WINDOW_AL_PPN, 1); - coreuser_csr.wfo(utra::coreuser::WINDOW_AL_PPN, baz); - - let foo = coreuser_csr.r(utra::coreuser::WINDOW_AH); - coreuser_csr.wo(utra::coreuser::WINDOW_AH, foo); - let bar = coreuser_csr.rf(utra::coreuser::WINDOW_AH_PPN); - coreuser_csr.rmwf(utra::coreuser::WINDOW_AH_PPN, bar); - let mut baz = coreuser_csr.zf(utra::coreuser::WINDOW_AH_PPN, bar); - baz |= coreuser_csr.ms(utra::coreuser::WINDOW_AH_PPN, 1); - coreuser_csr.wfo(utra::coreuser::WINDOW_AH_PPN, baz); - - let foo = coreuser_csr.r(utra::coreuser::WINDOW_BL); - coreuser_csr.wo(utra::coreuser::WINDOW_BL, foo); - let bar = coreuser_csr.rf(utra::coreuser::WINDOW_BL_PPN); - coreuser_csr.rmwf(utra::coreuser::WINDOW_BL_PPN, bar); - let mut baz = coreuser_csr.zf(utra::coreuser::WINDOW_BL_PPN, bar); - baz |= coreuser_csr.ms(utra::coreuser::WINDOW_BL_PPN, 1); - coreuser_csr.wfo(utra::coreuser::WINDOW_BL_PPN, baz); - - let foo = coreuser_csr.r(utra::coreuser::WINDOW_BH); - coreuser_csr.wo(utra::coreuser::WINDOW_BH, foo); - let bar = coreuser_csr.rf(utra::coreuser::WINDOW_BH_PPN); - coreuser_csr.rmwf(utra::coreuser::WINDOW_BH_PPN, bar); - let mut baz = coreuser_csr.zf(utra::coreuser::WINDOW_BH_PPN, bar); - baz |= coreuser_csr.ms(utra::coreuser::WINDOW_BH_PPN, 1); - coreuser_csr.wfo(utra::coreuser::WINDOW_BH_PPN, baz); - } - #[test] #[ignore] fn compile_check_csrtest_csr() { @@ -11919,6 +11276,3958 @@ mod tests { pl230_csr.wfo(utra::pl230::PERIPH_ID_2_REVISION, baz); } + #[test] + #[ignore] + fn compile_check_alu_csr() { + use super::*; + let mut alu_csr = CSR::new(HW_ALU_BASE as *mut u32); + + let foo = alu_csr.r(utra::alu::SFR_CRFUNC); + alu_csr.wo(utra::alu::SFR_CRFUNC, foo); + let bar = alu_csr.rf(utra::alu::SFR_CRFUNC_SFR_CRFUNC); + alu_csr.rmwf(utra::alu::SFR_CRFUNC_SFR_CRFUNC, bar); + let mut baz = alu_csr.zf(utra::alu::SFR_CRFUNC_SFR_CRFUNC, bar); + baz |= alu_csr.ms(utra::alu::SFR_CRFUNC_SFR_CRFUNC, 1); + alu_csr.wfo(utra::alu::SFR_CRFUNC_SFR_CRFUNC, baz); + + let foo = alu_csr.r(utra::alu::SFR_AR); + alu_csr.wo(utra::alu::SFR_AR, foo); + let bar = alu_csr.rf(utra::alu::SFR_AR_SFR_AR); + alu_csr.rmwf(utra::alu::SFR_AR_SFR_AR, bar); + let mut baz = alu_csr.zf(utra::alu::SFR_AR_SFR_AR, bar); + baz |= alu_csr.ms(utra::alu::SFR_AR_SFR_AR, 1); + alu_csr.wfo(utra::alu::SFR_AR_SFR_AR, baz); + + let foo = alu_csr.r(utra::alu::SFR_SRMFSM); + alu_csr.wo(utra::alu::SFR_SRMFSM, foo); + let bar = alu_csr.rf(utra::alu::SFR_SRMFSM_MFSM); + alu_csr.rmwf(utra::alu::SFR_SRMFSM_MFSM, bar); + let mut baz = alu_csr.zf(utra::alu::SFR_SRMFSM_MFSM, bar); + baz |= alu_csr.ms(utra::alu::SFR_SRMFSM_MFSM, 1); + alu_csr.wfo(utra::alu::SFR_SRMFSM_MFSM, baz); + let bar = alu_csr.rf(utra::alu::SFR_SRMFSM_CRREG); + alu_csr.rmwf(utra::alu::SFR_SRMFSM_CRREG, bar); + let mut baz = alu_csr.zf(utra::alu::SFR_SRMFSM_CRREG, bar); + baz |= alu_csr.ms(utra::alu::SFR_SRMFSM_CRREG, 1); + alu_csr.wfo(utra::alu::SFR_SRMFSM_CRREG, baz); + + let foo = alu_csr.r(utra::alu::SFR_FR); + alu_csr.wo(utra::alu::SFR_FR, foo); + let bar = alu_csr.rf(utra::alu::SFR_FR_MFSM_DONE); + alu_csr.rmwf(utra::alu::SFR_FR_MFSM_DONE, bar); + let mut baz = alu_csr.zf(utra::alu::SFR_FR_MFSM_DONE, bar); + baz |= alu_csr.ms(utra::alu::SFR_FR_MFSM_DONE, 1); + alu_csr.wfo(utra::alu::SFR_FR_MFSM_DONE, baz); + let bar = alu_csr.rf(utra::alu::SFR_FR_DIV_DONE); + alu_csr.rmwf(utra::alu::SFR_FR_DIV_DONE, bar); + let mut baz = alu_csr.zf(utra::alu::SFR_FR_DIV_DONE, bar); + baz |= alu_csr.ms(utra::alu::SFR_FR_DIV_DONE, 1); + alu_csr.wfo(utra::alu::SFR_FR_DIV_DONE, baz); + let bar = alu_csr.rf(utra::alu::SFR_FR_CHNLO_DONE); + alu_csr.rmwf(utra::alu::SFR_FR_CHNLO_DONE, bar); + let mut baz = alu_csr.zf(utra::alu::SFR_FR_CHNLO_DONE, bar); + baz |= alu_csr.ms(utra::alu::SFR_FR_CHNLO_DONE, 1); + alu_csr.wfo(utra::alu::SFR_FR_CHNLO_DONE, baz); + let bar = alu_csr.rf(utra::alu::SFR_FR_CHNLI_DONE); + alu_csr.rmwf(utra::alu::SFR_FR_CHNLI_DONE, bar); + let mut baz = alu_csr.zf(utra::alu::SFR_FR_CHNLI_DONE, bar); + baz |= alu_csr.ms(utra::alu::SFR_FR_CHNLI_DONE, 1); + alu_csr.wfo(utra::alu::SFR_FR_CHNLI_DONE, baz); + let bar = alu_csr.rf(utra::alu::SFR_FR_QS0ERR); + alu_csr.rmwf(utra::alu::SFR_FR_QS0ERR, bar); + let mut baz = alu_csr.zf(utra::alu::SFR_FR_QS0ERR, bar); + baz |= alu_csr.ms(utra::alu::SFR_FR_QS0ERR, 1); + alu_csr.wfo(utra::alu::SFR_FR_QS0ERR, baz); + + let foo = alu_csr.r(utra::alu::SFR_CRDIVLEN); + alu_csr.wo(utra::alu::SFR_CRDIVLEN, foo); + let bar = alu_csr.rf(utra::alu::SFR_CRDIVLEN_SFR_CRDIVLEN); + alu_csr.rmwf(utra::alu::SFR_CRDIVLEN_SFR_CRDIVLEN, bar); + let mut baz = alu_csr.zf(utra::alu::SFR_CRDIVLEN_SFR_CRDIVLEN, bar); + baz |= alu_csr.ms(utra::alu::SFR_CRDIVLEN_SFR_CRDIVLEN, 1); + alu_csr.wfo(utra::alu::SFR_CRDIVLEN_SFR_CRDIVLEN, baz); + + let foo = alu_csr.r(utra::alu::SFR_SRDIVLEN); + alu_csr.wo(utra::alu::SFR_SRDIVLEN, foo); + let bar = alu_csr.rf(utra::alu::SFR_SRDIVLEN_SFR_SRDIVLEN); + alu_csr.rmwf(utra::alu::SFR_SRDIVLEN_SFR_SRDIVLEN, bar); + let mut baz = alu_csr.zf(utra::alu::SFR_SRDIVLEN_SFR_SRDIVLEN, bar); + baz |= alu_csr.ms(utra::alu::SFR_SRDIVLEN_SFR_SRDIVLEN, 1); + alu_csr.wfo(utra::alu::SFR_SRDIVLEN_SFR_SRDIVLEN, baz); + + let foo = alu_csr.r(utra::alu::SFR_OPT); + alu_csr.wo(utra::alu::SFR_OPT, foo); + let bar = alu_csr.rf(utra::alu::SFR_OPT_SFR_OPT); + alu_csr.rmwf(utra::alu::SFR_OPT_SFR_OPT, bar); + let mut baz = alu_csr.zf(utra::alu::SFR_OPT_SFR_OPT, bar); + baz |= alu_csr.ms(utra::alu::SFR_OPT_SFR_OPT, 1); + alu_csr.wfo(utra::alu::SFR_OPT_SFR_OPT, baz); + + let foo = alu_csr.r(utra::alu::SFR_OPTLTX); + alu_csr.wo(utra::alu::SFR_OPTLTX, foo); + let bar = alu_csr.rf(utra::alu::SFR_OPTLTX_SFR_OPTLTX); + alu_csr.rmwf(utra::alu::SFR_OPTLTX_SFR_OPTLTX, bar); + let mut baz = alu_csr.zf(utra::alu::SFR_OPTLTX_SFR_OPTLTX, bar); + baz |= alu_csr.ms(utra::alu::SFR_OPTLTX_SFR_OPTLTX, 1); + alu_csr.wfo(utra::alu::SFR_OPTLTX_SFR_OPTLTX, baz); + + let foo = alu_csr.r(utra::alu::SFR_SEGPTR_CR_SEGCFG0); + alu_csr.wo(utra::alu::SFR_SEGPTR_CR_SEGCFG0, foo); + let bar = alu_csr.rf(utra::alu::SFR_SEGPTR_CR_SEGCFG0_CR_SEGCFG0); + alu_csr.rmwf(utra::alu::SFR_SEGPTR_CR_SEGCFG0_CR_SEGCFG0, bar); + let mut baz = alu_csr.zf(utra::alu::SFR_SEGPTR_CR_SEGCFG0_CR_SEGCFG0, bar); + baz |= alu_csr.ms(utra::alu::SFR_SEGPTR_CR_SEGCFG0_CR_SEGCFG0, 1); + alu_csr.wfo(utra::alu::SFR_SEGPTR_CR_SEGCFG0_CR_SEGCFG0, baz); + + let foo = alu_csr.r(utra::alu::SFR_SEGPTR_CR_SEGCFG1); + alu_csr.wo(utra::alu::SFR_SEGPTR_CR_SEGCFG1, foo); + let bar = alu_csr.rf(utra::alu::SFR_SEGPTR_CR_SEGCFG1_CR_SEGCFG1); + alu_csr.rmwf(utra::alu::SFR_SEGPTR_CR_SEGCFG1_CR_SEGCFG1, bar); + let mut baz = alu_csr.zf(utra::alu::SFR_SEGPTR_CR_SEGCFG1_CR_SEGCFG1, bar); + baz |= alu_csr.ms(utra::alu::SFR_SEGPTR_CR_SEGCFG1_CR_SEGCFG1, 1); + alu_csr.wfo(utra::alu::SFR_SEGPTR_CR_SEGCFG1_CR_SEGCFG1, baz); + + let foo = alu_csr.r(utra::alu::SFR_SEGPTR_CR_SEGCFG2); + alu_csr.wo(utra::alu::SFR_SEGPTR_CR_SEGCFG2, foo); + let bar = alu_csr.rf(utra::alu::SFR_SEGPTR_CR_SEGCFG2_CR_SEGCFG2); + alu_csr.rmwf(utra::alu::SFR_SEGPTR_CR_SEGCFG2_CR_SEGCFG2, bar); + let mut baz = alu_csr.zf(utra::alu::SFR_SEGPTR_CR_SEGCFG2_CR_SEGCFG2, bar); + baz |= alu_csr.ms(utra::alu::SFR_SEGPTR_CR_SEGCFG2_CR_SEGCFG2, 1); + alu_csr.wfo(utra::alu::SFR_SEGPTR_CR_SEGCFG2_CR_SEGCFG2, baz); + + let foo = alu_csr.r(utra::alu::SFR_SEGPTR_CR_SEGCFG3); + alu_csr.wo(utra::alu::SFR_SEGPTR_CR_SEGCFG3, foo); + let bar = alu_csr.rf(utra::alu::SFR_SEGPTR_CR_SEGCFG3_CR_SEGCFG3); + alu_csr.rmwf(utra::alu::SFR_SEGPTR_CR_SEGCFG3_CR_SEGCFG3, bar); + let mut baz = alu_csr.zf(utra::alu::SFR_SEGPTR_CR_SEGCFG3_CR_SEGCFG3, bar); + baz |= alu_csr.ms(utra::alu::SFR_SEGPTR_CR_SEGCFG3_CR_SEGCFG3, 1); + alu_csr.wfo(utra::alu::SFR_SEGPTR_CR_SEGCFG3_CR_SEGCFG3, baz); + } + + #[test] + #[ignore] + fn compile_check_aes_csr() { + use super::*; + let mut aes_csr = CSR::new(HW_AES_BASE as *mut u32); + + let foo = aes_csr.r(utra::aes::SFR_CRFUNC); + aes_csr.wo(utra::aes::SFR_CRFUNC, foo); + let bar = aes_csr.rf(utra::aes::SFR_CRFUNC_SFR_CRFUNC); + aes_csr.rmwf(utra::aes::SFR_CRFUNC_SFR_CRFUNC, bar); + let mut baz = aes_csr.zf(utra::aes::SFR_CRFUNC_SFR_CRFUNC, bar); + baz |= aes_csr.ms(utra::aes::SFR_CRFUNC_SFR_CRFUNC, 1); + aes_csr.wfo(utra::aes::SFR_CRFUNC_SFR_CRFUNC, baz); + + let foo = aes_csr.r(utra::aes::SFR_AR); + aes_csr.wo(utra::aes::SFR_AR, foo); + let bar = aes_csr.rf(utra::aes::SFR_AR_SFR_AR); + aes_csr.rmwf(utra::aes::SFR_AR_SFR_AR, bar); + let mut baz = aes_csr.zf(utra::aes::SFR_AR_SFR_AR, bar); + baz |= aes_csr.ms(utra::aes::SFR_AR_SFR_AR, 1); + aes_csr.wfo(utra::aes::SFR_AR_SFR_AR, baz); + + let foo = aes_csr.r(utra::aes::SFR_SRMFSM); + aes_csr.wo(utra::aes::SFR_SRMFSM, foo); + let bar = aes_csr.rf(utra::aes::SFR_SRMFSM_SFR_SRMFSM); + aes_csr.rmwf(utra::aes::SFR_SRMFSM_SFR_SRMFSM, bar); + let mut baz = aes_csr.zf(utra::aes::SFR_SRMFSM_SFR_SRMFSM, bar); + baz |= aes_csr.ms(utra::aes::SFR_SRMFSM_SFR_SRMFSM, 1); + aes_csr.wfo(utra::aes::SFR_SRMFSM_SFR_SRMFSM, baz); + + let foo = aes_csr.r(utra::aes::SFR_FR); + aes_csr.wo(utra::aes::SFR_FR, foo); + let bar = aes_csr.rf(utra::aes::SFR_FR_MFSM_DONE); + aes_csr.rmwf(utra::aes::SFR_FR_MFSM_DONE, bar); + let mut baz = aes_csr.zf(utra::aes::SFR_FR_MFSM_DONE, bar); + baz |= aes_csr.ms(utra::aes::SFR_FR_MFSM_DONE, 1); + aes_csr.wfo(utra::aes::SFR_FR_MFSM_DONE, baz); + let bar = aes_csr.rf(utra::aes::SFR_FR_ACORE_DONE); + aes_csr.rmwf(utra::aes::SFR_FR_ACORE_DONE, bar); + let mut baz = aes_csr.zf(utra::aes::SFR_FR_ACORE_DONE, bar); + baz |= aes_csr.ms(utra::aes::SFR_FR_ACORE_DONE, 1); + aes_csr.wfo(utra::aes::SFR_FR_ACORE_DONE, baz); + let bar = aes_csr.rf(utra::aes::SFR_FR_CHNLO_DONE); + aes_csr.rmwf(utra::aes::SFR_FR_CHNLO_DONE, bar); + let mut baz = aes_csr.zf(utra::aes::SFR_FR_CHNLO_DONE, bar); + baz |= aes_csr.ms(utra::aes::SFR_FR_CHNLO_DONE, 1); + aes_csr.wfo(utra::aes::SFR_FR_CHNLO_DONE, baz); + let bar = aes_csr.rf(utra::aes::SFR_FR_CHNLI_DONE); + aes_csr.rmwf(utra::aes::SFR_FR_CHNLI_DONE, bar); + let mut baz = aes_csr.zf(utra::aes::SFR_FR_CHNLI_DONE, bar); + baz |= aes_csr.ms(utra::aes::SFR_FR_CHNLI_DONE, 1); + aes_csr.wfo(utra::aes::SFR_FR_CHNLI_DONE, baz); + + let foo = aes_csr.r(utra::aes::SFR_OPT); + aes_csr.wo(utra::aes::SFR_OPT, foo); + let bar = aes_csr.rf(utra::aes::SFR_OPT_OPT_KLEN0); + aes_csr.rmwf(utra::aes::SFR_OPT_OPT_KLEN0, bar); + let mut baz = aes_csr.zf(utra::aes::SFR_OPT_OPT_KLEN0, bar); + baz |= aes_csr.ms(utra::aes::SFR_OPT_OPT_KLEN0, 1); + aes_csr.wfo(utra::aes::SFR_OPT_OPT_KLEN0, baz); + let bar = aes_csr.rf(utra::aes::SFR_OPT_OPT_MODE0); + aes_csr.rmwf(utra::aes::SFR_OPT_OPT_MODE0, bar); + let mut baz = aes_csr.zf(utra::aes::SFR_OPT_OPT_MODE0, bar); + baz |= aes_csr.ms(utra::aes::SFR_OPT_OPT_MODE0, 1); + aes_csr.wfo(utra::aes::SFR_OPT_OPT_MODE0, baz); + let bar = aes_csr.rf(utra::aes::SFR_OPT_OPT_IFSTART0); + aes_csr.rmwf(utra::aes::SFR_OPT_OPT_IFSTART0, bar); + let mut baz = aes_csr.zf(utra::aes::SFR_OPT_OPT_IFSTART0, bar); + baz |= aes_csr.ms(utra::aes::SFR_OPT_OPT_IFSTART0, 1); + aes_csr.wfo(utra::aes::SFR_OPT_OPT_IFSTART0, baz); + + let foo = aes_csr.r(utra::aes::SFR_OPT1); + aes_csr.wo(utra::aes::SFR_OPT1, foo); + let bar = aes_csr.rf(utra::aes::SFR_OPT1_SFR_OPT1); + aes_csr.rmwf(utra::aes::SFR_OPT1_SFR_OPT1, bar); + let mut baz = aes_csr.zf(utra::aes::SFR_OPT1_SFR_OPT1, bar); + baz |= aes_csr.ms(utra::aes::SFR_OPT1_SFR_OPT1, 1); + aes_csr.wfo(utra::aes::SFR_OPT1_SFR_OPT1, baz); + + let foo = aes_csr.r(utra::aes::SFR_OPTLTX); + aes_csr.wo(utra::aes::SFR_OPTLTX, foo); + let bar = aes_csr.rf(utra::aes::SFR_OPTLTX_SFR_OPTLTX); + aes_csr.rmwf(utra::aes::SFR_OPTLTX_SFR_OPTLTX, bar); + let mut baz = aes_csr.zf(utra::aes::SFR_OPTLTX_SFR_OPTLTX, bar); + baz |= aes_csr.ms(utra::aes::SFR_OPTLTX_SFR_OPTLTX, 1); + aes_csr.wfo(utra::aes::SFR_OPTLTX_SFR_OPTLTX, baz); + + let foo = aes_csr.r(utra::aes::SFR_MASKSEED); + aes_csr.wo(utra::aes::SFR_MASKSEED, foo); + let bar = aes_csr.rf(utra::aes::SFR_MASKSEED_SFR_MASKSEED); + aes_csr.rmwf(utra::aes::SFR_MASKSEED_SFR_MASKSEED, bar); + let mut baz = aes_csr.zf(utra::aes::SFR_MASKSEED_SFR_MASKSEED, bar); + baz |= aes_csr.ms(utra::aes::SFR_MASKSEED_SFR_MASKSEED, 1); + aes_csr.wfo(utra::aes::SFR_MASKSEED_SFR_MASKSEED, baz); + + let foo = aes_csr.r(utra::aes::SFR_MASKSEEDAR); + aes_csr.wo(utra::aes::SFR_MASKSEEDAR, foo); + let bar = aes_csr.rf(utra::aes::SFR_MASKSEEDAR_SFR_MASKSEEDAR); + aes_csr.rmwf(utra::aes::SFR_MASKSEEDAR_SFR_MASKSEEDAR, bar); + let mut baz = aes_csr.zf(utra::aes::SFR_MASKSEEDAR_SFR_MASKSEEDAR, bar); + baz |= aes_csr.ms(utra::aes::SFR_MASKSEEDAR_SFR_MASKSEEDAR, 1); + aes_csr.wfo(utra::aes::SFR_MASKSEEDAR_SFR_MASKSEEDAR, baz); + + let foo = aes_csr.r(utra::aes::SFR_SEGPTR_PTRID_IV); + aes_csr.wo(utra::aes::SFR_SEGPTR_PTRID_IV, foo); + let bar = aes_csr.rf(utra::aes::SFR_SEGPTR_PTRID_IV_PTRID_IV); + aes_csr.rmwf(utra::aes::SFR_SEGPTR_PTRID_IV_PTRID_IV, bar); + let mut baz = aes_csr.zf(utra::aes::SFR_SEGPTR_PTRID_IV_PTRID_IV, bar); + baz |= aes_csr.ms(utra::aes::SFR_SEGPTR_PTRID_IV_PTRID_IV, 1); + aes_csr.wfo(utra::aes::SFR_SEGPTR_PTRID_IV_PTRID_IV, baz); + + let foo = aes_csr.r(utra::aes::SFR_SEGPTR_PTRID_AKEY); + aes_csr.wo(utra::aes::SFR_SEGPTR_PTRID_AKEY, foo); + let bar = aes_csr.rf(utra::aes::SFR_SEGPTR_PTRID_AKEY_PTRID_AKEY); + aes_csr.rmwf(utra::aes::SFR_SEGPTR_PTRID_AKEY_PTRID_AKEY, bar); + let mut baz = aes_csr.zf(utra::aes::SFR_SEGPTR_PTRID_AKEY_PTRID_AKEY, bar); + baz |= aes_csr.ms(utra::aes::SFR_SEGPTR_PTRID_AKEY_PTRID_AKEY, 1); + aes_csr.wfo(utra::aes::SFR_SEGPTR_PTRID_AKEY_PTRID_AKEY, baz); + + let foo = aes_csr.r(utra::aes::SFR_SEGPTR_PTRID_AIB); + aes_csr.wo(utra::aes::SFR_SEGPTR_PTRID_AIB, foo); + let bar = aes_csr.rf(utra::aes::SFR_SEGPTR_PTRID_AIB_PTRID_AIB); + aes_csr.rmwf(utra::aes::SFR_SEGPTR_PTRID_AIB_PTRID_AIB, bar); + let mut baz = aes_csr.zf(utra::aes::SFR_SEGPTR_PTRID_AIB_PTRID_AIB, bar); + baz |= aes_csr.ms(utra::aes::SFR_SEGPTR_PTRID_AIB_PTRID_AIB, 1); + aes_csr.wfo(utra::aes::SFR_SEGPTR_PTRID_AIB_PTRID_AIB, baz); + + let foo = aes_csr.r(utra::aes::SFR_SEGPTR_PTRID_AOB); + aes_csr.wo(utra::aes::SFR_SEGPTR_PTRID_AOB, foo); + let bar = aes_csr.rf(utra::aes::SFR_SEGPTR_PTRID_AOB_PTRID_AOB); + aes_csr.rmwf(utra::aes::SFR_SEGPTR_PTRID_AOB_PTRID_AOB, bar); + let mut baz = aes_csr.zf(utra::aes::SFR_SEGPTR_PTRID_AOB_PTRID_AOB, bar); + baz |= aes_csr.ms(utra::aes::SFR_SEGPTR_PTRID_AOB_PTRID_AOB, 1); + aes_csr.wfo(utra::aes::SFR_SEGPTR_PTRID_AOB_PTRID_AOB, baz); + } + + #[test] + #[ignore] + fn compile_check_combohash_csr() { + use super::*; + let mut combohash_csr = CSR::new(HW_COMBOHASH_BASE as *mut u32); + + let foo = combohash_csr.r(utra::combohash::SFR_CRFUNC); + combohash_csr.wo(utra::combohash::SFR_CRFUNC, foo); + let bar = combohash_csr.rf(utra::combohash::SFR_CRFUNC_CR_FUNC); + combohash_csr.rmwf(utra::combohash::SFR_CRFUNC_CR_FUNC, bar); + let mut baz = combohash_csr.zf(utra::combohash::SFR_CRFUNC_CR_FUNC, bar); + baz |= combohash_csr.ms(utra::combohash::SFR_CRFUNC_CR_FUNC, 1); + combohash_csr.wfo(utra::combohash::SFR_CRFUNC_CR_FUNC, baz); + + let foo = combohash_csr.r(utra::combohash::SFR_AR); + combohash_csr.wo(utra::combohash::SFR_AR, foo); + let bar = combohash_csr.rf(utra::combohash::SFR_AR_SFR_AR); + combohash_csr.rmwf(utra::combohash::SFR_AR_SFR_AR, bar); + let mut baz = combohash_csr.zf(utra::combohash::SFR_AR_SFR_AR, bar); + baz |= combohash_csr.ms(utra::combohash::SFR_AR_SFR_AR, 1); + combohash_csr.wfo(utra::combohash::SFR_AR_SFR_AR, baz); + + let foo = combohash_csr.r(utra::combohash::SFR_SRMFSM); + combohash_csr.wo(utra::combohash::SFR_SRMFSM, foo); + let bar = combohash_csr.rf(utra::combohash::SFR_SRMFSM_MFSM); + combohash_csr.rmwf(utra::combohash::SFR_SRMFSM_MFSM, bar); + let mut baz = combohash_csr.zf(utra::combohash::SFR_SRMFSM_MFSM, bar); + baz |= combohash_csr.ms(utra::combohash::SFR_SRMFSM_MFSM, 1); + combohash_csr.wfo(utra::combohash::SFR_SRMFSM_MFSM, baz); + + let foo = combohash_csr.r(utra::combohash::SFR_FR); + combohash_csr.wo(utra::combohash::SFR_FR, foo); + let bar = combohash_csr.rf(utra::combohash::SFR_FR_MFSM_DONE); + combohash_csr.rmwf(utra::combohash::SFR_FR_MFSM_DONE, bar); + let mut baz = combohash_csr.zf(utra::combohash::SFR_FR_MFSM_DONE, bar); + baz |= combohash_csr.ms(utra::combohash::SFR_FR_MFSM_DONE, 1); + combohash_csr.wfo(utra::combohash::SFR_FR_MFSM_DONE, baz); + let bar = combohash_csr.rf(utra::combohash::SFR_FR_HASH_DONE); + combohash_csr.rmwf(utra::combohash::SFR_FR_HASH_DONE, bar); + let mut baz = combohash_csr.zf(utra::combohash::SFR_FR_HASH_DONE, bar); + baz |= combohash_csr.ms(utra::combohash::SFR_FR_HASH_DONE, 1); + combohash_csr.wfo(utra::combohash::SFR_FR_HASH_DONE, baz); + let bar = combohash_csr.rf(utra::combohash::SFR_FR_CHNLO_DONE); + combohash_csr.rmwf(utra::combohash::SFR_FR_CHNLO_DONE, bar); + let mut baz = combohash_csr.zf(utra::combohash::SFR_FR_CHNLO_DONE, bar); + baz |= combohash_csr.ms(utra::combohash::SFR_FR_CHNLO_DONE, 1); + combohash_csr.wfo(utra::combohash::SFR_FR_CHNLO_DONE, baz); + let bar = combohash_csr.rf(utra::combohash::SFR_FR_CHNLI_DONE); + combohash_csr.rmwf(utra::combohash::SFR_FR_CHNLI_DONE, bar); + let mut baz = combohash_csr.zf(utra::combohash::SFR_FR_CHNLI_DONE, bar); + baz |= combohash_csr.ms(utra::combohash::SFR_FR_CHNLI_DONE, 1); + combohash_csr.wfo(utra::combohash::SFR_FR_CHNLI_DONE, baz); + let bar = combohash_csr.rf(utra::combohash::SFR_FR_CHKDONE); + combohash_csr.rmwf(utra::combohash::SFR_FR_CHKDONE, bar); + let mut baz = combohash_csr.zf(utra::combohash::SFR_FR_CHKDONE, bar); + baz |= combohash_csr.ms(utra::combohash::SFR_FR_CHKDONE, 1); + combohash_csr.wfo(utra::combohash::SFR_FR_CHKDONE, baz); + let bar = combohash_csr.rf(utra::combohash::SFR_FR_CHKPASS); + combohash_csr.rmwf(utra::combohash::SFR_FR_CHKPASS, bar); + let mut baz = combohash_csr.zf(utra::combohash::SFR_FR_CHKPASS, bar); + baz |= combohash_csr.ms(utra::combohash::SFR_FR_CHKPASS, 1); + combohash_csr.wfo(utra::combohash::SFR_FR_CHKPASS, baz); + + let foo = combohash_csr.r(utra::combohash::SFR_OPT1); + combohash_csr.wo(utra::combohash::SFR_OPT1, foo); + let bar = combohash_csr.rf(utra::combohash::SFR_OPT1_CR_OPT_HASHCNT); + combohash_csr.rmwf(utra::combohash::SFR_OPT1_CR_OPT_HASHCNT, bar); + let mut baz = combohash_csr.zf(utra::combohash::SFR_OPT1_CR_OPT_HASHCNT, bar); + baz |= combohash_csr.ms(utra::combohash::SFR_OPT1_CR_OPT_HASHCNT, 1); + combohash_csr.wfo(utra::combohash::SFR_OPT1_CR_OPT_HASHCNT, baz); + + let foo = combohash_csr.r(utra::combohash::SFR_OPT2); + combohash_csr.wo(utra::combohash::SFR_OPT2, foo); + let bar = combohash_csr.rf(utra::combohash::SFR_OPT2_CR_OPT_SCRTCHK); + combohash_csr.rmwf(utra::combohash::SFR_OPT2_CR_OPT_SCRTCHK, bar); + let mut baz = combohash_csr.zf(utra::combohash::SFR_OPT2_CR_OPT_SCRTCHK, bar); + baz |= combohash_csr.ms(utra::combohash::SFR_OPT2_CR_OPT_SCRTCHK, 1); + combohash_csr.wfo(utra::combohash::SFR_OPT2_CR_OPT_SCRTCHK, baz); + let bar = combohash_csr.rf(utra::combohash::SFR_OPT2_CR_OPT_IFSOB); + combohash_csr.rmwf(utra::combohash::SFR_OPT2_CR_OPT_IFSOB, bar); + let mut baz = combohash_csr.zf(utra::combohash::SFR_OPT2_CR_OPT_IFSOB, bar); + baz |= combohash_csr.ms(utra::combohash::SFR_OPT2_CR_OPT_IFSOB, 1); + combohash_csr.wfo(utra::combohash::SFR_OPT2_CR_OPT_IFSOB, baz); + let bar = combohash_csr.rf(utra::combohash::SFR_OPT2_CR_OPT_IFSTART); + combohash_csr.rmwf(utra::combohash::SFR_OPT2_CR_OPT_IFSTART, bar); + let mut baz = combohash_csr.zf(utra::combohash::SFR_OPT2_CR_OPT_IFSTART, bar); + baz |= combohash_csr.ms(utra::combohash::SFR_OPT2_CR_OPT_IFSTART, 1); + combohash_csr.wfo(utra::combohash::SFR_OPT2_CR_OPT_IFSTART, baz); + let bar = combohash_csr.rf(utra::combohash::SFR_OPT2_OPT_SCHNR1_0); + combohash_csr.rmwf(utra::combohash::SFR_OPT2_OPT_SCHNR1_0, bar); + let mut baz = combohash_csr.zf(utra::combohash::SFR_OPT2_OPT_SCHNR1_0, bar); + baz |= combohash_csr.ms(utra::combohash::SFR_OPT2_OPT_SCHNR1_0, 1); + combohash_csr.wfo(utra::combohash::SFR_OPT2_OPT_SCHNR1_0, baz); + + let foo = combohash_csr.r(utra::combohash::SFR_OPT3); + combohash_csr.wo(utra::combohash::SFR_OPT3, foo); + let bar = combohash_csr.rf(utra::combohash::SFR_OPT3_SFR_OPT3); + combohash_csr.rmwf(utra::combohash::SFR_OPT3_SFR_OPT3, bar); + let mut baz = combohash_csr.zf(utra::combohash::SFR_OPT3_SFR_OPT3, bar); + baz |= combohash_csr.ms(utra::combohash::SFR_OPT3_SFR_OPT3, 1); + combohash_csr.wfo(utra::combohash::SFR_OPT3_SFR_OPT3, baz); + + let foo = combohash_csr.r(utra::combohash::SFR_BLKT0); + combohash_csr.wo(utra::combohash::SFR_BLKT0, foo); + let bar = combohash_csr.rf(utra::combohash::SFR_BLKT0_SFR_BLKT0); + combohash_csr.rmwf(utra::combohash::SFR_BLKT0_SFR_BLKT0, bar); + let mut baz = combohash_csr.zf(utra::combohash::SFR_BLKT0_SFR_BLKT0, bar); + baz |= combohash_csr.ms(utra::combohash::SFR_BLKT0_SFR_BLKT0, 1); + combohash_csr.wfo(utra::combohash::SFR_BLKT0_SFR_BLKT0, baz); + + let foo = combohash_csr.r(utra::combohash::SFR_SEGPTR_SEGID_LKEY); + combohash_csr.wo(utra::combohash::SFR_SEGPTR_SEGID_LKEY, foo); + let bar = combohash_csr.rf(utra::combohash::SFR_SEGPTR_SEGID_LKEY_SEGID_LKEY); + combohash_csr.rmwf(utra::combohash::SFR_SEGPTR_SEGID_LKEY_SEGID_LKEY, bar); + let mut baz = combohash_csr.zf(utra::combohash::SFR_SEGPTR_SEGID_LKEY_SEGID_LKEY, bar); + baz |= combohash_csr.ms(utra::combohash::SFR_SEGPTR_SEGID_LKEY_SEGID_LKEY, 1); + combohash_csr.wfo(utra::combohash::SFR_SEGPTR_SEGID_LKEY_SEGID_LKEY, baz); + + let foo = combohash_csr.r(utra::combohash::SFR_SEGPTR_SEGID_KEY); + combohash_csr.wo(utra::combohash::SFR_SEGPTR_SEGID_KEY, foo); + let bar = combohash_csr.rf(utra::combohash::SFR_SEGPTR_SEGID_KEY_SEGID_KEY); + combohash_csr.rmwf(utra::combohash::SFR_SEGPTR_SEGID_KEY_SEGID_KEY, bar); + let mut baz = combohash_csr.zf(utra::combohash::SFR_SEGPTR_SEGID_KEY_SEGID_KEY, bar); + baz |= combohash_csr.ms(utra::combohash::SFR_SEGPTR_SEGID_KEY_SEGID_KEY, 1); + combohash_csr.wfo(utra::combohash::SFR_SEGPTR_SEGID_KEY_SEGID_KEY, baz); + + let foo = combohash_csr.r(utra::combohash::SFR_SEGPTR_SEGID_SCRT); + combohash_csr.wo(utra::combohash::SFR_SEGPTR_SEGID_SCRT, foo); + let bar = combohash_csr.rf(utra::combohash::SFR_SEGPTR_SEGID_SCRT_SEGID_SCRT); + combohash_csr.rmwf(utra::combohash::SFR_SEGPTR_SEGID_SCRT_SEGID_SCRT, bar); + let mut baz = combohash_csr.zf(utra::combohash::SFR_SEGPTR_SEGID_SCRT_SEGID_SCRT, bar); + baz |= combohash_csr.ms(utra::combohash::SFR_SEGPTR_SEGID_SCRT_SEGID_SCRT, 1); + combohash_csr.wfo(utra::combohash::SFR_SEGPTR_SEGID_SCRT_SEGID_SCRT, baz); + + let foo = combohash_csr.r(utra::combohash::SFR_SEGPTR_SEGID_MSG); + combohash_csr.wo(utra::combohash::SFR_SEGPTR_SEGID_MSG, foo); + let bar = combohash_csr.rf(utra::combohash::SFR_SEGPTR_SEGID_MSG_SEGID_MSG); + combohash_csr.rmwf(utra::combohash::SFR_SEGPTR_SEGID_MSG_SEGID_MSG, bar); + let mut baz = combohash_csr.zf(utra::combohash::SFR_SEGPTR_SEGID_MSG_SEGID_MSG, bar); + baz |= combohash_csr.ms(utra::combohash::SFR_SEGPTR_SEGID_MSG_SEGID_MSG, 1); + combohash_csr.wfo(utra::combohash::SFR_SEGPTR_SEGID_MSG_SEGID_MSG, baz); + + let foo = combohash_csr.r(utra::combohash::SFR_SEGPTR_SEGID_HOUT); + combohash_csr.wo(utra::combohash::SFR_SEGPTR_SEGID_HOUT, foo); + let bar = combohash_csr.rf(utra::combohash::SFR_SEGPTR_SEGID_HOUT_SEGID_HOUT); + combohash_csr.rmwf(utra::combohash::SFR_SEGPTR_SEGID_HOUT_SEGID_HOUT, bar); + let mut baz = combohash_csr.zf(utra::combohash::SFR_SEGPTR_SEGID_HOUT_SEGID_HOUT, bar); + baz |= combohash_csr.ms(utra::combohash::SFR_SEGPTR_SEGID_HOUT_SEGID_HOUT, 1); + combohash_csr.wfo(utra::combohash::SFR_SEGPTR_SEGID_HOUT_SEGID_HOUT, baz); + + let foo = combohash_csr.r(utra::combohash::SFR_SEGPTR_SEGID_HOUT2); + combohash_csr.wo(utra::combohash::SFR_SEGPTR_SEGID_HOUT2, foo); + let bar = combohash_csr.rf(utra::combohash::SFR_SEGPTR_SEGID_HOUT2_SEGID_HOUT2); + combohash_csr.rmwf(utra::combohash::SFR_SEGPTR_SEGID_HOUT2_SEGID_HOUT2, bar); + let mut baz = combohash_csr.zf(utra::combohash::SFR_SEGPTR_SEGID_HOUT2_SEGID_HOUT2, bar); + baz |= combohash_csr.ms(utra::combohash::SFR_SEGPTR_SEGID_HOUT2_SEGID_HOUT2, 1); + combohash_csr.wfo(utra::combohash::SFR_SEGPTR_SEGID_HOUT2_SEGID_HOUT2, baz); + } + + #[test] + #[ignore] + fn compile_check_pke_csr() { + use super::*; + let mut pke_csr = CSR::new(HW_PKE_BASE as *mut u32); + + let foo = pke_csr.r(utra::pke::SFR_CRFUNC); + pke_csr.wo(utra::pke::SFR_CRFUNC, foo); + let bar = pke_csr.rf(utra::pke::SFR_CRFUNC_CR_FUNC); + pke_csr.rmwf(utra::pke::SFR_CRFUNC_CR_FUNC, bar); + let mut baz = pke_csr.zf(utra::pke::SFR_CRFUNC_CR_FUNC, bar); + baz |= pke_csr.ms(utra::pke::SFR_CRFUNC_CR_FUNC, 1); + pke_csr.wfo(utra::pke::SFR_CRFUNC_CR_FUNC, baz); + let bar = pke_csr.rf(utra::pke::SFR_CRFUNC_CR_PCOREIR); + pke_csr.rmwf(utra::pke::SFR_CRFUNC_CR_PCOREIR, bar); + let mut baz = pke_csr.zf(utra::pke::SFR_CRFUNC_CR_PCOREIR, bar); + baz |= pke_csr.ms(utra::pke::SFR_CRFUNC_CR_PCOREIR, 1); + pke_csr.wfo(utra::pke::SFR_CRFUNC_CR_PCOREIR, baz); + + let foo = pke_csr.r(utra::pke::SFR_AR); + pke_csr.wo(utra::pke::SFR_AR, foo); + let bar = pke_csr.rf(utra::pke::SFR_AR_SFR_AR); + pke_csr.rmwf(utra::pke::SFR_AR_SFR_AR, bar); + let mut baz = pke_csr.zf(utra::pke::SFR_AR_SFR_AR, bar); + baz |= pke_csr.ms(utra::pke::SFR_AR_SFR_AR, 1); + pke_csr.wfo(utra::pke::SFR_AR_SFR_AR, baz); + + let foo = pke_csr.r(utra::pke::SFR_SRMFSM); + pke_csr.wo(utra::pke::SFR_SRMFSM, foo); + let bar = pke_csr.rf(utra::pke::SFR_SRMFSM_MFSM); + pke_csr.rmwf(utra::pke::SFR_SRMFSM_MFSM, bar); + let mut baz = pke_csr.zf(utra::pke::SFR_SRMFSM_MFSM, bar); + baz |= pke_csr.ms(utra::pke::SFR_SRMFSM_MFSM, 1); + pke_csr.wfo(utra::pke::SFR_SRMFSM_MFSM, baz); + let bar = pke_csr.rf(utra::pke::SFR_SRMFSM_MODINVREADY); + pke_csr.rmwf(utra::pke::SFR_SRMFSM_MODINVREADY, bar); + let mut baz = pke_csr.zf(utra::pke::SFR_SRMFSM_MODINVREADY, bar); + baz |= pke_csr.ms(utra::pke::SFR_SRMFSM_MODINVREADY, 1); + pke_csr.wfo(utra::pke::SFR_SRMFSM_MODINVREADY, baz); + + let foo = pke_csr.r(utra::pke::SFR_FR); + pke_csr.wo(utra::pke::SFR_FR, foo); + let bar = pke_csr.rf(utra::pke::SFR_FR_MFSM_DONE); + pke_csr.rmwf(utra::pke::SFR_FR_MFSM_DONE, bar); + let mut baz = pke_csr.zf(utra::pke::SFR_FR_MFSM_DONE, bar); + baz |= pke_csr.ms(utra::pke::SFR_FR_MFSM_DONE, 1); + pke_csr.wfo(utra::pke::SFR_FR_MFSM_DONE, baz); + let bar = pke_csr.rf(utra::pke::SFR_FR_PCORE_DONE); + pke_csr.rmwf(utra::pke::SFR_FR_PCORE_DONE, bar); + let mut baz = pke_csr.zf(utra::pke::SFR_FR_PCORE_DONE, bar); + baz |= pke_csr.ms(utra::pke::SFR_FR_PCORE_DONE, 1); + pke_csr.wfo(utra::pke::SFR_FR_PCORE_DONE, baz); + let bar = pke_csr.rf(utra::pke::SFR_FR_CHNLO_DONE); + pke_csr.rmwf(utra::pke::SFR_FR_CHNLO_DONE, bar); + let mut baz = pke_csr.zf(utra::pke::SFR_FR_CHNLO_DONE, bar); + baz |= pke_csr.ms(utra::pke::SFR_FR_CHNLO_DONE, 1); + pke_csr.wfo(utra::pke::SFR_FR_CHNLO_DONE, baz); + let bar = pke_csr.rf(utra::pke::SFR_FR_CHNLI_DONE); + pke_csr.rmwf(utra::pke::SFR_FR_CHNLI_DONE, bar); + let mut baz = pke_csr.zf(utra::pke::SFR_FR_CHNLI_DONE, bar); + baz |= pke_csr.ms(utra::pke::SFR_FR_CHNLI_DONE, 1); + pke_csr.wfo(utra::pke::SFR_FR_CHNLI_DONE, baz); + let bar = pke_csr.rf(utra::pke::SFR_FR_CHNLX_DONE); + pke_csr.rmwf(utra::pke::SFR_FR_CHNLX_DONE, bar); + let mut baz = pke_csr.zf(utra::pke::SFR_FR_CHNLX_DONE, bar); + baz |= pke_csr.ms(utra::pke::SFR_FR_CHNLX_DONE, 1); + pke_csr.wfo(utra::pke::SFR_FR_CHNLX_DONE, baz); + + let foo = pke_csr.r(utra::pke::SFR_OPTNW); + pke_csr.wo(utra::pke::SFR_OPTNW, foo); + let bar = pke_csr.rf(utra::pke::SFR_OPTNW_SFR_OPTNW); + pke_csr.rmwf(utra::pke::SFR_OPTNW_SFR_OPTNW, bar); + let mut baz = pke_csr.zf(utra::pke::SFR_OPTNW_SFR_OPTNW, bar); + baz |= pke_csr.ms(utra::pke::SFR_OPTNW_SFR_OPTNW, 1); + pke_csr.wfo(utra::pke::SFR_OPTNW_SFR_OPTNW, baz); + + let foo = pke_csr.r(utra::pke::SFR_OPTEW); + pke_csr.wo(utra::pke::SFR_OPTEW, foo); + let bar = pke_csr.rf(utra::pke::SFR_OPTEW_SFR_OPTEW); + pke_csr.rmwf(utra::pke::SFR_OPTEW_SFR_OPTEW, bar); + let mut baz = pke_csr.zf(utra::pke::SFR_OPTEW_SFR_OPTEW, bar); + baz |= pke_csr.ms(utra::pke::SFR_OPTEW_SFR_OPTEW, 1); + pke_csr.wfo(utra::pke::SFR_OPTEW_SFR_OPTEW, baz); + + let foo = pke_csr.r(utra::pke::SFR_OPTRW); + pke_csr.wo(utra::pke::SFR_OPTRW, foo); + let bar = pke_csr.rf(utra::pke::SFR_OPTRW_SFR_OPTRW); + pke_csr.rmwf(utra::pke::SFR_OPTRW_SFR_OPTRW, bar); + let mut baz = pke_csr.zf(utra::pke::SFR_OPTRW_SFR_OPTRW, bar); + baz |= pke_csr.ms(utra::pke::SFR_OPTRW_SFR_OPTRW, 1); + pke_csr.wfo(utra::pke::SFR_OPTRW_SFR_OPTRW, baz); + + let foo = pke_csr.r(utra::pke::SFR_OPTLTX); + pke_csr.wo(utra::pke::SFR_OPTLTX, foo); + let bar = pke_csr.rf(utra::pke::SFR_OPTLTX_SFR_OPTLTX); + pke_csr.rmwf(utra::pke::SFR_OPTLTX_SFR_OPTLTX, bar); + let mut baz = pke_csr.zf(utra::pke::SFR_OPTLTX_SFR_OPTLTX, bar); + baz |= pke_csr.ms(utra::pke::SFR_OPTLTX_SFR_OPTLTX, 1); + pke_csr.wfo(utra::pke::SFR_OPTLTX_SFR_OPTLTX, baz); + + let foo = pke_csr.r(utra::pke::SFR_OPTMASK); + pke_csr.wo(utra::pke::SFR_OPTMASK, foo); + let bar = pke_csr.rf(utra::pke::SFR_OPTMASK_SFR_OPTMASK); + pke_csr.rmwf(utra::pke::SFR_OPTMASK_SFR_OPTMASK, bar); + let mut baz = pke_csr.zf(utra::pke::SFR_OPTMASK_SFR_OPTMASK, bar); + baz |= pke_csr.ms(utra::pke::SFR_OPTMASK_SFR_OPTMASK, 1); + pke_csr.wfo(utra::pke::SFR_OPTMASK_SFR_OPTMASK, baz); + + let foo = pke_csr.r(utra::pke::SFR_MIMMCR); + pke_csr.wo(utra::pke::SFR_MIMMCR, foo); + let bar = pke_csr.rf(utra::pke::SFR_MIMMCR_SFR_MIMMCR); + pke_csr.rmwf(utra::pke::SFR_MIMMCR_SFR_MIMMCR, bar); + let mut baz = pke_csr.zf(utra::pke::SFR_MIMMCR_SFR_MIMMCR, bar); + baz |= pke_csr.ms(utra::pke::SFR_MIMMCR_SFR_MIMMCR, 1); + pke_csr.wfo(utra::pke::SFR_MIMMCR_SFR_MIMMCR, baz); + + let foo = pke_csr.r(utra::pke::SFR_SEGPTR_PTRID_PCON); + pke_csr.wo(utra::pke::SFR_SEGPTR_PTRID_PCON, foo); + let bar = pke_csr.rf(utra::pke::SFR_SEGPTR_PTRID_PCON_PTRID_PCON); + pke_csr.rmwf(utra::pke::SFR_SEGPTR_PTRID_PCON_PTRID_PCON, bar); + let mut baz = pke_csr.zf(utra::pke::SFR_SEGPTR_PTRID_PCON_PTRID_PCON, bar); + baz |= pke_csr.ms(utra::pke::SFR_SEGPTR_PTRID_PCON_PTRID_PCON, 1); + pke_csr.wfo(utra::pke::SFR_SEGPTR_PTRID_PCON_PTRID_PCON, baz); + + let foo = pke_csr.r(utra::pke::SFR_SEGPTR_PTRID_PIB0); + pke_csr.wo(utra::pke::SFR_SEGPTR_PTRID_PIB0, foo); + let bar = pke_csr.rf(utra::pke::SFR_SEGPTR_PTRID_PIB0_PTRID_PIB0); + pke_csr.rmwf(utra::pke::SFR_SEGPTR_PTRID_PIB0_PTRID_PIB0, bar); + let mut baz = pke_csr.zf(utra::pke::SFR_SEGPTR_PTRID_PIB0_PTRID_PIB0, bar); + baz |= pke_csr.ms(utra::pke::SFR_SEGPTR_PTRID_PIB0_PTRID_PIB0, 1); + pke_csr.wfo(utra::pke::SFR_SEGPTR_PTRID_PIB0_PTRID_PIB0, baz); + + let foo = pke_csr.r(utra::pke::SFR_SEGPTR_PTRID_PIB1); + pke_csr.wo(utra::pke::SFR_SEGPTR_PTRID_PIB1, foo); + let bar = pke_csr.rf(utra::pke::SFR_SEGPTR_PTRID_PIB1_PTRID_PIB1); + pke_csr.rmwf(utra::pke::SFR_SEGPTR_PTRID_PIB1_PTRID_PIB1, bar); + let mut baz = pke_csr.zf(utra::pke::SFR_SEGPTR_PTRID_PIB1_PTRID_PIB1, bar); + baz |= pke_csr.ms(utra::pke::SFR_SEGPTR_PTRID_PIB1_PTRID_PIB1, 1); + pke_csr.wfo(utra::pke::SFR_SEGPTR_PTRID_PIB1_PTRID_PIB1, baz); + + let foo = pke_csr.r(utra::pke::SFR_SEGPTR_PTRID_PKB); + pke_csr.wo(utra::pke::SFR_SEGPTR_PTRID_PKB, foo); + let bar = pke_csr.rf(utra::pke::SFR_SEGPTR_PTRID_PKB_PTRID_PKB); + pke_csr.rmwf(utra::pke::SFR_SEGPTR_PTRID_PKB_PTRID_PKB, bar); + let mut baz = pke_csr.zf(utra::pke::SFR_SEGPTR_PTRID_PKB_PTRID_PKB, bar); + baz |= pke_csr.ms(utra::pke::SFR_SEGPTR_PTRID_PKB_PTRID_PKB, 1); + pke_csr.wfo(utra::pke::SFR_SEGPTR_PTRID_PKB_PTRID_PKB, baz); + + let foo = pke_csr.r(utra::pke::SFR_SEGPTR_PTRID_POB); + pke_csr.wo(utra::pke::SFR_SEGPTR_PTRID_POB, foo); + let bar = pke_csr.rf(utra::pke::SFR_SEGPTR_PTRID_POB_PTRID_POB); + pke_csr.rmwf(utra::pke::SFR_SEGPTR_PTRID_POB_PTRID_POB, bar); + let mut baz = pke_csr.zf(utra::pke::SFR_SEGPTR_PTRID_POB_PTRID_POB, bar); + baz |= pke_csr.ms(utra::pke::SFR_SEGPTR_PTRID_POB_PTRID_POB, 1); + pke_csr.wfo(utra::pke::SFR_SEGPTR_PTRID_POB_PTRID_POB, baz); + } + + #[test] + #[ignore] + fn compile_check_trng_csr() { + use super::*; + let mut trng_csr = CSR::new(HW_TRNG_BASE as *mut u32); + + let foo = trng_csr.r(utra::trng::SFR_CRSRC); + trng_csr.wo(utra::trng::SFR_CRSRC, foo); + let bar = trng_csr.rf(utra::trng::SFR_CRSRC_SFR_CRSRC); + trng_csr.rmwf(utra::trng::SFR_CRSRC_SFR_CRSRC, bar); + let mut baz = trng_csr.zf(utra::trng::SFR_CRSRC_SFR_CRSRC, bar); + baz |= trng_csr.ms(utra::trng::SFR_CRSRC_SFR_CRSRC, 1); + trng_csr.wfo(utra::trng::SFR_CRSRC_SFR_CRSRC, baz); + + let foo = trng_csr.r(utra::trng::SFR_CRANA); + trng_csr.wo(utra::trng::SFR_CRANA, foo); + let bar = trng_csr.rf(utra::trng::SFR_CRANA_SFR_CRANA); + trng_csr.rmwf(utra::trng::SFR_CRANA_SFR_CRANA, bar); + let mut baz = trng_csr.zf(utra::trng::SFR_CRANA_SFR_CRANA, bar); + baz |= trng_csr.ms(utra::trng::SFR_CRANA_SFR_CRANA, 1); + trng_csr.wfo(utra::trng::SFR_CRANA_SFR_CRANA, baz); + + let foo = trng_csr.r(utra::trng::SFR_PP); + trng_csr.wo(utra::trng::SFR_PP, foo); + let bar = trng_csr.rf(utra::trng::SFR_PP_SFR_PP); + trng_csr.rmwf(utra::trng::SFR_PP_SFR_PP, bar); + let mut baz = trng_csr.zf(utra::trng::SFR_PP_SFR_PP, bar); + baz |= trng_csr.ms(utra::trng::SFR_PP_SFR_PP, 1); + trng_csr.wfo(utra::trng::SFR_PP_SFR_PP, baz); + + let foo = trng_csr.r(utra::trng::SFR_OPT); + trng_csr.wo(utra::trng::SFR_OPT, foo); + let bar = trng_csr.rf(utra::trng::SFR_OPT_SFR_OPT); + trng_csr.rmwf(utra::trng::SFR_OPT_SFR_OPT, bar); + let mut baz = trng_csr.zf(utra::trng::SFR_OPT_SFR_OPT, bar); + baz |= trng_csr.ms(utra::trng::SFR_OPT_SFR_OPT, 1); + trng_csr.wfo(utra::trng::SFR_OPT_SFR_OPT, baz); + + let foo = trng_csr.r(utra::trng::SFR_SR); + trng_csr.wo(utra::trng::SFR_SR, foo); + let bar = trng_csr.rf(utra::trng::SFR_SR_SR_RNG); + trng_csr.rmwf(utra::trng::SFR_SR_SR_RNG, bar); + let mut baz = trng_csr.zf(utra::trng::SFR_SR_SR_RNG, bar); + baz |= trng_csr.ms(utra::trng::SFR_SR_SR_RNG, 1); + trng_csr.wfo(utra::trng::SFR_SR_SR_RNG, baz); + + let foo = trng_csr.r(utra::trng::SFR_AR_GEN); + trng_csr.wo(utra::trng::SFR_AR_GEN, foo); + let bar = trng_csr.rf(utra::trng::SFR_AR_GEN_SFR_AR_GEN); + trng_csr.rmwf(utra::trng::SFR_AR_GEN_SFR_AR_GEN, bar); + let mut baz = trng_csr.zf(utra::trng::SFR_AR_GEN_SFR_AR_GEN, bar); + baz |= trng_csr.ms(utra::trng::SFR_AR_GEN_SFR_AR_GEN, 1); + trng_csr.wfo(utra::trng::SFR_AR_GEN_SFR_AR_GEN, baz); + + let foo = trng_csr.r(utra::trng::SFR_FR); + trng_csr.wo(utra::trng::SFR_FR, foo); + let bar = trng_csr.rf(utra::trng::SFR_FR_SFR_FR); + trng_csr.rmwf(utra::trng::SFR_FR_SFR_FR, bar); + let mut baz = trng_csr.zf(utra::trng::SFR_FR_SFR_FR, bar); + baz |= trng_csr.ms(utra::trng::SFR_FR_SFR_FR, 1); + trng_csr.wfo(utra::trng::SFR_FR_SFR_FR, baz); + + let foo = trng_csr.r(utra::trng::SFR_DRPSZ); + trng_csr.wo(utra::trng::SFR_DRPSZ, foo); + let bar = trng_csr.rf(utra::trng::SFR_DRPSZ_SFR_DRPSZ); + trng_csr.rmwf(utra::trng::SFR_DRPSZ_SFR_DRPSZ, bar); + let mut baz = trng_csr.zf(utra::trng::SFR_DRPSZ_SFR_DRPSZ, bar); + baz |= trng_csr.ms(utra::trng::SFR_DRPSZ_SFR_DRPSZ, 1); + trng_csr.wfo(utra::trng::SFR_DRPSZ_SFR_DRPSZ, baz); + + let foo = trng_csr.r(utra::trng::SFR_DRGEN); + trng_csr.wo(utra::trng::SFR_DRGEN, foo); + let bar = trng_csr.rf(utra::trng::SFR_DRGEN_SFR_DRGEN); + trng_csr.rmwf(utra::trng::SFR_DRGEN_SFR_DRGEN, bar); + let mut baz = trng_csr.zf(utra::trng::SFR_DRGEN_SFR_DRGEN, bar); + baz |= trng_csr.ms(utra::trng::SFR_DRGEN_SFR_DRGEN, 1); + trng_csr.wfo(utra::trng::SFR_DRGEN_SFR_DRGEN, baz); + + let foo = trng_csr.r(utra::trng::SFR_DRRESEED); + trng_csr.wo(utra::trng::SFR_DRRESEED, foo); + let bar = trng_csr.rf(utra::trng::SFR_DRRESEED_SFR_DRRESEED); + trng_csr.rmwf(utra::trng::SFR_DRRESEED_SFR_DRRESEED, bar); + let mut baz = trng_csr.zf(utra::trng::SFR_DRRESEED_SFR_DRRESEED, bar); + baz |= trng_csr.ms(utra::trng::SFR_DRRESEED_SFR_DRRESEED, 1); + trng_csr.wfo(utra::trng::SFR_DRRESEED_SFR_DRRESEED, baz); + + let foo = trng_csr.r(utra::trng::SFR_BUF); + trng_csr.wo(utra::trng::SFR_BUF, foo); + let bar = trng_csr.rf(utra::trng::SFR_BUF_SFR_BUF); + trng_csr.rmwf(utra::trng::SFR_BUF_SFR_BUF, bar); + let mut baz = trng_csr.zf(utra::trng::SFR_BUF_SFR_BUF, bar); + baz |= trng_csr.ms(utra::trng::SFR_BUF_SFR_BUF, 1); + trng_csr.wfo(utra::trng::SFR_BUF_SFR_BUF, baz); + + let foo = trng_csr.r(utra::trng::SFR_CHAIN_RNGCHAINEN0); + trng_csr.wo(utra::trng::SFR_CHAIN_RNGCHAINEN0, foo); + let bar = trng_csr.rf(utra::trng::SFR_CHAIN_RNGCHAINEN0_RNGCHAINEN0); + trng_csr.rmwf(utra::trng::SFR_CHAIN_RNGCHAINEN0_RNGCHAINEN0, bar); + let mut baz = trng_csr.zf(utra::trng::SFR_CHAIN_RNGCHAINEN0_RNGCHAINEN0, bar); + baz |= trng_csr.ms(utra::trng::SFR_CHAIN_RNGCHAINEN0_RNGCHAINEN0, 1); + trng_csr.wfo(utra::trng::SFR_CHAIN_RNGCHAINEN0_RNGCHAINEN0, baz); + + let foo = trng_csr.r(utra::trng::SFR_CHAIN_RNGCHAINEN1); + trng_csr.wo(utra::trng::SFR_CHAIN_RNGCHAINEN1, foo); + let bar = trng_csr.rf(utra::trng::SFR_CHAIN_RNGCHAINEN1_RNGCHAINEN1); + trng_csr.rmwf(utra::trng::SFR_CHAIN_RNGCHAINEN1_RNGCHAINEN1, bar); + let mut baz = trng_csr.zf(utra::trng::SFR_CHAIN_RNGCHAINEN1_RNGCHAINEN1, bar); + baz |= trng_csr.ms(utra::trng::SFR_CHAIN_RNGCHAINEN1_RNGCHAINEN1, 1); + trng_csr.wfo(utra::trng::SFR_CHAIN_RNGCHAINEN1_RNGCHAINEN1, baz); + } + + #[test] + #[ignore] + fn compile_check_scedma_csr() { + use super::*; + let mut scedma_csr = CSR::new(HW_SCEDMA_BASE as *mut u32); + + let foo = scedma_csr.r(utra::scedma::SFR_SCHSTART_AR); + scedma_csr.wo(utra::scedma::SFR_SCHSTART_AR, foo); + let bar = scedma_csr.rf(utra::scedma::SFR_SCHSTART_AR_SFR_SCHSTART_AR); + scedma_csr.rmwf(utra::scedma::SFR_SCHSTART_AR_SFR_SCHSTART_AR, bar); + let mut baz = scedma_csr.zf(utra::scedma::SFR_SCHSTART_AR_SFR_SCHSTART_AR, bar); + baz |= scedma_csr.ms(utra::scedma::SFR_SCHSTART_AR_SFR_SCHSTART_AR, 1); + scedma_csr.wfo(utra::scedma::SFR_SCHSTART_AR_SFR_SCHSTART_AR, baz); + + let foo = scedma_csr.r(utra::scedma::SFR_XCH_FUNC); + scedma_csr.wo(utra::scedma::SFR_XCH_FUNC, foo); + let bar = scedma_csr.rf(utra::scedma::SFR_XCH_FUNC_SFR_XCH_FUNC); + scedma_csr.rmwf(utra::scedma::SFR_XCH_FUNC_SFR_XCH_FUNC, bar); + let mut baz = scedma_csr.zf(utra::scedma::SFR_XCH_FUNC_SFR_XCH_FUNC, bar); + baz |= scedma_csr.ms(utra::scedma::SFR_XCH_FUNC_SFR_XCH_FUNC, 1); + scedma_csr.wfo(utra::scedma::SFR_XCH_FUNC_SFR_XCH_FUNC, baz); + + let foo = scedma_csr.r(utra::scedma::SFR_XCH_OPT); + scedma_csr.wo(utra::scedma::SFR_XCH_OPT, foo); + let bar = scedma_csr.rf(utra::scedma::SFR_XCH_OPT_SFR_XCH_OPT); + scedma_csr.rmwf(utra::scedma::SFR_XCH_OPT_SFR_XCH_OPT, bar); + let mut baz = scedma_csr.zf(utra::scedma::SFR_XCH_OPT_SFR_XCH_OPT, bar); + baz |= scedma_csr.ms(utra::scedma::SFR_XCH_OPT_SFR_XCH_OPT, 1); + scedma_csr.wfo(utra::scedma::SFR_XCH_OPT_SFR_XCH_OPT, baz); + + let foo = scedma_csr.r(utra::scedma::SFR_XCH_AXSTART); + scedma_csr.wo(utra::scedma::SFR_XCH_AXSTART, foo); + let bar = scedma_csr.rf(utra::scedma::SFR_XCH_AXSTART_SFR_XCH_AXSTART); + scedma_csr.rmwf(utra::scedma::SFR_XCH_AXSTART_SFR_XCH_AXSTART, bar); + let mut baz = scedma_csr.zf(utra::scedma::SFR_XCH_AXSTART_SFR_XCH_AXSTART, bar); + baz |= scedma_csr.ms(utra::scedma::SFR_XCH_AXSTART_SFR_XCH_AXSTART, 1); + scedma_csr.wfo(utra::scedma::SFR_XCH_AXSTART_SFR_XCH_AXSTART, baz); + + let foo = scedma_csr.r(utra::scedma::SFR_XCH_SEGID); + scedma_csr.wo(utra::scedma::SFR_XCH_SEGID, foo); + let bar = scedma_csr.rf(utra::scedma::SFR_XCH_SEGID_SFR_XCH_SEGID); + scedma_csr.rmwf(utra::scedma::SFR_XCH_SEGID_SFR_XCH_SEGID, bar); + let mut baz = scedma_csr.zf(utra::scedma::SFR_XCH_SEGID_SFR_XCH_SEGID, bar); + baz |= scedma_csr.ms(utra::scedma::SFR_XCH_SEGID_SFR_XCH_SEGID, 1); + scedma_csr.wfo(utra::scedma::SFR_XCH_SEGID_SFR_XCH_SEGID, baz); + + let foo = scedma_csr.r(utra::scedma::SFR_XCH_SEGSTART); + scedma_csr.wo(utra::scedma::SFR_XCH_SEGSTART, foo); + let bar = scedma_csr.rf(utra::scedma::SFR_XCH_SEGSTART_XCHCR_SEGSTART); + scedma_csr.rmwf(utra::scedma::SFR_XCH_SEGSTART_XCHCR_SEGSTART, bar); + let mut baz = scedma_csr.zf(utra::scedma::SFR_XCH_SEGSTART_XCHCR_SEGSTART, bar); + baz |= scedma_csr.ms(utra::scedma::SFR_XCH_SEGSTART_XCHCR_SEGSTART, 1); + scedma_csr.wfo(utra::scedma::SFR_XCH_SEGSTART_XCHCR_SEGSTART, baz); + + let foo = scedma_csr.r(utra::scedma::SFR_XCH_TRANSIZE); + scedma_csr.wo(utra::scedma::SFR_XCH_TRANSIZE, foo); + let bar = scedma_csr.rf(utra::scedma::SFR_XCH_TRANSIZE_XCHCR_TRANSIZE); + scedma_csr.rmwf(utra::scedma::SFR_XCH_TRANSIZE_XCHCR_TRANSIZE, bar); + let mut baz = scedma_csr.zf(utra::scedma::SFR_XCH_TRANSIZE_XCHCR_TRANSIZE, bar); + baz |= scedma_csr.ms(utra::scedma::SFR_XCH_TRANSIZE_XCHCR_TRANSIZE, 1); + scedma_csr.wfo(utra::scedma::SFR_XCH_TRANSIZE_XCHCR_TRANSIZE, baz); + + let foo = scedma_csr.r(utra::scedma::SFR_SCH_FUNC); + scedma_csr.wo(utra::scedma::SFR_SCH_FUNC, foo); + let bar = scedma_csr.rf(utra::scedma::SFR_SCH_FUNC_SFR_SCH_FUNC); + scedma_csr.rmwf(utra::scedma::SFR_SCH_FUNC_SFR_SCH_FUNC, bar); + let mut baz = scedma_csr.zf(utra::scedma::SFR_SCH_FUNC_SFR_SCH_FUNC, bar); + baz |= scedma_csr.ms(utra::scedma::SFR_SCH_FUNC_SFR_SCH_FUNC, 1); + scedma_csr.wfo(utra::scedma::SFR_SCH_FUNC_SFR_SCH_FUNC, baz); + + let foo = scedma_csr.r(utra::scedma::SFR_SCH_OPT); + scedma_csr.wo(utra::scedma::SFR_SCH_OPT, foo); + let bar = scedma_csr.rf(utra::scedma::SFR_SCH_OPT_SFR_SCH_OPT); + scedma_csr.rmwf(utra::scedma::SFR_SCH_OPT_SFR_SCH_OPT, bar); + let mut baz = scedma_csr.zf(utra::scedma::SFR_SCH_OPT_SFR_SCH_OPT, bar); + baz |= scedma_csr.ms(utra::scedma::SFR_SCH_OPT_SFR_SCH_OPT, 1); + scedma_csr.wfo(utra::scedma::SFR_SCH_OPT_SFR_SCH_OPT, baz); + + let foo = scedma_csr.r(utra::scedma::SFR_SCH_AXSTART); + scedma_csr.wo(utra::scedma::SFR_SCH_AXSTART, foo); + let bar = scedma_csr.rf(utra::scedma::SFR_SCH_AXSTART_SFR_SCH_AXSTART); + scedma_csr.rmwf(utra::scedma::SFR_SCH_AXSTART_SFR_SCH_AXSTART, bar); + let mut baz = scedma_csr.zf(utra::scedma::SFR_SCH_AXSTART_SFR_SCH_AXSTART, bar); + baz |= scedma_csr.ms(utra::scedma::SFR_SCH_AXSTART_SFR_SCH_AXSTART, 1); + scedma_csr.wfo(utra::scedma::SFR_SCH_AXSTART_SFR_SCH_AXSTART, baz); + + let foo = scedma_csr.r(utra::scedma::SFR_SCH_SEGID); + scedma_csr.wo(utra::scedma::SFR_SCH_SEGID, foo); + let bar = scedma_csr.rf(utra::scedma::SFR_SCH_SEGID_SFR_SCH_SEGID); + scedma_csr.rmwf(utra::scedma::SFR_SCH_SEGID_SFR_SCH_SEGID, bar); + let mut baz = scedma_csr.zf(utra::scedma::SFR_SCH_SEGID_SFR_SCH_SEGID, bar); + baz |= scedma_csr.ms(utra::scedma::SFR_SCH_SEGID_SFR_SCH_SEGID, 1); + scedma_csr.wfo(utra::scedma::SFR_SCH_SEGID_SFR_SCH_SEGID, baz); + + let foo = scedma_csr.r(utra::scedma::SFR_SCH_SEGSTART); + scedma_csr.wo(utra::scedma::SFR_SCH_SEGSTART, foo); + let bar = scedma_csr.rf(utra::scedma::SFR_SCH_SEGSTART_SCHCR_SEGSTART); + scedma_csr.rmwf(utra::scedma::SFR_SCH_SEGSTART_SCHCR_SEGSTART, bar); + let mut baz = scedma_csr.zf(utra::scedma::SFR_SCH_SEGSTART_SCHCR_SEGSTART, bar); + baz |= scedma_csr.ms(utra::scedma::SFR_SCH_SEGSTART_SCHCR_SEGSTART, 1); + scedma_csr.wfo(utra::scedma::SFR_SCH_SEGSTART_SCHCR_SEGSTART, baz); + + let foo = scedma_csr.r(utra::scedma::SFR_SCH_TRANSIZE); + scedma_csr.wo(utra::scedma::SFR_SCH_TRANSIZE, foo); + let bar = scedma_csr.rf(utra::scedma::SFR_SCH_TRANSIZE_SCHCR_TRANSIZE); + scedma_csr.rmwf(utra::scedma::SFR_SCH_TRANSIZE_SCHCR_TRANSIZE, bar); + let mut baz = scedma_csr.zf(utra::scedma::SFR_SCH_TRANSIZE_SCHCR_TRANSIZE, bar); + baz |= scedma_csr.ms(utra::scedma::SFR_SCH_TRANSIZE_SCHCR_TRANSIZE, 1); + scedma_csr.wfo(utra::scedma::SFR_SCH_TRANSIZE_SCHCR_TRANSIZE, baz); + + let foo = scedma_csr.r(utra::scedma::SFR_ICH_OPT); + scedma_csr.wo(utra::scedma::SFR_ICH_OPT, foo); + let bar = scedma_csr.rf(utra::scedma::SFR_ICH_OPT_SFR_ICH_OPT); + scedma_csr.rmwf(utra::scedma::SFR_ICH_OPT_SFR_ICH_OPT, bar); + let mut baz = scedma_csr.zf(utra::scedma::SFR_ICH_OPT_SFR_ICH_OPT, bar); + baz |= scedma_csr.ms(utra::scedma::SFR_ICH_OPT_SFR_ICH_OPT, 1); + scedma_csr.wfo(utra::scedma::SFR_ICH_OPT_SFR_ICH_OPT, baz); + + let foo = scedma_csr.r(utra::scedma::SFR_ICH_SEGID); + scedma_csr.wo(utra::scedma::SFR_ICH_SEGID, foo); + let bar = scedma_csr.rf(utra::scedma::SFR_ICH_SEGID_SFR_ICH_SEGID); + scedma_csr.rmwf(utra::scedma::SFR_ICH_SEGID_SFR_ICH_SEGID, bar); + let mut baz = scedma_csr.zf(utra::scedma::SFR_ICH_SEGID_SFR_ICH_SEGID, bar); + baz |= scedma_csr.ms(utra::scedma::SFR_ICH_SEGID_SFR_ICH_SEGID, 1); + scedma_csr.wfo(utra::scedma::SFR_ICH_SEGID_SFR_ICH_SEGID, baz); + + let foo = scedma_csr.r(utra::scedma::SFR_ICH_RPSTART); + scedma_csr.wo(utra::scedma::SFR_ICH_RPSTART, foo); + let bar = scedma_csr.rf(utra::scedma::SFR_ICH_RPSTART_ICHCR_RPSTART); + scedma_csr.rmwf(utra::scedma::SFR_ICH_RPSTART_ICHCR_RPSTART, bar); + let mut baz = scedma_csr.zf(utra::scedma::SFR_ICH_RPSTART_ICHCR_RPSTART, bar); + baz |= scedma_csr.ms(utra::scedma::SFR_ICH_RPSTART_ICHCR_RPSTART, 1); + scedma_csr.wfo(utra::scedma::SFR_ICH_RPSTART_ICHCR_RPSTART, baz); + + let foo = scedma_csr.r(utra::scedma::SFR_ICH_WPSTART); + scedma_csr.wo(utra::scedma::SFR_ICH_WPSTART, foo); + let bar = scedma_csr.rf(utra::scedma::SFR_ICH_WPSTART_ICHCR_WPSTART); + scedma_csr.rmwf(utra::scedma::SFR_ICH_WPSTART_ICHCR_WPSTART, bar); + let mut baz = scedma_csr.zf(utra::scedma::SFR_ICH_WPSTART_ICHCR_WPSTART, bar); + baz |= scedma_csr.ms(utra::scedma::SFR_ICH_WPSTART_ICHCR_WPSTART, 1); + scedma_csr.wfo(utra::scedma::SFR_ICH_WPSTART_ICHCR_WPSTART, baz); + + let foo = scedma_csr.r(utra::scedma::SFR_ICH_TRANSIZE); + scedma_csr.wo(utra::scedma::SFR_ICH_TRANSIZE, foo); + let bar = scedma_csr.rf(utra::scedma::SFR_ICH_TRANSIZE_ICHCR_TRANSIZE); + scedma_csr.rmwf(utra::scedma::SFR_ICH_TRANSIZE_ICHCR_TRANSIZE, bar); + let mut baz = scedma_csr.zf(utra::scedma::SFR_ICH_TRANSIZE_ICHCR_TRANSIZE, bar); + baz |= scedma_csr.ms(utra::scedma::SFR_ICH_TRANSIZE_ICHCR_TRANSIZE, 1); + scedma_csr.wfo(utra::scedma::SFR_ICH_TRANSIZE_ICHCR_TRANSIZE, baz); + } + + #[test] + #[ignore] + fn compile_check_sce_glbsfr_csr() { + use super::*; + let mut sce_glbsfr_csr = CSR::new(HW_SCE_GLBSFR_BASE as *mut u32); + + let foo = sce_glbsfr_csr.r(utra::sce_glbsfr::SFR_SCEMODE); + sce_glbsfr_csr.wo(utra::sce_glbsfr::SFR_SCEMODE, foo); + let bar = sce_glbsfr_csr.rf(utra::sce_glbsfr::SFR_SCEMODE_CR_SCEMODE); + sce_glbsfr_csr.rmwf(utra::sce_glbsfr::SFR_SCEMODE_CR_SCEMODE, bar); + let mut baz = sce_glbsfr_csr.zf(utra::sce_glbsfr::SFR_SCEMODE_CR_SCEMODE, bar); + baz |= sce_glbsfr_csr.ms(utra::sce_glbsfr::SFR_SCEMODE_CR_SCEMODE, 1); + sce_glbsfr_csr.wfo(utra::sce_glbsfr::SFR_SCEMODE_CR_SCEMODE, baz); + + let foo = sce_glbsfr_csr.r(utra::sce_glbsfr::SFR_SUBEN); + sce_glbsfr_csr.wo(utra::sce_glbsfr::SFR_SUBEN, foo); + let bar = sce_glbsfr_csr.rf(utra::sce_glbsfr::SFR_SUBEN_CR_SUBEN); + sce_glbsfr_csr.rmwf(utra::sce_glbsfr::SFR_SUBEN_CR_SUBEN, bar); + let mut baz = sce_glbsfr_csr.zf(utra::sce_glbsfr::SFR_SUBEN_CR_SUBEN, bar); + baz |= sce_glbsfr_csr.ms(utra::sce_glbsfr::SFR_SUBEN_CR_SUBEN, 1); + sce_glbsfr_csr.wfo(utra::sce_glbsfr::SFR_SUBEN_CR_SUBEN, baz); + + let foo = sce_glbsfr_csr.r(utra::sce_glbsfr::SFR_AHBS); + sce_glbsfr_csr.wo(utra::sce_glbsfr::SFR_AHBS, foo); + let bar = sce_glbsfr_csr.rf(utra::sce_glbsfr::SFR_AHBS_CR_AHBSOPT); + sce_glbsfr_csr.rmwf(utra::sce_glbsfr::SFR_AHBS_CR_AHBSOPT, bar); + let mut baz = sce_glbsfr_csr.zf(utra::sce_glbsfr::SFR_AHBS_CR_AHBSOPT, bar); + baz |= sce_glbsfr_csr.ms(utra::sce_glbsfr::SFR_AHBS_CR_AHBSOPT, 1); + sce_glbsfr_csr.wfo(utra::sce_glbsfr::SFR_AHBS_CR_AHBSOPT, baz); + + let foo = sce_glbsfr_csr.r(utra::sce_glbsfr::SFR_SRBUSY); + sce_glbsfr_csr.wo(utra::sce_glbsfr::SFR_SRBUSY, foo); + let bar = sce_glbsfr_csr.rf(utra::sce_glbsfr::SFR_SRBUSY_SR_BUSY); + sce_glbsfr_csr.rmwf(utra::sce_glbsfr::SFR_SRBUSY_SR_BUSY, bar); + let mut baz = sce_glbsfr_csr.zf(utra::sce_glbsfr::SFR_SRBUSY_SR_BUSY, bar); + baz |= sce_glbsfr_csr.ms(utra::sce_glbsfr::SFR_SRBUSY_SR_BUSY, 1); + sce_glbsfr_csr.wfo(utra::sce_glbsfr::SFR_SRBUSY_SR_BUSY, baz); + + let foo = sce_glbsfr_csr.r(utra::sce_glbsfr::SFR_FRDONE); + sce_glbsfr_csr.wo(utra::sce_glbsfr::SFR_FRDONE, foo); + let bar = sce_glbsfr_csr.rf(utra::sce_glbsfr::SFR_FRDONE_FR_DONE); + sce_glbsfr_csr.rmwf(utra::sce_glbsfr::SFR_FRDONE_FR_DONE, bar); + let mut baz = sce_glbsfr_csr.zf(utra::sce_glbsfr::SFR_FRDONE_FR_DONE, bar); + baz |= sce_glbsfr_csr.ms(utra::sce_glbsfr::SFR_FRDONE_FR_DONE, 1); + sce_glbsfr_csr.wfo(utra::sce_glbsfr::SFR_FRDONE_FR_DONE, baz); + + let foo = sce_glbsfr_csr.r(utra::sce_glbsfr::SFR_FRERR); + sce_glbsfr_csr.wo(utra::sce_glbsfr::SFR_FRERR, foo); + let bar = sce_glbsfr_csr.rf(utra::sce_glbsfr::SFR_FRERR_FR_ERR); + sce_glbsfr_csr.rmwf(utra::sce_glbsfr::SFR_FRERR_FR_ERR, bar); + let mut baz = sce_glbsfr_csr.zf(utra::sce_glbsfr::SFR_FRERR_FR_ERR, bar); + baz |= sce_glbsfr_csr.ms(utra::sce_glbsfr::SFR_FRERR_FR_ERR, 1); + sce_glbsfr_csr.wfo(utra::sce_glbsfr::SFR_FRERR_FR_ERR, baz); + + let foo = sce_glbsfr_csr.r(utra::sce_glbsfr::SFR_ARCLR); + sce_glbsfr_csr.wo(utra::sce_glbsfr::SFR_ARCLR, foo); + let bar = sce_glbsfr_csr.rf(utra::sce_glbsfr::SFR_ARCLR_AR_CLRRAM); + sce_glbsfr_csr.rmwf(utra::sce_glbsfr::SFR_ARCLR_AR_CLRRAM, bar); + let mut baz = sce_glbsfr_csr.zf(utra::sce_glbsfr::SFR_ARCLR_AR_CLRRAM, bar); + baz |= sce_glbsfr_csr.ms(utra::sce_glbsfr::SFR_ARCLR_AR_CLRRAM, 1); + sce_glbsfr_csr.wfo(utra::sce_glbsfr::SFR_ARCLR_AR_CLRRAM, baz); + + let foo = sce_glbsfr_csr.r(utra::sce_glbsfr::SFR_TICKCYC); + sce_glbsfr_csr.wo(utra::sce_glbsfr::SFR_TICKCYC, foo); + let bar = sce_glbsfr_csr.rf(utra::sce_glbsfr::SFR_TICKCYC_SFR_TICKCYC); + sce_glbsfr_csr.rmwf(utra::sce_glbsfr::SFR_TICKCYC_SFR_TICKCYC, bar); + let mut baz = sce_glbsfr_csr.zf(utra::sce_glbsfr::SFR_TICKCYC_SFR_TICKCYC, bar); + baz |= sce_glbsfr_csr.ms(utra::sce_glbsfr::SFR_TICKCYC_SFR_TICKCYC, 1); + sce_glbsfr_csr.wfo(utra::sce_glbsfr::SFR_TICKCYC_SFR_TICKCYC, baz); + + let foo = sce_glbsfr_csr.r(utra::sce_glbsfr::SFR_TICKCNT); + sce_glbsfr_csr.wo(utra::sce_glbsfr::SFR_TICKCNT, foo); + let bar = sce_glbsfr_csr.rf(utra::sce_glbsfr::SFR_TICKCNT_SFR_TICKCNT); + sce_glbsfr_csr.rmwf(utra::sce_glbsfr::SFR_TICKCNT_SFR_TICKCNT, bar); + let mut baz = sce_glbsfr_csr.zf(utra::sce_glbsfr::SFR_TICKCNT_SFR_TICKCNT, bar); + baz |= sce_glbsfr_csr.ms(utra::sce_glbsfr::SFR_TICKCNT_SFR_TICKCNT, 1); + sce_glbsfr_csr.wfo(utra::sce_glbsfr::SFR_TICKCNT_SFR_TICKCNT, baz); + + let foo = sce_glbsfr_csr.r(utra::sce_glbsfr::SFR_FFEN); + sce_glbsfr_csr.wo(utra::sce_glbsfr::SFR_FFEN, foo); + let bar = sce_glbsfr_csr.rf(utra::sce_glbsfr::SFR_FFEN_CR_FFEN); + sce_glbsfr_csr.rmwf(utra::sce_glbsfr::SFR_FFEN_CR_FFEN, bar); + let mut baz = sce_glbsfr_csr.zf(utra::sce_glbsfr::SFR_FFEN_CR_FFEN, bar); + baz |= sce_glbsfr_csr.ms(utra::sce_glbsfr::SFR_FFEN_CR_FFEN, 1); + sce_glbsfr_csr.wfo(utra::sce_glbsfr::SFR_FFEN_CR_FFEN, baz); + + let foo = sce_glbsfr_csr.r(utra::sce_glbsfr::SFR_FFCLR); + sce_glbsfr_csr.wo(utra::sce_glbsfr::SFR_FFCLR, foo); + let bar = sce_glbsfr_csr.rf(utra::sce_glbsfr::SFR_FFCLR_AR_FFCLR); + sce_glbsfr_csr.rmwf(utra::sce_glbsfr::SFR_FFCLR_AR_FFCLR, bar); + let mut baz = sce_glbsfr_csr.zf(utra::sce_glbsfr::SFR_FFCLR_AR_FFCLR, bar); + baz |= sce_glbsfr_csr.ms(utra::sce_glbsfr::SFR_FFCLR_AR_FFCLR, 1); + sce_glbsfr_csr.wfo(utra::sce_glbsfr::SFR_FFCLR_AR_FFCLR, baz); + + let foo = sce_glbsfr_csr.r(utra::sce_glbsfr::SFR_FFCNT_SR_FF0); + sce_glbsfr_csr.wo(utra::sce_glbsfr::SFR_FFCNT_SR_FF0, foo); + let bar = sce_glbsfr_csr.rf(utra::sce_glbsfr::SFR_FFCNT_SR_FF0_SR_FF0); + sce_glbsfr_csr.rmwf(utra::sce_glbsfr::SFR_FFCNT_SR_FF0_SR_FF0, bar); + let mut baz = sce_glbsfr_csr.zf(utra::sce_glbsfr::SFR_FFCNT_SR_FF0_SR_FF0, bar); + baz |= sce_glbsfr_csr.ms(utra::sce_glbsfr::SFR_FFCNT_SR_FF0_SR_FF0, 1); + sce_glbsfr_csr.wfo(utra::sce_glbsfr::SFR_FFCNT_SR_FF0_SR_FF0, baz); + + let foo = sce_glbsfr_csr.r(utra::sce_glbsfr::SFR_FFCNT_SR_FF1); + sce_glbsfr_csr.wo(utra::sce_glbsfr::SFR_FFCNT_SR_FF1, foo); + let bar = sce_glbsfr_csr.rf(utra::sce_glbsfr::SFR_FFCNT_SR_FF1_SR_FF1); + sce_glbsfr_csr.rmwf(utra::sce_glbsfr::SFR_FFCNT_SR_FF1_SR_FF1, bar); + let mut baz = sce_glbsfr_csr.zf(utra::sce_glbsfr::SFR_FFCNT_SR_FF1_SR_FF1, bar); + baz |= sce_glbsfr_csr.ms(utra::sce_glbsfr::SFR_FFCNT_SR_FF1_SR_FF1, 1); + sce_glbsfr_csr.wfo(utra::sce_glbsfr::SFR_FFCNT_SR_FF1_SR_FF1, baz); + + let foo = sce_glbsfr_csr.r(utra::sce_glbsfr::SFR_FFCNT_SR_FF2); + sce_glbsfr_csr.wo(utra::sce_glbsfr::SFR_FFCNT_SR_FF2, foo); + let bar = sce_glbsfr_csr.rf(utra::sce_glbsfr::SFR_FFCNT_SR_FF2_SR_FF2); + sce_glbsfr_csr.rmwf(utra::sce_glbsfr::SFR_FFCNT_SR_FF2_SR_FF2, bar); + let mut baz = sce_glbsfr_csr.zf(utra::sce_glbsfr::SFR_FFCNT_SR_FF2_SR_FF2, bar); + baz |= sce_glbsfr_csr.ms(utra::sce_glbsfr::SFR_FFCNT_SR_FF2_SR_FF2, 1); + sce_glbsfr_csr.wfo(utra::sce_glbsfr::SFR_FFCNT_SR_FF2_SR_FF2, baz); + + let foo = sce_glbsfr_csr.r(utra::sce_glbsfr::SFR_FFCNT_SR_FF3); + sce_glbsfr_csr.wo(utra::sce_glbsfr::SFR_FFCNT_SR_FF3, foo); + let bar = sce_glbsfr_csr.rf(utra::sce_glbsfr::SFR_FFCNT_SR_FF3_SR_FF3); + sce_glbsfr_csr.rmwf(utra::sce_glbsfr::SFR_FFCNT_SR_FF3_SR_FF3, bar); + let mut baz = sce_glbsfr_csr.zf(utra::sce_glbsfr::SFR_FFCNT_SR_FF3_SR_FF3, bar); + baz |= sce_glbsfr_csr.ms(utra::sce_glbsfr::SFR_FFCNT_SR_FF3_SR_FF3, 1); + sce_glbsfr_csr.wfo(utra::sce_glbsfr::SFR_FFCNT_SR_FF3_SR_FF3, baz); + + let foo = sce_glbsfr_csr.r(utra::sce_glbsfr::SFR_FFCNT_SR_FF4); + sce_glbsfr_csr.wo(utra::sce_glbsfr::SFR_FFCNT_SR_FF4, foo); + let bar = sce_glbsfr_csr.rf(utra::sce_glbsfr::SFR_FFCNT_SR_FF4_SR_FF4); + sce_glbsfr_csr.rmwf(utra::sce_glbsfr::SFR_FFCNT_SR_FF4_SR_FF4, bar); + let mut baz = sce_glbsfr_csr.zf(utra::sce_glbsfr::SFR_FFCNT_SR_FF4_SR_FF4, bar); + baz |= sce_glbsfr_csr.ms(utra::sce_glbsfr::SFR_FFCNT_SR_FF4_SR_FF4, 1); + sce_glbsfr_csr.wfo(utra::sce_glbsfr::SFR_FFCNT_SR_FF4_SR_FF4, baz); + + let foo = sce_glbsfr_csr.r(utra::sce_glbsfr::SFR_FFCNT_SR_FF5); + sce_glbsfr_csr.wo(utra::sce_glbsfr::SFR_FFCNT_SR_FF5, foo); + let bar = sce_glbsfr_csr.rf(utra::sce_glbsfr::SFR_FFCNT_SR_FF5_SR_FF5); + sce_glbsfr_csr.rmwf(utra::sce_glbsfr::SFR_FFCNT_SR_FF5_SR_FF5, bar); + let mut baz = sce_glbsfr_csr.zf(utra::sce_glbsfr::SFR_FFCNT_SR_FF5_SR_FF5, bar); + baz |= sce_glbsfr_csr.ms(utra::sce_glbsfr::SFR_FFCNT_SR_FF5_SR_FF5, 1); + sce_glbsfr_csr.wfo(utra::sce_glbsfr::SFR_FFCNT_SR_FF5_SR_FF5, baz); + + let foo = sce_glbsfr_csr.r(utra::sce_glbsfr::SFR_FRACERR); + sce_glbsfr_csr.wo(utra::sce_glbsfr::SFR_FRACERR, foo); + let bar = sce_glbsfr_csr.rf(utra::sce_glbsfr::SFR_FRACERR_FR_ACERR); + sce_glbsfr_csr.rmwf(utra::sce_glbsfr::SFR_FRACERR_FR_ACERR, bar); + let mut baz = sce_glbsfr_csr.zf(utra::sce_glbsfr::SFR_FRACERR_FR_ACERR, bar); + baz |= sce_glbsfr_csr.ms(utra::sce_glbsfr::SFR_FRACERR_FR_ACERR, 1); + sce_glbsfr_csr.wfo(utra::sce_glbsfr::SFR_FRACERR_FR_ACERR, baz); + + let foo = sce_glbsfr_csr.r(utra::sce_glbsfr::SFR_TS); + sce_glbsfr_csr.wo(utra::sce_glbsfr::SFR_TS, foo); + let bar = sce_glbsfr_csr.rf(utra::sce_glbsfr::SFR_TS_CR_TS); + sce_glbsfr_csr.rmwf(utra::sce_glbsfr::SFR_TS_CR_TS, bar); + let mut baz = sce_glbsfr_csr.zf(utra::sce_glbsfr::SFR_TS_CR_TS, bar); + baz |= sce_glbsfr_csr.ms(utra::sce_glbsfr::SFR_TS_CR_TS, 1); + sce_glbsfr_csr.wfo(utra::sce_glbsfr::SFR_TS_CR_TS, baz); + } + + #[test] + #[ignore] + fn compile_check_duart_csr() { + use super::*; + let mut duart_csr = CSR::new(HW_DUART_BASE as *mut u32); + + let foo = duart_csr.r(utra::duart::SFR_TXD); + duart_csr.wo(utra::duart::SFR_TXD, foo); + let bar = duart_csr.rf(utra::duart::SFR_TXD_SFR_TXD); + duart_csr.rmwf(utra::duart::SFR_TXD_SFR_TXD, bar); + let mut baz = duart_csr.zf(utra::duart::SFR_TXD_SFR_TXD, bar); + baz |= duart_csr.ms(utra::duart::SFR_TXD_SFR_TXD, 1); + duart_csr.wfo(utra::duart::SFR_TXD_SFR_TXD, baz); + + let foo = duart_csr.r(utra::duart::SFR_CR); + duart_csr.wo(utra::duart::SFR_CR, foo); + let bar = duart_csr.rf(utra::duart::SFR_CR_SFR_CR); + duart_csr.rmwf(utra::duart::SFR_CR_SFR_CR, bar); + let mut baz = duart_csr.zf(utra::duart::SFR_CR_SFR_CR, bar); + baz |= duart_csr.ms(utra::duart::SFR_CR_SFR_CR, 1); + duart_csr.wfo(utra::duart::SFR_CR_SFR_CR, baz); + + let foo = duart_csr.r(utra::duart::SFR_SR); + duart_csr.wo(utra::duart::SFR_SR, foo); + let bar = duart_csr.rf(utra::duart::SFR_SR_SFR_SR); + duart_csr.rmwf(utra::duart::SFR_SR_SFR_SR, bar); + let mut baz = duart_csr.zf(utra::duart::SFR_SR_SFR_SR, bar); + baz |= duart_csr.ms(utra::duart::SFR_SR_SFR_SR, 1); + duart_csr.wfo(utra::duart::SFR_SR_SFR_SR, baz); + + let foo = duart_csr.r(utra::duart::SFR_ETUC); + duart_csr.wo(utra::duart::SFR_ETUC, foo); + let bar = duart_csr.rf(utra::duart::SFR_ETUC_SFR_ETUC); + duart_csr.rmwf(utra::duart::SFR_ETUC_SFR_ETUC, bar); + let mut baz = duart_csr.zf(utra::duart::SFR_ETUC_SFR_ETUC, bar); + baz |= duart_csr.ms(utra::duart::SFR_ETUC_SFR_ETUC, 1); + duart_csr.wfo(utra::duart::SFR_ETUC_SFR_ETUC, baz); + } + + #[test] + #[ignore] + fn compile_check_rbist_wrp_csr() { + use super::*; + let mut rbist_wrp_csr = CSR::new(HW_RBIST_WRP_BASE as *mut u32); + + let foo = rbist_wrp_csr.r(utra::rbist_wrp::SFRCR_TRM); + rbist_wrp_csr.wo(utra::rbist_wrp::SFRCR_TRM, foo); + let bar = rbist_wrp_csr.rf(utra::rbist_wrp::SFRCR_TRM_SFRCR_TRM); + rbist_wrp_csr.rmwf(utra::rbist_wrp::SFRCR_TRM_SFRCR_TRM, bar); + let mut baz = rbist_wrp_csr.zf(utra::rbist_wrp::SFRCR_TRM_SFRCR_TRM, bar); + baz |= rbist_wrp_csr.ms(utra::rbist_wrp::SFRCR_TRM_SFRCR_TRM, 1); + rbist_wrp_csr.wfo(utra::rbist_wrp::SFRCR_TRM_SFRCR_TRM, baz); + + let foo = rbist_wrp_csr.r(utra::rbist_wrp::SFRAR_TRM); + rbist_wrp_csr.wo(utra::rbist_wrp::SFRAR_TRM, foo); + let bar = rbist_wrp_csr.rf(utra::rbist_wrp::SFRAR_TRM_SFRAR_TRM); + rbist_wrp_csr.rmwf(utra::rbist_wrp::SFRAR_TRM_SFRAR_TRM, bar); + let mut baz = rbist_wrp_csr.zf(utra::rbist_wrp::SFRAR_TRM_SFRAR_TRM, bar); + baz |= rbist_wrp_csr.ms(utra::rbist_wrp::SFRAR_TRM_SFRAR_TRM, 1); + rbist_wrp_csr.wfo(utra::rbist_wrp::SFRAR_TRM_SFRAR_TRM, baz); + } + + #[test] + #[ignore] + fn compile_check_wdg_intf_csr() { + use super::*; + let mut wdg_intf_csr = CSR::new(HW_WDG_INTF_BASE as *mut u32); + } + + #[test] + #[ignore] + fn compile_check_timer_intf_csr() { + use super::*; + let mut timer_intf_csr = CSR::new(HW_TIMER_INTF_BASE as *mut u32); + } + + #[test] + #[ignore] + fn compile_check_evc_csr() { + use super::*; + let mut evc_csr = CSR::new(HW_EVC_BASE as *mut u32); + + let foo = evc_csr.r(utra::evc::SFR_CM7EVSEL_CM7EVSEL0); + evc_csr.wo(utra::evc::SFR_CM7EVSEL_CM7EVSEL0, foo); + let bar = evc_csr.rf(utra::evc::SFR_CM7EVSEL_CM7EVSEL0_CM7EVSEL0); + evc_csr.rmwf(utra::evc::SFR_CM7EVSEL_CM7EVSEL0_CM7EVSEL0, bar); + let mut baz = evc_csr.zf(utra::evc::SFR_CM7EVSEL_CM7EVSEL0_CM7EVSEL0, bar); + baz |= evc_csr.ms(utra::evc::SFR_CM7EVSEL_CM7EVSEL0_CM7EVSEL0, 1); + evc_csr.wfo(utra::evc::SFR_CM7EVSEL_CM7EVSEL0_CM7EVSEL0, baz); + + let foo = evc_csr.r(utra::evc::SFR_CM7EVSEL_CM7EVSEL1); + evc_csr.wo(utra::evc::SFR_CM7EVSEL_CM7EVSEL1, foo); + let bar = evc_csr.rf(utra::evc::SFR_CM7EVSEL_CM7EVSEL1_CM7EVSEL1); + evc_csr.rmwf(utra::evc::SFR_CM7EVSEL_CM7EVSEL1_CM7EVSEL1, bar); + let mut baz = evc_csr.zf(utra::evc::SFR_CM7EVSEL_CM7EVSEL1_CM7EVSEL1, bar); + baz |= evc_csr.ms(utra::evc::SFR_CM7EVSEL_CM7EVSEL1_CM7EVSEL1, 1); + evc_csr.wfo(utra::evc::SFR_CM7EVSEL_CM7EVSEL1_CM7EVSEL1, baz); + + let foo = evc_csr.r(utra::evc::SFR_CM7EVSEL_CM7EVSEL2); + evc_csr.wo(utra::evc::SFR_CM7EVSEL_CM7EVSEL2, foo); + let bar = evc_csr.rf(utra::evc::SFR_CM7EVSEL_CM7EVSEL2_CM7EVSEL2); + evc_csr.rmwf(utra::evc::SFR_CM7EVSEL_CM7EVSEL2_CM7EVSEL2, bar); + let mut baz = evc_csr.zf(utra::evc::SFR_CM7EVSEL_CM7EVSEL2_CM7EVSEL2, bar); + baz |= evc_csr.ms(utra::evc::SFR_CM7EVSEL_CM7EVSEL2_CM7EVSEL2, 1); + evc_csr.wfo(utra::evc::SFR_CM7EVSEL_CM7EVSEL2_CM7EVSEL2, baz); + + let foo = evc_csr.r(utra::evc::SFR_CM7EVSEL_CM7EVSEL3); + evc_csr.wo(utra::evc::SFR_CM7EVSEL_CM7EVSEL3, foo); + let bar = evc_csr.rf(utra::evc::SFR_CM7EVSEL_CM7EVSEL3_CM7EVSEL3); + evc_csr.rmwf(utra::evc::SFR_CM7EVSEL_CM7EVSEL3_CM7EVSEL3, bar); + let mut baz = evc_csr.zf(utra::evc::SFR_CM7EVSEL_CM7EVSEL3_CM7EVSEL3, bar); + baz |= evc_csr.ms(utra::evc::SFR_CM7EVSEL_CM7EVSEL3_CM7EVSEL3, 1); + evc_csr.wfo(utra::evc::SFR_CM7EVSEL_CM7EVSEL3_CM7EVSEL3, baz); + + let foo = evc_csr.r(utra::evc::SFR_CM7EVSEL_CM7EVSEL4); + evc_csr.wo(utra::evc::SFR_CM7EVSEL_CM7EVSEL4, foo); + let bar = evc_csr.rf(utra::evc::SFR_CM7EVSEL_CM7EVSEL4_CM7EVSEL4); + evc_csr.rmwf(utra::evc::SFR_CM7EVSEL_CM7EVSEL4_CM7EVSEL4, bar); + let mut baz = evc_csr.zf(utra::evc::SFR_CM7EVSEL_CM7EVSEL4_CM7EVSEL4, bar); + baz |= evc_csr.ms(utra::evc::SFR_CM7EVSEL_CM7EVSEL4_CM7EVSEL4, 1); + evc_csr.wfo(utra::evc::SFR_CM7EVSEL_CM7EVSEL4_CM7EVSEL4, baz); + + let foo = evc_csr.r(utra::evc::SFR_CM7EVSEL_CM7EVSEL5); + evc_csr.wo(utra::evc::SFR_CM7EVSEL_CM7EVSEL5, foo); + let bar = evc_csr.rf(utra::evc::SFR_CM7EVSEL_CM7EVSEL5_CM7EVSEL5); + evc_csr.rmwf(utra::evc::SFR_CM7EVSEL_CM7EVSEL5_CM7EVSEL5, bar); + let mut baz = evc_csr.zf(utra::evc::SFR_CM7EVSEL_CM7EVSEL5_CM7EVSEL5, bar); + baz |= evc_csr.ms(utra::evc::SFR_CM7EVSEL_CM7EVSEL5_CM7EVSEL5, 1); + evc_csr.wfo(utra::evc::SFR_CM7EVSEL_CM7EVSEL5_CM7EVSEL5, baz); + + let foo = evc_csr.r(utra::evc::SFR_CM7EVSEL_CM7EVSEL6); + evc_csr.wo(utra::evc::SFR_CM7EVSEL_CM7EVSEL6, foo); + let bar = evc_csr.rf(utra::evc::SFR_CM7EVSEL_CM7EVSEL6_CM7EVSEL6); + evc_csr.rmwf(utra::evc::SFR_CM7EVSEL_CM7EVSEL6_CM7EVSEL6, bar); + let mut baz = evc_csr.zf(utra::evc::SFR_CM7EVSEL_CM7EVSEL6_CM7EVSEL6, bar); + baz |= evc_csr.ms(utra::evc::SFR_CM7EVSEL_CM7EVSEL6_CM7EVSEL6, 1); + evc_csr.wfo(utra::evc::SFR_CM7EVSEL_CM7EVSEL6_CM7EVSEL6, baz); + + let foo = evc_csr.r(utra::evc::SFR_CM7EVSEL_CM7EVSEL7); + evc_csr.wo(utra::evc::SFR_CM7EVSEL_CM7EVSEL7, foo); + let bar = evc_csr.rf(utra::evc::SFR_CM7EVSEL_CM7EVSEL7_CM7EVSEL7); + evc_csr.rmwf(utra::evc::SFR_CM7EVSEL_CM7EVSEL7_CM7EVSEL7, bar); + let mut baz = evc_csr.zf(utra::evc::SFR_CM7EVSEL_CM7EVSEL7_CM7EVSEL7, bar); + baz |= evc_csr.ms(utra::evc::SFR_CM7EVSEL_CM7EVSEL7_CM7EVSEL7, 1); + evc_csr.wfo(utra::evc::SFR_CM7EVSEL_CM7EVSEL7_CM7EVSEL7, baz); + + let foo = evc_csr.r(utra::evc::SFR_CM7EVEN); + evc_csr.wo(utra::evc::SFR_CM7EVEN, foo); + let bar = evc_csr.rf(utra::evc::SFR_CM7EVEN_CM7EVEN); + evc_csr.rmwf(utra::evc::SFR_CM7EVEN_CM7EVEN, bar); + let mut baz = evc_csr.zf(utra::evc::SFR_CM7EVEN_CM7EVEN, bar); + baz |= evc_csr.ms(utra::evc::SFR_CM7EVEN_CM7EVEN, 1); + evc_csr.wfo(utra::evc::SFR_CM7EVEN_CM7EVEN, baz); + + let foo = evc_csr.r(utra::evc::SFR_CM7EVFR); + evc_csr.wo(utra::evc::SFR_CM7EVFR, foo); + let bar = evc_csr.rf(utra::evc::SFR_CM7EVFR_CM7EVS); + evc_csr.rmwf(utra::evc::SFR_CM7EVFR_CM7EVS, bar); + let mut baz = evc_csr.zf(utra::evc::SFR_CM7EVFR_CM7EVS, bar); + baz |= evc_csr.ms(utra::evc::SFR_CM7EVFR_CM7EVS, 1); + evc_csr.wfo(utra::evc::SFR_CM7EVFR_CM7EVS, baz); + + let foo = evc_csr.r(utra::evc::SFR_TMREVSEL); + evc_csr.wo(utra::evc::SFR_TMREVSEL, foo); + let bar = evc_csr.rf(utra::evc::SFR_TMREVSEL_TMR_EVSEL); + evc_csr.rmwf(utra::evc::SFR_TMREVSEL_TMR_EVSEL, bar); + let mut baz = evc_csr.zf(utra::evc::SFR_TMREVSEL_TMR_EVSEL, bar); + baz |= evc_csr.ms(utra::evc::SFR_TMREVSEL_TMR_EVSEL, 1); + evc_csr.wfo(utra::evc::SFR_TMREVSEL_TMR_EVSEL, baz); + + let foo = evc_csr.r(utra::evc::SFR_PWMEVSEL); + evc_csr.wo(utra::evc::SFR_PWMEVSEL, foo); + let bar = evc_csr.rf(utra::evc::SFR_PWMEVSEL_PWM_EVSEL); + evc_csr.rmwf(utra::evc::SFR_PWMEVSEL_PWM_EVSEL, bar); + let mut baz = evc_csr.zf(utra::evc::SFR_PWMEVSEL_PWM_EVSEL, bar); + baz |= evc_csr.ms(utra::evc::SFR_PWMEVSEL_PWM_EVSEL, 1); + evc_csr.wfo(utra::evc::SFR_PWMEVSEL_PWM_EVSEL, baz); + + let foo = evc_csr.r(utra::evc::SFR_IFEVEN_IFEVEN0); + evc_csr.wo(utra::evc::SFR_IFEVEN_IFEVEN0, foo); + let bar = evc_csr.rf(utra::evc::SFR_IFEVEN_IFEVEN0_IFEVEN0); + evc_csr.rmwf(utra::evc::SFR_IFEVEN_IFEVEN0_IFEVEN0, bar); + let mut baz = evc_csr.zf(utra::evc::SFR_IFEVEN_IFEVEN0_IFEVEN0, bar); + baz |= evc_csr.ms(utra::evc::SFR_IFEVEN_IFEVEN0_IFEVEN0, 1); + evc_csr.wfo(utra::evc::SFR_IFEVEN_IFEVEN0_IFEVEN0, baz); + + let foo = evc_csr.r(utra::evc::SFR_IFEVEN_IFEVEN1); + evc_csr.wo(utra::evc::SFR_IFEVEN_IFEVEN1, foo); + let bar = evc_csr.rf(utra::evc::SFR_IFEVEN_IFEVEN1_IFEVEN1); + evc_csr.rmwf(utra::evc::SFR_IFEVEN_IFEVEN1_IFEVEN1, bar); + let mut baz = evc_csr.zf(utra::evc::SFR_IFEVEN_IFEVEN1_IFEVEN1, bar); + baz |= evc_csr.ms(utra::evc::SFR_IFEVEN_IFEVEN1_IFEVEN1, 1); + evc_csr.wfo(utra::evc::SFR_IFEVEN_IFEVEN1_IFEVEN1, baz); + + let foo = evc_csr.r(utra::evc::SFR_IFEVEN_IFEVEN2); + evc_csr.wo(utra::evc::SFR_IFEVEN_IFEVEN2, foo); + let bar = evc_csr.rf(utra::evc::SFR_IFEVEN_IFEVEN2_IFEVEN2); + evc_csr.rmwf(utra::evc::SFR_IFEVEN_IFEVEN2_IFEVEN2, bar); + let mut baz = evc_csr.zf(utra::evc::SFR_IFEVEN_IFEVEN2_IFEVEN2, bar); + baz |= evc_csr.ms(utra::evc::SFR_IFEVEN_IFEVEN2_IFEVEN2, 1); + evc_csr.wfo(utra::evc::SFR_IFEVEN_IFEVEN2_IFEVEN2, baz); + + let foo = evc_csr.r(utra::evc::SFR_IFEVEN_IFEVEN3); + evc_csr.wo(utra::evc::SFR_IFEVEN_IFEVEN3, foo); + let bar = evc_csr.rf(utra::evc::SFR_IFEVEN_IFEVEN3_IFEVEN3); + evc_csr.rmwf(utra::evc::SFR_IFEVEN_IFEVEN3_IFEVEN3, bar); + let mut baz = evc_csr.zf(utra::evc::SFR_IFEVEN_IFEVEN3_IFEVEN3, bar); + baz |= evc_csr.ms(utra::evc::SFR_IFEVEN_IFEVEN3_IFEVEN3, 1); + evc_csr.wfo(utra::evc::SFR_IFEVEN_IFEVEN3_IFEVEN3, baz); + + let foo = evc_csr.r(utra::evc::SFR_IFEVEN_IFEVEN4); + evc_csr.wo(utra::evc::SFR_IFEVEN_IFEVEN4, foo); + let bar = evc_csr.rf(utra::evc::SFR_IFEVEN_IFEVEN4_IFEVEN4); + evc_csr.rmwf(utra::evc::SFR_IFEVEN_IFEVEN4_IFEVEN4, bar); + let mut baz = evc_csr.zf(utra::evc::SFR_IFEVEN_IFEVEN4_IFEVEN4, bar); + baz |= evc_csr.ms(utra::evc::SFR_IFEVEN_IFEVEN4_IFEVEN4, 1); + evc_csr.wfo(utra::evc::SFR_IFEVEN_IFEVEN4_IFEVEN4, baz); + + let foo = evc_csr.r(utra::evc::SFR_IFEVEN_IFEVEN5); + evc_csr.wo(utra::evc::SFR_IFEVEN_IFEVEN5, foo); + let bar = evc_csr.rf(utra::evc::SFR_IFEVEN_IFEVEN5_IFEVEN5); + evc_csr.rmwf(utra::evc::SFR_IFEVEN_IFEVEN5_IFEVEN5, bar); + let mut baz = evc_csr.zf(utra::evc::SFR_IFEVEN_IFEVEN5_IFEVEN5, bar); + baz |= evc_csr.ms(utra::evc::SFR_IFEVEN_IFEVEN5_IFEVEN5, 1); + evc_csr.wfo(utra::evc::SFR_IFEVEN_IFEVEN5_IFEVEN5, baz); + + let foo = evc_csr.r(utra::evc::SFR_IFEVEN_IFEVEN6); + evc_csr.wo(utra::evc::SFR_IFEVEN_IFEVEN6, foo); + let bar = evc_csr.rf(utra::evc::SFR_IFEVEN_IFEVEN6_IFEVEN6); + evc_csr.rmwf(utra::evc::SFR_IFEVEN_IFEVEN6_IFEVEN6, bar); + let mut baz = evc_csr.zf(utra::evc::SFR_IFEVEN_IFEVEN6_IFEVEN6, bar); + baz |= evc_csr.ms(utra::evc::SFR_IFEVEN_IFEVEN6_IFEVEN6, 1); + evc_csr.wfo(utra::evc::SFR_IFEVEN_IFEVEN6_IFEVEN6, baz); + + let foo = evc_csr.r(utra::evc::SFR_IFEVEN_IFEVEN7); + evc_csr.wo(utra::evc::SFR_IFEVEN_IFEVEN7, foo); + let bar = evc_csr.rf(utra::evc::SFR_IFEVEN_IFEVEN7_IFEVEN7); + evc_csr.rmwf(utra::evc::SFR_IFEVEN_IFEVEN7_IFEVEN7, bar); + let mut baz = evc_csr.zf(utra::evc::SFR_IFEVEN_IFEVEN7_IFEVEN7, bar); + baz |= evc_csr.ms(utra::evc::SFR_IFEVEN_IFEVEN7_IFEVEN7, 1); + evc_csr.wfo(utra::evc::SFR_IFEVEN_IFEVEN7_IFEVEN7, baz); + + let foo = evc_csr.r(utra::evc::SFR_IFEVERRFR); + evc_csr.wo(utra::evc::SFR_IFEVERRFR, foo); + let bar = evc_csr.rf(utra::evc::SFR_IFEVERRFR_IFEV_ERRS); + evc_csr.rmwf(utra::evc::SFR_IFEVERRFR_IFEV_ERRS, bar); + let mut baz = evc_csr.zf(utra::evc::SFR_IFEVERRFR_IFEV_ERRS, bar); + baz |= evc_csr.ms(utra::evc::SFR_IFEVERRFR_IFEV_ERRS, 1); + evc_csr.wfo(utra::evc::SFR_IFEVERRFR_IFEV_ERRS, baz); + + let foo = evc_csr.r(utra::evc::SFR_CM7ERRFR); + evc_csr.wo(utra::evc::SFR_CM7ERRFR, foo); + let bar = evc_csr.rf(utra::evc::SFR_CM7ERRFR_ERRIN); + evc_csr.rmwf(utra::evc::SFR_CM7ERRFR_ERRIN, bar); + let mut baz = evc_csr.zf(utra::evc::SFR_CM7ERRFR_ERRIN, bar); + baz |= evc_csr.ms(utra::evc::SFR_CM7ERRFR_ERRIN, 1); + evc_csr.wfo(utra::evc::SFR_CM7ERRFR_ERRIN, baz); + } + + #[test] + #[ignore] + fn compile_check_sysctrl_csr() { + use super::*; + let mut sysctrl_csr = CSR::new(HW_SYSCTRL_BASE as *mut u32); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_CGUSEC); + sysctrl_csr.wo(utra::sysctrl::SFR_CGUSEC, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_CGUSEC_SFR_CGUSEC); + sysctrl_csr.rmwf(utra::sysctrl::SFR_CGUSEC_SFR_CGUSEC, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_CGUSEC_SFR_CGUSEC, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_CGUSEC_SFR_CGUSEC, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_CGUSEC_SFR_CGUSEC, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_CGULP); + sysctrl_csr.wo(utra::sysctrl::SFR_CGULP, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_CGULP_SFR_CGULP); + sysctrl_csr.rmwf(utra::sysctrl::SFR_CGULP_SFR_CGULP, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_CGULP_SFR_CGULP, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_CGULP_SFR_CGULP, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_CGULP_SFR_CGULP, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_SEED); + sysctrl_csr.wo(utra::sysctrl::SFR_SEED, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_SEED_SFR_SEED); + sysctrl_csr.rmwf(utra::sysctrl::SFR_SEED_SFR_SEED, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_SEED_SFR_SEED, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_SEED_SFR_SEED, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_SEED_SFR_SEED, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_SEEDAR); + sysctrl_csr.wo(utra::sysctrl::SFR_SEEDAR, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_SEEDAR_SFR_SEEDAR); + sysctrl_csr.rmwf(utra::sysctrl::SFR_SEEDAR_SFR_SEEDAR, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_SEEDAR_SFR_SEEDAR, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_SEEDAR_SFR_SEEDAR, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_SEEDAR_SFR_SEEDAR, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_CGUSEL0); + sysctrl_csr.wo(utra::sysctrl::SFR_CGUSEL0, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_CGUSEL0_SFR_CGUSEL0); + sysctrl_csr.rmwf(utra::sysctrl::SFR_CGUSEL0_SFR_CGUSEL0, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_CGUSEL0_SFR_CGUSEL0, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_CGUSEL0_SFR_CGUSEL0, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_CGUSEL0_SFR_CGUSEL0, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_0); + sysctrl_csr.wo(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_0, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_0_CFGFDCR_0_4_0); + sysctrl_csr.rmwf(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_0_CFGFDCR_0_4_0, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_0_CFGFDCR_0_4_0, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_0_CFGFDCR_0_4_0, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_0_CFGFDCR_0_4_0, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_1); + sysctrl_csr.wo(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_1, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_1_CFGFDCR_0_4_1); + sysctrl_csr.rmwf(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_1_CFGFDCR_0_4_1, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_1_CFGFDCR_0_4_1, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_1_CFGFDCR_0_4_1, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_1_CFGFDCR_0_4_1, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_2); + sysctrl_csr.wo(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_2, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_2_CFGFDCR_0_4_2); + sysctrl_csr.rmwf(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_2_CFGFDCR_0_4_2, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_2_CFGFDCR_0_4_2, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_2_CFGFDCR_0_4_2, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_2_CFGFDCR_0_4_2, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_3); + sysctrl_csr.wo(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_3, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_3_CFGFDCR_0_4_3); + sysctrl_csr.rmwf(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_3_CFGFDCR_0_4_3, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_3_CFGFDCR_0_4_3, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_3_CFGFDCR_0_4_3, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_3_CFGFDCR_0_4_3, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_4); + sysctrl_csr.wo(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_4, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_4_CFGFDCR_0_4_4); + sysctrl_csr.rmwf(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_4_CFGFDCR_0_4_4, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_4_CFGFDCR_0_4_4, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_4_CFGFDCR_0_4_4, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_4_CFGFDCR_0_4_4, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_CGUFDAO); + sysctrl_csr.wo(utra::sysctrl::SFR_CGUFDAO, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_CGUFDAO_CFGFDCR); + sysctrl_csr.rmwf(utra::sysctrl::SFR_CGUFDAO_CFGFDCR, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_CGUFDAO_CFGFDCR, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_CGUFDAO_CFGFDCR, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_CGUFDAO_CFGFDCR, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_CGUSET); + sysctrl_csr.wo(utra::sysctrl::SFR_CGUSET, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_CGUSET_SFR_CGUSET); + sysctrl_csr.rmwf(utra::sysctrl::SFR_CGUSET_SFR_CGUSET, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_CGUSET_SFR_CGUSET, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_CGUSET_SFR_CGUSET, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_CGUSET_SFR_CGUSET, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_CGUSEL1); + sysctrl_csr.wo(utra::sysctrl::SFR_CGUSEL1, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_CGUSEL1_SFR_CGUSEL1); + sysctrl_csr.rmwf(utra::sysctrl::SFR_CGUSEL1_SFR_CGUSEL1, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_CGUSEL1_SFR_CGUSEL1, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_CGUSEL1_SFR_CGUSEL1, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_CGUSEL1_SFR_CGUSEL1, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_CGUFDPKE); + sysctrl_csr.wo(utra::sysctrl::SFR_CGUFDPKE, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_CGUFDPKE_SFR_CGUFDPKE); + sysctrl_csr.rmwf(utra::sysctrl::SFR_CGUFDPKE_SFR_CGUFDPKE, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_CGUFDPKE_SFR_CGUFDPKE, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_CGUFDPKE_SFR_CGUFDPKE, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_CGUFDPKE_SFR_CGUFDPKE, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_CGUFSSR_FSFREQ0); + sysctrl_csr.wo(utra::sysctrl::SFR_CGUFSSR_FSFREQ0, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_CGUFSSR_FSFREQ0_FSFREQ0); + sysctrl_csr.rmwf(utra::sysctrl::SFR_CGUFSSR_FSFREQ0_FSFREQ0, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_CGUFSSR_FSFREQ0_FSFREQ0, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_CGUFSSR_FSFREQ0_FSFREQ0, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_CGUFSSR_FSFREQ0_FSFREQ0, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_CGUFSSR_FSFREQ1); + sysctrl_csr.wo(utra::sysctrl::SFR_CGUFSSR_FSFREQ1, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_CGUFSSR_FSFREQ1_FSFREQ1); + sysctrl_csr.rmwf(utra::sysctrl::SFR_CGUFSSR_FSFREQ1_FSFREQ1, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_CGUFSSR_FSFREQ1_FSFREQ1, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_CGUFSSR_FSFREQ1_FSFREQ1, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_CGUFSSR_FSFREQ1_FSFREQ1, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_CGUFSSR_FSFREQ2); + sysctrl_csr.wo(utra::sysctrl::SFR_CGUFSSR_FSFREQ2, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_CGUFSSR_FSFREQ2_FSFREQ2); + sysctrl_csr.rmwf(utra::sysctrl::SFR_CGUFSSR_FSFREQ2_FSFREQ2, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_CGUFSSR_FSFREQ2_FSFREQ2, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_CGUFSSR_FSFREQ2_FSFREQ2, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_CGUFSSR_FSFREQ2_FSFREQ2, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_CGUFSSR_FSFREQ3); + sysctrl_csr.wo(utra::sysctrl::SFR_CGUFSSR_FSFREQ3, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_CGUFSSR_FSFREQ3_FSFREQ3); + sysctrl_csr.rmwf(utra::sysctrl::SFR_CGUFSSR_FSFREQ3_FSFREQ3, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_CGUFSSR_FSFREQ3_FSFREQ3, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_CGUFSSR_FSFREQ3_FSFREQ3, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_CGUFSSR_FSFREQ3_FSFREQ3, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_CGUFSVLD); + sysctrl_csr.wo(utra::sysctrl::SFR_CGUFSVLD, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_CGUFSVLD_SFR_CGUFSVLD); + sysctrl_csr.rmwf(utra::sysctrl::SFR_CGUFSVLD_SFR_CGUFSVLD, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_CGUFSVLD_SFR_CGUFSVLD, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_CGUFSVLD_SFR_CGUFSVLD, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_CGUFSVLD_SFR_CGUFSVLD, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_CGUFSCR); + sysctrl_csr.wo(utra::sysctrl::SFR_CGUFSCR, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_CGUFSCR_SFR_CGUFSCR); + sysctrl_csr.rmwf(utra::sysctrl::SFR_CGUFSCR_SFR_CGUFSCR, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_CGUFSCR_SFR_CGUFSCR, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_CGUFSCR_SFR_CGUFSCR, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_CGUFSCR_SFR_CGUFSCR, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_ACLKGR); + sysctrl_csr.wo(utra::sysctrl::SFR_ACLKGR, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_ACLKGR_SFR_ACLKGR); + sysctrl_csr.rmwf(utra::sysctrl::SFR_ACLKGR_SFR_ACLKGR, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_ACLKGR_SFR_ACLKGR, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_ACLKGR_SFR_ACLKGR, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_ACLKGR_SFR_ACLKGR, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_HCLKGR); + sysctrl_csr.wo(utra::sysctrl::SFR_HCLKGR, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_HCLKGR_SFR_HCLKGR); + sysctrl_csr.rmwf(utra::sysctrl::SFR_HCLKGR_SFR_HCLKGR, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_HCLKGR_SFR_HCLKGR, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_HCLKGR_SFR_HCLKGR, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_HCLKGR_SFR_HCLKGR, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_ICLKGR); + sysctrl_csr.wo(utra::sysctrl::SFR_ICLKGR, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_ICLKGR_SFR_ICLKGR); + sysctrl_csr.rmwf(utra::sysctrl::SFR_ICLKGR_SFR_ICLKGR, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_ICLKGR_SFR_ICLKGR, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_ICLKGR_SFR_ICLKGR, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_ICLKGR_SFR_ICLKGR, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_PCLKGR); + sysctrl_csr.wo(utra::sysctrl::SFR_PCLKGR, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_PCLKGR_SFR_PCLKGR); + sysctrl_csr.rmwf(utra::sysctrl::SFR_PCLKGR_SFR_PCLKGR, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_PCLKGR_SFR_PCLKGR, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_PCLKGR_SFR_PCLKGR, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_PCLKGR_SFR_PCLKGR, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_RCURST0); + sysctrl_csr.wo(utra::sysctrl::SFR_RCURST0, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_RCURST0_SFR_RCURST0); + sysctrl_csr.rmwf(utra::sysctrl::SFR_RCURST0_SFR_RCURST0, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_RCURST0_SFR_RCURST0, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_RCURST0_SFR_RCURST0, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_RCURST0_SFR_RCURST0, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_RCURST1); + sysctrl_csr.wo(utra::sysctrl::SFR_RCURST1, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_RCURST1_SFR_RCURST1); + sysctrl_csr.rmwf(utra::sysctrl::SFR_RCURST1_SFR_RCURST1, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_RCURST1_SFR_RCURST1, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_RCURST1_SFR_RCURST1, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_RCURST1_SFR_RCURST1, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_RCUSRCFR); + sysctrl_csr.wo(utra::sysctrl::SFR_RCUSRCFR, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_RCUSRCFR_SFR_RCUSRCFR); + sysctrl_csr.rmwf(utra::sysctrl::SFR_RCUSRCFR_SFR_RCUSRCFR, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_RCUSRCFR_SFR_RCUSRCFR, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_RCUSRCFR_SFR_RCUSRCFR, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_RCUSRCFR_SFR_RCUSRCFR, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_IPCARIPFLOW); + sysctrl_csr.wo(utra::sysctrl::SFR_IPCARIPFLOW, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_IPCARIPFLOW_SFR_IPCARIPFLOW); + sysctrl_csr.rmwf(utra::sysctrl::SFR_IPCARIPFLOW_SFR_IPCARIPFLOW, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_IPCARIPFLOW_SFR_IPCARIPFLOW, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_IPCARIPFLOW_SFR_IPCARIPFLOW, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_IPCARIPFLOW_SFR_IPCARIPFLOW, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_IPCEN); + sysctrl_csr.wo(utra::sysctrl::SFR_IPCEN, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_IPCEN_SFR_IPCEN); + sysctrl_csr.rmwf(utra::sysctrl::SFR_IPCEN_SFR_IPCEN, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_IPCEN_SFR_IPCEN, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_IPCEN_SFR_IPCEN, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_IPCEN_SFR_IPCEN, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_IPCLPEN); + sysctrl_csr.wo(utra::sysctrl::SFR_IPCLPEN, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_IPCLPEN_SFR_IPCLPEN); + sysctrl_csr.rmwf(utra::sysctrl::SFR_IPCLPEN_SFR_IPCLPEN, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_IPCLPEN_SFR_IPCLPEN, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_IPCLPEN_SFR_IPCLPEN, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_IPCLPEN_SFR_IPCLPEN, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_IPCOSC); + sysctrl_csr.wo(utra::sysctrl::SFR_IPCOSC, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_IPCOSC_SFR_IPCOSC); + sysctrl_csr.rmwf(utra::sysctrl::SFR_IPCOSC_SFR_IPCOSC, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_IPCOSC_SFR_IPCOSC, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_IPCOSC_SFR_IPCOSC, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_IPCOSC_SFR_IPCOSC, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_IPCPLLMN); + sysctrl_csr.wo(utra::sysctrl::SFR_IPCPLLMN, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_IPCPLLMN_SFR_IPCPLLMN); + sysctrl_csr.rmwf(utra::sysctrl::SFR_IPCPLLMN_SFR_IPCPLLMN, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_IPCPLLMN_SFR_IPCPLLMN, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_IPCPLLMN_SFR_IPCPLLMN, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_IPCPLLMN_SFR_IPCPLLMN, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_IPCPLLF); + sysctrl_csr.wo(utra::sysctrl::SFR_IPCPLLF, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_IPCPLLF_SFR_IPCPLLF); + sysctrl_csr.rmwf(utra::sysctrl::SFR_IPCPLLF_SFR_IPCPLLF, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_IPCPLLF_SFR_IPCPLLF, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_IPCPLLF_SFR_IPCPLLF, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_IPCPLLF_SFR_IPCPLLF, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_IPCPLLQ); + sysctrl_csr.wo(utra::sysctrl::SFR_IPCPLLQ, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_IPCPLLQ_SFR_IPCPLLQ); + sysctrl_csr.rmwf(utra::sysctrl::SFR_IPCPLLQ_SFR_IPCPLLQ, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_IPCPLLQ_SFR_IPCPLLQ, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_IPCPLLQ_SFR_IPCPLLQ, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_IPCPLLQ_SFR_IPCPLLQ, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_IPCCR); + sysctrl_csr.wo(utra::sysctrl::SFR_IPCCR, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_IPCCR_SFR_IPCCR); + sysctrl_csr.rmwf(utra::sysctrl::SFR_IPCCR_SFR_IPCCR, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_IPCCR_SFR_IPCCR, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_IPCCR_SFR_IPCCR, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_IPCCR_SFR_IPCCR, baz); + } + + #[test] + #[ignore] + fn compile_check_apb_thru_csr() { + use super::*; + let mut apb_thru_csr = CSR::new(HW_APB_THRU_BASE as *mut u32); + } + + #[test] + #[ignore] + fn compile_check_bio_bdma_csr() { + use super::*; + let mut bio_bdma_csr = CSR::new(HW_BIO_BDMA_BASE as *mut u32); + + let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_CTRL); + bio_bdma_csr.wo(utra::bio_bdma::SFR_CTRL, foo); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_CTRL_EN); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_CTRL_EN, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_CTRL_EN, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_CTRL_EN, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_CTRL_EN, baz); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_CTRL_RESTART); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_CTRL_RESTART, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_CTRL_RESTART, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_CTRL_RESTART, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_CTRL_RESTART, baz); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_CTRL_CLKDIV_RESTART); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_CTRL_CLKDIV_RESTART, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_CTRL_CLKDIV_RESTART, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_CTRL_CLKDIV_RESTART, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_CTRL_CLKDIV_RESTART, baz); + + let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_CFGINFO); + bio_bdma_csr.wo(utra::bio_bdma::SFR_CFGINFO, foo); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_CFGINFO_CONSTANT0); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_CFGINFO_CONSTANT0, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_CFGINFO_CONSTANT0, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_CFGINFO_CONSTANT0, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_CFGINFO_CONSTANT0, baz); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_CFGINFO_CONSTANT1); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_CFGINFO_CONSTANT1, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_CFGINFO_CONSTANT1, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_CFGINFO_CONSTANT1, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_CFGINFO_CONSTANT1, baz); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_CFGINFO_CONSTANT2); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_CFGINFO_CONSTANT2, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_CFGINFO_CONSTANT2, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_CFGINFO_CONSTANT2, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_CFGINFO_CONSTANT2, baz); + + let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_CONFIG); + bio_bdma_csr.wo(utra::bio_bdma::SFR_CONFIG, foo); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_CONFIG_SNAP_OUTPUT_TO_WHICH); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_CONFIG_SNAP_OUTPUT_TO_WHICH, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_CONFIG_SNAP_OUTPUT_TO_WHICH, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_CONFIG_SNAP_OUTPUT_TO_WHICH, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_CONFIG_SNAP_OUTPUT_TO_WHICH, baz); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_CONFIG_SNAP_OUTPUT_TO_QUANTUM); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_CONFIG_SNAP_OUTPUT_TO_QUANTUM, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_CONFIG_SNAP_OUTPUT_TO_QUANTUM, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_CONFIG_SNAP_OUTPUT_TO_QUANTUM, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_CONFIG_SNAP_OUTPUT_TO_QUANTUM, baz); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_CONFIG_SNAP_INPUT_TO_WHICH); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_CONFIG_SNAP_INPUT_TO_WHICH, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_CONFIG_SNAP_INPUT_TO_WHICH, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_CONFIG_SNAP_INPUT_TO_WHICH, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_CONFIG_SNAP_INPUT_TO_WHICH, baz); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_CONFIG_SNAP_INPUT_TO_QUANTUM); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_CONFIG_SNAP_INPUT_TO_QUANTUM, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_CONFIG_SNAP_INPUT_TO_QUANTUM, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_CONFIG_SNAP_INPUT_TO_QUANTUM, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_CONFIG_SNAP_INPUT_TO_QUANTUM, baz); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_CONFIG_DISABLE_FILTER_PERI); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_CONFIG_DISABLE_FILTER_PERI, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_CONFIG_DISABLE_FILTER_PERI, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_CONFIG_DISABLE_FILTER_PERI, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_CONFIG_DISABLE_FILTER_PERI, baz); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_CONFIG_DISABLE_FILTER_MEM); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_CONFIG_DISABLE_FILTER_MEM, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_CONFIG_DISABLE_FILTER_MEM, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_CONFIG_DISABLE_FILTER_MEM, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_CONFIG_DISABLE_FILTER_MEM, baz); + + let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_FLEVEL); + bio_bdma_csr.wo(utra::bio_bdma::SFR_FLEVEL, foo); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_FLEVEL_PCLK_REGFIFO_LEVEL0); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_FLEVEL_PCLK_REGFIFO_LEVEL0, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_FLEVEL_PCLK_REGFIFO_LEVEL0, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_FLEVEL_PCLK_REGFIFO_LEVEL0, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_FLEVEL_PCLK_REGFIFO_LEVEL0, baz); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_FLEVEL_PCLK_REGFIFO_LEVEL1); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_FLEVEL_PCLK_REGFIFO_LEVEL1, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_FLEVEL_PCLK_REGFIFO_LEVEL1, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_FLEVEL_PCLK_REGFIFO_LEVEL1, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_FLEVEL_PCLK_REGFIFO_LEVEL1, baz); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_FLEVEL_PCLK_REGFIFO_LEVEL2); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_FLEVEL_PCLK_REGFIFO_LEVEL2, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_FLEVEL_PCLK_REGFIFO_LEVEL2, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_FLEVEL_PCLK_REGFIFO_LEVEL2, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_FLEVEL_PCLK_REGFIFO_LEVEL2, baz); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_FLEVEL_PCLK_REGFIFO_LEVEL3); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_FLEVEL_PCLK_REGFIFO_LEVEL3, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_FLEVEL_PCLK_REGFIFO_LEVEL3, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_FLEVEL_PCLK_REGFIFO_LEVEL3, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_FLEVEL_PCLK_REGFIFO_LEVEL3, baz); + + let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_TXF0); + bio_bdma_csr.wo(utra::bio_bdma::SFR_TXF0, foo); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_TXF0_FDIN); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_TXF0_FDIN, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_TXF0_FDIN, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_TXF0_FDIN, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_TXF0_FDIN, baz); + + let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_TXF1); + bio_bdma_csr.wo(utra::bio_bdma::SFR_TXF1, foo); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_TXF1_FDIN); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_TXF1_FDIN, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_TXF1_FDIN, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_TXF1_FDIN, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_TXF1_FDIN, baz); + + let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_TXF2); + bio_bdma_csr.wo(utra::bio_bdma::SFR_TXF2, foo); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_TXF2_FDIN); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_TXF2_FDIN, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_TXF2_FDIN, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_TXF2_FDIN, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_TXF2_FDIN, baz); + + let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_TXF3); + bio_bdma_csr.wo(utra::bio_bdma::SFR_TXF3, foo); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_TXF3_FDIN); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_TXF3_FDIN, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_TXF3_FDIN, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_TXF3_FDIN, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_TXF3_FDIN, baz); + + let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_RXF0); + bio_bdma_csr.wo(utra::bio_bdma::SFR_RXF0, foo); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_RXF0_FDOUT); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_RXF0_FDOUT, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_RXF0_FDOUT, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_RXF0_FDOUT, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_RXF0_FDOUT, baz); + + let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_RXF1); + bio_bdma_csr.wo(utra::bio_bdma::SFR_RXF1, foo); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_RXF1_FDOUT); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_RXF1_FDOUT, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_RXF1_FDOUT, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_RXF1_FDOUT, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_RXF1_FDOUT, baz); + + let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_RXF2); + bio_bdma_csr.wo(utra::bio_bdma::SFR_RXF2, foo); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_RXF2_FDOUT); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_RXF2_FDOUT, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_RXF2_FDOUT, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_RXF2_FDOUT, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_RXF2_FDOUT, baz); + + let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_RXF3); + bio_bdma_csr.wo(utra::bio_bdma::SFR_RXF3, foo); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_RXF3_FDOUT); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_RXF3_FDOUT, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_RXF3_FDOUT, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_RXF3_FDOUT, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_RXF3_FDOUT, baz); + + let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_ELEVEL); + bio_bdma_csr.wo(utra::bio_bdma::SFR_ELEVEL, foo); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL0); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL0, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL0, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL0, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL0, baz); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL1); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL1, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL1, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL1, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL1, baz); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL2); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL2, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL2, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL2, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL2, baz); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL3); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL3, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL3, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL3, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL3, baz); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL4); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL4, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL4, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL4, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL4, baz); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL5); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL5, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL5, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL5, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL5, baz); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL6); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL6, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL6, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL6, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL6, baz); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL7); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL7, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL7, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL7, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL7, baz); + + let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_ETYPE); + bio_bdma_csr.wo(utra::bio_bdma::SFR_ETYPE, foo); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_ETYPE_FIFO_EVENT_LT_MASK); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_ETYPE_FIFO_EVENT_LT_MASK, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_ETYPE_FIFO_EVENT_LT_MASK, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_ETYPE_FIFO_EVENT_LT_MASK, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_ETYPE_FIFO_EVENT_LT_MASK, baz); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_ETYPE_FIFO_EVENT_EQ_MASK); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_ETYPE_FIFO_EVENT_EQ_MASK, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_ETYPE_FIFO_EVENT_EQ_MASK, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_ETYPE_FIFO_EVENT_EQ_MASK, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_ETYPE_FIFO_EVENT_EQ_MASK, baz); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_ETYPE_FIFO_EVENT_GT_MASK); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_ETYPE_FIFO_EVENT_GT_MASK, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_ETYPE_FIFO_EVENT_GT_MASK, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_ETYPE_FIFO_EVENT_GT_MASK, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_ETYPE_FIFO_EVENT_GT_MASK, baz); + + let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_EVENT_SET); + bio_bdma_csr.wo(utra::bio_bdma::SFR_EVENT_SET, foo); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_EVENT_SET_SFR_EVENT_SET); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_EVENT_SET_SFR_EVENT_SET, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_EVENT_SET_SFR_EVENT_SET, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_EVENT_SET_SFR_EVENT_SET, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_EVENT_SET_SFR_EVENT_SET, baz); + + let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_EVENT_CLR); + bio_bdma_csr.wo(utra::bio_bdma::SFR_EVENT_CLR, foo); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_EVENT_CLR_SFR_EVENT_CLR); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_EVENT_CLR_SFR_EVENT_CLR, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_EVENT_CLR_SFR_EVENT_CLR, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_EVENT_CLR_SFR_EVENT_CLR, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_EVENT_CLR_SFR_EVENT_CLR, baz); + + let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_EVENT_STATUS); + bio_bdma_csr.wo(utra::bio_bdma::SFR_EVENT_STATUS, foo); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_EVENT_STATUS_SFR_EVENT_STATUS); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_EVENT_STATUS_SFR_EVENT_STATUS, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_EVENT_STATUS_SFR_EVENT_STATUS, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_EVENT_STATUS_SFR_EVENT_STATUS, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_EVENT_STATUS_SFR_EVENT_STATUS, baz); + + let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_EXTCLOCK); + bio_bdma_csr.wo(utra::bio_bdma::SFR_EXTCLOCK, foo); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_EXTCLOCK_USE_EXTCLK); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_EXTCLOCK_USE_EXTCLK, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_EXTCLOCK_USE_EXTCLK, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_EXTCLOCK_USE_EXTCLK, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_EXTCLOCK_USE_EXTCLK, baz); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_EXTCLOCK_EXTCLK_GPIO_0); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_EXTCLOCK_EXTCLK_GPIO_0, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_EXTCLOCK_EXTCLK_GPIO_0, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_EXTCLOCK_EXTCLK_GPIO_0, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_EXTCLOCK_EXTCLK_GPIO_0, baz); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_EXTCLOCK_EXTCLK_GPIO_1); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_EXTCLOCK_EXTCLK_GPIO_1, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_EXTCLOCK_EXTCLK_GPIO_1, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_EXTCLOCK_EXTCLK_GPIO_1, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_EXTCLOCK_EXTCLK_GPIO_1, baz); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_EXTCLOCK_EXTCLK_GPIO_2); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_EXTCLOCK_EXTCLK_GPIO_2, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_EXTCLOCK_EXTCLK_GPIO_2, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_EXTCLOCK_EXTCLK_GPIO_2, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_EXTCLOCK_EXTCLK_GPIO_2, baz); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_EXTCLOCK_EXTCLK_GPIO_3); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_EXTCLOCK_EXTCLK_GPIO_3, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_EXTCLOCK_EXTCLK_GPIO_3, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_EXTCLOCK_EXTCLK_GPIO_3, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_EXTCLOCK_EXTCLK_GPIO_3, baz); + + let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_FIFO_CLR); + bio_bdma_csr.wo(utra::bio_bdma::SFR_FIFO_CLR, foo); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_FIFO_CLR_SFR_FIFO_CLR); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_FIFO_CLR_SFR_FIFO_CLR, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_FIFO_CLR_SFR_FIFO_CLR, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_FIFO_CLR_SFR_FIFO_CLR, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_FIFO_CLR_SFR_FIFO_CLR, baz); + + let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_QDIV0); + bio_bdma_csr.wo(utra::bio_bdma::SFR_QDIV0, foo); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_QDIV0_UNUSED_DIV); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_QDIV0_UNUSED_DIV, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_QDIV0_UNUSED_DIV, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_QDIV0_UNUSED_DIV, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_QDIV0_UNUSED_DIV, baz); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_QDIV0_DIV_FRAC); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_QDIV0_DIV_FRAC, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_QDIV0_DIV_FRAC, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_QDIV0_DIV_FRAC, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_QDIV0_DIV_FRAC, baz); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_QDIV0_DIV_INT); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_QDIV0_DIV_INT, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_QDIV0_DIV_INT, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_QDIV0_DIV_INT, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_QDIV0_DIV_INT, baz); + + let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_QDIV1); + bio_bdma_csr.wo(utra::bio_bdma::SFR_QDIV1, foo); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_QDIV1_UNUSED_DIV); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_QDIV1_UNUSED_DIV, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_QDIV1_UNUSED_DIV, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_QDIV1_UNUSED_DIV, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_QDIV1_UNUSED_DIV, baz); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_QDIV1_DIV_FRAC); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_QDIV1_DIV_FRAC, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_QDIV1_DIV_FRAC, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_QDIV1_DIV_FRAC, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_QDIV1_DIV_FRAC, baz); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_QDIV1_DIV_INT); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_QDIV1_DIV_INT, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_QDIV1_DIV_INT, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_QDIV1_DIV_INT, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_QDIV1_DIV_INT, baz); + + let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_QDIV2); + bio_bdma_csr.wo(utra::bio_bdma::SFR_QDIV2, foo); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_QDIV2_UNUSED_DIV); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_QDIV2_UNUSED_DIV, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_QDIV2_UNUSED_DIV, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_QDIV2_UNUSED_DIV, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_QDIV2_UNUSED_DIV, baz); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_QDIV2_DIV_FRAC); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_QDIV2_DIV_FRAC, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_QDIV2_DIV_FRAC, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_QDIV2_DIV_FRAC, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_QDIV2_DIV_FRAC, baz); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_QDIV2_DIV_INT); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_QDIV2_DIV_INT, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_QDIV2_DIV_INT, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_QDIV2_DIV_INT, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_QDIV2_DIV_INT, baz); + + let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_QDIV3); + bio_bdma_csr.wo(utra::bio_bdma::SFR_QDIV3, foo); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_QDIV3_UNUSED_DIV); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_QDIV3_UNUSED_DIV, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_QDIV3_UNUSED_DIV, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_QDIV3_UNUSED_DIV, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_QDIV3_UNUSED_DIV, baz); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_QDIV3_DIV_FRAC); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_QDIV3_DIV_FRAC, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_QDIV3_DIV_FRAC, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_QDIV3_DIV_FRAC, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_QDIV3_DIV_FRAC, baz); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_QDIV3_DIV_INT); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_QDIV3_DIV_INT, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_QDIV3_DIV_INT, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_QDIV3_DIV_INT, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_QDIV3_DIV_INT, baz); + + let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_SYNC_BYPASS); + bio_bdma_csr.wo(utra::bio_bdma::SFR_SYNC_BYPASS, foo); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_SYNC_BYPASS_SFR_SYNC_BYPASS); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_SYNC_BYPASS_SFR_SYNC_BYPASS, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_SYNC_BYPASS_SFR_SYNC_BYPASS, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_SYNC_BYPASS_SFR_SYNC_BYPASS, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_SYNC_BYPASS_SFR_SYNC_BYPASS, baz); + + let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_IO_OE_INV); + bio_bdma_csr.wo(utra::bio_bdma::SFR_IO_OE_INV, foo); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_IO_OE_INV_SFR_IO_OE_INV); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_IO_OE_INV_SFR_IO_OE_INV, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_IO_OE_INV_SFR_IO_OE_INV, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_IO_OE_INV_SFR_IO_OE_INV, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_IO_OE_INV_SFR_IO_OE_INV, baz); + + let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_IO_O_INV); + bio_bdma_csr.wo(utra::bio_bdma::SFR_IO_O_INV, foo); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_IO_O_INV_SFR_IO_O_INV); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_IO_O_INV_SFR_IO_O_INV, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_IO_O_INV_SFR_IO_O_INV, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_IO_O_INV_SFR_IO_O_INV, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_IO_O_INV_SFR_IO_O_INV, baz); + + let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_IO_I_INV); + bio_bdma_csr.wo(utra::bio_bdma::SFR_IO_I_INV, foo); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_IO_I_INV_SFR_IO_I_INV); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_IO_I_INV_SFR_IO_I_INV, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_IO_I_INV_SFR_IO_I_INV, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_IO_I_INV_SFR_IO_I_INV, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_IO_I_INV_SFR_IO_I_INV, baz); + + let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_IRQMASK_0); + bio_bdma_csr.wo(utra::bio_bdma::SFR_IRQMASK_0, foo); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_IRQMASK_0_SFR_IRQMASK_0); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_IRQMASK_0_SFR_IRQMASK_0, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_IRQMASK_0_SFR_IRQMASK_0, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_IRQMASK_0_SFR_IRQMASK_0, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_IRQMASK_0_SFR_IRQMASK_0, baz); + + let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_IRQMASK_1); + bio_bdma_csr.wo(utra::bio_bdma::SFR_IRQMASK_1, foo); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_IRQMASK_1_SFR_IRQMASK_1); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_IRQMASK_1_SFR_IRQMASK_1, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_IRQMASK_1_SFR_IRQMASK_1, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_IRQMASK_1_SFR_IRQMASK_1, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_IRQMASK_1_SFR_IRQMASK_1, baz); + + let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_IRQMASK_2); + bio_bdma_csr.wo(utra::bio_bdma::SFR_IRQMASK_2, foo); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_IRQMASK_2_SFR_IRQMASK_2); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_IRQMASK_2_SFR_IRQMASK_2, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_IRQMASK_2_SFR_IRQMASK_2, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_IRQMASK_2_SFR_IRQMASK_2, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_IRQMASK_2_SFR_IRQMASK_2, baz); + + let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_IRQMASK_3); + bio_bdma_csr.wo(utra::bio_bdma::SFR_IRQMASK_3, foo); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_IRQMASK_3_SFR_IRQMASK_3); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_IRQMASK_3_SFR_IRQMASK_3, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_IRQMASK_3_SFR_IRQMASK_3, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_IRQMASK_3_SFR_IRQMASK_3, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_IRQMASK_3_SFR_IRQMASK_3, baz); + + let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_IRQ_EDGE); + bio_bdma_csr.wo(utra::bio_bdma::SFR_IRQ_EDGE, foo); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_IRQ_EDGE_SFR_IRQ_EDGE); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_IRQ_EDGE_SFR_IRQ_EDGE, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_IRQ_EDGE_SFR_IRQ_EDGE, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_IRQ_EDGE_SFR_IRQ_EDGE, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_IRQ_EDGE_SFR_IRQ_EDGE, baz); + + let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_DBG_PADOUT); + bio_bdma_csr.wo(utra::bio_bdma::SFR_DBG_PADOUT, foo); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_DBG_PADOUT_SFR_DBG_PADOUT); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_DBG_PADOUT_SFR_DBG_PADOUT, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_DBG_PADOUT_SFR_DBG_PADOUT, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_DBG_PADOUT_SFR_DBG_PADOUT, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_DBG_PADOUT_SFR_DBG_PADOUT, baz); + + let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_DBG_PADOE); + bio_bdma_csr.wo(utra::bio_bdma::SFR_DBG_PADOE, foo); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_DBG_PADOE_SFR_DBG_PADOE); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_DBG_PADOE_SFR_DBG_PADOE, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_DBG_PADOE_SFR_DBG_PADOE, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_DBG_PADOE_SFR_DBG_PADOE, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_DBG_PADOE_SFR_DBG_PADOE, baz); + + let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_DBG0); + bio_bdma_csr.wo(utra::bio_bdma::SFR_DBG0, foo); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_DBG0_DBG_PC); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_DBG0_DBG_PC, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_DBG0_DBG_PC, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_DBG0_DBG_PC, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_DBG0_DBG_PC, baz); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_DBG0_TRAP); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_DBG0_TRAP, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_DBG0_TRAP, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_DBG0_TRAP, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_DBG0_TRAP, baz); + + let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_DBG1); + bio_bdma_csr.wo(utra::bio_bdma::SFR_DBG1, foo); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_DBG1_DBG_PC); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_DBG1_DBG_PC, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_DBG1_DBG_PC, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_DBG1_DBG_PC, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_DBG1_DBG_PC, baz); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_DBG1_TRAP); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_DBG1_TRAP, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_DBG1_TRAP, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_DBG1_TRAP, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_DBG1_TRAP, baz); + + let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_DBG2); + bio_bdma_csr.wo(utra::bio_bdma::SFR_DBG2, foo); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_DBG2_DBG_PC); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_DBG2_DBG_PC, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_DBG2_DBG_PC, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_DBG2_DBG_PC, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_DBG2_DBG_PC, baz); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_DBG2_TRAP); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_DBG2_TRAP, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_DBG2_TRAP, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_DBG2_TRAP, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_DBG2_TRAP, baz); + + let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_DBG3); + bio_bdma_csr.wo(utra::bio_bdma::SFR_DBG3, foo); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_DBG3_DBG_PC); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_DBG3_DBG_PC, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_DBG3_DBG_PC, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_DBG3_DBG_PC, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_DBG3_DBG_PC, baz); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_DBG3_TRAP); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_DBG3_TRAP, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_DBG3_TRAP, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_DBG3_TRAP, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_DBG3_TRAP, baz); + + let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_MEM_GUTTER); + bio_bdma_csr.wo(utra::bio_bdma::SFR_MEM_GUTTER, foo); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_MEM_GUTTER_SFR_MEM_GUTTER); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_MEM_GUTTER_SFR_MEM_GUTTER, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_MEM_GUTTER_SFR_MEM_GUTTER, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_MEM_GUTTER_SFR_MEM_GUTTER, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_MEM_GUTTER_SFR_MEM_GUTTER, baz); + + let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_PERI_GUTTER); + bio_bdma_csr.wo(utra::bio_bdma::SFR_PERI_GUTTER, foo); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_PERI_GUTTER_SFR_PERI_GUTTER); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_PERI_GUTTER_SFR_PERI_GUTTER, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_PERI_GUTTER_SFR_PERI_GUTTER, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_PERI_GUTTER_SFR_PERI_GUTTER, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_PERI_GUTTER_SFR_PERI_GUTTER, baz); + + let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP0); + bio_bdma_csr.wo(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP0, foo); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP0_CR_EVMAP0); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP0_CR_EVMAP0, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP0_CR_EVMAP0, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP0_CR_EVMAP0, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP0_CR_EVMAP0, baz); + + let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP1); + bio_bdma_csr.wo(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP1, foo); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP1_CR_EVMAP1); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP1_CR_EVMAP1, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP1_CR_EVMAP1, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP1_CR_EVMAP1, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP1_CR_EVMAP1, baz); + + let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP2); + bio_bdma_csr.wo(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP2, foo); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP2_CR_EVMAP2); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP2_CR_EVMAP2, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP2_CR_EVMAP2, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP2_CR_EVMAP2, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP2_CR_EVMAP2, baz); + + let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP3); + bio_bdma_csr.wo(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP3, foo); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP3_CR_EVMAP3); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP3_CR_EVMAP3, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP3_CR_EVMAP3, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP3_CR_EVMAP3, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP3_CR_EVMAP3, baz); + + let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP4); + bio_bdma_csr.wo(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP4, foo); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP4_CR_EVMAP4); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP4_CR_EVMAP4, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP4_CR_EVMAP4, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP4_CR_EVMAP4, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP4_CR_EVMAP4, baz); + + let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP5); + bio_bdma_csr.wo(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP5, foo); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP5_CR_EVMAP5); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP5_CR_EVMAP5, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP5_CR_EVMAP5, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP5_CR_EVMAP5, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP5_CR_EVMAP5, baz); + + let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT0); + bio_bdma_csr.wo(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT0, foo); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT0_SR_EVSTAT0); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT0_SR_EVSTAT0, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT0_SR_EVSTAT0, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT0_SR_EVSTAT0, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT0_SR_EVSTAT0, baz); + + let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT1); + bio_bdma_csr.wo(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT1, foo); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT1_SR_EVSTAT1); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT1_SR_EVSTAT1, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT1_SR_EVSTAT1, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT1_SR_EVSTAT1, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT1_SR_EVSTAT1, baz); + + let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT2); + bio_bdma_csr.wo(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT2, foo); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT2_SR_EVSTAT2); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT2_SR_EVSTAT2, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT2_SR_EVSTAT2, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT2_SR_EVSTAT2, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT2_SR_EVSTAT2, baz); + + let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT3); + bio_bdma_csr.wo(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT3, foo); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT3_SR_EVSTAT3); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT3_SR_EVSTAT3, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT3_SR_EVSTAT3, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT3_SR_EVSTAT3, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT3_SR_EVSTAT3, baz); + + let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT4); + bio_bdma_csr.wo(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT4, foo); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT4_SR_EVSTAT4); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT4_SR_EVSTAT4, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT4_SR_EVSTAT4, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT4_SR_EVSTAT4, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT4_SR_EVSTAT4, baz); + + let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT5); + bio_bdma_csr.wo(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT5, foo); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT5_SR_EVSTAT5); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT5_SR_EVSTAT5, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT5_SR_EVSTAT5, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT5_SR_EVSTAT5, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT5_SR_EVSTAT5, baz); + + let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_FILTER_BASE_0); + bio_bdma_csr.wo(utra::bio_bdma::SFR_FILTER_BASE_0, foo); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_FILTER_BASE_0_FILTER_BASE); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_FILTER_BASE_0_FILTER_BASE, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_FILTER_BASE_0_FILTER_BASE, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_FILTER_BASE_0_FILTER_BASE, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_FILTER_BASE_0_FILTER_BASE, baz); + + let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_FILTER_BOUNDS_0); + bio_bdma_csr.wo(utra::bio_bdma::SFR_FILTER_BOUNDS_0, foo); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_FILTER_BOUNDS_0_FILTER_BOUNDS); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_FILTER_BOUNDS_0_FILTER_BOUNDS, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_FILTER_BOUNDS_0_FILTER_BOUNDS, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_FILTER_BOUNDS_0_FILTER_BOUNDS, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_FILTER_BOUNDS_0_FILTER_BOUNDS, baz); + + let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_FILTER_BASE_1); + bio_bdma_csr.wo(utra::bio_bdma::SFR_FILTER_BASE_1, foo); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_FILTER_BASE_1_FILTER_BASE); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_FILTER_BASE_1_FILTER_BASE, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_FILTER_BASE_1_FILTER_BASE, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_FILTER_BASE_1_FILTER_BASE, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_FILTER_BASE_1_FILTER_BASE, baz); + + let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_FILTER_BOUNDS_1); + bio_bdma_csr.wo(utra::bio_bdma::SFR_FILTER_BOUNDS_1, foo); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_FILTER_BOUNDS_1_FILTER_BOUNDS); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_FILTER_BOUNDS_1_FILTER_BOUNDS, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_FILTER_BOUNDS_1_FILTER_BOUNDS, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_FILTER_BOUNDS_1_FILTER_BOUNDS, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_FILTER_BOUNDS_1_FILTER_BOUNDS, baz); + + let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_FILTER_BASE_2); + bio_bdma_csr.wo(utra::bio_bdma::SFR_FILTER_BASE_2, foo); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_FILTER_BASE_2_FILTER_BASE); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_FILTER_BASE_2_FILTER_BASE, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_FILTER_BASE_2_FILTER_BASE, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_FILTER_BASE_2_FILTER_BASE, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_FILTER_BASE_2_FILTER_BASE, baz); + + let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_FILTER_BOUNDS_2); + bio_bdma_csr.wo(utra::bio_bdma::SFR_FILTER_BOUNDS_2, foo); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_FILTER_BOUNDS_2_FILTER_BOUNDS); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_FILTER_BOUNDS_2_FILTER_BOUNDS, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_FILTER_BOUNDS_2_FILTER_BOUNDS, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_FILTER_BOUNDS_2_FILTER_BOUNDS, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_FILTER_BOUNDS_2_FILTER_BOUNDS, baz); + + let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_FILTER_BASE_3); + bio_bdma_csr.wo(utra::bio_bdma::SFR_FILTER_BASE_3, foo); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_FILTER_BASE_3_FILTER_BASE); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_FILTER_BASE_3_FILTER_BASE, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_FILTER_BASE_3_FILTER_BASE, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_FILTER_BASE_3_FILTER_BASE, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_FILTER_BASE_3_FILTER_BASE, baz); + + let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_FILTER_BOUNDS_3); + bio_bdma_csr.wo(utra::bio_bdma::SFR_FILTER_BOUNDS_3, foo); + let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_FILTER_BOUNDS_3_FILTER_BOUNDS); + bio_bdma_csr.rmwf(utra::bio_bdma::SFR_FILTER_BOUNDS_3_FILTER_BOUNDS, bar); + let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_FILTER_BOUNDS_3_FILTER_BOUNDS, bar); + baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_FILTER_BOUNDS_3_FILTER_BOUNDS, 1); + bio_bdma_csr.wfo(utra::bio_bdma::SFR_FILTER_BOUNDS_3_FILTER_BOUNDS, baz); + } + + #[test] + #[ignore] + fn compile_check_iox_csr() { + use super::*; + let mut iox_csr = CSR::new(HW_IOX_BASE as *mut u32); + + let foo = iox_csr.r(utra::iox::SFR_AFSEL_CRAFSEL0); + iox_csr.wo(utra::iox::SFR_AFSEL_CRAFSEL0, foo); + let bar = iox_csr.rf(utra::iox::SFR_AFSEL_CRAFSEL0_CRAFSEL0); + iox_csr.rmwf(utra::iox::SFR_AFSEL_CRAFSEL0_CRAFSEL0, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_AFSEL_CRAFSEL0_CRAFSEL0, bar); + baz |= iox_csr.ms(utra::iox::SFR_AFSEL_CRAFSEL0_CRAFSEL0, 1); + iox_csr.wfo(utra::iox::SFR_AFSEL_CRAFSEL0_CRAFSEL0, baz); + + let foo = iox_csr.r(utra::iox::SFR_AFSEL_CRAFSEL1); + iox_csr.wo(utra::iox::SFR_AFSEL_CRAFSEL1, foo); + let bar = iox_csr.rf(utra::iox::SFR_AFSEL_CRAFSEL1_CRAFSEL1); + iox_csr.rmwf(utra::iox::SFR_AFSEL_CRAFSEL1_CRAFSEL1, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_AFSEL_CRAFSEL1_CRAFSEL1, bar); + baz |= iox_csr.ms(utra::iox::SFR_AFSEL_CRAFSEL1_CRAFSEL1, 1); + iox_csr.wfo(utra::iox::SFR_AFSEL_CRAFSEL1_CRAFSEL1, baz); + + let foo = iox_csr.r(utra::iox::SFR_AFSEL_CRAFSEL2); + iox_csr.wo(utra::iox::SFR_AFSEL_CRAFSEL2, foo); + let bar = iox_csr.rf(utra::iox::SFR_AFSEL_CRAFSEL2_CRAFSEL2); + iox_csr.rmwf(utra::iox::SFR_AFSEL_CRAFSEL2_CRAFSEL2, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_AFSEL_CRAFSEL2_CRAFSEL2, bar); + baz |= iox_csr.ms(utra::iox::SFR_AFSEL_CRAFSEL2_CRAFSEL2, 1); + iox_csr.wfo(utra::iox::SFR_AFSEL_CRAFSEL2_CRAFSEL2, baz); + + let foo = iox_csr.r(utra::iox::SFR_AFSEL_CRAFSEL3); + iox_csr.wo(utra::iox::SFR_AFSEL_CRAFSEL3, foo); + let bar = iox_csr.rf(utra::iox::SFR_AFSEL_CRAFSEL3_CRAFSEL3); + iox_csr.rmwf(utra::iox::SFR_AFSEL_CRAFSEL3_CRAFSEL3, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_AFSEL_CRAFSEL3_CRAFSEL3, bar); + baz |= iox_csr.ms(utra::iox::SFR_AFSEL_CRAFSEL3_CRAFSEL3, 1); + iox_csr.wfo(utra::iox::SFR_AFSEL_CRAFSEL3_CRAFSEL3, baz); + + let foo = iox_csr.r(utra::iox::SFR_AFSEL_CRAFSEL4); + iox_csr.wo(utra::iox::SFR_AFSEL_CRAFSEL4, foo); + let bar = iox_csr.rf(utra::iox::SFR_AFSEL_CRAFSEL4_CRAFSEL4); + iox_csr.rmwf(utra::iox::SFR_AFSEL_CRAFSEL4_CRAFSEL4, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_AFSEL_CRAFSEL4_CRAFSEL4, bar); + baz |= iox_csr.ms(utra::iox::SFR_AFSEL_CRAFSEL4_CRAFSEL4, 1); + iox_csr.wfo(utra::iox::SFR_AFSEL_CRAFSEL4_CRAFSEL4, baz); + + let foo = iox_csr.r(utra::iox::SFR_AFSEL_CRAFSEL5); + iox_csr.wo(utra::iox::SFR_AFSEL_CRAFSEL5, foo); + let bar = iox_csr.rf(utra::iox::SFR_AFSEL_CRAFSEL5_CRAFSEL5); + iox_csr.rmwf(utra::iox::SFR_AFSEL_CRAFSEL5_CRAFSEL5, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_AFSEL_CRAFSEL5_CRAFSEL5, bar); + baz |= iox_csr.ms(utra::iox::SFR_AFSEL_CRAFSEL5_CRAFSEL5, 1); + iox_csr.wfo(utra::iox::SFR_AFSEL_CRAFSEL5_CRAFSEL5, baz); + + let foo = iox_csr.r(utra::iox::SFR_AFSEL_CRAFSEL6); + iox_csr.wo(utra::iox::SFR_AFSEL_CRAFSEL6, foo); + let bar = iox_csr.rf(utra::iox::SFR_AFSEL_CRAFSEL6_CRAFSEL6); + iox_csr.rmwf(utra::iox::SFR_AFSEL_CRAFSEL6_CRAFSEL6, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_AFSEL_CRAFSEL6_CRAFSEL6, bar); + baz |= iox_csr.ms(utra::iox::SFR_AFSEL_CRAFSEL6_CRAFSEL6, 1); + iox_csr.wfo(utra::iox::SFR_AFSEL_CRAFSEL6_CRAFSEL6, baz); + + let foo = iox_csr.r(utra::iox::SFR_AFSEL_CRAFSEL7); + iox_csr.wo(utra::iox::SFR_AFSEL_CRAFSEL7, foo); + let bar = iox_csr.rf(utra::iox::SFR_AFSEL_CRAFSEL7_CRAFSEL7); + iox_csr.rmwf(utra::iox::SFR_AFSEL_CRAFSEL7_CRAFSEL7, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_AFSEL_CRAFSEL7_CRAFSEL7, bar); + baz |= iox_csr.ms(utra::iox::SFR_AFSEL_CRAFSEL7_CRAFSEL7, 1); + iox_csr.wfo(utra::iox::SFR_AFSEL_CRAFSEL7_CRAFSEL7, baz); + + let foo = iox_csr.r(utra::iox::SFR_AFSEL_CRAFSEL8); + iox_csr.wo(utra::iox::SFR_AFSEL_CRAFSEL8, foo); + let bar = iox_csr.rf(utra::iox::SFR_AFSEL_CRAFSEL8_CRAFSEL8); + iox_csr.rmwf(utra::iox::SFR_AFSEL_CRAFSEL8_CRAFSEL8, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_AFSEL_CRAFSEL8_CRAFSEL8, bar); + baz |= iox_csr.ms(utra::iox::SFR_AFSEL_CRAFSEL8_CRAFSEL8, 1); + iox_csr.wfo(utra::iox::SFR_AFSEL_CRAFSEL8_CRAFSEL8, baz); + + let foo = iox_csr.r(utra::iox::SFR_AFSEL_CRAFSEL9); + iox_csr.wo(utra::iox::SFR_AFSEL_CRAFSEL9, foo); + let bar = iox_csr.rf(utra::iox::SFR_AFSEL_CRAFSEL9_CRAFSEL9); + iox_csr.rmwf(utra::iox::SFR_AFSEL_CRAFSEL9_CRAFSEL9, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_AFSEL_CRAFSEL9_CRAFSEL9, bar); + baz |= iox_csr.ms(utra::iox::SFR_AFSEL_CRAFSEL9_CRAFSEL9, 1); + iox_csr.wfo(utra::iox::SFR_AFSEL_CRAFSEL9_CRAFSEL9, baz); + + let foo = iox_csr.r(utra::iox::SFR_AFSEL_CRAFSEL10); + iox_csr.wo(utra::iox::SFR_AFSEL_CRAFSEL10, foo); + let bar = iox_csr.rf(utra::iox::SFR_AFSEL_CRAFSEL10_CRAFSEL10); + iox_csr.rmwf(utra::iox::SFR_AFSEL_CRAFSEL10_CRAFSEL10, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_AFSEL_CRAFSEL10_CRAFSEL10, bar); + baz |= iox_csr.ms(utra::iox::SFR_AFSEL_CRAFSEL10_CRAFSEL10, 1); + iox_csr.wfo(utra::iox::SFR_AFSEL_CRAFSEL10_CRAFSEL10, baz); + + let foo = iox_csr.r(utra::iox::SFR_AFSEL_CRAFSEL11); + iox_csr.wo(utra::iox::SFR_AFSEL_CRAFSEL11, foo); + let bar = iox_csr.rf(utra::iox::SFR_AFSEL_CRAFSEL11_CRAFSEL11); + iox_csr.rmwf(utra::iox::SFR_AFSEL_CRAFSEL11_CRAFSEL11, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_AFSEL_CRAFSEL11_CRAFSEL11, bar); + baz |= iox_csr.ms(utra::iox::SFR_AFSEL_CRAFSEL11_CRAFSEL11, 1); + iox_csr.wfo(utra::iox::SFR_AFSEL_CRAFSEL11_CRAFSEL11, baz); + + let foo = iox_csr.r(utra::iox::SFR_INTCR_CRINT0); + iox_csr.wo(utra::iox::SFR_INTCR_CRINT0, foo); + let bar = iox_csr.rf(utra::iox::SFR_INTCR_CRINT0_CRINT0); + iox_csr.rmwf(utra::iox::SFR_INTCR_CRINT0_CRINT0, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_INTCR_CRINT0_CRINT0, bar); + baz |= iox_csr.ms(utra::iox::SFR_INTCR_CRINT0_CRINT0, 1); + iox_csr.wfo(utra::iox::SFR_INTCR_CRINT0_CRINT0, baz); + + let foo = iox_csr.r(utra::iox::SFR_INTCR_CRINT1); + iox_csr.wo(utra::iox::SFR_INTCR_CRINT1, foo); + let bar = iox_csr.rf(utra::iox::SFR_INTCR_CRINT1_CRINT1); + iox_csr.rmwf(utra::iox::SFR_INTCR_CRINT1_CRINT1, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_INTCR_CRINT1_CRINT1, bar); + baz |= iox_csr.ms(utra::iox::SFR_INTCR_CRINT1_CRINT1, 1); + iox_csr.wfo(utra::iox::SFR_INTCR_CRINT1_CRINT1, baz); + + let foo = iox_csr.r(utra::iox::SFR_INTCR_CRINT2); + iox_csr.wo(utra::iox::SFR_INTCR_CRINT2, foo); + let bar = iox_csr.rf(utra::iox::SFR_INTCR_CRINT2_CRINT2); + iox_csr.rmwf(utra::iox::SFR_INTCR_CRINT2_CRINT2, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_INTCR_CRINT2_CRINT2, bar); + baz |= iox_csr.ms(utra::iox::SFR_INTCR_CRINT2_CRINT2, 1); + iox_csr.wfo(utra::iox::SFR_INTCR_CRINT2_CRINT2, baz); + + let foo = iox_csr.r(utra::iox::SFR_INTCR_CRINT3); + iox_csr.wo(utra::iox::SFR_INTCR_CRINT3, foo); + let bar = iox_csr.rf(utra::iox::SFR_INTCR_CRINT3_CRINT3); + iox_csr.rmwf(utra::iox::SFR_INTCR_CRINT3_CRINT3, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_INTCR_CRINT3_CRINT3, bar); + baz |= iox_csr.ms(utra::iox::SFR_INTCR_CRINT3_CRINT3, 1); + iox_csr.wfo(utra::iox::SFR_INTCR_CRINT3_CRINT3, baz); + + let foo = iox_csr.r(utra::iox::SFR_INTCR_CRINT4); + iox_csr.wo(utra::iox::SFR_INTCR_CRINT4, foo); + let bar = iox_csr.rf(utra::iox::SFR_INTCR_CRINT4_CRINT4); + iox_csr.rmwf(utra::iox::SFR_INTCR_CRINT4_CRINT4, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_INTCR_CRINT4_CRINT4, bar); + baz |= iox_csr.ms(utra::iox::SFR_INTCR_CRINT4_CRINT4, 1); + iox_csr.wfo(utra::iox::SFR_INTCR_CRINT4_CRINT4, baz); + + let foo = iox_csr.r(utra::iox::SFR_INTCR_CRINT5); + iox_csr.wo(utra::iox::SFR_INTCR_CRINT5, foo); + let bar = iox_csr.rf(utra::iox::SFR_INTCR_CRINT5_CRINT5); + iox_csr.rmwf(utra::iox::SFR_INTCR_CRINT5_CRINT5, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_INTCR_CRINT5_CRINT5, bar); + baz |= iox_csr.ms(utra::iox::SFR_INTCR_CRINT5_CRINT5, 1); + iox_csr.wfo(utra::iox::SFR_INTCR_CRINT5_CRINT5, baz); + + let foo = iox_csr.r(utra::iox::SFR_INTCR_CRINT6); + iox_csr.wo(utra::iox::SFR_INTCR_CRINT6, foo); + let bar = iox_csr.rf(utra::iox::SFR_INTCR_CRINT6_CRINT6); + iox_csr.rmwf(utra::iox::SFR_INTCR_CRINT6_CRINT6, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_INTCR_CRINT6_CRINT6, bar); + baz |= iox_csr.ms(utra::iox::SFR_INTCR_CRINT6_CRINT6, 1); + iox_csr.wfo(utra::iox::SFR_INTCR_CRINT6_CRINT6, baz); + + let foo = iox_csr.r(utra::iox::SFR_INTCR_CRINT7); + iox_csr.wo(utra::iox::SFR_INTCR_CRINT7, foo); + let bar = iox_csr.rf(utra::iox::SFR_INTCR_CRINT7_CRINT7); + iox_csr.rmwf(utra::iox::SFR_INTCR_CRINT7_CRINT7, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_INTCR_CRINT7_CRINT7, bar); + baz |= iox_csr.ms(utra::iox::SFR_INTCR_CRINT7_CRINT7, 1); + iox_csr.wfo(utra::iox::SFR_INTCR_CRINT7_CRINT7, baz); + + let foo = iox_csr.r(utra::iox::SFR_INTFR); + iox_csr.wo(utra::iox::SFR_INTFR, foo); + let bar = iox_csr.rf(utra::iox::SFR_INTFR_FRINT); + iox_csr.rmwf(utra::iox::SFR_INTFR_FRINT, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_INTFR_FRINT, bar); + baz |= iox_csr.ms(utra::iox::SFR_INTFR_FRINT, 1); + iox_csr.wfo(utra::iox::SFR_INTFR_FRINT, baz); + + let foo = iox_csr.r(utra::iox::SFR_GPIOOUT_CRGO0); + iox_csr.wo(utra::iox::SFR_GPIOOUT_CRGO0, foo); + let bar = iox_csr.rf(utra::iox::SFR_GPIOOUT_CRGO0_CRGO0); + iox_csr.rmwf(utra::iox::SFR_GPIOOUT_CRGO0_CRGO0, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_GPIOOUT_CRGO0_CRGO0, bar); + baz |= iox_csr.ms(utra::iox::SFR_GPIOOUT_CRGO0_CRGO0, 1); + iox_csr.wfo(utra::iox::SFR_GPIOOUT_CRGO0_CRGO0, baz); + + let foo = iox_csr.r(utra::iox::SFR_GPIOOUT_CRGO1); + iox_csr.wo(utra::iox::SFR_GPIOOUT_CRGO1, foo); + let bar = iox_csr.rf(utra::iox::SFR_GPIOOUT_CRGO1_CRGO1); + iox_csr.rmwf(utra::iox::SFR_GPIOOUT_CRGO1_CRGO1, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_GPIOOUT_CRGO1_CRGO1, bar); + baz |= iox_csr.ms(utra::iox::SFR_GPIOOUT_CRGO1_CRGO1, 1); + iox_csr.wfo(utra::iox::SFR_GPIOOUT_CRGO1_CRGO1, baz); + + let foo = iox_csr.r(utra::iox::SFR_GPIOOUT_CRGO2); + iox_csr.wo(utra::iox::SFR_GPIOOUT_CRGO2, foo); + let bar = iox_csr.rf(utra::iox::SFR_GPIOOUT_CRGO2_CRGO2); + iox_csr.rmwf(utra::iox::SFR_GPIOOUT_CRGO2_CRGO2, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_GPIOOUT_CRGO2_CRGO2, bar); + baz |= iox_csr.ms(utra::iox::SFR_GPIOOUT_CRGO2_CRGO2, 1); + iox_csr.wfo(utra::iox::SFR_GPIOOUT_CRGO2_CRGO2, baz); + + let foo = iox_csr.r(utra::iox::SFR_GPIOOUT_CRGO3); + iox_csr.wo(utra::iox::SFR_GPIOOUT_CRGO3, foo); + let bar = iox_csr.rf(utra::iox::SFR_GPIOOUT_CRGO3_CRGO3); + iox_csr.rmwf(utra::iox::SFR_GPIOOUT_CRGO3_CRGO3, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_GPIOOUT_CRGO3_CRGO3, bar); + baz |= iox_csr.ms(utra::iox::SFR_GPIOOUT_CRGO3_CRGO3, 1); + iox_csr.wfo(utra::iox::SFR_GPIOOUT_CRGO3_CRGO3, baz); + + let foo = iox_csr.r(utra::iox::SFR_GPIOOUT_CRGO4); + iox_csr.wo(utra::iox::SFR_GPIOOUT_CRGO4, foo); + let bar = iox_csr.rf(utra::iox::SFR_GPIOOUT_CRGO4_CRGO4); + iox_csr.rmwf(utra::iox::SFR_GPIOOUT_CRGO4_CRGO4, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_GPIOOUT_CRGO4_CRGO4, bar); + baz |= iox_csr.ms(utra::iox::SFR_GPIOOUT_CRGO4_CRGO4, 1); + iox_csr.wfo(utra::iox::SFR_GPIOOUT_CRGO4_CRGO4, baz); + + let foo = iox_csr.r(utra::iox::SFR_GPIOOUT_CRGO5); + iox_csr.wo(utra::iox::SFR_GPIOOUT_CRGO5, foo); + let bar = iox_csr.rf(utra::iox::SFR_GPIOOUT_CRGO5_CRGO5); + iox_csr.rmwf(utra::iox::SFR_GPIOOUT_CRGO5_CRGO5, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_GPIOOUT_CRGO5_CRGO5, bar); + baz |= iox_csr.ms(utra::iox::SFR_GPIOOUT_CRGO5_CRGO5, 1); + iox_csr.wfo(utra::iox::SFR_GPIOOUT_CRGO5_CRGO5, baz); + + let foo = iox_csr.r(utra::iox::SFR_GPIOOE_CRGOE0); + iox_csr.wo(utra::iox::SFR_GPIOOE_CRGOE0, foo); + let bar = iox_csr.rf(utra::iox::SFR_GPIOOE_CRGOE0_CRGOE0); + iox_csr.rmwf(utra::iox::SFR_GPIOOE_CRGOE0_CRGOE0, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_GPIOOE_CRGOE0_CRGOE0, bar); + baz |= iox_csr.ms(utra::iox::SFR_GPIOOE_CRGOE0_CRGOE0, 1); + iox_csr.wfo(utra::iox::SFR_GPIOOE_CRGOE0_CRGOE0, baz); + + let foo = iox_csr.r(utra::iox::SFR_GPIOOE_CRGOE1); + iox_csr.wo(utra::iox::SFR_GPIOOE_CRGOE1, foo); + let bar = iox_csr.rf(utra::iox::SFR_GPIOOE_CRGOE1_CRGOE1); + iox_csr.rmwf(utra::iox::SFR_GPIOOE_CRGOE1_CRGOE1, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_GPIOOE_CRGOE1_CRGOE1, bar); + baz |= iox_csr.ms(utra::iox::SFR_GPIOOE_CRGOE1_CRGOE1, 1); + iox_csr.wfo(utra::iox::SFR_GPIOOE_CRGOE1_CRGOE1, baz); + + let foo = iox_csr.r(utra::iox::SFR_GPIOOE_CRGOE2); + iox_csr.wo(utra::iox::SFR_GPIOOE_CRGOE2, foo); + let bar = iox_csr.rf(utra::iox::SFR_GPIOOE_CRGOE2_CRGOE2); + iox_csr.rmwf(utra::iox::SFR_GPIOOE_CRGOE2_CRGOE2, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_GPIOOE_CRGOE2_CRGOE2, bar); + baz |= iox_csr.ms(utra::iox::SFR_GPIOOE_CRGOE2_CRGOE2, 1); + iox_csr.wfo(utra::iox::SFR_GPIOOE_CRGOE2_CRGOE2, baz); + + let foo = iox_csr.r(utra::iox::SFR_GPIOOE_CRGOE3); + iox_csr.wo(utra::iox::SFR_GPIOOE_CRGOE3, foo); + let bar = iox_csr.rf(utra::iox::SFR_GPIOOE_CRGOE3_CRGOE3); + iox_csr.rmwf(utra::iox::SFR_GPIOOE_CRGOE3_CRGOE3, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_GPIOOE_CRGOE3_CRGOE3, bar); + baz |= iox_csr.ms(utra::iox::SFR_GPIOOE_CRGOE3_CRGOE3, 1); + iox_csr.wfo(utra::iox::SFR_GPIOOE_CRGOE3_CRGOE3, baz); + + let foo = iox_csr.r(utra::iox::SFR_GPIOOE_CRGOE4); + iox_csr.wo(utra::iox::SFR_GPIOOE_CRGOE4, foo); + let bar = iox_csr.rf(utra::iox::SFR_GPIOOE_CRGOE4_CRGOE4); + iox_csr.rmwf(utra::iox::SFR_GPIOOE_CRGOE4_CRGOE4, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_GPIOOE_CRGOE4_CRGOE4, bar); + baz |= iox_csr.ms(utra::iox::SFR_GPIOOE_CRGOE4_CRGOE4, 1); + iox_csr.wfo(utra::iox::SFR_GPIOOE_CRGOE4_CRGOE4, baz); + + let foo = iox_csr.r(utra::iox::SFR_GPIOOE_CRGOE5); + iox_csr.wo(utra::iox::SFR_GPIOOE_CRGOE5, foo); + let bar = iox_csr.rf(utra::iox::SFR_GPIOOE_CRGOE5_CRGOE5); + iox_csr.rmwf(utra::iox::SFR_GPIOOE_CRGOE5_CRGOE5, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_GPIOOE_CRGOE5_CRGOE5, bar); + baz |= iox_csr.ms(utra::iox::SFR_GPIOOE_CRGOE5_CRGOE5, 1); + iox_csr.wfo(utra::iox::SFR_GPIOOE_CRGOE5_CRGOE5, baz); + + let foo = iox_csr.r(utra::iox::SFR_GPIOPU_CRGPU0); + iox_csr.wo(utra::iox::SFR_GPIOPU_CRGPU0, foo); + let bar = iox_csr.rf(utra::iox::SFR_GPIOPU_CRGPU0_CRGPU0); + iox_csr.rmwf(utra::iox::SFR_GPIOPU_CRGPU0_CRGPU0, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_GPIOPU_CRGPU0_CRGPU0, bar); + baz |= iox_csr.ms(utra::iox::SFR_GPIOPU_CRGPU0_CRGPU0, 1); + iox_csr.wfo(utra::iox::SFR_GPIOPU_CRGPU0_CRGPU0, baz); + + let foo = iox_csr.r(utra::iox::SFR_GPIOPU_CRGPU1); + iox_csr.wo(utra::iox::SFR_GPIOPU_CRGPU1, foo); + let bar = iox_csr.rf(utra::iox::SFR_GPIOPU_CRGPU1_CRGPU1); + iox_csr.rmwf(utra::iox::SFR_GPIOPU_CRGPU1_CRGPU1, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_GPIOPU_CRGPU1_CRGPU1, bar); + baz |= iox_csr.ms(utra::iox::SFR_GPIOPU_CRGPU1_CRGPU1, 1); + iox_csr.wfo(utra::iox::SFR_GPIOPU_CRGPU1_CRGPU1, baz); + + let foo = iox_csr.r(utra::iox::SFR_GPIOPU_CRGPU2); + iox_csr.wo(utra::iox::SFR_GPIOPU_CRGPU2, foo); + let bar = iox_csr.rf(utra::iox::SFR_GPIOPU_CRGPU2_CRGPU2); + iox_csr.rmwf(utra::iox::SFR_GPIOPU_CRGPU2_CRGPU2, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_GPIOPU_CRGPU2_CRGPU2, bar); + baz |= iox_csr.ms(utra::iox::SFR_GPIOPU_CRGPU2_CRGPU2, 1); + iox_csr.wfo(utra::iox::SFR_GPIOPU_CRGPU2_CRGPU2, baz); + + let foo = iox_csr.r(utra::iox::SFR_GPIOPU_CRGPU3); + iox_csr.wo(utra::iox::SFR_GPIOPU_CRGPU3, foo); + let bar = iox_csr.rf(utra::iox::SFR_GPIOPU_CRGPU3_CRGPU3); + iox_csr.rmwf(utra::iox::SFR_GPIOPU_CRGPU3_CRGPU3, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_GPIOPU_CRGPU3_CRGPU3, bar); + baz |= iox_csr.ms(utra::iox::SFR_GPIOPU_CRGPU3_CRGPU3, 1); + iox_csr.wfo(utra::iox::SFR_GPIOPU_CRGPU3_CRGPU3, baz); + + let foo = iox_csr.r(utra::iox::SFR_GPIOPU_CRGPU4); + iox_csr.wo(utra::iox::SFR_GPIOPU_CRGPU4, foo); + let bar = iox_csr.rf(utra::iox::SFR_GPIOPU_CRGPU4_CRGPU4); + iox_csr.rmwf(utra::iox::SFR_GPIOPU_CRGPU4_CRGPU4, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_GPIOPU_CRGPU4_CRGPU4, bar); + baz |= iox_csr.ms(utra::iox::SFR_GPIOPU_CRGPU4_CRGPU4, 1); + iox_csr.wfo(utra::iox::SFR_GPIOPU_CRGPU4_CRGPU4, baz); + + let foo = iox_csr.r(utra::iox::SFR_GPIOPU_CRGPU5); + iox_csr.wo(utra::iox::SFR_GPIOPU_CRGPU5, foo); + let bar = iox_csr.rf(utra::iox::SFR_GPIOPU_CRGPU5_CRGPU5); + iox_csr.rmwf(utra::iox::SFR_GPIOPU_CRGPU5_CRGPU5, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_GPIOPU_CRGPU5_CRGPU5, bar); + baz |= iox_csr.ms(utra::iox::SFR_GPIOPU_CRGPU5_CRGPU5, 1); + iox_csr.wfo(utra::iox::SFR_GPIOPU_CRGPU5_CRGPU5, baz); + + let foo = iox_csr.r(utra::iox::SFR_GPIOIN_SRGI0); + iox_csr.wo(utra::iox::SFR_GPIOIN_SRGI0, foo); + let bar = iox_csr.rf(utra::iox::SFR_GPIOIN_SRGI0_SRGI0); + iox_csr.rmwf(utra::iox::SFR_GPIOIN_SRGI0_SRGI0, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_GPIOIN_SRGI0_SRGI0, bar); + baz |= iox_csr.ms(utra::iox::SFR_GPIOIN_SRGI0_SRGI0, 1); + iox_csr.wfo(utra::iox::SFR_GPIOIN_SRGI0_SRGI0, baz); + + let foo = iox_csr.r(utra::iox::SFR_GPIOIN_SRGI1); + iox_csr.wo(utra::iox::SFR_GPIOIN_SRGI1, foo); + let bar = iox_csr.rf(utra::iox::SFR_GPIOIN_SRGI1_SRGI1); + iox_csr.rmwf(utra::iox::SFR_GPIOIN_SRGI1_SRGI1, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_GPIOIN_SRGI1_SRGI1, bar); + baz |= iox_csr.ms(utra::iox::SFR_GPIOIN_SRGI1_SRGI1, 1); + iox_csr.wfo(utra::iox::SFR_GPIOIN_SRGI1_SRGI1, baz); + + let foo = iox_csr.r(utra::iox::SFR_GPIOIN_SRGI2); + iox_csr.wo(utra::iox::SFR_GPIOIN_SRGI2, foo); + let bar = iox_csr.rf(utra::iox::SFR_GPIOIN_SRGI2_SRGI2); + iox_csr.rmwf(utra::iox::SFR_GPIOIN_SRGI2_SRGI2, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_GPIOIN_SRGI2_SRGI2, bar); + baz |= iox_csr.ms(utra::iox::SFR_GPIOIN_SRGI2_SRGI2, 1); + iox_csr.wfo(utra::iox::SFR_GPIOIN_SRGI2_SRGI2, baz); + + let foo = iox_csr.r(utra::iox::SFR_GPIOIN_SRGI3); + iox_csr.wo(utra::iox::SFR_GPIOIN_SRGI3, foo); + let bar = iox_csr.rf(utra::iox::SFR_GPIOIN_SRGI3_SRGI3); + iox_csr.rmwf(utra::iox::SFR_GPIOIN_SRGI3_SRGI3, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_GPIOIN_SRGI3_SRGI3, bar); + baz |= iox_csr.ms(utra::iox::SFR_GPIOIN_SRGI3_SRGI3, 1); + iox_csr.wfo(utra::iox::SFR_GPIOIN_SRGI3_SRGI3, baz); + + let foo = iox_csr.r(utra::iox::SFR_GPIOIN_SRGI4); + iox_csr.wo(utra::iox::SFR_GPIOIN_SRGI4, foo); + let bar = iox_csr.rf(utra::iox::SFR_GPIOIN_SRGI4_SRGI4); + iox_csr.rmwf(utra::iox::SFR_GPIOIN_SRGI4_SRGI4, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_GPIOIN_SRGI4_SRGI4, bar); + baz |= iox_csr.ms(utra::iox::SFR_GPIOIN_SRGI4_SRGI4, 1); + iox_csr.wfo(utra::iox::SFR_GPIOIN_SRGI4_SRGI4, baz); + + let foo = iox_csr.r(utra::iox::SFR_GPIOIN_SRGI5); + iox_csr.wo(utra::iox::SFR_GPIOIN_SRGI5, foo); + let bar = iox_csr.rf(utra::iox::SFR_GPIOIN_SRGI5_SRGI5); + iox_csr.rmwf(utra::iox::SFR_GPIOIN_SRGI5_SRGI5, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_GPIOIN_SRGI5_SRGI5, bar); + baz |= iox_csr.ms(utra::iox::SFR_GPIOIN_SRGI5_SRGI5, 1); + iox_csr.wfo(utra::iox::SFR_GPIOIN_SRGI5_SRGI5, baz); + + let foo = iox_csr.r(utra::iox::SFR_PIOSEL); + iox_csr.wo(utra::iox::SFR_PIOSEL, foo); + let bar = iox_csr.rf(utra::iox::SFR_PIOSEL_PIOSEL); + iox_csr.rmwf(utra::iox::SFR_PIOSEL_PIOSEL, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_PIOSEL_PIOSEL, bar); + baz |= iox_csr.ms(utra::iox::SFR_PIOSEL_PIOSEL, 1); + iox_csr.wfo(utra::iox::SFR_PIOSEL_PIOSEL, baz); + + let foo = iox_csr.r(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL0); + iox_csr.wo(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL0, foo); + let bar = iox_csr.rf(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL0_CR_CFG_SCHMSEL0); + iox_csr.rmwf(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL0_CR_CFG_SCHMSEL0, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL0_CR_CFG_SCHMSEL0, bar); + baz |= iox_csr.ms(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL0_CR_CFG_SCHMSEL0, 1); + iox_csr.wfo(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL0_CR_CFG_SCHMSEL0, baz); + + let foo = iox_csr.r(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL1); + iox_csr.wo(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL1, foo); + let bar = iox_csr.rf(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL1_CR_CFG_SCHMSEL1); + iox_csr.rmwf(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL1_CR_CFG_SCHMSEL1, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL1_CR_CFG_SCHMSEL1, bar); + baz |= iox_csr.ms(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL1_CR_CFG_SCHMSEL1, 1); + iox_csr.wfo(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL1_CR_CFG_SCHMSEL1, baz); + + let foo = iox_csr.r(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL2); + iox_csr.wo(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL2, foo); + let bar = iox_csr.rf(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL2_CR_CFG_SCHMSEL2); + iox_csr.rmwf(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL2_CR_CFG_SCHMSEL2, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL2_CR_CFG_SCHMSEL2, bar); + baz |= iox_csr.ms(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL2_CR_CFG_SCHMSEL2, 1); + iox_csr.wfo(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL2_CR_CFG_SCHMSEL2, baz); + + let foo = iox_csr.r(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL3); + iox_csr.wo(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL3, foo); + let bar = iox_csr.rf(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL3_CR_CFG_SCHMSEL3); + iox_csr.rmwf(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL3_CR_CFG_SCHMSEL3, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL3_CR_CFG_SCHMSEL3, bar); + baz |= iox_csr.ms(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL3_CR_CFG_SCHMSEL3, 1); + iox_csr.wfo(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL3_CR_CFG_SCHMSEL3, baz); + + let foo = iox_csr.r(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL4); + iox_csr.wo(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL4, foo); + let bar = iox_csr.rf(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL4_CR_CFG_SCHMSEL4); + iox_csr.rmwf(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL4_CR_CFG_SCHMSEL4, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL4_CR_CFG_SCHMSEL4, bar); + baz |= iox_csr.ms(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL4_CR_CFG_SCHMSEL4, 1); + iox_csr.wfo(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL4_CR_CFG_SCHMSEL4, baz); + + let foo = iox_csr.r(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL5); + iox_csr.wo(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL5, foo); + let bar = iox_csr.rf(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL5_CR_CFG_SCHMSEL5); + iox_csr.rmwf(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL5_CR_CFG_SCHMSEL5, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL5_CR_CFG_SCHMSEL5, bar); + baz |= iox_csr.ms(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL5_CR_CFG_SCHMSEL5, 1); + iox_csr.wfo(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL5_CR_CFG_SCHMSEL5, baz); + + let foo = iox_csr.r(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW0); + iox_csr.wo(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW0, foo); + let bar = iox_csr.rf(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW0_CR_CFG_SLEWSLOW0); + iox_csr.rmwf(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW0_CR_CFG_SLEWSLOW0, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW0_CR_CFG_SLEWSLOW0, bar); + baz |= iox_csr.ms(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW0_CR_CFG_SLEWSLOW0, 1); + iox_csr.wfo(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW0_CR_CFG_SLEWSLOW0, baz); + + let foo = iox_csr.r(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW1); + iox_csr.wo(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW1, foo); + let bar = iox_csr.rf(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW1_CR_CFG_SLEWSLOW1); + iox_csr.rmwf(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW1_CR_CFG_SLEWSLOW1, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW1_CR_CFG_SLEWSLOW1, bar); + baz |= iox_csr.ms(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW1_CR_CFG_SLEWSLOW1, 1); + iox_csr.wfo(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW1_CR_CFG_SLEWSLOW1, baz); + + let foo = iox_csr.r(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW2); + iox_csr.wo(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW2, foo); + let bar = iox_csr.rf(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW2_CR_CFG_SLEWSLOW2); + iox_csr.rmwf(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW2_CR_CFG_SLEWSLOW2, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW2_CR_CFG_SLEWSLOW2, bar); + baz |= iox_csr.ms(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW2_CR_CFG_SLEWSLOW2, 1); + iox_csr.wfo(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW2_CR_CFG_SLEWSLOW2, baz); + + let foo = iox_csr.r(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW3); + iox_csr.wo(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW3, foo); + let bar = iox_csr.rf(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW3_CR_CFG_SLEWSLOW3); + iox_csr.rmwf(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW3_CR_CFG_SLEWSLOW3, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW3_CR_CFG_SLEWSLOW3, bar); + baz |= iox_csr.ms(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW3_CR_CFG_SLEWSLOW3, 1); + iox_csr.wfo(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW3_CR_CFG_SLEWSLOW3, baz); + + let foo = iox_csr.r(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW4); + iox_csr.wo(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW4, foo); + let bar = iox_csr.rf(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW4_CR_CFG_SLEWSLOW4); + iox_csr.rmwf(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW4_CR_CFG_SLEWSLOW4, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW4_CR_CFG_SLEWSLOW4, bar); + baz |= iox_csr.ms(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW4_CR_CFG_SLEWSLOW4, 1); + iox_csr.wfo(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW4_CR_CFG_SLEWSLOW4, baz); + + let foo = iox_csr.r(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW5); + iox_csr.wo(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW5, foo); + let bar = iox_csr.rf(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW5_CR_CFG_SLEWSLOW5); + iox_csr.rmwf(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW5_CR_CFG_SLEWSLOW5, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW5_CR_CFG_SLEWSLOW5, bar); + baz |= iox_csr.ms(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW5_CR_CFG_SLEWSLOW5, 1); + iox_csr.wfo(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW5_CR_CFG_SLEWSLOW5, baz); + + let foo = iox_csr.r(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL0); + iox_csr.wo(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL0, foo); + let bar = iox_csr.rf(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL0_CR_CFG_DRVSEL0); + iox_csr.rmwf(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL0_CR_CFG_DRVSEL0, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL0_CR_CFG_DRVSEL0, bar); + baz |= iox_csr.ms(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL0_CR_CFG_DRVSEL0, 1); + iox_csr.wfo(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL0_CR_CFG_DRVSEL0, baz); + + let foo = iox_csr.r(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL1); + iox_csr.wo(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL1, foo); + let bar = iox_csr.rf(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL1_CR_CFG_DRVSEL1); + iox_csr.rmwf(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL1_CR_CFG_DRVSEL1, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL1_CR_CFG_DRVSEL1, bar); + baz |= iox_csr.ms(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL1_CR_CFG_DRVSEL1, 1); + iox_csr.wfo(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL1_CR_CFG_DRVSEL1, baz); + + let foo = iox_csr.r(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL2); + iox_csr.wo(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL2, foo); + let bar = iox_csr.rf(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL2_CR_CFG_DRVSEL2); + iox_csr.rmwf(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL2_CR_CFG_DRVSEL2, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL2_CR_CFG_DRVSEL2, bar); + baz |= iox_csr.ms(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL2_CR_CFG_DRVSEL2, 1); + iox_csr.wfo(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL2_CR_CFG_DRVSEL2, baz); + + let foo = iox_csr.r(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL3); + iox_csr.wo(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL3, foo); + let bar = iox_csr.rf(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL3_CR_CFG_DRVSEL3); + iox_csr.rmwf(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL3_CR_CFG_DRVSEL3, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL3_CR_CFG_DRVSEL3, bar); + baz |= iox_csr.ms(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL3_CR_CFG_DRVSEL3, 1); + iox_csr.wfo(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL3_CR_CFG_DRVSEL3, baz); + + let foo = iox_csr.r(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL4); + iox_csr.wo(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL4, foo); + let bar = iox_csr.rf(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL4_CR_CFG_DRVSEL4); + iox_csr.rmwf(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL4_CR_CFG_DRVSEL4, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL4_CR_CFG_DRVSEL4, bar); + baz |= iox_csr.ms(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL4_CR_CFG_DRVSEL4, 1); + iox_csr.wfo(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL4_CR_CFG_DRVSEL4, baz); + + let foo = iox_csr.r(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL5); + iox_csr.wo(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL5, foo); + let bar = iox_csr.rf(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL5_CR_CFG_DRVSEL5); + iox_csr.rmwf(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL5_CR_CFG_DRVSEL5, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL5_CR_CFG_DRVSEL5, bar); + baz |= iox_csr.ms(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL5_CR_CFG_DRVSEL5, 1); + iox_csr.wfo(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL5_CR_CFG_DRVSEL5, baz); + } + + #[test] + #[ignore] + fn compile_check_pwm_csr() { + use super::*; + let mut pwm_csr = CSR::new(HW_PWM_BASE as *mut u32); + + let foo = pwm_csr.r(utra::pwm::REG_TIM0_CMD); + pwm_csr.wo(utra::pwm::REG_TIM0_CMD, foo); + let bar = pwm_csr.rf(utra::pwm::REG_TIM0_CMD_R_TIMER0_START); + pwm_csr.rmwf(utra::pwm::REG_TIM0_CMD_R_TIMER0_START, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM0_CMD_R_TIMER0_START, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM0_CMD_R_TIMER0_START, 1); + pwm_csr.wfo(utra::pwm::REG_TIM0_CMD_R_TIMER0_START, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM0_CMD_R_TIMER0_STOP); + pwm_csr.rmwf(utra::pwm::REG_TIM0_CMD_R_TIMER0_STOP, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM0_CMD_R_TIMER0_STOP, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM0_CMD_R_TIMER0_STOP, 1); + pwm_csr.wfo(utra::pwm::REG_TIM0_CMD_R_TIMER0_STOP, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM0_CMD_R_TIMER0_UPDATE); + pwm_csr.rmwf(utra::pwm::REG_TIM0_CMD_R_TIMER0_UPDATE, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM0_CMD_R_TIMER0_UPDATE, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM0_CMD_R_TIMER0_UPDATE, 1); + pwm_csr.wfo(utra::pwm::REG_TIM0_CMD_R_TIMER0_UPDATE, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM0_CMD_R_TIMER0_RST); + pwm_csr.rmwf(utra::pwm::REG_TIM0_CMD_R_TIMER0_RST, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM0_CMD_R_TIMER0_RST, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM0_CMD_R_TIMER0_RST, 1); + pwm_csr.wfo(utra::pwm::REG_TIM0_CMD_R_TIMER0_RST, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM0_CMD_R_TIMER0_ARM); + pwm_csr.rmwf(utra::pwm::REG_TIM0_CMD_R_TIMER0_ARM, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM0_CMD_R_TIMER0_ARM, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM0_CMD_R_TIMER0_ARM, 1); + pwm_csr.wfo(utra::pwm::REG_TIM0_CMD_R_TIMER0_ARM, baz); + + let foo = pwm_csr.r(utra::pwm::REG_TIM0_CFG); + pwm_csr.wo(utra::pwm::REG_TIM0_CFG, foo); + let bar = pwm_csr.rf(utra::pwm::REG_TIM0_CFG_R_TIMER0_IN_SEL); + pwm_csr.rmwf(utra::pwm::REG_TIM0_CFG_R_TIMER0_IN_SEL, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM0_CFG_R_TIMER0_IN_SEL, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM0_CFG_R_TIMER0_IN_SEL, 1); + pwm_csr.wfo(utra::pwm::REG_TIM0_CFG_R_TIMER0_IN_SEL, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM0_CFG_R_TIMER0_IN_MODE); + pwm_csr.rmwf(utra::pwm::REG_TIM0_CFG_R_TIMER0_IN_MODE, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM0_CFG_R_TIMER0_IN_MODE, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM0_CFG_R_TIMER0_IN_MODE, 1); + pwm_csr.wfo(utra::pwm::REG_TIM0_CFG_R_TIMER0_IN_MODE, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM0_CFG_R_TIMER0_IN_CLK); + pwm_csr.rmwf(utra::pwm::REG_TIM0_CFG_R_TIMER0_IN_CLK, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM0_CFG_R_TIMER0_IN_CLK, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM0_CFG_R_TIMER0_IN_CLK, 1); + pwm_csr.wfo(utra::pwm::REG_TIM0_CFG_R_TIMER0_IN_CLK, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM0_CFG_R_TIMER0_SAW); + pwm_csr.rmwf(utra::pwm::REG_TIM0_CFG_R_TIMER0_SAW, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM0_CFG_R_TIMER0_SAW, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM0_CFG_R_TIMER0_SAW, 1); + pwm_csr.wfo(utra::pwm::REG_TIM0_CFG_R_TIMER0_SAW, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM0_CFG_R_TIMER0_PRESC); + pwm_csr.rmwf(utra::pwm::REG_TIM0_CFG_R_TIMER0_PRESC, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM0_CFG_R_TIMER0_PRESC, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM0_CFG_R_TIMER0_PRESC, 1); + pwm_csr.wfo(utra::pwm::REG_TIM0_CFG_R_TIMER0_PRESC, baz); + + let foo = pwm_csr.r(utra::pwm::REG_TIM0_CH0_TH); + pwm_csr.wo(utra::pwm::REG_TIM0_CH0_TH, foo); + let bar = pwm_csr.rf(utra::pwm::REG_TIM0_CH0_TH_R_TIMER0_CH0_TH); + pwm_csr.rmwf(utra::pwm::REG_TIM0_CH0_TH_R_TIMER0_CH0_TH, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM0_CH0_TH_R_TIMER0_CH0_TH, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM0_CH0_TH_R_TIMER0_CH0_TH, 1); + pwm_csr.wfo(utra::pwm::REG_TIM0_CH0_TH_R_TIMER0_CH0_TH, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM0_CH0_TH_R_TIMER0_CH0_MODE); + pwm_csr.rmwf(utra::pwm::REG_TIM0_CH0_TH_R_TIMER0_CH0_MODE, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM0_CH0_TH_R_TIMER0_CH0_MODE, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM0_CH0_TH_R_TIMER0_CH0_MODE, 1); + pwm_csr.wfo(utra::pwm::REG_TIM0_CH0_TH_R_TIMER0_CH0_MODE, baz); + + let foo = pwm_csr.r(utra::pwm::REG_TIM0_CH1_TH); + pwm_csr.wo(utra::pwm::REG_TIM0_CH1_TH, foo); + let bar = pwm_csr.rf(utra::pwm::REG_TIM0_CH1_TH_R_TIMER0_CH1_TH); + pwm_csr.rmwf(utra::pwm::REG_TIM0_CH1_TH_R_TIMER0_CH1_TH, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM0_CH1_TH_R_TIMER0_CH1_TH, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM0_CH1_TH_R_TIMER0_CH1_TH, 1); + pwm_csr.wfo(utra::pwm::REG_TIM0_CH1_TH_R_TIMER0_CH1_TH, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM0_CH1_TH_R_TIMER0_CH1_MODE); + pwm_csr.rmwf(utra::pwm::REG_TIM0_CH1_TH_R_TIMER0_CH1_MODE, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM0_CH1_TH_R_TIMER0_CH1_MODE, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM0_CH1_TH_R_TIMER0_CH1_MODE, 1); + pwm_csr.wfo(utra::pwm::REG_TIM0_CH1_TH_R_TIMER0_CH1_MODE, baz); + + let foo = pwm_csr.r(utra::pwm::REG_TIM0_CH2_TH); + pwm_csr.wo(utra::pwm::REG_TIM0_CH2_TH, foo); + let bar = pwm_csr.rf(utra::pwm::REG_TIM0_CH2_TH_R_TIMER0_CH2_TH); + pwm_csr.rmwf(utra::pwm::REG_TIM0_CH2_TH_R_TIMER0_CH2_TH, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM0_CH2_TH_R_TIMER0_CH2_TH, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM0_CH2_TH_R_TIMER0_CH2_TH, 1); + pwm_csr.wfo(utra::pwm::REG_TIM0_CH2_TH_R_TIMER0_CH2_TH, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM0_CH2_TH_R_TIMER0_CH2_MODE); + pwm_csr.rmwf(utra::pwm::REG_TIM0_CH2_TH_R_TIMER0_CH2_MODE, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM0_CH2_TH_R_TIMER0_CH2_MODE, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM0_CH2_TH_R_TIMER0_CH2_MODE, 1); + pwm_csr.wfo(utra::pwm::REG_TIM0_CH2_TH_R_TIMER0_CH2_MODE, baz); + + let foo = pwm_csr.r(utra::pwm::REG_TIM0_CH3_TH); + pwm_csr.wo(utra::pwm::REG_TIM0_CH3_TH, foo); + let bar = pwm_csr.rf(utra::pwm::REG_TIM0_CH3_TH_R_TIMER0_CH3_TH); + pwm_csr.rmwf(utra::pwm::REG_TIM0_CH3_TH_R_TIMER0_CH3_TH, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM0_CH3_TH_R_TIMER0_CH3_TH, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM0_CH3_TH_R_TIMER0_CH3_TH, 1); + pwm_csr.wfo(utra::pwm::REG_TIM0_CH3_TH_R_TIMER0_CH3_TH, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM0_CH3_TH_R_TIMER0_CH3_MODE); + pwm_csr.rmwf(utra::pwm::REG_TIM0_CH3_TH_R_TIMER0_CH3_MODE, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM0_CH3_TH_R_TIMER0_CH3_MODE, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM0_CH3_TH_R_TIMER0_CH3_MODE, 1); + pwm_csr.wfo(utra::pwm::REG_TIM0_CH3_TH_R_TIMER0_CH3_MODE, baz); + + let foo = pwm_csr.r(utra::pwm::REG_TIM0_CH0_LUT); + pwm_csr.wo(utra::pwm::REG_TIM0_CH0_LUT, foo); + let bar = pwm_csr.rf(utra::pwm::REG_TIM0_CH0_LUT_R_TIMER0_CH0_LUT); + pwm_csr.rmwf(utra::pwm::REG_TIM0_CH0_LUT_R_TIMER0_CH0_LUT, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM0_CH0_LUT_R_TIMER0_CH0_LUT, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM0_CH0_LUT_R_TIMER0_CH0_LUT, 1); + pwm_csr.wfo(utra::pwm::REG_TIM0_CH0_LUT_R_TIMER0_CH0_LUT, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM0_CH0_LUT_R_TIMER0_CH0_FLT); + pwm_csr.rmwf(utra::pwm::REG_TIM0_CH0_LUT_R_TIMER0_CH0_FLT, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM0_CH0_LUT_R_TIMER0_CH0_FLT, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM0_CH0_LUT_R_TIMER0_CH0_FLT, 1); + pwm_csr.wfo(utra::pwm::REG_TIM0_CH0_LUT_R_TIMER0_CH0_FLT, baz); + + let foo = pwm_csr.r(utra::pwm::REG_TIM0_CH1_LUT); + pwm_csr.wo(utra::pwm::REG_TIM0_CH1_LUT, foo); + let bar = pwm_csr.rf(utra::pwm::REG_TIM0_CH1_LUT_R_TIMER0_CH1_LUT); + pwm_csr.rmwf(utra::pwm::REG_TIM0_CH1_LUT_R_TIMER0_CH1_LUT, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM0_CH1_LUT_R_TIMER0_CH1_LUT, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM0_CH1_LUT_R_TIMER0_CH1_LUT, 1); + pwm_csr.wfo(utra::pwm::REG_TIM0_CH1_LUT_R_TIMER0_CH1_LUT, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM0_CH1_LUT_R_TIMER0_CH1_FLT); + pwm_csr.rmwf(utra::pwm::REG_TIM0_CH1_LUT_R_TIMER0_CH1_FLT, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM0_CH1_LUT_R_TIMER0_CH1_FLT, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM0_CH1_LUT_R_TIMER0_CH1_FLT, 1); + pwm_csr.wfo(utra::pwm::REG_TIM0_CH1_LUT_R_TIMER0_CH1_FLT, baz); + + let foo = pwm_csr.r(utra::pwm::REG_TIM0_CH2_LUT); + pwm_csr.wo(utra::pwm::REG_TIM0_CH2_LUT, foo); + let bar = pwm_csr.rf(utra::pwm::REG_TIM0_CH2_LUT_R_TIMER0_CH2_LUT); + pwm_csr.rmwf(utra::pwm::REG_TIM0_CH2_LUT_R_TIMER0_CH2_LUT, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM0_CH2_LUT_R_TIMER0_CH2_LUT, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM0_CH2_LUT_R_TIMER0_CH2_LUT, 1); + pwm_csr.wfo(utra::pwm::REG_TIM0_CH2_LUT_R_TIMER0_CH2_LUT, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM0_CH2_LUT_R_TIMER0_CH2_FLT); + pwm_csr.rmwf(utra::pwm::REG_TIM0_CH2_LUT_R_TIMER0_CH2_FLT, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM0_CH2_LUT_R_TIMER0_CH2_FLT, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM0_CH2_LUT_R_TIMER0_CH2_FLT, 1); + pwm_csr.wfo(utra::pwm::REG_TIM0_CH2_LUT_R_TIMER0_CH2_FLT, baz); + + let foo = pwm_csr.r(utra::pwm::REG_TIM0_CH3_LUT); + pwm_csr.wo(utra::pwm::REG_TIM0_CH3_LUT, foo); + let bar = pwm_csr.rf(utra::pwm::REG_TIM0_CH3_LUT_R_TIMER0_CH3_LUT); + pwm_csr.rmwf(utra::pwm::REG_TIM0_CH3_LUT_R_TIMER0_CH3_LUT, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM0_CH3_LUT_R_TIMER0_CH3_LUT, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM0_CH3_LUT_R_TIMER0_CH3_LUT, 1); + pwm_csr.wfo(utra::pwm::REG_TIM0_CH3_LUT_R_TIMER0_CH3_LUT, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM0_CH3_LUT_R_TIMER0_CH3_FLT); + pwm_csr.rmwf(utra::pwm::REG_TIM0_CH3_LUT_R_TIMER0_CH3_FLT, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM0_CH3_LUT_R_TIMER0_CH3_FLT, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM0_CH3_LUT_R_TIMER0_CH3_FLT, 1); + pwm_csr.wfo(utra::pwm::REG_TIM0_CH3_LUT_R_TIMER0_CH3_FLT, baz); + + let foo = pwm_csr.r(utra::pwm::REG_TIM1_CMD); + pwm_csr.wo(utra::pwm::REG_TIM1_CMD, foo); + let bar = pwm_csr.rf(utra::pwm::REG_TIM1_CMD_R_TIMER1_START); + pwm_csr.rmwf(utra::pwm::REG_TIM1_CMD_R_TIMER1_START, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM1_CMD_R_TIMER1_START, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM1_CMD_R_TIMER1_START, 1); + pwm_csr.wfo(utra::pwm::REG_TIM1_CMD_R_TIMER1_START, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM1_CMD_R_TIMER1_STOP); + pwm_csr.rmwf(utra::pwm::REG_TIM1_CMD_R_TIMER1_STOP, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM1_CMD_R_TIMER1_STOP, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM1_CMD_R_TIMER1_STOP, 1); + pwm_csr.wfo(utra::pwm::REG_TIM1_CMD_R_TIMER1_STOP, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM1_CMD_R_TIMER1_UPDATE); + pwm_csr.rmwf(utra::pwm::REG_TIM1_CMD_R_TIMER1_UPDATE, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM1_CMD_R_TIMER1_UPDATE, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM1_CMD_R_TIMER1_UPDATE, 1); + pwm_csr.wfo(utra::pwm::REG_TIM1_CMD_R_TIMER1_UPDATE, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM1_CMD_R_TIMER1_RST); + pwm_csr.rmwf(utra::pwm::REG_TIM1_CMD_R_TIMER1_RST, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM1_CMD_R_TIMER1_RST, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM1_CMD_R_TIMER1_RST, 1); + pwm_csr.wfo(utra::pwm::REG_TIM1_CMD_R_TIMER1_RST, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM1_CMD_R_TIMER1_ARM); + pwm_csr.rmwf(utra::pwm::REG_TIM1_CMD_R_TIMER1_ARM, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM1_CMD_R_TIMER1_ARM, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM1_CMD_R_TIMER1_ARM, 1); + pwm_csr.wfo(utra::pwm::REG_TIM1_CMD_R_TIMER1_ARM, baz); + + let foo = pwm_csr.r(utra::pwm::REG_TIM1_CFG); + pwm_csr.wo(utra::pwm::REG_TIM1_CFG, foo); + let bar = pwm_csr.rf(utra::pwm::REG_TIM1_CFG_R_TIMER1_IN_SEL); + pwm_csr.rmwf(utra::pwm::REG_TIM1_CFG_R_TIMER1_IN_SEL, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM1_CFG_R_TIMER1_IN_SEL, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM1_CFG_R_TIMER1_IN_SEL, 1); + pwm_csr.wfo(utra::pwm::REG_TIM1_CFG_R_TIMER1_IN_SEL, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM1_CFG_R_TIMER1_IN_MODE); + pwm_csr.rmwf(utra::pwm::REG_TIM1_CFG_R_TIMER1_IN_MODE, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM1_CFG_R_TIMER1_IN_MODE, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM1_CFG_R_TIMER1_IN_MODE, 1); + pwm_csr.wfo(utra::pwm::REG_TIM1_CFG_R_TIMER1_IN_MODE, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM1_CFG_R_TIMER1_IN_CLK); + pwm_csr.rmwf(utra::pwm::REG_TIM1_CFG_R_TIMER1_IN_CLK, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM1_CFG_R_TIMER1_IN_CLK, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM1_CFG_R_TIMER1_IN_CLK, 1); + pwm_csr.wfo(utra::pwm::REG_TIM1_CFG_R_TIMER1_IN_CLK, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM1_CFG_R_TIMER1_SAW); + pwm_csr.rmwf(utra::pwm::REG_TIM1_CFG_R_TIMER1_SAW, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM1_CFG_R_TIMER1_SAW, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM1_CFG_R_TIMER1_SAW, 1); + pwm_csr.wfo(utra::pwm::REG_TIM1_CFG_R_TIMER1_SAW, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM1_CFG_R_TIMER1_PRESC); + pwm_csr.rmwf(utra::pwm::REG_TIM1_CFG_R_TIMER1_PRESC, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM1_CFG_R_TIMER1_PRESC, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM1_CFG_R_TIMER1_PRESC, 1); + pwm_csr.wfo(utra::pwm::REG_TIM1_CFG_R_TIMER1_PRESC, baz); + + let foo = pwm_csr.r(utra::pwm::REG_TIM1_CH0_TH); + pwm_csr.wo(utra::pwm::REG_TIM1_CH0_TH, foo); + let bar = pwm_csr.rf(utra::pwm::REG_TIM1_CH0_TH_R_TIMER1_CH0_TH); + pwm_csr.rmwf(utra::pwm::REG_TIM1_CH0_TH_R_TIMER1_CH0_TH, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM1_CH0_TH_R_TIMER1_CH0_TH, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM1_CH0_TH_R_TIMER1_CH0_TH, 1); + pwm_csr.wfo(utra::pwm::REG_TIM1_CH0_TH_R_TIMER1_CH0_TH, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM1_CH0_TH_R_TIMER1_CH0_MODE); + pwm_csr.rmwf(utra::pwm::REG_TIM1_CH0_TH_R_TIMER1_CH0_MODE, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM1_CH0_TH_R_TIMER1_CH0_MODE, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM1_CH0_TH_R_TIMER1_CH0_MODE, 1); + pwm_csr.wfo(utra::pwm::REG_TIM1_CH0_TH_R_TIMER1_CH0_MODE, baz); + + let foo = pwm_csr.r(utra::pwm::REG_TIM1_CH1_TH); + pwm_csr.wo(utra::pwm::REG_TIM1_CH1_TH, foo); + let bar = pwm_csr.rf(utra::pwm::REG_TIM1_CH1_TH_R_TIMER1_CH1_TH); + pwm_csr.rmwf(utra::pwm::REG_TIM1_CH1_TH_R_TIMER1_CH1_TH, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM1_CH1_TH_R_TIMER1_CH1_TH, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM1_CH1_TH_R_TIMER1_CH1_TH, 1); + pwm_csr.wfo(utra::pwm::REG_TIM1_CH1_TH_R_TIMER1_CH1_TH, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM1_CH1_TH_R_TIMER1_CH1_MODE); + pwm_csr.rmwf(utra::pwm::REG_TIM1_CH1_TH_R_TIMER1_CH1_MODE, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM1_CH1_TH_R_TIMER1_CH1_MODE, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM1_CH1_TH_R_TIMER1_CH1_MODE, 1); + pwm_csr.wfo(utra::pwm::REG_TIM1_CH1_TH_R_TIMER1_CH1_MODE, baz); + + let foo = pwm_csr.r(utra::pwm::REG_TIM1_CH2_TH); + pwm_csr.wo(utra::pwm::REG_TIM1_CH2_TH, foo); + let bar = pwm_csr.rf(utra::pwm::REG_TIM1_CH2_TH_R_TIMER1_CH2_TH); + pwm_csr.rmwf(utra::pwm::REG_TIM1_CH2_TH_R_TIMER1_CH2_TH, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM1_CH2_TH_R_TIMER1_CH2_TH, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM1_CH2_TH_R_TIMER1_CH2_TH, 1); + pwm_csr.wfo(utra::pwm::REG_TIM1_CH2_TH_R_TIMER1_CH2_TH, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM1_CH2_TH_R_TIMER1_CH2_MODE); + pwm_csr.rmwf(utra::pwm::REG_TIM1_CH2_TH_R_TIMER1_CH2_MODE, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM1_CH2_TH_R_TIMER1_CH2_MODE, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM1_CH2_TH_R_TIMER1_CH2_MODE, 1); + pwm_csr.wfo(utra::pwm::REG_TIM1_CH2_TH_R_TIMER1_CH2_MODE, baz); + + let foo = pwm_csr.r(utra::pwm::REG_TIM1_CH3_TH); + pwm_csr.wo(utra::pwm::REG_TIM1_CH3_TH, foo); + let bar = pwm_csr.rf(utra::pwm::REG_TIM1_CH3_TH_R_TIMER1_CH3_TH); + pwm_csr.rmwf(utra::pwm::REG_TIM1_CH3_TH_R_TIMER1_CH3_TH, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM1_CH3_TH_R_TIMER1_CH3_TH, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM1_CH3_TH_R_TIMER1_CH3_TH, 1); + pwm_csr.wfo(utra::pwm::REG_TIM1_CH3_TH_R_TIMER1_CH3_TH, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM1_CH3_TH_R_TIMER1_CH3_MODE); + pwm_csr.rmwf(utra::pwm::REG_TIM1_CH3_TH_R_TIMER1_CH3_MODE, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM1_CH3_TH_R_TIMER1_CH3_MODE, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM1_CH3_TH_R_TIMER1_CH3_MODE, 1); + pwm_csr.wfo(utra::pwm::REG_TIM1_CH3_TH_R_TIMER1_CH3_MODE, baz); + + let foo = pwm_csr.r(utra::pwm::REG_TIM1_CH0_LUT); + pwm_csr.wo(utra::pwm::REG_TIM1_CH0_LUT, foo); + let bar = pwm_csr.rf(utra::pwm::REG_TIM1_CH0_LUT_R_TIMER1_CH0_LUT); + pwm_csr.rmwf(utra::pwm::REG_TIM1_CH0_LUT_R_TIMER1_CH0_LUT, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM1_CH0_LUT_R_TIMER1_CH0_LUT, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM1_CH0_LUT_R_TIMER1_CH0_LUT, 1); + pwm_csr.wfo(utra::pwm::REG_TIM1_CH0_LUT_R_TIMER1_CH0_LUT, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM1_CH0_LUT_R_TIMER1_CH0_FLT); + pwm_csr.rmwf(utra::pwm::REG_TIM1_CH0_LUT_R_TIMER1_CH0_FLT, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM1_CH0_LUT_R_TIMER1_CH0_FLT, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM1_CH0_LUT_R_TIMER1_CH0_FLT, 1); + pwm_csr.wfo(utra::pwm::REG_TIM1_CH0_LUT_R_TIMER1_CH0_FLT, baz); + + let foo = pwm_csr.r(utra::pwm::REG_TIM1_CH1_LUT); + pwm_csr.wo(utra::pwm::REG_TIM1_CH1_LUT, foo); + let bar = pwm_csr.rf(utra::pwm::REG_TIM1_CH1_LUT_R_TIMER1_CH1_LUT); + pwm_csr.rmwf(utra::pwm::REG_TIM1_CH1_LUT_R_TIMER1_CH1_LUT, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM1_CH1_LUT_R_TIMER1_CH1_LUT, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM1_CH1_LUT_R_TIMER1_CH1_LUT, 1); + pwm_csr.wfo(utra::pwm::REG_TIM1_CH1_LUT_R_TIMER1_CH1_LUT, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM1_CH1_LUT_R_TIMER1_CH1_FLT); + pwm_csr.rmwf(utra::pwm::REG_TIM1_CH1_LUT_R_TIMER1_CH1_FLT, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM1_CH1_LUT_R_TIMER1_CH1_FLT, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM1_CH1_LUT_R_TIMER1_CH1_FLT, 1); + pwm_csr.wfo(utra::pwm::REG_TIM1_CH1_LUT_R_TIMER1_CH1_FLT, baz); + + let foo = pwm_csr.r(utra::pwm::REG_TIM1_CH2_LUT); + pwm_csr.wo(utra::pwm::REG_TIM1_CH2_LUT, foo); + let bar = pwm_csr.rf(utra::pwm::REG_TIM1_CH2_LUT_R_TIMER1_CH2_LUT); + pwm_csr.rmwf(utra::pwm::REG_TIM1_CH2_LUT_R_TIMER1_CH2_LUT, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM1_CH2_LUT_R_TIMER1_CH2_LUT, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM1_CH2_LUT_R_TIMER1_CH2_LUT, 1); + pwm_csr.wfo(utra::pwm::REG_TIM1_CH2_LUT_R_TIMER1_CH2_LUT, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM1_CH2_LUT_R_TIMER1_CH2_FLT); + pwm_csr.rmwf(utra::pwm::REG_TIM1_CH2_LUT_R_TIMER1_CH2_FLT, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM1_CH2_LUT_R_TIMER1_CH2_FLT, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM1_CH2_LUT_R_TIMER1_CH2_FLT, 1); + pwm_csr.wfo(utra::pwm::REG_TIM1_CH2_LUT_R_TIMER1_CH2_FLT, baz); + + let foo = pwm_csr.r(utra::pwm::REG_TIM1_CH3_LUT); + pwm_csr.wo(utra::pwm::REG_TIM1_CH3_LUT, foo); + let bar = pwm_csr.rf(utra::pwm::REG_TIM1_CH3_LUT_R_TIMER1_CH3_LUT); + pwm_csr.rmwf(utra::pwm::REG_TIM1_CH3_LUT_R_TIMER1_CH3_LUT, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM1_CH3_LUT_R_TIMER1_CH3_LUT, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM1_CH3_LUT_R_TIMER1_CH3_LUT, 1); + pwm_csr.wfo(utra::pwm::REG_TIM1_CH3_LUT_R_TIMER1_CH3_LUT, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM1_CH3_LUT_R_TIMER1_CH3_FLT); + pwm_csr.rmwf(utra::pwm::REG_TIM1_CH3_LUT_R_TIMER1_CH3_FLT, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM1_CH3_LUT_R_TIMER1_CH3_FLT, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM1_CH3_LUT_R_TIMER1_CH3_FLT, 1); + pwm_csr.wfo(utra::pwm::REG_TIM1_CH3_LUT_R_TIMER1_CH3_FLT, baz); + + let foo = pwm_csr.r(utra::pwm::REG_TIM2_CMD); + pwm_csr.wo(utra::pwm::REG_TIM2_CMD, foo); + let bar = pwm_csr.rf(utra::pwm::REG_TIM2_CMD_R_TIMER2_START); + pwm_csr.rmwf(utra::pwm::REG_TIM2_CMD_R_TIMER2_START, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM2_CMD_R_TIMER2_START, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM2_CMD_R_TIMER2_START, 1); + pwm_csr.wfo(utra::pwm::REG_TIM2_CMD_R_TIMER2_START, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM2_CMD_R_TIMER2_STOP); + pwm_csr.rmwf(utra::pwm::REG_TIM2_CMD_R_TIMER2_STOP, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM2_CMD_R_TIMER2_STOP, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM2_CMD_R_TIMER2_STOP, 1); + pwm_csr.wfo(utra::pwm::REG_TIM2_CMD_R_TIMER2_STOP, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM2_CMD_R_TIMER2_UPDATE); + pwm_csr.rmwf(utra::pwm::REG_TIM2_CMD_R_TIMER2_UPDATE, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM2_CMD_R_TIMER2_UPDATE, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM2_CMD_R_TIMER2_UPDATE, 1); + pwm_csr.wfo(utra::pwm::REG_TIM2_CMD_R_TIMER2_UPDATE, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM2_CMD_R_TIMER2_RST); + pwm_csr.rmwf(utra::pwm::REG_TIM2_CMD_R_TIMER2_RST, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM2_CMD_R_TIMER2_RST, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM2_CMD_R_TIMER2_RST, 1); + pwm_csr.wfo(utra::pwm::REG_TIM2_CMD_R_TIMER2_RST, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM2_CMD_R_TIMER2_ARM); + pwm_csr.rmwf(utra::pwm::REG_TIM2_CMD_R_TIMER2_ARM, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM2_CMD_R_TIMER2_ARM, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM2_CMD_R_TIMER2_ARM, 1); + pwm_csr.wfo(utra::pwm::REG_TIM2_CMD_R_TIMER2_ARM, baz); + + let foo = pwm_csr.r(utra::pwm::REG_TIM2_CFG); + pwm_csr.wo(utra::pwm::REG_TIM2_CFG, foo); + let bar = pwm_csr.rf(utra::pwm::REG_TIM2_CFG_R_TIMER2_IN_SEL); + pwm_csr.rmwf(utra::pwm::REG_TIM2_CFG_R_TIMER2_IN_SEL, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM2_CFG_R_TIMER2_IN_SEL, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM2_CFG_R_TIMER2_IN_SEL, 1); + pwm_csr.wfo(utra::pwm::REG_TIM2_CFG_R_TIMER2_IN_SEL, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM2_CFG_R_TIMER2_IN_MODE); + pwm_csr.rmwf(utra::pwm::REG_TIM2_CFG_R_TIMER2_IN_MODE, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM2_CFG_R_TIMER2_IN_MODE, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM2_CFG_R_TIMER2_IN_MODE, 1); + pwm_csr.wfo(utra::pwm::REG_TIM2_CFG_R_TIMER2_IN_MODE, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM2_CFG_R_TIMER2_IN_CLK); + pwm_csr.rmwf(utra::pwm::REG_TIM2_CFG_R_TIMER2_IN_CLK, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM2_CFG_R_TIMER2_IN_CLK, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM2_CFG_R_TIMER2_IN_CLK, 1); + pwm_csr.wfo(utra::pwm::REG_TIM2_CFG_R_TIMER2_IN_CLK, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM2_CFG_R_TIMER2_SAW); + pwm_csr.rmwf(utra::pwm::REG_TIM2_CFG_R_TIMER2_SAW, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM2_CFG_R_TIMER2_SAW, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM2_CFG_R_TIMER2_SAW, 1); + pwm_csr.wfo(utra::pwm::REG_TIM2_CFG_R_TIMER2_SAW, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM2_CFG_R_TIMER2_PRESC); + pwm_csr.rmwf(utra::pwm::REG_TIM2_CFG_R_TIMER2_PRESC, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM2_CFG_R_TIMER2_PRESC, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM2_CFG_R_TIMER2_PRESC, 1); + pwm_csr.wfo(utra::pwm::REG_TIM2_CFG_R_TIMER2_PRESC, baz); + + let foo = pwm_csr.r(utra::pwm::REG_TIM2_CH0_TH); + pwm_csr.wo(utra::pwm::REG_TIM2_CH0_TH, foo); + let bar = pwm_csr.rf(utra::pwm::REG_TIM2_CH0_TH_R_TIMER2_CH0_TH); + pwm_csr.rmwf(utra::pwm::REG_TIM2_CH0_TH_R_TIMER2_CH0_TH, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM2_CH0_TH_R_TIMER2_CH0_TH, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM2_CH0_TH_R_TIMER2_CH0_TH, 1); + pwm_csr.wfo(utra::pwm::REG_TIM2_CH0_TH_R_TIMER2_CH0_TH, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM2_CH0_TH_R_TIMER2_CH0_MODE); + pwm_csr.rmwf(utra::pwm::REG_TIM2_CH0_TH_R_TIMER2_CH0_MODE, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM2_CH0_TH_R_TIMER2_CH0_MODE, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM2_CH0_TH_R_TIMER2_CH0_MODE, 1); + pwm_csr.wfo(utra::pwm::REG_TIM2_CH0_TH_R_TIMER2_CH0_MODE, baz); + + let foo = pwm_csr.r(utra::pwm::REG_TIM2_CH1_TH); + pwm_csr.wo(utra::pwm::REG_TIM2_CH1_TH, foo); + let bar = pwm_csr.rf(utra::pwm::REG_TIM2_CH1_TH_R_TIMER2_CH1_TH); + pwm_csr.rmwf(utra::pwm::REG_TIM2_CH1_TH_R_TIMER2_CH1_TH, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM2_CH1_TH_R_TIMER2_CH1_TH, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM2_CH1_TH_R_TIMER2_CH1_TH, 1); + pwm_csr.wfo(utra::pwm::REG_TIM2_CH1_TH_R_TIMER2_CH1_TH, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM2_CH1_TH_R_TIMER2_CH1_MODE); + pwm_csr.rmwf(utra::pwm::REG_TIM2_CH1_TH_R_TIMER2_CH1_MODE, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM2_CH1_TH_R_TIMER2_CH1_MODE, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM2_CH1_TH_R_TIMER2_CH1_MODE, 1); + pwm_csr.wfo(utra::pwm::REG_TIM2_CH1_TH_R_TIMER2_CH1_MODE, baz); + + let foo = pwm_csr.r(utra::pwm::REG_TIM2_CH2_TH); + pwm_csr.wo(utra::pwm::REG_TIM2_CH2_TH, foo); + let bar = pwm_csr.rf(utra::pwm::REG_TIM2_CH2_TH_R_TIMER2_CH2_TH); + pwm_csr.rmwf(utra::pwm::REG_TIM2_CH2_TH_R_TIMER2_CH2_TH, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM2_CH2_TH_R_TIMER2_CH2_TH, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM2_CH2_TH_R_TIMER2_CH2_TH, 1); + pwm_csr.wfo(utra::pwm::REG_TIM2_CH2_TH_R_TIMER2_CH2_TH, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM2_CH2_TH_R_TIMER2_CH2_MODE); + pwm_csr.rmwf(utra::pwm::REG_TIM2_CH2_TH_R_TIMER2_CH2_MODE, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM2_CH2_TH_R_TIMER2_CH2_MODE, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM2_CH2_TH_R_TIMER2_CH2_MODE, 1); + pwm_csr.wfo(utra::pwm::REG_TIM2_CH2_TH_R_TIMER2_CH2_MODE, baz); + + let foo = pwm_csr.r(utra::pwm::REG_TIM2_CH3_TH); + pwm_csr.wo(utra::pwm::REG_TIM2_CH3_TH, foo); + let bar = pwm_csr.rf(utra::pwm::REG_TIM2_CH3_TH_R_TIMER2_CH3_TH); + pwm_csr.rmwf(utra::pwm::REG_TIM2_CH3_TH_R_TIMER2_CH3_TH, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM2_CH3_TH_R_TIMER2_CH3_TH, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM2_CH3_TH_R_TIMER2_CH3_TH, 1); + pwm_csr.wfo(utra::pwm::REG_TIM2_CH3_TH_R_TIMER2_CH3_TH, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM2_CH3_TH_R_TIMER2_CH3_MODE); + pwm_csr.rmwf(utra::pwm::REG_TIM2_CH3_TH_R_TIMER2_CH3_MODE, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM2_CH3_TH_R_TIMER2_CH3_MODE, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM2_CH3_TH_R_TIMER2_CH3_MODE, 1); + pwm_csr.wfo(utra::pwm::REG_TIM2_CH3_TH_R_TIMER2_CH3_MODE, baz); + + let foo = pwm_csr.r(utra::pwm::REG_TIM2_CH0_LUT); + pwm_csr.wo(utra::pwm::REG_TIM2_CH0_LUT, foo); + let bar = pwm_csr.rf(utra::pwm::REG_TIM2_CH0_LUT_R_TIMER2_CH0_LUT); + pwm_csr.rmwf(utra::pwm::REG_TIM2_CH0_LUT_R_TIMER2_CH0_LUT, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM2_CH0_LUT_R_TIMER2_CH0_LUT, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM2_CH0_LUT_R_TIMER2_CH0_LUT, 1); + pwm_csr.wfo(utra::pwm::REG_TIM2_CH0_LUT_R_TIMER2_CH0_LUT, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM2_CH0_LUT_R_TIMER2_CH0_FLT); + pwm_csr.rmwf(utra::pwm::REG_TIM2_CH0_LUT_R_TIMER2_CH0_FLT, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM2_CH0_LUT_R_TIMER2_CH0_FLT, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM2_CH0_LUT_R_TIMER2_CH0_FLT, 1); + pwm_csr.wfo(utra::pwm::REG_TIM2_CH0_LUT_R_TIMER2_CH0_FLT, baz); + + let foo = pwm_csr.r(utra::pwm::REG_TIM2_CH1_LUT); + pwm_csr.wo(utra::pwm::REG_TIM2_CH1_LUT, foo); + let bar = pwm_csr.rf(utra::pwm::REG_TIM2_CH1_LUT_R_TIMER2_CH1_LUT); + pwm_csr.rmwf(utra::pwm::REG_TIM2_CH1_LUT_R_TIMER2_CH1_LUT, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM2_CH1_LUT_R_TIMER2_CH1_LUT, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM2_CH1_LUT_R_TIMER2_CH1_LUT, 1); + pwm_csr.wfo(utra::pwm::REG_TIM2_CH1_LUT_R_TIMER2_CH1_LUT, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM2_CH1_LUT_R_TIMER2_CH1_FLT); + pwm_csr.rmwf(utra::pwm::REG_TIM2_CH1_LUT_R_TIMER2_CH1_FLT, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM2_CH1_LUT_R_TIMER2_CH1_FLT, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM2_CH1_LUT_R_TIMER2_CH1_FLT, 1); + pwm_csr.wfo(utra::pwm::REG_TIM2_CH1_LUT_R_TIMER2_CH1_FLT, baz); + + let foo = pwm_csr.r(utra::pwm::REG_TIM2_CH2_LUT); + pwm_csr.wo(utra::pwm::REG_TIM2_CH2_LUT, foo); + let bar = pwm_csr.rf(utra::pwm::REG_TIM2_CH2_LUT_R_TIMER2_CH2_LUT); + pwm_csr.rmwf(utra::pwm::REG_TIM2_CH2_LUT_R_TIMER2_CH2_LUT, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM2_CH2_LUT_R_TIMER2_CH2_LUT, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM2_CH2_LUT_R_TIMER2_CH2_LUT, 1); + pwm_csr.wfo(utra::pwm::REG_TIM2_CH2_LUT_R_TIMER2_CH2_LUT, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM2_CH2_LUT_R_TIMER2_CH2_FLT); + pwm_csr.rmwf(utra::pwm::REG_TIM2_CH2_LUT_R_TIMER2_CH2_FLT, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM2_CH2_LUT_R_TIMER2_CH2_FLT, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM2_CH2_LUT_R_TIMER2_CH2_FLT, 1); + pwm_csr.wfo(utra::pwm::REG_TIM2_CH2_LUT_R_TIMER2_CH2_FLT, baz); + + let foo = pwm_csr.r(utra::pwm::REG_TIM2_CH3_LUT); + pwm_csr.wo(utra::pwm::REG_TIM2_CH3_LUT, foo); + let bar = pwm_csr.rf(utra::pwm::REG_TIM2_CH3_LUT_R_TIMER2_CH3_LUT); + pwm_csr.rmwf(utra::pwm::REG_TIM2_CH3_LUT_R_TIMER2_CH3_LUT, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM2_CH3_LUT_R_TIMER2_CH3_LUT, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM2_CH3_LUT_R_TIMER2_CH3_LUT, 1); + pwm_csr.wfo(utra::pwm::REG_TIM2_CH3_LUT_R_TIMER2_CH3_LUT, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM2_CH3_LUT_R_TIMER2_CH3_FLT); + pwm_csr.rmwf(utra::pwm::REG_TIM2_CH3_LUT_R_TIMER2_CH3_FLT, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM2_CH3_LUT_R_TIMER2_CH3_FLT, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM2_CH3_LUT_R_TIMER2_CH3_FLT, 1); + pwm_csr.wfo(utra::pwm::REG_TIM2_CH3_LUT_R_TIMER2_CH3_FLT, baz); + + let foo = pwm_csr.r(utra::pwm::REG_TIM3_CMD); + pwm_csr.wo(utra::pwm::REG_TIM3_CMD, foo); + let bar = pwm_csr.rf(utra::pwm::REG_TIM3_CMD_R_TIMER3_START); + pwm_csr.rmwf(utra::pwm::REG_TIM3_CMD_R_TIMER3_START, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM3_CMD_R_TIMER3_START, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM3_CMD_R_TIMER3_START, 1); + pwm_csr.wfo(utra::pwm::REG_TIM3_CMD_R_TIMER3_START, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM3_CMD_R_TIMER3_STOP); + pwm_csr.rmwf(utra::pwm::REG_TIM3_CMD_R_TIMER3_STOP, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM3_CMD_R_TIMER3_STOP, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM3_CMD_R_TIMER3_STOP, 1); + pwm_csr.wfo(utra::pwm::REG_TIM3_CMD_R_TIMER3_STOP, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM3_CMD_R_TIMER3_UPDATE); + pwm_csr.rmwf(utra::pwm::REG_TIM3_CMD_R_TIMER3_UPDATE, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM3_CMD_R_TIMER3_UPDATE, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM3_CMD_R_TIMER3_UPDATE, 1); + pwm_csr.wfo(utra::pwm::REG_TIM3_CMD_R_TIMER3_UPDATE, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM3_CMD_R_TIMER3_RST); + pwm_csr.rmwf(utra::pwm::REG_TIM3_CMD_R_TIMER3_RST, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM3_CMD_R_TIMER3_RST, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM3_CMD_R_TIMER3_RST, 1); + pwm_csr.wfo(utra::pwm::REG_TIM3_CMD_R_TIMER3_RST, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM3_CMD_R_TIMER3_ARM); + pwm_csr.rmwf(utra::pwm::REG_TIM3_CMD_R_TIMER3_ARM, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM3_CMD_R_TIMER3_ARM, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM3_CMD_R_TIMER3_ARM, 1); + pwm_csr.wfo(utra::pwm::REG_TIM3_CMD_R_TIMER3_ARM, baz); + + let foo = pwm_csr.r(utra::pwm::REG_TIM3_CFG); + pwm_csr.wo(utra::pwm::REG_TIM3_CFG, foo); + let bar = pwm_csr.rf(utra::pwm::REG_TIM3_CFG_R_TIMER3_IN_SEL); + pwm_csr.rmwf(utra::pwm::REG_TIM3_CFG_R_TIMER3_IN_SEL, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM3_CFG_R_TIMER3_IN_SEL, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM3_CFG_R_TIMER3_IN_SEL, 1); + pwm_csr.wfo(utra::pwm::REG_TIM3_CFG_R_TIMER3_IN_SEL, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM3_CFG_R_TIMER3_IN_MODE); + pwm_csr.rmwf(utra::pwm::REG_TIM3_CFG_R_TIMER3_IN_MODE, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM3_CFG_R_TIMER3_IN_MODE, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM3_CFG_R_TIMER3_IN_MODE, 1); + pwm_csr.wfo(utra::pwm::REG_TIM3_CFG_R_TIMER3_IN_MODE, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM3_CFG_R_TIMER3_IN_CLK); + pwm_csr.rmwf(utra::pwm::REG_TIM3_CFG_R_TIMER3_IN_CLK, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM3_CFG_R_TIMER3_IN_CLK, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM3_CFG_R_TIMER3_IN_CLK, 1); + pwm_csr.wfo(utra::pwm::REG_TIM3_CFG_R_TIMER3_IN_CLK, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM3_CFG_R_TIMER3_SAW); + pwm_csr.rmwf(utra::pwm::REG_TIM3_CFG_R_TIMER3_SAW, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM3_CFG_R_TIMER3_SAW, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM3_CFG_R_TIMER3_SAW, 1); + pwm_csr.wfo(utra::pwm::REG_TIM3_CFG_R_TIMER3_SAW, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM3_CFG_R_TIMER3_PRESC); + pwm_csr.rmwf(utra::pwm::REG_TIM3_CFG_R_TIMER3_PRESC, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM3_CFG_R_TIMER3_PRESC, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM3_CFG_R_TIMER3_PRESC, 1); + pwm_csr.wfo(utra::pwm::REG_TIM3_CFG_R_TIMER3_PRESC, baz); + + let foo = pwm_csr.r(utra::pwm::REG_TIM3_CH0_TH); + pwm_csr.wo(utra::pwm::REG_TIM3_CH0_TH, foo); + let bar = pwm_csr.rf(utra::pwm::REG_TIM3_CH0_TH_R_TIMER3_CH0_TH); + pwm_csr.rmwf(utra::pwm::REG_TIM3_CH0_TH_R_TIMER3_CH0_TH, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM3_CH0_TH_R_TIMER3_CH0_TH, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM3_CH0_TH_R_TIMER3_CH0_TH, 1); + pwm_csr.wfo(utra::pwm::REG_TIM3_CH0_TH_R_TIMER3_CH0_TH, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM3_CH0_TH_R_TIMER3_CH0_MODE); + pwm_csr.rmwf(utra::pwm::REG_TIM3_CH0_TH_R_TIMER3_CH0_MODE, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM3_CH0_TH_R_TIMER3_CH0_MODE, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM3_CH0_TH_R_TIMER3_CH0_MODE, 1); + pwm_csr.wfo(utra::pwm::REG_TIM3_CH0_TH_R_TIMER3_CH0_MODE, baz); + + let foo = pwm_csr.r(utra::pwm::REG_TIM3_CH1_TH); + pwm_csr.wo(utra::pwm::REG_TIM3_CH1_TH, foo); + let bar = pwm_csr.rf(utra::pwm::REG_TIM3_CH1_TH_R_TIMER3_CH1_TH); + pwm_csr.rmwf(utra::pwm::REG_TIM3_CH1_TH_R_TIMER3_CH1_TH, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM3_CH1_TH_R_TIMER3_CH1_TH, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM3_CH1_TH_R_TIMER3_CH1_TH, 1); + pwm_csr.wfo(utra::pwm::REG_TIM3_CH1_TH_R_TIMER3_CH1_TH, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM3_CH1_TH_R_TIMER3_CH1_MODE); + pwm_csr.rmwf(utra::pwm::REG_TIM3_CH1_TH_R_TIMER3_CH1_MODE, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM3_CH1_TH_R_TIMER3_CH1_MODE, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM3_CH1_TH_R_TIMER3_CH1_MODE, 1); + pwm_csr.wfo(utra::pwm::REG_TIM3_CH1_TH_R_TIMER3_CH1_MODE, baz); + + let foo = pwm_csr.r(utra::pwm::REG_TIM3_CH2_TH); + pwm_csr.wo(utra::pwm::REG_TIM3_CH2_TH, foo); + let bar = pwm_csr.rf(utra::pwm::REG_TIM3_CH2_TH_R_TIMER3_CH2_TH); + pwm_csr.rmwf(utra::pwm::REG_TIM3_CH2_TH_R_TIMER3_CH2_TH, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM3_CH2_TH_R_TIMER3_CH2_TH, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM3_CH2_TH_R_TIMER3_CH2_TH, 1); + pwm_csr.wfo(utra::pwm::REG_TIM3_CH2_TH_R_TIMER3_CH2_TH, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM3_CH2_TH_R_TIMER3_CH2_MODE); + pwm_csr.rmwf(utra::pwm::REG_TIM3_CH2_TH_R_TIMER3_CH2_MODE, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM3_CH2_TH_R_TIMER3_CH2_MODE, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM3_CH2_TH_R_TIMER3_CH2_MODE, 1); + pwm_csr.wfo(utra::pwm::REG_TIM3_CH2_TH_R_TIMER3_CH2_MODE, baz); + + let foo = pwm_csr.r(utra::pwm::REG_TIM3_CH3_TH); + pwm_csr.wo(utra::pwm::REG_TIM3_CH3_TH, foo); + let bar = pwm_csr.rf(utra::pwm::REG_TIM3_CH3_TH_R_TIMER3_CH3_TH); + pwm_csr.rmwf(utra::pwm::REG_TIM3_CH3_TH_R_TIMER3_CH3_TH, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM3_CH3_TH_R_TIMER3_CH3_TH, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM3_CH3_TH_R_TIMER3_CH3_TH, 1); + pwm_csr.wfo(utra::pwm::REG_TIM3_CH3_TH_R_TIMER3_CH3_TH, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM3_CH3_TH_R_TIMER3_CH3_MODE); + pwm_csr.rmwf(utra::pwm::REG_TIM3_CH3_TH_R_TIMER3_CH3_MODE, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM3_CH3_TH_R_TIMER3_CH3_MODE, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM3_CH3_TH_R_TIMER3_CH3_MODE, 1); + pwm_csr.wfo(utra::pwm::REG_TIM3_CH3_TH_R_TIMER3_CH3_MODE, baz); + + let foo = pwm_csr.r(utra::pwm::REG_TIM3_CH0_LUT); + pwm_csr.wo(utra::pwm::REG_TIM3_CH0_LUT, foo); + let bar = pwm_csr.rf(utra::pwm::REG_TIM3_CH0_LUT_R_TIMER3_CH0_LUT); + pwm_csr.rmwf(utra::pwm::REG_TIM3_CH0_LUT_R_TIMER3_CH0_LUT, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM3_CH0_LUT_R_TIMER3_CH0_LUT, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM3_CH0_LUT_R_TIMER3_CH0_LUT, 1); + pwm_csr.wfo(utra::pwm::REG_TIM3_CH0_LUT_R_TIMER3_CH0_LUT, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM3_CH0_LUT_R_TIMER3_CH0_FLT); + pwm_csr.rmwf(utra::pwm::REG_TIM3_CH0_LUT_R_TIMER3_CH0_FLT, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM3_CH0_LUT_R_TIMER3_CH0_FLT, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM3_CH0_LUT_R_TIMER3_CH0_FLT, 1); + pwm_csr.wfo(utra::pwm::REG_TIM3_CH0_LUT_R_TIMER3_CH0_FLT, baz); + + let foo = pwm_csr.r(utra::pwm::REG_TIM3_CH1_LUT); + pwm_csr.wo(utra::pwm::REG_TIM3_CH1_LUT, foo); + let bar = pwm_csr.rf(utra::pwm::REG_TIM3_CH1_LUT_R_TIMER3_CH1_LUT); + pwm_csr.rmwf(utra::pwm::REG_TIM3_CH1_LUT_R_TIMER3_CH1_LUT, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM3_CH1_LUT_R_TIMER3_CH1_LUT, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM3_CH1_LUT_R_TIMER3_CH1_LUT, 1); + pwm_csr.wfo(utra::pwm::REG_TIM3_CH1_LUT_R_TIMER3_CH1_LUT, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM3_CH1_LUT_R_TIMER3_CH1_FLT); + pwm_csr.rmwf(utra::pwm::REG_TIM3_CH1_LUT_R_TIMER3_CH1_FLT, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM3_CH1_LUT_R_TIMER3_CH1_FLT, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM3_CH1_LUT_R_TIMER3_CH1_FLT, 1); + pwm_csr.wfo(utra::pwm::REG_TIM3_CH1_LUT_R_TIMER3_CH1_FLT, baz); + + let foo = pwm_csr.r(utra::pwm::REG_TIM3_CH2_LUT); + pwm_csr.wo(utra::pwm::REG_TIM3_CH2_LUT, foo); + let bar = pwm_csr.rf(utra::pwm::REG_TIM3_CH2_LUT_R_TIMER3_CH2_LUT); + pwm_csr.rmwf(utra::pwm::REG_TIM3_CH2_LUT_R_TIMER3_CH2_LUT, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM3_CH2_LUT_R_TIMER3_CH2_LUT, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM3_CH2_LUT_R_TIMER3_CH2_LUT, 1); + pwm_csr.wfo(utra::pwm::REG_TIM3_CH2_LUT_R_TIMER3_CH2_LUT, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM3_CH2_LUT_R_TIMER3_CH2_FLT); + pwm_csr.rmwf(utra::pwm::REG_TIM3_CH2_LUT_R_TIMER3_CH2_FLT, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM3_CH2_LUT_R_TIMER3_CH2_FLT, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM3_CH2_LUT_R_TIMER3_CH2_FLT, 1); + pwm_csr.wfo(utra::pwm::REG_TIM3_CH2_LUT_R_TIMER3_CH2_FLT, baz); + + let foo = pwm_csr.r(utra::pwm::REG_TIM3_CH3_LUT); + pwm_csr.wo(utra::pwm::REG_TIM3_CH3_LUT, foo); + let bar = pwm_csr.rf(utra::pwm::REG_TIM3_CH3_LUT_R_TIMER3_CH3_LUT); + pwm_csr.rmwf(utra::pwm::REG_TIM3_CH3_LUT_R_TIMER3_CH3_LUT, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM3_CH3_LUT_R_TIMER3_CH3_LUT, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM3_CH3_LUT_R_TIMER3_CH3_LUT, 1); + pwm_csr.wfo(utra::pwm::REG_TIM3_CH3_LUT_R_TIMER3_CH3_LUT, baz); + let bar = pwm_csr.rf(utra::pwm::REG_TIM3_CH3_LUT_R_TIMER3_CH3_FLT); + pwm_csr.rmwf(utra::pwm::REG_TIM3_CH3_LUT_R_TIMER3_CH3_FLT, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_TIM3_CH3_LUT_R_TIMER3_CH3_FLT, bar); + baz |= pwm_csr.ms(utra::pwm::REG_TIM3_CH3_LUT_R_TIMER3_CH3_FLT, 1); + pwm_csr.wfo(utra::pwm::REG_TIM3_CH3_LUT_R_TIMER3_CH3_FLT, baz); + + let foo = pwm_csr.r(utra::pwm::REG_EVENT_CFG); + pwm_csr.wo(utra::pwm::REG_EVENT_CFG, foo); + let bar = pwm_csr.rf(utra::pwm::REG_EVENT_CFG_R_EVENT_SEL_0); + pwm_csr.rmwf(utra::pwm::REG_EVENT_CFG_R_EVENT_SEL_0, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_EVENT_CFG_R_EVENT_SEL_0, bar); + baz |= pwm_csr.ms(utra::pwm::REG_EVENT_CFG_R_EVENT_SEL_0, 1); + pwm_csr.wfo(utra::pwm::REG_EVENT_CFG_R_EVENT_SEL_0, baz); + let bar = pwm_csr.rf(utra::pwm::REG_EVENT_CFG_R_EVENT_SEL_1); + pwm_csr.rmwf(utra::pwm::REG_EVENT_CFG_R_EVENT_SEL_1, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_EVENT_CFG_R_EVENT_SEL_1, bar); + baz |= pwm_csr.ms(utra::pwm::REG_EVENT_CFG_R_EVENT_SEL_1, 1); + pwm_csr.wfo(utra::pwm::REG_EVENT_CFG_R_EVENT_SEL_1, baz); + let bar = pwm_csr.rf(utra::pwm::REG_EVENT_CFG_R_EVENT_SEL_2); + pwm_csr.rmwf(utra::pwm::REG_EVENT_CFG_R_EVENT_SEL_2, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_EVENT_CFG_R_EVENT_SEL_2, bar); + baz |= pwm_csr.ms(utra::pwm::REG_EVENT_CFG_R_EVENT_SEL_2, 1); + pwm_csr.wfo(utra::pwm::REG_EVENT_CFG_R_EVENT_SEL_2, baz); + let bar = pwm_csr.rf(utra::pwm::REG_EVENT_CFG_R_EVENT_SEL_3); + pwm_csr.rmwf(utra::pwm::REG_EVENT_CFG_R_EVENT_SEL_3, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_EVENT_CFG_R_EVENT_SEL_3, bar); + baz |= pwm_csr.ms(utra::pwm::REG_EVENT_CFG_R_EVENT_SEL_3, 1); + pwm_csr.wfo(utra::pwm::REG_EVENT_CFG_R_EVENT_SEL_3, baz); + let bar = pwm_csr.rf(utra::pwm::REG_EVENT_CFG_R_EVENT_EN); + pwm_csr.rmwf(utra::pwm::REG_EVENT_CFG_R_EVENT_EN, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_EVENT_CFG_R_EVENT_EN, bar); + baz |= pwm_csr.ms(utra::pwm::REG_EVENT_CFG_R_EVENT_EN, 1); + pwm_csr.wfo(utra::pwm::REG_EVENT_CFG_R_EVENT_EN, baz); + + let foo = pwm_csr.r(utra::pwm::REG_CH_EN); + pwm_csr.wo(utra::pwm::REG_CH_EN, foo); + let bar = pwm_csr.rf(utra::pwm::REG_CH_EN_R_CLK_EN); + pwm_csr.rmwf(utra::pwm::REG_CH_EN_R_CLK_EN, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_CH_EN_R_CLK_EN, bar); + baz |= pwm_csr.ms(utra::pwm::REG_CH_EN_R_CLK_EN, 1); + pwm_csr.wfo(utra::pwm::REG_CH_EN_R_CLK_EN, baz); + + let foo = pwm_csr.r(utra::pwm::REG_PREFD0); + pwm_csr.wo(utra::pwm::REG_PREFD0, foo); + let bar = pwm_csr.rf(utra::pwm::REG_PREFD0_LSCLK_PREFD_0); + pwm_csr.rmwf(utra::pwm::REG_PREFD0_LSCLK_PREFD_0, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_PREFD0_LSCLK_PREFD_0, bar); + baz |= pwm_csr.ms(utra::pwm::REG_PREFD0_LSCLK_PREFD_0, 1); + pwm_csr.wfo(utra::pwm::REG_PREFD0_LSCLK_PREFD_0, baz); + + let foo = pwm_csr.r(utra::pwm::REG_PREFD1); + pwm_csr.wo(utra::pwm::REG_PREFD1, foo); + let bar = pwm_csr.rf(utra::pwm::REG_PREFD1_LSCLK_PREFD_1); + pwm_csr.rmwf(utra::pwm::REG_PREFD1_LSCLK_PREFD_1, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_PREFD1_LSCLK_PREFD_1, bar); + baz |= pwm_csr.ms(utra::pwm::REG_PREFD1_LSCLK_PREFD_1, 1); + pwm_csr.wfo(utra::pwm::REG_PREFD1_LSCLK_PREFD_1, baz); + + let foo = pwm_csr.r(utra::pwm::REG_PREFD2); + pwm_csr.wo(utra::pwm::REG_PREFD2, foo); + let bar = pwm_csr.rf(utra::pwm::REG_PREFD2_LSCLK_PREFD_2); + pwm_csr.rmwf(utra::pwm::REG_PREFD2_LSCLK_PREFD_2, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_PREFD2_LSCLK_PREFD_2, bar); + baz |= pwm_csr.ms(utra::pwm::REG_PREFD2_LSCLK_PREFD_2, 1); + pwm_csr.wfo(utra::pwm::REG_PREFD2_LSCLK_PREFD_2, baz); + + let foo = pwm_csr.r(utra::pwm::REG_PREFD3); + pwm_csr.wo(utra::pwm::REG_PREFD3, foo); + let bar = pwm_csr.rf(utra::pwm::REG_PREFD3_LSCLK_PREFD_3); + pwm_csr.rmwf(utra::pwm::REG_PREFD3_LSCLK_PREFD_3, bar); + let mut baz = pwm_csr.zf(utra::pwm::REG_PREFD3_LSCLK_PREFD_3, bar); + baz |= pwm_csr.ms(utra::pwm::REG_PREFD3_LSCLK_PREFD_3, 1); + pwm_csr.wfo(utra::pwm::REG_PREFD3_LSCLK_PREFD_3, baz); + } + + #[test] + #[ignore] + fn compile_check_coresub_sramtrm_csr() { + use super::*; + let mut coresub_sramtrm_csr = CSR::new(HW_CORESUB_SRAMTRM_BASE as *mut u32); + + let foo = coresub_sramtrm_csr.r(utra::coresub_sramtrm::SFR_CACHE); + coresub_sramtrm_csr.wo(utra::coresub_sramtrm::SFR_CACHE, foo); + let bar = coresub_sramtrm_csr.rf(utra::coresub_sramtrm::SFR_CACHE_SFR_CACHE); + coresub_sramtrm_csr.rmwf(utra::coresub_sramtrm::SFR_CACHE_SFR_CACHE, bar); + let mut baz = coresub_sramtrm_csr.zf(utra::coresub_sramtrm::SFR_CACHE_SFR_CACHE, bar); + baz |= coresub_sramtrm_csr.ms(utra::coresub_sramtrm::SFR_CACHE_SFR_CACHE, 1); + coresub_sramtrm_csr.wfo(utra::coresub_sramtrm::SFR_CACHE_SFR_CACHE, baz); + + let foo = coresub_sramtrm_csr.r(utra::coresub_sramtrm::SFR_ITCM); + coresub_sramtrm_csr.wo(utra::coresub_sramtrm::SFR_ITCM, foo); + let bar = coresub_sramtrm_csr.rf(utra::coresub_sramtrm::SFR_ITCM_SFR_ITCM); + coresub_sramtrm_csr.rmwf(utra::coresub_sramtrm::SFR_ITCM_SFR_ITCM, bar); + let mut baz = coresub_sramtrm_csr.zf(utra::coresub_sramtrm::SFR_ITCM_SFR_ITCM, bar); + baz |= coresub_sramtrm_csr.ms(utra::coresub_sramtrm::SFR_ITCM_SFR_ITCM, 1); + coresub_sramtrm_csr.wfo(utra::coresub_sramtrm::SFR_ITCM_SFR_ITCM, baz); + + let foo = coresub_sramtrm_csr.r(utra::coresub_sramtrm::SFR_DTCM); + coresub_sramtrm_csr.wo(utra::coresub_sramtrm::SFR_DTCM, foo); + let bar = coresub_sramtrm_csr.rf(utra::coresub_sramtrm::SFR_DTCM_SFR_DTCM); + coresub_sramtrm_csr.rmwf(utra::coresub_sramtrm::SFR_DTCM_SFR_DTCM, bar); + let mut baz = coresub_sramtrm_csr.zf(utra::coresub_sramtrm::SFR_DTCM_SFR_DTCM, bar); + baz |= coresub_sramtrm_csr.ms(utra::coresub_sramtrm::SFR_DTCM_SFR_DTCM, 1); + coresub_sramtrm_csr.wfo(utra::coresub_sramtrm::SFR_DTCM_SFR_DTCM, baz); + + let foo = coresub_sramtrm_csr.r(utra::coresub_sramtrm::SFR_SRAM0); + coresub_sramtrm_csr.wo(utra::coresub_sramtrm::SFR_SRAM0, foo); + let bar = coresub_sramtrm_csr.rf(utra::coresub_sramtrm::SFR_SRAM0_SFR_SRAM0); + coresub_sramtrm_csr.rmwf(utra::coresub_sramtrm::SFR_SRAM0_SFR_SRAM0, bar); + let mut baz = coresub_sramtrm_csr.zf(utra::coresub_sramtrm::SFR_SRAM0_SFR_SRAM0, bar); + baz |= coresub_sramtrm_csr.ms(utra::coresub_sramtrm::SFR_SRAM0_SFR_SRAM0, 1); + coresub_sramtrm_csr.wfo(utra::coresub_sramtrm::SFR_SRAM0_SFR_SRAM0, baz); + + let foo = coresub_sramtrm_csr.r(utra::coresub_sramtrm::SFR_SRAM1); + coresub_sramtrm_csr.wo(utra::coresub_sramtrm::SFR_SRAM1, foo); + let bar = coresub_sramtrm_csr.rf(utra::coresub_sramtrm::SFR_SRAM1_SFR_SRAM1); + coresub_sramtrm_csr.rmwf(utra::coresub_sramtrm::SFR_SRAM1_SFR_SRAM1, bar); + let mut baz = coresub_sramtrm_csr.zf(utra::coresub_sramtrm::SFR_SRAM1_SFR_SRAM1, bar); + baz |= coresub_sramtrm_csr.ms(utra::coresub_sramtrm::SFR_SRAM1_SFR_SRAM1, 1); + coresub_sramtrm_csr.wfo(utra::coresub_sramtrm::SFR_SRAM1_SFR_SRAM1, baz); + + let foo = coresub_sramtrm_csr.r(utra::coresub_sramtrm::SFR_VEXRAM); + coresub_sramtrm_csr.wo(utra::coresub_sramtrm::SFR_VEXRAM, foo); + let bar = coresub_sramtrm_csr.rf(utra::coresub_sramtrm::SFR_VEXRAM_SFR_VEXRAM); + coresub_sramtrm_csr.rmwf(utra::coresub_sramtrm::SFR_VEXRAM_SFR_VEXRAM, bar); + let mut baz = coresub_sramtrm_csr.zf(utra::coresub_sramtrm::SFR_VEXRAM_SFR_VEXRAM, bar); + baz |= coresub_sramtrm_csr.ms(utra::coresub_sramtrm::SFR_VEXRAM_SFR_VEXRAM, 1); + coresub_sramtrm_csr.wfo(utra::coresub_sramtrm::SFR_VEXRAM_SFR_VEXRAM, baz); + + let foo = coresub_sramtrm_csr.r(utra::coresub_sramtrm::SFR_SRAMERR); + coresub_sramtrm_csr.wo(utra::coresub_sramtrm::SFR_SRAMERR, foo); + let bar = coresub_sramtrm_csr.rf(utra::coresub_sramtrm::SFR_SRAMERR_SRAMBANKERR); + coresub_sramtrm_csr.rmwf(utra::coresub_sramtrm::SFR_SRAMERR_SRAMBANKERR, bar); + let mut baz = coresub_sramtrm_csr.zf(utra::coresub_sramtrm::SFR_SRAMERR_SRAMBANKERR, bar); + baz |= coresub_sramtrm_csr.ms(utra::coresub_sramtrm::SFR_SRAMERR_SRAMBANKERR, 1); + coresub_sramtrm_csr.wfo(utra::coresub_sramtrm::SFR_SRAMERR_SRAMBANKERR, baz); + } + + #[test] + #[ignore] + fn compile_check_mdma_csr() { + use super::*; + let mut mdma_csr = CSR::new(HW_MDMA_BASE as *mut u32); + + let foo = mdma_csr.r(utra::mdma::SFR_EVSEL_CR_EVSEL0); + mdma_csr.wo(utra::mdma::SFR_EVSEL_CR_EVSEL0, foo); + let bar = mdma_csr.rf(utra::mdma::SFR_EVSEL_CR_EVSEL0_CR_EVSEL0); + mdma_csr.rmwf(utra::mdma::SFR_EVSEL_CR_EVSEL0_CR_EVSEL0, bar); + let mut baz = mdma_csr.zf(utra::mdma::SFR_EVSEL_CR_EVSEL0_CR_EVSEL0, bar); + baz |= mdma_csr.ms(utra::mdma::SFR_EVSEL_CR_EVSEL0_CR_EVSEL0, 1); + mdma_csr.wfo(utra::mdma::SFR_EVSEL_CR_EVSEL0_CR_EVSEL0, baz); + + let foo = mdma_csr.r(utra::mdma::SFR_EVSEL_CR_EVSEL1); + mdma_csr.wo(utra::mdma::SFR_EVSEL_CR_EVSEL1, foo); + let bar = mdma_csr.rf(utra::mdma::SFR_EVSEL_CR_EVSEL1_CR_EVSEL1); + mdma_csr.rmwf(utra::mdma::SFR_EVSEL_CR_EVSEL1_CR_EVSEL1, bar); + let mut baz = mdma_csr.zf(utra::mdma::SFR_EVSEL_CR_EVSEL1_CR_EVSEL1, bar); + baz |= mdma_csr.ms(utra::mdma::SFR_EVSEL_CR_EVSEL1_CR_EVSEL1, 1); + mdma_csr.wfo(utra::mdma::SFR_EVSEL_CR_EVSEL1_CR_EVSEL1, baz); + + let foo = mdma_csr.r(utra::mdma::SFR_EVSEL_CR_EVSEL2); + mdma_csr.wo(utra::mdma::SFR_EVSEL_CR_EVSEL2, foo); + let bar = mdma_csr.rf(utra::mdma::SFR_EVSEL_CR_EVSEL2_CR_EVSEL2); + mdma_csr.rmwf(utra::mdma::SFR_EVSEL_CR_EVSEL2_CR_EVSEL2, bar); + let mut baz = mdma_csr.zf(utra::mdma::SFR_EVSEL_CR_EVSEL2_CR_EVSEL2, bar); + baz |= mdma_csr.ms(utra::mdma::SFR_EVSEL_CR_EVSEL2_CR_EVSEL2, 1); + mdma_csr.wfo(utra::mdma::SFR_EVSEL_CR_EVSEL2_CR_EVSEL2, baz); + + let foo = mdma_csr.r(utra::mdma::SFR_EVSEL_CR_EVSEL3); + mdma_csr.wo(utra::mdma::SFR_EVSEL_CR_EVSEL3, foo); + let bar = mdma_csr.rf(utra::mdma::SFR_EVSEL_CR_EVSEL3_CR_EVSEL3); + mdma_csr.rmwf(utra::mdma::SFR_EVSEL_CR_EVSEL3_CR_EVSEL3, bar); + let mut baz = mdma_csr.zf(utra::mdma::SFR_EVSEL_CR_EVSEL3_CR_EVSEL3, bar); + baz |= mdma_csr.ms(utra::mdma::SFR_EVSEL_CR_EVSEL3_CR_EVSEL3, 1); + mdma_csr.wfo(utra::mdma::SFR_EVSEL_CR_EVSEL3_CR_EVSEL3, baz); + + let foo = mdma_csr.r(utra::mdma::SFR_EVSEL_CR_EVSEL4); + mdma_csr.wo(utra::mdma::SFR_EVSEL_CR_EVSEL4, foo); + let bar = mdma_csr.rf(utra::mdma::SFR_EVSEL_CR_EVSEL4_CR_EVSEL4); + mdma_csr.rmwf(utra::mdma::SFR_EVSEL_CR_EVSEL4_CR_EVSEL4, bar); + let mut baz = mdma_csr.zf(utra::mdma::SFR_EVSEL_CR_EVSEL4_CR_EVSEL4, bar); + baz |= mdma_csr.ms(utra::mdma::SFR_EVSEL_CR_EVSEL4_CR_EVSEL4, 1); + mdma_csr.wfo(utra::mdma::SFR_EVSEL_CR_EVSEL4_CR_EVSEL4, baz); + + let foo = mdma_csr.r(utra::mdma::SFR_EVSEL_CR_EVSEL5); + mdma_csr.wo(utra::mdma::SFR_EVSEL_CR_EVSEL5, foo); + let bar = mdma_csr.rf(utra::mdma::SFR_EVSEL_CR_EVSEL5_CR_EVSEL5); + mdma_csr.rmwf(utra::mdma::SFR_EVSEL_CR_EVSEL5_CR_EVSEL5, bar); + let mut baz = mdma_csr.zf(utra::mdma::SFR_EVSEL_CR_EVSEL5_CR_EVSEL5, bar); + baz |= mdma_csr.ms(utra::mdma::SFR_EVSEL_CR_EVSEL5_CR_EVSEL5, 1); + mdma_csr.wfo(utra::mdma::SFR_EVSEL_CR_EVSEL5_CR_EVSEL5, baz); + + let foo = mdma_csr.r(utra::mdma::SFR_EVSEL_CR_EVSEL6); + mdma_csr.wo(utra::mdma::SFR_EVSEL_CR_EVSEL6, foo); + let bar = mdma_csr.rf(utra::mdma::SFR_EVSEL_CR_EVSEL6_CR_EVSEL6); + mdma_csr.rmwf(utra::mdma::SFR_EVSEL_CR_EVSEL6_CR_EVSEL6, bar); + let mut baz = mdma_csr.zf(utra::mdma::SFR_EVSEL_CR_EVSEL6_CR_EVSEL6, bar); + baz |= mdma_csr.ms(utra::mdma::SFR_EVSEL_CR_EVSEL6_CR_EVSEL6, 1); + mdma_csr.wfo(utra::mdma::SFR_EVSEL_CR_EVSEL6_CR_EVSEL6, baz); + + let foo = mdma_csr.r(utra::mdma::SFR_EVSEL_CR_EVSEL7); + mdma_csr.wo(utra::mdma::SFR_EVSEL_CR_EVSEL7, foo); + let bar = mdma_csr.rf(utra::mdma::SFR_EVSEL_CR_EVSEL7_CR_EVSEL7); + mdma_csr.rmwf(utra::mdma::SFR_EVSEL_CR_EVSEL7_CR_EVSEL7, bar); + let mut baz = mdma_csr.zf(utra::mdma::SFR_EVSEL_CR_EVSEL7_CR_EVSEL7, bar); + baz |= mdma_csr.ms(utra::mdma::SFR_EVSEL_CR_EVSEL7_CR_EVSEL7, 1); + mdma_csr.wfo(utra::mdma::SFR_EVSEL_CR_EVSEL7_CR_EVSEL7, baz); + + let foo = mdma_csr.r(utra::mdma::SFR_CR_CR_MDMAREQ0); + mdma_csr.wo(utra::mdma::SFR_CR_CR_MDMAREQ0, foo); + let bar = mdma_csr.rf(utra::mdma::SFR_CR_CR_MDMAREQ0_CR_MDMAREQ0); + mdma_csr.rmwf(utra::mdma::SFR_CR_CR_MDMAREQ0_CR_MDMAREQ0, bar); + let mut baz = mdma_csr.zf(utra::mdma::SFR_CR_CR_MDMAREQ0_CR_MDMAREQ0, bar); + baz |= mdma_csr.ms(utra::mdma::SFR_CR_CR_MDMAREQ0_CR_MDMAREQ0, 1); + mdma_csr.wfo(utra::mdma::SFR_CR_CR_MDMAREQ0_CR_MDMAREQ0, baz); + + let foo = mdma_csr.r(utra::mdma::SFR_CR_CR_MDMAREQ1); + mdma_csr.wo(utra::mdma::SFR_CR_CR_MDMAREQ1, foo); + let bar = mdma_csr.rf(utra::mdma::SFR_CR_CR_MDMAREQ1_CR_MDMAREQ1); + mdma_csr.rmwf(utra::mdma::SFR_CR_CR_MDMAREQ1_CR_MDMAREQ1, bar); + let mut baz = mdma_csr.zf(utra::mdma::SFR_CR_CR_MDMAREQ1_CR_MDMAREQ1, bar); + baz |= mdma_csr.ms(utra::mdma::SFR_CR_CR_MDMAREQ1_CR_MDMAREQ1, 1); + mdma_csr.wfo(utra::mdma::SFR_CR_CR_MDMAREQ1_CR_MDMAREQ1, baz); + + let foo = mdma_csr.r(utra::mdma::SFR_CR_CR_MDMAREQ2); + mdma_csr.wo(utra::mdma::SFR_CR_CR_MDMAREQ2, foo); + let bar = mdma_csr.rf(utra::mdma::SFR_CR_CR_MDMAREQ2_CR_MDMAREQ2); + mdma_csr.rmwf(utra::mdma::SFR_CR_CR_MDMAREQ2_CR_MDMAREQ2, bar); + let mut baz = mdma_csr.zf(utra::mdma::SFR_CR_CR_MDMAREQ2_CR_MDMAREQ2, bar); + baz |= mdma_csr.ms(utra::mdma::SFR_CR_CR_MDMAREQ2_CR_MDMAREQ2, 1); + mdma_csr.wfo(utra::mdma::SFR_CR_CR_MDMAREQ2_CR_MDMAREQ2, baz); + + let foo = mdma_csr.r(utra::mdma::SFR_CR_CR_MDMAREQ3); + mdma_csr.wo(utra::mdma::SFR_CR_CR_MDMAREQ3, foo); + let bar = mdma_csr.rf(utra::mdma::SFR_CR_CR_MDMAREQ3_CR_MDMAREQ3); + mdma_csr.rmwf(utra::mdma::SFR_CR_CR_MDMAREQ3_CR_MDMAREQ3, bar); + let mut baz = mdma_csr.zf(utra::mdma::SFR_CR_CR_MDMAREQ3_CR_MDMAREQ3, bar); + baz |= mdma_csr.ms(utra::mdma::SFR_CR_CR_MDMAREQ3_CR_MDMAREQ3, 1); + mdma_csr.wfo(utra::mdma::SFR_CR_CR_MDMAREQ3_CR_MDMAREQ3, baz); + + let foo = mdma_csr.r(utra::mdma::SFR_CR_CR_MDMAREQ4); + mdma_csr.wo(utra::mdma::SFR_CR_CR_MDMAREQ4, foo); + let bar = mdma_csr.rf(utra::mdma::SFR_CR_CR_MDMAREQ4_CR_MDMAREQ4); + mdma_csr.rmwf(utra::mdma::SFR_CR_CR_MDMAREQ4_CR_MDMAREQ4, bar); + let mut baz = mdma_csr.zf(utra::mdma::SFR_CR_CR_MDMAREQ4_CR_MDMAREQ4, bar); + baz |= mdma_csr.ms(utra::mdma::SFR_CR_CR_MDMAREQ4_CR_MDMAREQ4, 1); + mdma_csr.wfo(utra::mdma::SFR_CR_CR_MDMAREQ4_CR_MDMAREQ4, baz); + + let foo = mdma_csr.r(utra::mdma::SFR_CR_CR_MDMAREQ5); + mdma_csr.wo(utra::mdma::SFR_CR_CR_MDMAREQ5, foo); + let bar = mdma_csr.rf(utra::mdma::SFR_CR_CR_MDMAREQ5_CR_MDMAREQ5); + mdma_csr.rmwf(utra::mdma::SFR_CR_CR_MDMAREQ5_CR_MDMAREQ5, bar); + let mut baz = mdma_csr.zf(utra::mdma::SFR_CR_CR_MDMAREQ5_CR_MDMAREQ5, bar); + baz |= mdma_csr.ms(utra::mdma::SFR_CR_CR_MDMAREQ5_CR_MDMAREQ5, 1); + mdma_csr.wfo(utra::mdma::SFR_CR_CR_MDMAREQ5_CR_MDMAREQ5, baz); + + let foo = mdma_csr.r(utra::mdma::SFR_CR_CR_MDMAREQ6); + mdma_csr.wo(utra::mdma::SFR_CR_CR_MDMAREQ6, foo); + let bar = mdma_csr.rf(utra::mdma::SFR_CR_CR_MDMAREQ6_CR_MDMAREQ6); + mdma_csr.rmwf(utra::mdma::SFR_CR_CR_MDMAREQ6_CR_MDMAREQ6, bar); + let mut baz = mdma_csr.zf(utra::mdma::SFR_CR_CR_MDMAREQ6_CR_MDMAREQ6, bar); + baz |= mdma_csr.ms(utra::mdma::SFR_CR_CR_MDMAREQ6_CR_MDMAREQ6, 1); + mdma_csr.wfo(utra::mdma::SFR_CR_CR_MDMAREQ6_CR_MDMAREQ6, baz); + + let foo = mdma_csr.r(utra::mdma::SFR_CR_CR_MDMAREQ7); + mdma_csr.wo(utra::mdma::SFR_CR_CR_MDMAREQ7, foo); + let bar = mdma_csr.rf(utra::mdma::SFR_CR_CR_MDMAREQ7_CR_MDMAREQ7); + mdma_csr.rmwf(utra::mdma::SFR_CR_CR_MDMAREQ7_CR_MDMAREQ7, bar); + let mut baz = mdma_csr.zf(utra::mdma::SFR_CR_CR_MDMAREQ7_CR_MDMAREQ7, bar); + baz |= mdma_csr.ms(utra::mdma::SFR_CR_CR_MDMAREQ7_CR_MDMAREQ7, 1); + mdma_csr.wfo(utra::mdma::SFR_CR_CR_MDMAREQ7_CR_MDMAREQ7, baz); + + let foo = mdma_csr.r(utra::mdma::SFR_SR_SR_MDMAREQ0); + mdma_csr.wo(utra::mdma::SFR_SR_SR_MDMAREQ0, foo); + let bar = mdma_csr.rf(utra::mdma::SFR_SR_SR_MDMAREQ0_SR_MDMAREQ0); + mdma_csr.rmwf(utra::mdma::SFR_SR_SR_MDMAREQ0_SR_MDMAREQ0, bar); + let mut baz = mdma_csr.zf(utra::mdma::SFR_SR_SR_MDMAREQ0_SR_MDMAREQ0, bar); + baz |= mdma_csr.ms(utra::mdma::SFR_SR_SR_MDMAREQ0_SR_MDMAREQ0, 1); + mdma_csr.wfo(utra::mdma::SFR_SR_SR_MDMAREQ0_SR_MDMAREQ0, baz); + + let foo = mdma_csr.r(utra::mdma::SFR_SR_SR_MDMAREQ1); + mdma_csr.wo(utra::mdma::SFR_SR_SR_MDMAREQ1, foo); + let bar = mdma_csr.rf(utra::mdma::SFR_SR_SR_MDMAREQ1_SR_MDMAREQ1); + mdma_csr.rmwf(utra::mdma::SFR_SR_SR_MDMAREQ1_SR_MDMAREQ1, bar); + let mut baz = mdma_csr.zf(utra::mdma::SFR_SR_SR_MDMAREQ1_SR_MDMAREQ1, bar); + baz |= mdma_csr.ms(utra::mdma::SFR_SR_SR_MDMAREQ1_SR_MDMAREQ1, 1); + mdma_csr.wfo(utra::mdma::SFR_SR_SR_MDMAREQ1_SR_MDMAREQ1, baz); + + let foo = mdma_csr.r(utra::mdma::SFR_SR_SR_MDMAREQ2); + mdma_csr.wo(utra::mdma::SFR_SR_SR_MDMAREQ2, foo); + let bar = mdma_csr.rf(utra::mdma::SFR_SR_SR_MDMAREQ2_SR_MDMAREQ2); + mdma_csr.rmwf(utra::mdma::SFR_SR_SR_MDMAREQ2_SR_MDMAREQ2, bar); + let mut baz = mdma_csr.zf(utra::mdma::SFR_SR_SR_MDMAREQ2_SR_MDMAREQ2, bar); + baz |= mdma_csr.ms(utra::mdma::SFR_SR_SR_MDMAREQ2_SR_MDMAREQ2, 1); + mdma_csr.wfo(utra::mdma::SFR_SR_SR_MDMAREQ2_SR_MDMAREQ2, baz); + + let foo = mdma_csr.r(utra::mdma::SFR_SR_SR_MDMAREQ3); + mdma_csr.wo(utra::mdma::SFR_SR_SR_MDMAREQ3, foo); + let bar = mdma_csr.rf(utra::mdma::SFR_SR_SR_MDMAREQ3_SR_MDMAREQ3); + mdma_csr.rmwf(utra::mdma::SFR_SR_SR_MDMAREQ3_SR_MDMAREQ3, bar); + let mut baz = mdma_csr.zf(utra::mdma::SFR_SR_SR_MDMAREQ3_SR_MDMAREQ3, bar); + baz |= mdma_csr.ms(utra::mdma::SFR_SR_SR_MDMAREQ3_SR_MDMAREQ3, 1); + mdma_csr.wfo(utra::mdma::SFR_SR_SR_MDMAREQ3_SR_MDMAREQ3, baz); + + let foo = mdma_csr.r(utra::mdma::SFR_SR_SR_MDMAREQ4); + mdma_csr.wo(utra::mdma::SFR_SR_SR_MDMAREQ4, foo); + let bar = mdma_csr.rf(utra::mdma::SFR_SR_SR_MDMAREQ4_SR_MDMAREQ4); + mdma_csr.rmwf(utra::mdma::SFR_SR_SR_MDMAREQ4_SR_MDMAREQ4, bar); + let mut baz = mdma_csr.zf(utra::mdma::SFR_SR_SR_MDMAREQ4_SR_MDMAREQ4, bar); + baz |= mdma_csr.ms(utra::mdma::SFR_SR_SR_MDMAREQ4_SR_MDMAREQ4, 1); + mdma_csr.wfo(utra::mdma::SFR_SR_SR_MDMAREQ4_SR_MDMAREQ4, baz); + + let foo = mdma_csr.r(utra::mdma::SFR_SR_SR_MDMAREQ5); + mdma_csr.wo(utra::mdma::SFR_SR_SR_MDMAREQ5, foo); + let bar = mdma_csr.rf(utra::mdma::SFR_SR_SR_MDMAREQ5_SR_MDMAREQ5); + mdma_csr.rmwf(utra::mdma::SFR_SR_SR_MDMAREQ5_SR_MDMAREQ5, bar); + let mut baz = mdma_csr.zf(utra::mdma::SFR_SR_SR_MDMAREQ5_SR_MDMAREQ5, bar); + baz |= mdma_csr.ms(utra::mdma::SFR_SR_SR_MDMAREQ5_SR_MDMAREQ5, 1); + mdma_csr.wfo(utra::mdma::SFR_SR_SR_MDMAREQ5_SR_MDMAREQ5, baz); + + let foo = mdma_csr.r(utra::mdma::SFR_SR_SR_MDMAREQ6); + mdma_csr.wo(utra::mdma::SFR_SR_SR_MDMAREQ6, foo); + let bar = mdma_csr.rf(utra::mdma::SFR_SR_SR_MDMAREQ6_SR_MDMAREQ6); + mdma_csr.rmwf(utra::mdma::SFR_SR_SR_MDMAREQ6_SR_MDMAREQ6, bar); + let mut baz = mdma_csr.zf(utra::mdma::SFR_SR_SR_MDMAREQ6_SR_MDMAREQ6, bar); + baz |= mdma_csr.ms(utra::mdma::SFR_SR_SR_MDMAREQ6_SR_MDMAREQ6, 1); + mdma_csr.wfo(utra::mdma::SFR_SR_SR_MDMAREQ6_SR_MDMAREQ6, baz); + + let foo = mdma_csr.r(utra::mdma::SFR_SR_SR_MDMAREQ7); + mdma_csr.wo(utra::mdma::SFR_SR_SR_MDMAREQ7, foo); + let bar = mdma_csr.rf(utra::mdma::SFR_SR_SR_MDMAREQ7_SR_MDMAREQ7); + mdma_csr.rmwf(utra::mdma::SFR_SR_SR_MDMAREQ7_SR_MDMAREQ7, bar); + let mut baz = mdma_csr.zf(utra::mdma::SFR_SR_SR_MDMAREQ7_SR_MDMAREQ7, bar); + baz |= mdma_csr.ms(utra::mdma::SFR_SR_SR_MDMAREQ7_SR_MDMAREQ7, 1); + mdma_csr.wfo(utra::mdma::SFR_SR_SR_MDMAREQ7_SR_MDMAREQ7, baz); + } + + #[test] + #[ignore] + fn compile_check_qfc_csr() { + use super::*; + let mut qfc_csr = CSR::new(HW_QFC_BASE as *mut u32); + + let foo = qfc_csr.r(utra::qfc::SFR_IO); + qfc_csr.wo(utra::qfc::SFR_IO, foo); + let bar = qfc_csr.rf(utra::qfc::SFR_IO_SFR_IO); + qfc_csr.rmwf(utra::qfc::SFR_IO_SFR_IO, bar); + let mut baz = qfc_csr.zf(utra::qfc::SFR_IO_SFR_IO, bar); + baz |= qfc_csr.ms(utra::qfc::SFR_IO_SFR_IO, 1); + qfc_csr.wfo(utra::qfc::SFR_IO_SFR_IO, baz); + + let foo = qfc_csr.r(utra::qfc::SFR_AR); + qfc_csr.wo(utra::qfc::SFR_AR, foo); + let bar = qfc_csr.rf(utra::qfc::SFR_AR_SFR_AR); + qfc_csr.rmwf(utra::qfc::SFR_AR_SFR_AR, bar); + let mut baz = qfc_csr.zf(utra::qfc::SFR_AR_SFR_AR, bar); + baz |= qfc_csr.ms(utra::qfc::SFR_AR_SFR_AR, 1); + qfc_csr.wfo(utra::qfc::SFR_AR_SFR_AR, baz); + + let foo = qfc_csr.r(utra::qfc::SFR_IODRV); + qfc_csr.wo(utra::qfc::SFR_IODRV, foo); + let bar = qfc_csr.rf(utra::qfc::SFR_IODRV_PADDRVSEL); + qfc_csr.rmwf(utra::qfc::SFR_IODRV_PADDRVSEL, bar); + let mut baz = qfc_csr.zf(utra::qfc::SFR_IODRV_PADDRVSEL, bar); + baz |= qfc_csr.ms(utra::qfc::SFR_IODRV_PADDRVSEL, 1); + qfc_csr.wfo(utra::qfc::SFR_IODRV_PADDRVSEL, baz); + + let foo = qfc_csr.r(utra::qfc::CR_XIP_ADDRMODE); + qfc_csr.wo(utra::qfc::CR_XIP_ADDRMODE, foo); + let bar = qfc_csr.rf(utra::qfc::CR_XIP_ADDRMODE_CR_XIP_ADDRMODE); + qfc_csr.rmwf(utra::qfc::CR_XIP_ADDRMODE_CR_XIP_ADDRMODE, bar); + let mut baz = qfc_csr.zf(utra::qfc::CR_XIP_ADDRMODE_CR_XIP_ADDRMODE, bar); + baz |= qfc_csr.ms(utra::qfc::CR_XIP_ADDRMODE_CR_XIP_ADDRMODE, 1); + qfc_csr.wfo(utra::qfc::CR_XIP_ADDRMODE_CR_XIP_ADDRMODE, baz); + + let foo = qfc_csr.r(utra::qfc::CR_XIP_OPCODE); + qfc_csr.wo(utra::qfc::CR_XIP_OPCODE, foo); + let bar = qfc_csr.rf(utra::qfc::CR_XIP_OPCODE_CR_XIP_OPCODE); + qfc_csr.rmwf(utra::qfc::CR_XIP_OPCODE_CR_XIP_OPCODE, bar); + let mut baz = qfc_csr.zf(utra::qfc::CR_XIP_OPCODE_CR_XIP_OPCODE, bar); + baz |= qfc_csr.ms(utra::qfc::CR_XIP_OPCODE_CR_XIP_OPCODE, 1); + qfc_csr.wfo(utra::qfc::CR_XIP_OPCODE_CR_XIP_OPCODE, baz); + + let foo = qfc_csr.r(utra::qfc::CR_XIP_WIDTH); + qfc_csr.wo(utra::qfc::CR_XIP_WIDTH, foo); + let bar = qfc_csr.rf(utra::qfc::CR_XIP_WIDTH_CR_XIP_WIDTH); + qfc_csr.rmwf(utra::qfc::CR_XIP_WIDTH_CR_XIP_WIDTH, bar); + let mut baz = qfc_csr.zf(utra::qfc::CR_XIP_WIDTH_CR_XIP_WIDTH, bar); + baz |= qfc_csr.ms(utra::qfc::CR_XIP_WIDTH_CR_XIP_WIDTH, 1); + qfc_csr.wfo(utra::qfc::CR_XIP_WIDTH_CR_XIP_WIDTH, baz); + + let foo = qfc_csr.r(utra::qfc::CR_XIP_SSEL); + qfc_csr.wo(utra::qfc::CR_XIP_SSEL, foo); + let bar = qfc_csr.rf(utra::qfc::CR_XIP_SSEL_CR_XIP_SSEL); + qfc_csr.rmwf(utra::qfc::CR_XIP_SSEL_CR_XIP_SSEL, bar); + let mut baz = qfc_csr.zf(utra::qfc::CR_XIP_SSEL_CR_XIP_SSEL, bar); + baz |= qfc_csr.ms(utra::qfc::CR_XIP_SSEL_CR_XIP_SSEL, 1); + qfc_csr.wfo(utra::qfc::CR_XIP_SSEL_CR_XIP_SSEL, baz); + + let foo = qfc_csr.r(utra::qfc::CR_XIP_DUMCYC); + qfc_csr.wo(utra::qfc::CR_XIP_DUMCYC, foo); + let bar = qfc_csr.rf(utra::qfc::CR_XIP_DUMCYC_CR_XIP_DUMCYC); + qfc_csr.rmwf(utra::qfc::CR_XIP_DUMCYC_CR_XIP_DUMCYC, bar); + let mut baz = qfc_csr.zf(utra::qfc::CR_XIP_DUMCYC_CR_XIP_DUMCYC, bar); + baz |= qfc_csr.ms(utra::qfc::CR_XIP_DUMCYC_CR_XIP_DUMCYC, 1); + qfc_csr.wfo(utra::qfc::CR_XIP_DUMCYC_CR_XIP_DUMCYC, baz); + + let foo = qfc_csr.r(utra::qfc::CR_XIP_CFG); + qfc_csr.wo(utra::qfc::CR_XIP_CFG, foo); + let bar = qfc_csr.rf(utra::qfc::CR_XIP_CFG_CR_XIP_CFG); + qfc_csr.rmwf(utra::qfc::CR_XIP_CFG_CR_XIP_CFG, bar); + let mut baz = qfc_csr.zf(utra::qfc::CR_XIP_CFG_CR_XIP_CFG, bar); + baz |= qfc_csr.ms(utra::qfc::CR_XIP_CFG_CR_XIP_CFG, 1); + qfc_csr.wfo(utra::qfc::CR_XIP_CFG_CR_XIP_CFG, baz); + + let foo = qfc_csr.r(utra::qfc::CR_AESKEY_AESKEYIN0); + qfc_csr.wo(utra::qfc::CR_AESKEY_AESKEYIN0, foo); + let bar = qfc_csr.rf(utra::qfc::CR_AESKEY_AESKEYIN0_AESKEYIN0); + qfc_csr.rmwf(utra::qfc::CR_AESKEY_AESKEYIN0_AESKEYIN0, bar); + let mut baz = qfc_csr.zf(utra::qfc::CR_AESKEY_AESKEYIN0_AESKEYIN0, bar); + baz |= qfc_csr.ms(utra::qfc::CR_AESKEY_AESKEYIN0_AESKEYIN0, 1); + qfc_csr.wfo(utra::qfc::CR_AESKEY_AESKEYIN0_AESKEYIN0, baz); + + let foo = qfc_csr.r(utra::qfc::CR_AESKEY_AESKEYIN1); + qfc_csr.wo(utra::qfc::CR_AESKEY_AESKEYIN1, foo); + let bar = qfc_csr.rf(utra::qfc::CR_AESKEY_AESKEYIN1_AESKEYIN1); + qfc_csr.rmwf(utra::qfc::CR_AESKEY_AESKEYIN1_AESKEYIN1, bar); + let mut baz = qfc_csr.zf(utra::qfc::CR_AESKEY_AESKEYIN1_AESKEYIN1, bar); + baz |= qfc_csr.ms(utra::qfc::CR_AESKEY_AESKEYIN1_AESKEYIN1, 1); + qfc_csr.wfo(utra::qfc::CR_AESKEY_AESKEYIN1_AESKEYIN1, baz); + + let foo = qfc_csr.r(utra::qfc::CR_AESKEY_AESKEYIN2); + qfc_csr.wo(utra::qfc::CR_AESKEY_AESKEYIN2, foo); + let bar = qfc_csr.rf(utra::qfc::CR_AESKEY_AESKEYIN2_AESKEYIN2); + qfc_csr.rmwf(utra::qfc::CR_AESKEY_AESKEYIN2_AESKEYIN2, bar); + let mut baz = qfc_csr.zf(utra::qfc::CR_AESKEY_AESKEYIN2_AESKEYIN2, bar); + baz |= qfc_csr.ms(utra::qfc::CR_AESKEY_AESKEYIN2_AESKEYIN2, 1); + qfc_csr.wfo(utra::qfc::CR_AESKEY_AESKEYIN2_AESKEYIN2, baz); + + let foo = qfc_csr.r(utra::qfc::CR_AESKEY_AESKEYIN3); + qfc_csr.wo(utra::qfc::CR_AESKEY_AESKEYIN3, foo); + let bar = qfc_csr.rf(utra::qfc::CR_AESKEY_AESKEYIN3_AESKEYIN3); + qfc_csr.rmwf(utra::qfc::CR_AESKEY_AESKEYIN3_AESKEYIN3, bar); + let mut baz = qfc_csr.zf(utra::qfc::CR_AESKEY_AESKEYIN3_AESKEYIN3, bar); + baz |= qfc_csr.ms(utra::qfc::CR_AESKEY_AESKEYIN3_AESKEYIN3, 1); + qfc_csr.wfo(utra::qfc::CR_AESKEY_AESKEYIN3_AESKEYIN3, baz); + + let foo = qfc_csr.r(utra::qfc::CR_AESENA); + qfc_csr.wo(utra::qfc::CR_AESENA, foo); + let bar = qfc_csr.rf(utra::qfc::CR_AESENA_CR_AESENA); + qfc_csr.rmwf(utra::qfc::CR_AESENA_CR_AESENA, bar); + let mut baz = qfc_csr.zf(utra::qfc::CR_AESENA_CR_AESENA, bar); + baz |= qfc_csr.ms(utra::qfc::CR_AESENA_CR_AESENA, 1); + qfc_csr.wfo(utra::qfc::CR_AESENA_CR_AESENA, baz); + } + + #[test] + #[ignore] + fn compile_check_mbox_apb_csr() { + use super::*; + let mut mbox_apb_csr = CSR::new(HW_MBOX_APB_BASE as *mut u32); + + let foo = mbox_apb_csr.r(utra::mbox_apb::SFR_WDATA); + mbox_apb_csr.wo(utra::mbox_apb::SFR_WDATA, foo); + let bar = mbox_apb_csr.rf(utra::mbox_apb::SFR_WDATA_SFR_WDATA); + mbox_apb_csr.rmwf(utra::mbox_apb::SFR_WDATA_SFR_WDATA, bar); + let mut baz = mbox_apb_csr.zf(utra::mbox_apb::SFR_WDATA_SFR_WDATA, bar); + baz |= mbox_apb_csr.ms(utra::mbox_apb::SFR_WDATA_SFR_WDATA, 1); + mbox_apb_csr.wfo(utra::mbox_apb::SFR_WDATA_SFR_WDATA, baz); + + let foo = mbox_apb_csr.r(utra::mbox_apb::SFR_RDATA); + mbox_apb_csr.wo(utra::mbox_apb::SFR_RDATA, foo); + let bar = mbox_apb_csr.rf(utra::mbox_apb::SFR_RDATA_SFR_RDATA); + mbox_apb_csr.rmwf(utra::mbox_apb::SFR_RDATA_SFR_RDATA, bar); + let mut baz = mbox_apb_csr.zf(utra::mbox_apb::SFR_RDATA_SFR_RDATA, bar); + baz |= mbox_apb_csr.ms(utra::mbox_apb::SFR_RDATA_SFR_RDATA, 1); + mbox_apb_csr.wfo(utra::mbox_apb::SFR_RDATA_SFR_RDATA, baz); + + let foo = mbox_apb_csr.r(utra::mbox_apb::SFR_STATUS); + mbox_apb_csr.wo(utra::mbox_apb::SFR_STATUS, foo); + let bar = mbox_apb_csr.rf(utra::mbox_apb::SFR_STATUS_RX_AVAIL); + mbox_apb_csr.rmwf(utra::mbox_apb::SFR_STATUS_RX_AVAIL, bar); + let mut baz = mbox_apb_csr.zf(utra::mbox_apb::SFR_STATUS_RX_AVAIL, bar); + baz |= mbox_apb_csr.ms(utra::mbox_apb::SFR_STATUS_RX_AVAIL, 1); + mbox_apb_csr.wfo(utra::mbox_apb::SFR_STATUS_RX_AVAIL, baz); + let bar = mbox_apb_csr.rf(utra::mbox_apb::SFR_STATUS_TX_FREE); + mbox_apb_csr.rmwf(utra::mbox_apb::SFR_STATUS_TX_FREE, bar); + let mut baz = mbox_apb_csr.zf(utra::mbox_apb::SFR_STATUS_TX_FREE, bar); + baz |= mbox_apb_csr.ms(utra::mbox_apb::SFR_STATUS_TX_FREE, 1); + mbox_apb_csr.wfo(utra::mbox_apb::SFR_STATUS_TX_FREE, baz); + let bar = mbox_apb_csr.rf(utra::mbox_apb::SFR_STATUS_ABORT_IN_PROGRESS); + mbox_apb_csr.rmwf(utra::mbox_apb::SFR_STATUS_ABORT_IN_PROGRESS, bar); + let mut baz = mbox_apb_csr.zf(utra::mbox_apb::SFR_STATUS_ABORT_IN_PROGRESS, bar); + baz |= mbox_apb_csr.ms(utra::mbox_apb::SFR_STATUS_ABORT_IN_PROGRESS, 1); + mbox_apb_csr.wfo(utra::mbox_apb::SFR_STATUS_ABORT_IN_PROGRESS, baz); + let bar = mbox_apb_csr.rf(utra::mbox_apb::SFR_STATUS_ABORT_ACK); + mbox_apb_csr.rmwf(utra::mbox_apb::SFR_STATUS_ABORT_ACK, bar); + let mut baz = mbox_apb_csr.zf(utra::mbox_apb::SFR_STATUS_ABORT_ACK, bar); + baz |= mbox_apb_csr.ms(utra::mbox_apb::SFR_STATUS_ABORT_ACK, 1); + mbox_apb_csr.wfo(utra::mbox_apb::SFR_STATUS_ABORT_ACK, baz); + let bar = mbox_apb_csr.rf(utra::mbox_apb::SFR_STATUS_TX_ERR); + mbox_apb_csr.rmwf(utra::mbox_apb::SFR_STATUS_TX_ERR, bar); + let mut baz = mbox_apb_csr.zf(utra::mbox_apb::SFR_STATUS_TX_ERR, bar); + baz |= mbox_apb_csr.ms(utra::mbox_apb::SFR_STATUS_TX_ERR, 1); + mbox_apb_csr.wfo(utra::mbox_apb::SFR_STATUS_TX_ERR, baz); + let bar = mbox_apb_csr.rf(utra::mbox_apb::SFR_STATUS_RX_ERR); + mbox_apb_csr.rmwf(utra::mbox_apb::SFR_STATUS_RX_ERR, bar); + let mut baz = mbox_apb_csr.zf(utra::mbox_apb::SFR_STATUS_RX_ERR, bar); + baz |= mbox_apb_csr.ms(utra::mbox_apb::SFR_STATUS_RX_ERR, 1); + mbox_apb_csr.wfo(utra::mbox_apb::SFR_STATUS_RX_ERR, baz); + + let foo = mbox_apb_csr.r(utra::mbox_apb::SFR_ABORT); + mbox_apb_csr.wo(utra::mbox_apb::SFR_ABORT, foo); + let bar = mbox_apb_csr.rf(utra::mbox_apb::SFR_ABORT_SFR_ABORT); + mbox_apb_csr.rmwf(utra::mbox_apb::SFR_ABORT_SFR_ABORT, bar); + let mut baz = mbox_apb_csr.zf(utra::mbox_apb::SFR_ABORT_SFR_ABORT, bar); + baz |= mbox_apb_csr.ms(utra::mbox_apb::SFR_ABORT_SFR_ABORT, 1); + mbox_apb_csr.wfo(utra::mbox_apb::SFR_ABORT_SFR_ABORT, baz); + + let foo = mbox_apb_csr.r(utra::mbox_apb::SFR_DONE); + mbox_apb_csr.wo(utra::mbox_apb::SFR_DONE, foo); + let bar = mbox_apb_csr.rf(utra::mbox_apb::SFR_DONE_SFR_DONE); + mbox_apb_csr.rmwf(utra::mbox_apb::SFR_DONE_SFR_DONE, bar); + let mut baz = mbox_apb_csr.zf(utra::mbox_apb::SFR_DONE_SFR_DONE, bar); + baz |= mbox_apb_csr.ms(utra::mbox_apb::SFR_DONE_SFR_DONE, 1); + mbox_apb_csr.wfo(utra::mbox_apb::SFR_DONE_SFR_DONE, baz); + } + + #[test] + #[ignore] + fn compile_check_gluechain_csr() { + use super::*; + let mut gluechain_csr = CSR::new(HW_GLUECHAIN_BASE as *mut u32); + + let foo = gluechain_csr.r(utra::gluechain::SFR_GCMASK); + gluechain_csr.wo(utra::gluechain::SFR_GCMASK, foo); + let bar = gluechain_csr.rf(utra::gluechain::SFR_GCMASK_CR_GCMASK); + gluechain_csr.rmwf(utra::gluechain::SFR_GCMASK_CR_GCMASK, bar); + let mut baz = gluechain_csr.zf(utra::gluechain::SFR_GCMASK_CR_GCMASK, bar); + baz |= gluechain_csr.ms(utra::gluechain::SFR_GCMASK_CR_GCMASK, 1); + gluechain_csr.wfo(utra::gluechain::SFR_GCMASK_CR_GCMASK, baz); + + let foo = gluechain_csr.r(utra::gluechain::SFR_GCSR); + gluechain_csr.wo(utra::gluechain::SFR_GCSR, foo); + let bar = gluechain_csr.rf(utra::gluechain::SFR_GCSR_GLUEREG); + gluechain_csr.rmwf(utra::gluechain::SFR_GCSR_GLUEREG, bar); + let mut baz = gluechain_csr.zf(utra::gluechain::SFR_GCSR_GLUEREG, bar); + baz |= gluechain_csr.ms(utra::gluechain::SFR_GCSR_GLUEREG, 1); + gluechain_csr.wfo(utra::gluechain::SFR_GCSR_GLUEREG, baz); + + let foo = gluechain_csr.r(utra::gluechain::SFR_GCRST); + gluechain_csr.wo(utra::gluechain::SFR_GCRST, foo); + let bar = gluechain_csr.rf(utra::gluechain::SFR_GCRST_GLUERST); + gluechain_csr.rmwf(utra::gluechain::SFR_GCRST_GLUERST, bar); + let mut baz = gluechain_csr.zf(utra::gluechain::SFR_GCRST_GLUERST, bar); + baz |= gluechain_csr.ms(utra::gluechain::SFR_GCRST_GLUERST, 1); + gluechain_csr.wfo(utra::gluechain::SFR_GCRST_GLUERST, baz); + + let foo = gluechain_csr.r(utra::gluechain::SFR_GCTEST); + gluechain_csr.wo(utra::gluechain::SFR_GCTEST, foo); + let bar = gluechain_csr.rf(utra::gluechain::SFR_GCTEST_GLUETEST); + gluechain_csr.rmwf(utra::gluechain::SFR_GCTEST_GLUETEST, bar); + let mut baz = gluechain_csr.zf(utra::gluechain::SFR_GCTEST_GLUETEST, bar); + baz |= gluechain_csr.ms(utra::gluechain::SFR_GCTEST_GLUETEST, 1); + gluechain_csr.wfo(utra::gluechain::SFR_GCTEST_GLUETEST, baz); + } + #[test] #[ignore] fn compile_check_udma_ctrl_csr() { @@ -12681,6 +15990,11 @@ mod tests { let mut baz = udma_spim_0_csr.zf(utra::udma_spim_0::REG_RX_CFG_R_RX_CLR, bar); baz |= udma_spim_0_csr.ms(utra::udma_spim_0::REG_RX_CFG_R_RX_CLR, 1); udma_spim_0_csr.wfo(utra::udma_spim_0::REG_RX_CFG_R_RX_CLR, baz); + let bar = udma_spim_0_csr.rf(utra::udma_spim_0::REG_RX_CFG_R_RX_BACKPRESSURE); + udma_spim_0_csr.rmwf(utra::udma_spim_0::REG_RX_CFG_R_RX_BACKPRESSURE, bar); + let mut baz = udma_spim_0_csr.zf(utra::udma_spim_0::REG_RX_CFG_R_RX_BACKPRESSURE, bar); + baz |= udma_spim_0_csr.ms(utra::udma_spim_0::REG_RX_CFG_R_RX_BACKPRESSURE, 1); + udma_spim_0_csr.wfo(utra::udma_spim_0::REG_RX_CFG_R_RX_BACKPRESSURE, baz); let foo = udma_spim_0_csr.r(utra::udma_spim_0::REG_TX_SADDR); udma_spim_0_csr.wo(utra::udma_spim_0::REG_TX_SADDR, foo); @@ -12808,6 +16122,11 @@ mod tests { let mut baz = udma_spim_1_csr.zf(utra::udma_spim_1::REG_RX_CFG_R_RX_CLR, bar); baz |= udma_spim_1_csr.ms(utra::udma_spim_1::REG_RX_CFG_R_RX_CLR, 1); udma_spim_1_csr.wfo(utra::udma_spim_1::REG_RX_CFG_R_RX_CLR, baz); + let bar = udma_spim_1_csr.rf(utra::udma_spim_1::REG_RX_CFG_R_RX_BACKPRESSURE); + udma_spim_1_csr.rmwf(utra::udma_spim_1::REG_RX_CFG_R_RX_BACKPRESSURE, bar); + let mut baz = udma_spim_1_csr.zf(utra::udma_spim_1::REG_RX_CFG_R_RX_BACKPRESSURE, bar); + baz |= udma_spim_1_csr.ms(utra::udma_spim_1::REG_RX_CFG_R_RX_BACKPRESSURE, 1); + udma_spim_1_csr.wfo(utra::udma_spim_1::REG_RX_CFG_R_RX_BACKPRESSURE, baz); let foo = udma_spim_1_csr.r(utra::udma_spim_1::REG_TX_SADDR); udma_spim_1_csr.wo(utra::udma_spim_1::REG_TX_SADDR, foo); @@ -12935,6 +16254,11 @@ mod tests { let mut baz = udma_spim_2_csr.zf(utra::udma_spim_2::REG_RX_CFG_R_RX_CLR, bar); baz |= udma_spim_2_csr.ms(utra::udma_spim_2::REG_RX_CFG_R_RX_CLR, 1); udma_spim_2_csr.wfo(utra::udma_spim_2::REG_RX_CFG_R_RX_CLR, baz); + let bar = udma_spim_2_csr.rf(utra::udma_spim_2::REG_RX_CFG_R_RX_BACKPRESSURE); + udma_spim_2_csr.rmwf(utra::udma_spim_2::REG_RX_CFG_R_RX_BACKPRESSURE, bar); + let mut baz = udma_spim_2_csr.zf(utra::udma_spim_2::REG_RX_CFG_R_RX_BACKPRESSURE, bar); + baz |= udma_spim_2_csr.ms(utra::udma_spim_2::REG_RX_CFG_R_RX_BACKPRESSURE, 1); + udma_spim_2_csr.wfo(utra::udma_spim_2::REG_RX_CFG_R_RX_BACKPRESSURE, baz); let foo = udma_spim_2_csr.r(utra::udma_spim_2::REG_TX_SADDR); udma_spim_2_csr.wo(utra::udma_spim_2::REG_TX_SADDR, foo); @@ -13062,6 +16386,11 @@ mod tests { let mut baz = udma_spim_3_csr.zf(utra::udma_spim_3::REG_RX_CFG_R_RX_CLR, bar); baz |= udma_spim_3_csr.ms(utra::udma_spim_3::REG_RX_CFG_R_RX_CLR, 1); udma_spim_3_csr.wfo(utra::udma_spim_3::REG_RX_CFG_R_RX_CLR, baz); + let bar = udma_spim_3_csr.rf(utra::udma_spim_3::REG_RX_CFG_R_RX_BACKPRESSURE); + udma_spim_3_csr.rmwf(utra::udma_spim_3::REG_RX_CFG_R_RX_BACKPRESSURE, bar); + let mut baz = udma_spim_3_csr.zf(utra::udma_spim_3::REG_RX_CFG_R_RX_BACKPRESSURE, bar); + baz |= udma_spim_3_csr.ms(utra::udma_spim_3::REG_RX_CFG_R_RX_BACKPRESSURE, 1); + udma_spim_3_csr.wfo(utra::udma_spim_3::REG_RX_CFG_R_RX_BACKPRESSURE, baz); let foo = udma_spim_3_csr.r(utra::udma_spim_3::REG_TX_SADDR); udma_spim_3_csr.wo(utra::udma_spim_3::REG_TX_SADDR, foo); @@ -13699,436 +17028,414 @@ mod tests { #[test] #[ignore] - fn compile_check_udma_i2s_0_csr() { + fn compile_check_udma_sdio_csr() { use super::*; - let mut udma_i2s_0_csr = CSR::new(HW_UDMA_I2S_0_BASE as *mut u32); + let mut udma_sdio_csr = CSR::new(HW_UDMA_SDIO_BASE as *mut u32); - let foo = udma_i2s_0_csr.r(utra::udma_i2s_0::REG_RX_SADDR); - udma_i2s_0_csr.wo(utra::udma_i2s_0::REG_RX_SADDR, foo); - let bar = udma_i2s_0_csr.rf(utra::udma_i2s_0::REG_RX_SADDR_R_RX_STARTADDR); - udma_i2s_0_csr.rmwf(utra::udma_i2s_0::REG_RX_SADDR_R_RX_STARTADDR, bar); - let mut baz = udma_i2s_0_csr.zf(utra::udma_i2s_0::REG_RX_SADDR_R_RX_STARTADDR, bar); - baz |= udma_i2s_0_csr.ms(utra::udma_i2s_0::REG_RX_SADDR_R_RX_STARTADDR, 1); - udma_i2s_0_csr.wfo(utra::udma_i2s_0::REG_RX_SADDR_R_RX_STARTADDR, baz); + let foo = udma_sdio_csr.r(utra::udma_sdio::REG_RX_SADDR); + udma_sdio_csr.wo(utra::udma_sdio::REG_RX_SADDR, foo); + let bar = udma_sdio_csr.rf(utra::udma_sdio::REG_RX_SADDR_R_RX_STARTADDR); + udma_sdio_csr.rmwf(utra::udma_sdio::REG_RX_SADDR_R_RX_STARTADDR, bar); + let mut baz = udma_sdio_csr.zf(utra::udma_sdio::REG_RX_SADDR_R_RX_STARTADDR, bar); + baz |= udma_sdio_csr.ms(utra::udma_sdio::REG_RX_SADDR_R_RX_STARTADDR, 1); + udma_sdio_csr.wfo(utra::udma_sdio::REG_RX_SADDR_R_RX_STARTADDR, baz); - let foo = udma_i2s_0_csr.r(utra::udma_i2s_0::REG_RX_SIZE); - udma_i2s_0_csr.wo(utra::udma_i2s_0::REG_RX_SIZE, foo); - let bar = udma_i2s_0_csr.rf(utra::udma_i2s_0::REG_RX_SIZE_R_RX_SIZE); - udma_i2s_0_csr.rmwf(utra::udma_i2s_0::REG_RX_SIZE_R_RX_SIZE, bar); - let mut baz = udma_i2s_0_csr.zf(utra::udma_i2s_0::REG_RX_SIZE_R_RX_SIZE, bar); - baz |= udma_i2s_0_csr.ms(utra::udma_i2s_0::REG_RX_SIZE_R_RX_SIZE, 1); - udma_i2s_0_csr.wfo(utra::udma_i2s_0::REG_RX_SIZE_R_RX_SIZE, baz); + let foo = udma_sdio_csr.r(utra::udma_sdio::REG_RX_SIZE); + udma_sdio_csr.wo(utra::udma_sdio::REG_RX_SIZE, foo); + let bar = udma_sdio_csr.rf(utra::udma_sdio::REG_RX_SIZE_R_RX_SIZE); + udma_sdio_csr.rmwf(utra::udma_sdio::REG_RX_SIZE_R_RX_SIZE, bar); + let mut baz = udma_sdio_csr.zf(utra::udma_sdio::REG_RX_SIZE_R_RX_SIZE, bar); + baz |= udma_sdio_csr.ms(utra::udma_sdio::REG_RX_SIZE_R_RX_SIZE, 1); + udma_sdio_csr.wfo(utra::udma_sdio::REG_RX_SIZE_R_RX_SIZE, baz); - let foo = udma_i2s_0_csr.r(utra::udma_i2s_0::REG_RX_CFG); - udma_i2s_0_csr.wo(utra::udma_i2s_0::REG_RX_CFG, foo); - let bar = udma_i2s_0_csr.rf(utra::udma_i2s_0::REG_RX_CFG_R_RX_CONTINUOUS); - udma_i2s_0_csr.rmwf(utra::udma_i2s_0::REG_RX_CFG_R_RX_CONTINUOUS, bar); - let mut baz = udma_i2s_0_csr.zf(utra::udma_i2s_0::REG_RX_CFG_R_RX_CONTINUOUS, bar); - baz |= udma_i2s_0_csr.ms(utra::udma_i2s_0::REG_RX_CFG_R_RX_CONTINUOUS, 1); - udma_i2s_0_csr.wfo(utra::udma_i2s_0::REG_RX_CFG_R_RX_CONTINUOUS, baz); - let bar = udma_i2s_0_csr.rf(utra::udma_i2s_0::REG_RX_CFG_R_RX_DATASIZE); - udma_i2s_0_csr.rmwf(utra::udma_i2s_0::REG_RX_CFG_R_RX_DATASIZE, bar); - let mut baz = udma_i2s_0_csr.zf(utra::udma_i2s_0::REG_RX_CFG_R_RX_DATASIZE, bar); - baz |= udma_i2s_0_csr.ms(utra::udma_i2s_0::REG_RX_CFG_R_RX_DATASIZE, 1); - udma_i2s_0_csr.wfo(utra::udma_i2s_0::REG_RX_CFG_R_RX_DATASIZE, baz); - let bar = udma_i2s_0_csr.rf(utra::udma_i2s_0::REG_RX_CFG_R_RX_EN); - udma_i2s_0_csr.rmwf(utra::udma_i2s_0::REG_RX_CFG_R_RX_EN, bar); - let mut baz = udma_i2s_0_csr.zf(utra::udma_i2s_0::REG_RX_CFG_R_RX_EN, bar); - baz |= udma_i2s_0_csr.ms(utra::udma_i2s_0::REG_RX_CFG_R_RX_EN, 1); - udma_i2s_0_csr.wfo(utra::udma_i2s_0::REG_RX_CFG_R_RX_EN, baz); - let bar = udma_i2s_0_csr.rf(utra::udma_i2s_0::REG_RX_CFG_R_RX_CLR); - udma_i2s_0_csr.rmwf(utra::udma_i2s_0::REG_RX_CFG_R_RX_CLR, bar); - let mut baz = udma_i2s_0_csr.zf(utra::udma_i2s_0::REG_RX_CFG_R_RX_CLR, bar); - baz |= udma_i2s_0_csr.ms(utra::udma_i2s_0::REG_RX_CFG_R_RX_CLR, 1); - udma_i2s_0_csr.wfo(utra::udma_i2s_0::REG_RX_CFG_R_RX_CLR, baz); + let foo = udma_sdio_csr.r(utra::udma_sdio::REG_RX_CFG); + udma_sdio_csr.wo(utra::udma_sdio::REG_RX_CFG, foo); + let bar = udma_sdio_csr.rf(utra::udma_sdio::REG_RX_CFG_R_RX_CONTINUOUS); + udma_sdio_csr.rmwf(utra::udma_sdio::REG_RX_CFG_R_RX_CONTINUOUS, bar); + let mut baz = udma_sdio_csr.zf(utra::udma_sdio::REG_RX_CFG_R_RX_CONTINUOUS, bar); + baz |= udma_sdio_csr.ms(utra::udma_sdio::REG_RX_CFG_R_RX_CONTINUOUS, 1); + udma_sdio_csr.wfo(utra::udma_sdio::REG_RX_CFG_R_RX_CONTINUOUS, baz); + let bar = udma_sdio_csr.rf(utra::udma_sdio::REG_RX_CFG_R_RX_EN); + udma_sdio_csr.rmwf(utra::udma_sdio::REG_RX_CFG_R_RX_EN, bar); + let mut baz = udma_sdio_csr.zf(utra::udma_sdio::REG_RX_CFG_R_RX_EN, bar); + baz |= udma_sdio_csr.ms(utra::udma_sdio::REG_RX_CFG_R_RX_EN, 1); + udma_sdio_csr.wfo(utra::udma_sdio::REG_RX_CFG_R_RX_EN, baz); + let bar = udma_sdio_csr.rf(utra::udma_sdio::REG_RX_CFG_R_RX_CLR); + udma_sdio_csr.rmwf(utra::udma_sdio::REG_RX_CFG_R_RX_CLR, bar); + let mut baz = udma_sdio_csr.zf(utra::udma_sdio::REG_RX_CFG_R_RX_CLR, bar); + baz |= udma_sdio_csr.ms(utra::udma_sdio::REG_RX_CFG_R_RX_CLR, 1); + udma_sdio_csr.wfo(utra::udma_sdio::REG_RX_CFG_R_RX_CLR, baz); - let foo = udma_i2s_0_csr.r(utra::udma_i2s_0::REG_TX_SADDR); - udma_i2s_0_csr.wo(utra::udma_i2s_0::REG_TX_SADDR, foo); - let bar = udma_i2s_0_csr.rf(utra::udma_i2s_0::REG_TX_SADDR_R_TX_STARTADDR); - udma_i2s_0_csr.rmwf(utra::udma_i2s_0::REG_TX_SADDR_R_TX_STARTADDR, bar); - let mut baz = udma_i2s_0_csr.zf(utra::udma_i2s_0::REG_TX_SADDR_R_TX_STARTADDR, bar); - baz |= udma_i2s_0_csr.ms(utra::udma_i2s_0::REG_TX_SADDR_R_TX_STARTADDR, 1); - udma_i2s_0_csr.wfo(utra::udma_i2s_0::REG_TX_SADDR_R_TX_STARTADDR, baz); + let foo = udma_sdio_csr.r(utra::udma_sdio::REG_TX_SADDR); + udma_sdio_csr.wo(utra::udma_sdio::REG_TX_SADDR, foo); + let bar = udma_sdio_csr.rf(utra::udma_sdio::REG_TX_SADDR_R_TX_STARTADDR); + udma_sdio_csr.rmwf(utra::udma_sdio::REG_TX_SADDR_R_TX_STARTADDR, bar); + let mut baz = udma_sdio_csr.zf(utra::udma_sdio::REG_TX_SADDR_R_TX_STARTADDR, bar); + baz |= udma_sdio_csr.ms(utra::udma_sdio::REG_TX_SADDR_R_TX_STARTADDR, 1); + udma_sdio_csr.wfo(utra::udma_sdio::REG_TX_SADDR_R_TX_STARTADDR, baz); - let foo = udma_i2s_0_csr.r(utra::udma_i2s_0::REG_TX_SIZE); - udma_i2s_0_csr.wo(utra::udma_i2s_0::REG_TX_SIZE, foo); - let bar = udma_i2s_0_csr.rf(utra::udma_i2s_0::REG_TX_SIZE_R_TX_SIZE); - udma_i2s_0_csr.rmwf(utra::udma_i2s_0::REG_TX_SIZE_R_TX_SIZE, bar); - let mut baz = udma_i2s_0_csr.zf(utra::udma_i2s_0::REG_TX_SIZE_R_TX_SIZE, bar); - baz |= udma_i2s_0_csr.ms(utra::udma_i2s_0::REG_TX_SIZE_R_TX_SIZE, 1); - udma_i2s_0_csr.wfo(utra::udma_i2s_0::REG_TX_SIZE_R_TX_SIZE, baz); + let foo = udma_sdio_csr.r(utra::udma_sdio::REG_TX_SIZE); + udma_sdio_csr.wo(utra::udma_sdio::REG_TX_SIZE, foo); + let bar = udma_sdio_csr.rf(utra::udma_sdio::REG_TX_SIZE_R_TX_SIZE); + udma_sdio_csr.rmwf(utra::udma_sdio::REG_TX_SIZE_R_TX_SIZE, bar); + let mut baz = udma_sdio_csr.zf(utra::udma_sdio::REG_TX_SIZE_R_TX_SIZE, bar); + baz |= udma_sdio_csr.ms(utra::udma_sdio::REG_TX_SIZE_R_TX_SIZE, 1); + udma_sdio_csr.wfo(utra::udma_sdio::REG_TX_SIZE_R_TX_SIZE, baz); - let foo = udma_i2s_0_csr.r(utra::udma_i2s_0::REG_TX_CFG); - udma_i2s_0_csr.wo(utra::udma_i2s_0::REG_TX_CFG, foo); - let bar = udma_i2s_0_csr.rf(utra::udma_i2s_0::REG_TX_CFG_R_TX_CONTINUOUS); - udma_i2s_0_csr.rmwf(utra::udma_i2s_0::REG_TX_CFG_R_TX_CONTINUOUS, bar); - let mut baz = udma_i2s_0_csr.zf(utra::udma_i2s_0::REG_TX_CFG_R_TX_CONTINUOUS, bar); - baz |= udma_i2s_0_csr.ms(utra::udma_i2s_0::REG_TX_CFG_R_TX_CONTINUOUS, 1); - udma_i2s_0_csr.wfo(utra::udma_i2s_0::REG_TX_CFG_R_TX_CONTINUOUS, baz); - let bar = udma_i2s_0_csr.rf(utra::udma_i2s_0::REG_TX_CFG_R_TX_DATASIZE); - udma_i2s_0_csr.rmwf(utra::udma_i2s_0::REG_TX_CFG_R_TX_DATASIZE, bar); - let mut baz = udma_i2s_0_csr.zf(utra::udma_i2s_0::REG_TX_CFG_R_TX_DATASIZE, bar); - baz |= udma_i2s_0_csr.ms(utra::udma_i2s_0::REG_TX_CFG_R_TX_DATASIZE, 1); - udma_i2s_0_csr.wfo(utra::udma_i2s_0::REG_TX_CFG_R_TX_DATASIZE, baz); - let bar = udma_i2s_0_csr.rf(utra::udma_i2s_0::REG_TX_CFG_R_TX_EN); - udma_i2s_0_csr.rmwf(utra::udma_i2s_0::REG_TX_CFG_R_TX_EN, bar); - let mut baz = udma_i2s_0_csr.zf(utra::udma_i2s_0::REG_TX_CFG_R_TX_EN, bar); - baz |= udma_i2s_0_csr.ms(utra::udma_i2s_0::REG_TX_CFG_R_TX_EN, 1); - udma_i2s_0_csr.wfo(utra::udma_i2s_0::REG_TX_CFG_R_TX_EN, baz); - let bar = udma_i2s_0_csr.rf(utra::udma_i2s_0::REG_TX_CFG_R_TX_CLR); - udma_i2s_0_csr.rmwf(utra::udma_i2s_0::REG_TX_CFG_R_TX_CLR, bar); - let mut baz = udma_i2s_0_csr.zf(utra::udma_i2s_0::REG_TX_CFG_R_TX_CLR, bar); - baz |= udma_i2s_0_csr.ms(utra::udma_i2s_0::REG_TX_CFG_R_TX_CLR, 1); - udma_i2s_0_csr.wfo(utra::udma_i2s_0::REG_TX_CFG_R_TX_CLR, baz); + let foo = udma_sdio_csr.r(utra::udma_sdio::REG_TX_CFG); + udma_sdio_csr.wo(utra::udma_sdio::REG_TX_CFG, foo); + let bar = udma_sdio_csr.rf(utra::udma_sdio::REG_TX_CFG_R_TX_CONTINUOUS); + udma_sdio_csr.rmwf(utra::udma_sdio::REG_TX_CFG_R_TX_CONTINUOUS, bar); + let mut baz = udma_sdio_csr.zf(utra::udma_sdio::REG_TX_CFG_R_TX_CONTINUOUS, bar); + baz |= udma_sdio_csr.ms(utra::udma_sdio::REG_TX_CFG_R_TX_CONTINUOUS, 1); + udma_sdio_csr.wfo(utra::udma_sdio::REG_TX_CFG_R_TX_CONTINUOUS, baz); + let bar = udma_sdio_csr.rf(utra::udma_sdio::REG_TX_CFG_R_TX_EN); + udma_sdio_csr.rmwf(utra::udma_sdio::REG_TX_CFG_R_TX_EN, bar); + let mut baz = udma_sdio_csr.zf(utra::udma_sdio::REG_TX_CFG_R_TX_EN, bar); + baz |= udma_sdio_csr.ms(utra::udma_sdio::REG_TX_CFG_R_TX_EN, 1); + udma_sdio_csr.wfo(utra::udma_sdio::REG_TX_CFG_R_TX_EN, baz); + let bar = udma_sdio_csr.rf(utra::udma_sdio::REG_TX_CFG_R_TX_CLR); + udma_sdio_csr.rmwf(utra::udma_sdio::REG_TX_CFG_R_TX_CLR, bar); + let mut baz = udma_sdio_csr.zf(utra::udma_sdio::REG_TX_CFG_R_TX_CLR, bar); + baz |= udma_sdio_csr.ms(utra::udma_sdio::REG_TX_CFG_R_TX_CLR, 1); + udma_sdio_csr.wfo(utra::udma_sdio::REG_TX_CFG_R_TX_CLR, baz); - let foo = udma_i2s_0_csr.r(utra::udma_i2s_0::REG_I2S_CLKCFG_SETUP); - udma_i2s_0_csr.wo(utra::udma_i2s_0::REG_I2S_CLKCFG_SETUP, foo); - let bar = udma_i2s_0_csr.rf(utra::udma_i2s_0::REG_I2S_CLKCFG_SETUP_R_MASTER_GEN_CLK_DIV); - udma_i2s_0_csr.rmwf(utra::udma_i2s_0::REG_I2S_CLKCFG_SETUP_R_MASTER_GEN_CLK_DIV, bar); - let mut baz = udma_i2s_0_csr.zf(utra::udma_i2s_0::REG_I2S_CLKCFG_SETUP_R_MASTER_GEN_CLK_DIV, bar); - baz |= udma_i2s_0_csr.ms(utra::udma_i2s_0::REG_I2S_CLKCFG_SETUP_R_MASTER_GEN_CLK_DIV, 1); - udma_i2s_0_csr.wfo(utra::udma_i2s_0::REG_I2S_CLKCFG_SETUP_R_MASTER_GEN_CLK_DIV, baz); - let bar = udma_i2s_0_csr.rf(utra::udma_i2s_0::REG_I2S_CLKCFG_SETUP_R_SLAVE_GEN_CLK_DIV); - udma_i2s_0_csr.rmwf(utra::udma_i2s_0::REG_I2S_CLKCFG_SETUP_R_SLAVE_GEN_CLK_DIV, bar); - let mut baz = udma_i2s_0_csr.zf(utra::udma_i2s_0::REG_I2S_CLKCFG_SETUP_R_SLAVE_GEN_CLK_DIV, bar); - baz |= udma_i2s_0_csr.ms(utra::udma_i2s_0::REG_I2S_CLKCFG_SETUP_R_SLAVE_GEN_CLK_DIV, 1); - udma_i2s_0_csr.wfo(utra::udma_i2s_0::REG_I2S_CLKCFG_SETUP_R_SLAVE_GEN_CLK_DIV, baz); - let bar = udma_i2s_0_csr.rf(utra::udma_i2s_0::REG_I2S_CLKCFG_SETUP_R_COMMON_GEN_CLK_DIV); - udma_i2s_0_csr.rmwf(utra::udma_i2s_0::REG_I2S_CLKCFG_SETUP_R_COMMON_GEN_CLK_DIV, bar); - let mut baz = udma_i2s_0_csr.zf(utra::udma_i2s_0::REG_I2S_CLKCFG_SETUP_R_COMMON_GEN_CLK_DIV, bar); - baz |= udma_i2s_0_csr.ms(utra::udma_i2s_0::REG_I2S_CLKCFG_SETUP_R_COMMON_GEN_CLK_DIV, 1); - udma_i2s_0_csr.wfo(utra::udma_i2s_0::REG_I2S_CLKCFG_SETUP_R_COMMON_GEN_CLK_DIV, baz); - let bar = udma_i2s_0_csr.rf(utra::udma_i2s_0::REG_I2S_CLKCFG_SETUP_R_SLAVE_CLK_EN); - udma_i2s_0_csr.rmwf(utra::udma_i2s_0::REG_I2S_CLKCFG_SETUP_R_SLAVE_CLK_EN, bar); - let mut baz = udma_i2s_0_csr.zf(utra::udma_i2s_0::REG_I2S_CLKCFG_SETUP_R_SLAVE_CLK_EN, bar); - baz |= udma_i2s_0_csr.ms(utra::udma_i2s_0::REG_I2S_CLKCFG_SETUP_R_SLAVE_CLK_EN, 1); - udma_i2s_0_csr.wfo(utra::udma_i2s_0::REG_I2S_CLKCFG_SETUP_R_SLAVE_CLK_EN, baz); - let bar = udma_i2s_0_csr.rf(utra::udma_i2s_0::REG_I2S_CLKCFG_SETUP_R_MASTER_CLK_EN); - udma_i2s_0_csr.rmwf(utra::udma_i2s_0::REG_I2S_CLKCFG_SETUP_R_MASTER_CLK_EN, bar); - let mut baz = udma_i2s_0_csr.zf(utra::udma_i2s_0::REG_I2S_CLKCFG_SETUP_R_MASTER_CLK_EN, bar); - baz |= udma_i2s_0_csr.ms(utra::udma_i2s_0::REG_I2S_CLKCFG_SETUP_R_MASTER_CLK_EN, 1); - udma_i2s_0_csr.wfo(utra::udma_i2s_0::REG_I2S_CLKCFG_SETUP_R_MASTER_CLK_EN, baz); - let bar = udma_i2s_0_csr.rf(utra::udma_i2s_0::REG_I2S_CLKCFG_SETUP_R_PDM_CLK_EN); - udma_i2s_0_csr.rmwf(utra::udma_i2s_0::REG_I2S_CLKCFG_SETUP_R_PDM_CLK_EN, bar); - let mut baz = udma_i2s_0_csr.zf(utra::udma_i2s_0::REG_I2S_CLKCFG_SETUP_R_PDM_CLK_EN, bar); - baz |= udma_i2s_0_csr.ms(utra::udma_i2s_0::REG_I2S_CLKCFG_SETUP_R_PDM_CLK_EN, 1); - udma_i2s_0_csr.wfo(utra::udma_i2s_0::REG_I2S_CLKCFG_SETUP_R_PDM_CLK_EN, baz); - let bar = udma_i2s_0_csr.rf(utra::udma_i2s_0::REG_I2S_CLKCFG_SETUP_R_SLAVE_SEL_EXT); - udma_i2s_0_csr.rmwf(utra::udma_i2s_0::REG_I2S_CLKCFG_SETUP_R_SLAVE_SEL_EXT, bar); - let mut baz = udma_i2s_0_csr.zf(utra::udma_i2s_0::REG_I2S_CLKCFG_SETUP_R_SLAVE_SEL_EXT, bar); - baz |= udma_i2s_0_csr.ms(utra::udma_i2s_0::REG_I2S_CLKCFG_SETUP_R_SLAVE_SEL_EXT, 1); - udma_i2s_0_csr.wfo(utra::udma_i2s_0::REG_I2S_CLKCFG_SETUP_R_SLAVE_SEL_EXT, baz); - let bar = udma_i2s_0_csr.rf(utra::udma_i2s_0::REG_I2S_CLKCFG_SETUP_R_SLAVE_SEL_NUM); - udma_i2s_0_csr.rmwf(utra::udma_i2s_0::REG_I2S_CLKCFG_SETUP_R_SLAVE_SEL_NUM, bar); - let mut baz = udma_i2s_0_csr.zf(utra::udma_i2s_0::REG_I2S_CLKCFG_SETUP_R_SLAVE_SEL_NUM, bar); - baz |= udma_i2s_0_csr.ms(utra::udma_i2s_0::REG_I2S_CLKCFG_SETUP_R_SLAVE_SEL_NUM, 1); - udma_i2s_0_csr.wfo(utra::udma_i2s_0::REG_I2S_CLKCFG_SETUP_R_SLAVE_SEL_NUM, baz); - let bar = udma_i2s_0_csr.rf(utra::udma_i2s_0::REG_I2S_CLKCFG_SETUP_R_MASTER_SEL_EXT); - udma_i2s_0_csr.rmwf(utra::udma_i2s_0::REG_I2S_CLKCFG_SETUP_R_MASTER_SEL_EXT, bar); - let mut baz = udma_i2s_0_csr.zf(utra::udma_i2s_0::REG_I2S_CLKCFG_SETUP_R_MASTER_SEL_EXT, bar); - baz |= udma_i2s_0_csr.ms(utra::udma_i2s_0::REG_I2S_CLKCFG_SETUP_R_MASTER_SEL_EXT, 1); - udma_i2s_0_csr.wfo(utra::udma_i2s_0::REG_I2S_CLKCFG_SETUP_R_MASTER_SEL_EXT, baz); - let bar = udma_i2s_0_csr.rf(utra::udma_i2s_0::REG_I2S_CLKCFG_SETUP_R_MASTER_SEL_NUM); - udma_i2s_0_csr.rmwf(utra::udma_i2s_0::REG_I2S_CLKCFG_SETUP_R_MASTER_SEL_NUM, bar); - let mut baz = udma_i2s_0_csr.zf(utra::udma_i2s_0::REG_I2S_CLKCFG_SETUP_R_MASTER_SEL_NUM, bar); - baz |= udma_i2s_0_csr.ms(utra::udma_i2s_0::REG_I2S_CLKCFG_SETUP_R_MASTER_SEL_NUM, 1); - udma_i2s_0_csr.wfo(utra::udma_i2s_0::REG_I2S_CLKCFG_SETUP_R_MASTER_SEL_NUM, baz); + let foo = udma_sdio_csr.r(utra::udma_sdio::REG_CMD_OP); + udma_sdio_csr.wo(utra::udma_sdio::REG_CMD_OP, foo); + let bar = udma_sdio_csr.rf(utra::udma_sdio::REG_CMD_OP_R_CMD_RSP_TYPE); + udma_sdio_csr.rmwf(utra::udma_sdio::REG_CMD_OP_R_CMD_RSP_TYPE, bar); + let mut baz = udma_sdio_csr.zf(utra::udma_sdio::REG_CMD_OP_R_CMD_RSP_TYPE, bar); + baz |= udma_sdio_csr.ms(utra::udma_sdio::REG_CMD_OP_R_CMD_RSP_TYPE, 1); + udma_sdio_csr.wfo(utra::udma_sdio::REG_CMD_OP_R_CMD_RSP_TYPE, baz); + let bar = udma_sdio_csr.rf(utra::udma_sdio::REG_CMD_OP_R_CMD_OP); + udma_sdio_csr.rmwf(utra::udma_sdio::REG_CMD_OP_R_CMD_OP, bar); + let mut baz = udma_sdio_csr.zf(utra::udma_sdio::REG_CMD_OP_R_CMD_OP, bar); + baz |= udma_sdio_csr.ms(utra::udma_sdio::REG_CMD_OP_R_CMD_OP, 1); + udma_sdio_csr.wfo(utra::udma_sdio::REG_CMD_OP_R_CMD_OP, baz); + let bar = udma_sdio_csr.rf(utra::udma_sdio::REG_CMD_OP_R_CMD_STOPOPT); + udma_sdio_csr.rmwf(utra::udma_sdio::REG_CMD_OP_R_CMD_STOPOPT, bar); + let mut baz = udma_sdio_csr.zf(utra::udma_sdio::REG_CMD_OP_R_CMD_STOPOPT, bar); + baz |= udma_sdio_csr.ms(utra::udma_sdio::REG_CMD_OP_R_CMD_STOPOPT, 1); + udma_sdio_csr.wfo(utra::udma_sdio::REG_CMD_OP_R_CMD_STOPOPT, baz); - let foo = udma_i2s_0_csr.r(utra::udma_i2s_0::REG_I2S_SLV_SETUP); - udma_i2s_0_csr.wo(utra::udma_i2s_0::REG_I2S_SLV_SETUP, foo); - let bar = udma_i2s_0_csr.rf(utra::udma_i2s_0::REG_I2S_SLV_SETUP_R_SLAVE_I2S_WORDS); - udma_i2s_0_csr.rmwf(utra::udma_i2s_0::REG_I2S_SLV_SETUP_R_SLAVE_I2S_WORDS, bar); - let mut baz = udma_i2s_0_csr.zf(utra::udma_i2s_0::REG_I2S_SLV_SETUP_R_SLAVE_I2S_WORDS, bar); - baz |= udma_i2s_0_csr.ms(utra::udma_i2s_0::REG_I2S_SLV_SETUP_R_SLAVE_I2S_WORDS, 1); - udma_i2s_0_csr.wfo(utra::udma_i2s_0::REG_I2S_SLV_SETUP_R_SLAVE_I2S_WORDS, baz); - let bar = udma_i2s_0_csr.rf(utra::udma_i2s_0::REG_I2S_SLV_SETUP_R_SLAVE_I2S_BITS_WORD); - udma_i2s_0_csr.rmwf(utra::udma_i2s_0::REG_I2S_SLV_SETUP_R_SLAVE_I2S_BITS_WORD, bar); - let mut baz = udma_i2s_0_csr.zf(utra::udma_i2s_0::REG_I2S_SLV_SETUP_R_SLAVE_I2S_BITS_WORD, bar); - baz |= udma_i2s_0_csr.ms(utra::udma_i2s_0::REG_I2S_SLV_SETUP_R_SLAVE_I2S_BITS_WORD, 1); - udma_i2s_0_csr.wfo(utra::udma_i2s_0::REG_I2S_SLV_SETUP_R_SLAVE_I2S_BITS_WORD, baz); - let bar = udma_i2s_0_csr.rf(utra::udma_i2s_0::REG_I2S_SLV_SETUP_R_SLAVE_I2S_LSB_FIRST); - udma_i2s_0_csr.rmwf(utra::udma_i2s_0::REG_I2S_SLV_SETUP_R_SLAVE_I2S_LSB_FIRST, bar); - let mut baz = udma_i2s_0_csr.zf(utra::udma_i2s_0::REG_I2S_SLV_SETUP_R_SLAVE_I2S_LSB_FIRST, bar); - baz |= udma_i2s_0_csr.ms(utra::udma_i2s_0::REG_I2S_SLV_SETUP_R_SLAVE_I2S_LSB_FIRST, 1); - udma_i2s_0_csr.wfo(utra::udma_i2s_0::REG_I2S_SLV_SETUP_R_SLAVE_I2S_LSB_FIRST, baz); - let bar = udma_i2s_0_csr.rf(utra::udma_i2s_0::REG_I2S_SLV_SETUP_R_SLAVE_I2S_2CH); - udma_i2s_0_csr.rmwf(utra::udma_i2s_0::REG_I2S_SLV_SETUP_R_SLAVE_I2S_2CH, bar); - let mut baz = udma_i2s_0_csr.zf(utra::udma_i2s_0::REG_I2S_SLV_SETUP_R_SLAVE_I2S_2CH, bar); - baz |= udma_i2s_0_csr.ms(utra::udma_i2s_0::REG_I2S_SLV_SETUP_R_SLAVE_I2S_2CH, 1); - udma_i2s_0_csr.wfo(utra::udma_i2s_0::REG_I2S_SLV_SETUP_R_SLAVE_I2S_2CH, baz); - let bar = udma_i2s_0_csr.rf(utra::udma_i2s_0::REG_I2S_SLV_SETUP_R_SLAVE_I2S_EN); - udma_i2s_0_csr.rmwf(utra::udma_i2s_0::REG_I2S_SLV_SETUP_R_SLAVE_I2S_EN, bar); - let mut baz = udma_i2s_0_csr.zf(utra::udma_i2s_0::REG_I2S_SLV_SETUP_R_SLAVE_I2S_EN, bar); - baz |= udma_i2s_0_csr.ms(utra::udma_i2s_0::REG_I2S_SLV_SETUP_R_SLAVE_I2S_EN, 1); - udma_i2s_0_csr.wfo(utra::udma_i2s_0::REG_I2S_SLV_SETUP_R_SLAVE_I2S_EN, baz); + let foo = udma_sdio_csr.r(utra::udma_sdio::REG_DATA_SETUP); + udma_sdio_csr.wo(utra::udma_sdio::REG_DATA_SETUP, foo); + let bar = udma_sdio_csr.rf(utra::udma_sdio::REG_DATA_SETUP_R_DATA_EN); + udma_sdio_csr.rmwf(utra::udma_sdio::REG_DATA_SETUP_R_DATA_EN, bar); + let mut baz = udma_sdio_csr.zf(utra::udma_sdio::REG_DATA_SETUP_R_DATA_EN, bar); + baz |= udma_sdio_csr.ms(utra::udma_sdio::REG_DATA_SETUP_R_DATA_EN, 1); + udma_sdio_csr.wfo(utra::udma_sdio::REG_DATA_SETUP_R_DATA_EN, baz); + let bar = udma_sdio_csr.rf(utra::udma_sdio::REG_DATA_SETUP_R_DATA_RWN); + udma_sdio_csr.rmwf(utra::udma_sdio::REG_DATA_SETUP_R_DATA_RWN, bar); + let mut baz = udma_sdio_csr.zf(utra::udma_sdio::REG_DATA_SETUP_R_DATA_RWN, bar); + baz |= udma_sdio_csr.ms(utra::udma_sdio::REG_DATA_SETUP_R_DATA_RWN, 1); + udma_sdio_csr.wfo(utra::udma_sdio::REG_DATA_SETUP_R_DATA_RWN, baz); + let bar = udma_sdio_csr.rf(utra::udma_sdio::REG_DATA_SETUP_R_DATA_QUAD); + udma_sdio_csr.rmwf(utra::udma_sdio::REG_DATA_SETUP_R_DATA_QUAD, bar); + let mut baz = udma_sdio_csr.zf(utra::udma_sdio::REG_DATA_SETUP_R_DATA_QUAD, bar); + baz |= udma_sdio_csr.ms(utra::udma_sdio::REG_DATA_SETUP_R_DATA_QUAD, 1); + udma_sdio_csr.wfo(utra::udma_sdio::REG_DATA_SETUP_R_DATA_QUAD, baz); + let bar = udma_sdio_csr.rf(utra::udma_sdio::REG_DATA_SETUP_R_DATA_BLOCK_NUM); + udma_sdio_csr.rmwf(utra::udma_sdio::REG_DATA_SETUP_R_DATA_BLOCK_NUM, bar); + let mut baz = udma_sdio_csr.zf(utra::udma_sdio::REG_DATA_SETUP_R_DATA_BLOCK_NUM, bar); + baz |= udma_sdio_csr.ms(utra::udma_sdio::REG_DATA_SETUP_R_DATA_BLOCK_NUM, 1); + udma_sdio_csr.wfo(utra::udma_sdio::REG_DATA_SETUP_R_DATA_BLOCK_NUM, baz); + let bar = udma_sdio_csr.rf(utra::udma_sdio::REG_DATA_SETUP_R_DATA_BLOCK_SIZE); + udma_sdio_csr.rmwf(utra::udma_sdio::REG_DATA_SETUP_R_DATA_BLOCK_SIZE, bar); + let mut baz = udma_sdio_csr.zf(utra::udma_sdio::REG_DATA_SETUP_R_DATA_BLOCK_SIZE, bar); + baz |= udma_sdio_csr.ms(utra::udma_sdio::REG_DATA_SETUP_R_DATA_BLOCK_SIZE, 1); + udma_sdio_csr.wfo(utra::udma_sdio::REG_DATA_SETUP_R_DATA_BLOCK_SIZE, baz); - let foo = udma_i2s_0_csr.r(utra::udma_i2s_0::REG_I2S_MST_SETUP); - udma_i2s_0_csr.wo(utra::udma_i2s_0::REG_I2S_MST_SETUP, foo); - let bar = udma_i2s_0_csr.rf(utra::udma_i2s_0::REG_I2S_MST_SETUP_R_MASTER_I2S_WORDS); - udma_i2s_0_csr.rmwf(utra::udma_i2s_0::REG_I2S_MST_SETUP_R_MASTER_I2S_WORDS, bar); - let mut baz = udma_i2s_0_csr.zf(utra::udma_i2s_0::REG_I2S_MST_SETUP_R_MASTER_I2S_WORDS, bar); - baz |= udma_i2s_0_csr.ms(utra::udma_i2s_0::REG_I2S_MST_SETUP_R_MASTER_I2S_WORDS, 1); - udma_i2s_0_csr.wfo(utra::udma_i2s_0::REG_I2S_MST_SETUP_R_MASTER_I2S_WORDS, baz); - let bar = udma_i2s_0_csr.rf(utra::udma_i2s_0::REG_I2S_MST_SETUP_R_MASTER_I2S_BITS_WORD); - udma_i2s_0_csr.rmwf(utra::udma_i2s_0::REG_I2S_MST_SETUP_R_MASTER_I2S_BITS_WORD, bar); - let mut baz = udma_i2s_0_csr.zf(utra::udma_i2s_0::REG_I2S_MST_SETUP_R_MASTER_I2S_BITS_WORD, bar); - baz |= udma_i2s_0_csr.ms(utra::udma_i2s_0::REG_I2S_MST_SETUP_R_MASTER_I2S_BITS_WORD, 1); - udma_i2s_0_csr.wfo(utra::udma_i2s_0::REG_I2S_MST_SETUP_R_MASTER_I2S_BITS_WORD, baz); - let bar = udma_i2s_0_csr.rf(utra::udma_i2s_0::REG_I2S_MST_SETUP_R_MASTER_I2S_LSB_FIRST); - udma_i2s_0_csr.rmwf(utra::udma_i2s_0::REG_I2S_MST_SETUP_R_MASTER_I2S_LSB_FIRST, bar); - let mut baz = udma_i2s_0_csr.zf(utra::udma_i2s_0::REG_I2S_MST_SETUP_R_MASTER_I2S_LSB_FIRST, bar); - baz |= udma_i2s_0_csr.ms(utra::udma_i2s_0::REG_I2S_MST_SETUP_R_MASTER_I2S_LSB_FIRST, 1); - udma_i2s_0_csr.wfo(utra::udma_i2s_0::REG_I2S_MST_SETUP_R_MASTER_I2S_LSB_FIRST, baz); - let bar = udma_i2s_0_csr.rf(utra::udma_i2s_0::REG_I2S_MST_SETUP_R_MASTER_I2S_2CH); - udma_i2s_0_csr.rmwf(utra::udma_i2s_0::REG_I2S_MST_SETUP_R_MASTER_I2S_2CH, bar); - let mut baz = udma_i2s_0_csr.zf(utra::udma_i2s_0::REG_I2S_MST_SETUP_R_MASTER_I2S_2CH, bar); - baz |= udma_i2s_0_csr.ms(utra::udma_i2s_0::REG_I2S_MST_SETUP_R_MASTER_I2S_2CH, 1); - udma_i2s_0_csr.wfo(utra::udma_i2s_0::REG_I2S_MST_SETUP_R_MASTER_I2S_2CH, baz); - let bar = udma_i2s_0_csr.rf(utra::udma_i2s_0::REG_I2S_MST_SETUP_R_MASTER_I2S_EN); - udma_i2s_0_csr.rmwf(utra::udma_i2s_0::REG_I2S_MST_SETUP_R_MASTER_I2S_EN, bar); - let mut baz = udma_i2s_0_csr.zf(utra::udma_i2s_0::REG_I2S_MST_SETUP_R_MASTER_I2S_EN, bar); - baz |= udma_i2s_0_csr.ms(utra::udma_i2s_0::REG_I2S_MST_SETUP_R_MASTER_I2S_EN, 1); - udma_i2s_0_csr.wfo(utra::udma_i2s_0::REG_I2S_MST_SETUP_R_MASTER_I2S_EN, baz); + let foo = udma_sdio_csr.r(utra::udma_sdio::REG_START); + udma_sdio_csr.wo(utra::udma_sdio::REG_START, foo); + let bar = udma_sdio_csr.rf(utra::udma_sdio::REG_START_R_SDIO_START); + udma_sdio_csr.rmwf(utra::udma_sdio::REG_START_R_SDIO_START, bar); + let mut baz = udma_sdio_csr.zf(utra::udma_sdio::REG_START_R_SDIO_START, bar); + baz |= udma_sdio_csr.ms(utra::udma_sdio::REG_START_R_SDIO_START, 1); + udma_sdio_csr.wfo(utra::udma_sdio::REG_START_R_SDIO_START, baz); - let foo = udma_i2s_0_csr.r(utra::udma_i2s_0::REG_I2S_PDM_SETUP); - udma_i2s_0_csr.wo(utra::udma_i2s_0::REG_I2S_PDM_SETUP, foo); - let bar = udma_i2s_0_csr.rf(utra::udma_i2s_0::REG_I2S_PDM_SETUP_R_SLAVE_PDM_SHIFT); - udma_i2s_0_csr.rmwf(utra::udma_i2s_0::REG_I2S_PDM_SETUP_R_SLAVE_PDM_SHIFT, bar); - let mut baz = udma_i2s_0_csr.zf(utra::udma_i2s_0::REG_I2S_PDM_SETUP_R_SLAVE_PDM_SHIFT, bar); - baz |= udma_i2s_0_csr.ms(utra::udma_i2s_0::REG_I2S_PDM_SETUP_R_SLAVE_PDM_SHIFT, 1); - udma_i2s_0_csr.wfo(utra::udma_i2s_0::REG_I2S_PDM_SETUP_R_SLAVE_PDM_SHIFT, baz); - let bar = udma_i2s_0_csr.rf(utra::udma_i2s_0::REG_I2S_PDM_SETUP_R_SLAVE_PDM_DECIMATION); - udma_i2s_0_csr.rmwf(utra::udma_i2s_0::REG_I2S_PDM_SETUP_R_SLAVE_PDM_DECIMATION, bar); - let mut baz = udma_i2s_0_csr.zf(utra::udma_i2s_0::REG_I2S_PDM_SETUP_R_SLAVE_PDM_DECIMATION, bar); - baz |= udma_i2s_0_csr.ms(utra::udma_i2s_0::REG_I2S_PDM_SETUP_R_SLAVE_PDM_DECIMATION, 1); - udma_i2s_0_csr.wfo(utra::udma_i2s_0::REG_I2S_PDM_SETUP_R_SLAVE_PDM_DECIMATION, baz); - let bar = udma_i2s_0_csr.rf(utra::udma_i2s_0::REG_I2S_PDM_SETUP_R_SLAVE_PDM_MODE); - udma_i2s_0_csr.rmwf(utra::udma_i2s_0::REG_I2S_PDM_SETUP_R_SLAVE_PDM_MODE, bar); - let mut baz = udma_i2s_0_csr.zf(utra::udma_i2s_0::REG_I2S_PDM_SETUP_R_SLAVE_PDM_MODE, bar); - baz |= udma_i2s_0_csr.ms(utra::udma_i2s_0::REG_I2S_PDM_SETUP_R_SLAVE_PDM_MODE, 1); - udma_i2s_0_csr.wfo(utra::udma_i2s_0::REG_I2S_PDM_SETUP_R_SLAVE_PDM_MODE, baz); - let bar = udma_i2s_0_csr.rf(utra::udma_i2s_0::REG_I2S_PDM_SETUP_R_SLAVE_PDM_EN); - udma_i2s_0_csr.rmwf(utra::udma_i2s_0::REG_I2S_PDM_SETUP_R_SLAVE_PDM_EN, bar); - let mut baz = udma_i2s_0_csr.zf(utra::udma_i2s_0::REG_I2S_PDM_SETUP_R_SLAVE_PDM_EN, bar); - baz |= udma_i2s_0_csr.ms(utra::udma_i2s_0::REG_I2S_PDM_SETUP_R_SLAVE_PDM_EN, 1); - udma_i2s_0_csr.wfo(utra::udma_i2s_0::REG_I2S_PDM_SETUP_R_SLAVE_PDM_EN, baz); + let foo = udma_sdio_csr.r(utra::udma_sdio::REG_RSP0); + udma_sdio_csr.wo(utra::udma_sdio::REG_RSP0, foo); + let bar = udma_sdio_csr.rf(utra::udma_sdio::REG_RSP0_CFG_RSP_DATA_I_31_0); + udma_sdio_csr.rmwf(utra::udma_sdio::REG_RSP0_CFG_RSP_DATA_I_31_0, bar); + let mut baz = udma_sdio_csr.zf(utra::udma_sdio::REG_RSP0_CFG_RSP_DATA_I_31_0, bar); + baz |= udma_sdio_csr.ms(utra::udma_sdio::REG_RSP0_CFG_RSP_DATA_I_31_0, 1); + udma_sdio_csr.wfo(utra::udma_sdio::REG_RSP0_CFG_RSP_DATA_I_31_0, baz); + + let foo = udma_sdio_csr.r(utra::udma_sdio::REG_RSP1); + udma_sdio_csr.wo(utra::udma_sdio::REG_RSP1, foo); + let bar = udma_sdio_csr.rf(utra::udma_sdio::REG_RSP1_CFG_RSP_DATA_I_63_32); + udma_sdio_csr.rmwf(utra::udma_sdio::REG_RSP1_CFG_RSP_DATA_I_63_32, bar); + let mut baz = udma_sdio_csr.zf(utra::udma_sdio::REG_RSP1_CFG_RSP_DATA_I_63_32, bar); + baz |= udma_sdio_csr.ms(utra::udma_sdio::REG_RSP1_CFG_RSP_DATA_I_63_32, 1); + udma_sdio_csr.wfo(utra::udma_sdio::REG_RSP1_CFG_RSP_DATA_I_63_32, baz); + + let foo = udma_sdio_csr.r(utra::udma_sdio::REG_RSP2); + udma_sdio_csr.wo(utra::udma_sdio::REG_RSP2, foo); + let bar = udma_sdio_csr.rf(utra::udma_sdio::REG_RSP2_CFG_RSP_DATA_I_95_64); + udma_sdio_csr.rmwf(utra::udma_sdio::REG_RSP2_CFG_RSP_DATA_I_95_64, bar); + let mut baz = udma_sdio_csr.zf(utra::udma_sdio::REG_RSP2_CFG_RSP_DATA_I_95_64, bar); + baz |= udma_sdio_csr.ms(utra::udma_sdio::REG_RSP2_CFG_RSP_DATA_I_95_64, 1); + udma_sdio_csr.wfo(utra::udma_sdio::REG_RSP2_CFG_RSP_DATA_I_95_64, baz); + + let foo = udma_sdio_csr.r(utra::udma_sdio::REG_RSP3); + udma_sdio_csr.wo(utra::udma_sdio::REG_RSP3, foo); + let bar = udma_sdio_csr.rf(utra::udma_sdio::REG_RSP3_CFG_RSP_DATA_I_127_96); + udma_sdio_csr.rmwf(utra::udma_sdio::REG_RSP3_CFG_RSP_DATA_I_127_96, bar); + let mut baz = udma_sdio_csr.zf(utra::udma_sdio::REG_RSP3_CFG_RSP_DATA_I_127_96, bar); + baz |= udma_sdio_csr.ms(utra::udma_sdio::REG_RSP3_CFG_RSP_DATA_I_127_96, 1); + udma_sdio_csr.wfo(utra::udma_sdio::REG_RSP3_CFG_RSP_DATA_I_127_96, baz); + + let foo = udma_sdio_csr.r(utra::udma_sdio::REG_CLK_DIV); + udma_sdio_csr.wo(utra::udma_sdio::REG_CLK_DIV, foo); + let bar = udma_sdio_csr.rf(utra::udma_sdio::REG_CLK_DIV_R_CLK_DIV_DATA); + udma_sdio_csr.rmwf(utra::udma_sdio::REG_CLK_DIV_R_CLK_DIV_DATA, bar); + let mut baz = udma_sdio_csr.zf(utra::udma_sdio::REG_CLK_DIV_R_CLK_DIV_DATA, bar); + baz |= udma_sdio_csr.ms(utra::udma_sdio::REG_CLK_DIV_R_CLK_DIV_DATA, 1); + udma_sdio_csr.wfo(utra::udma_sdio::REG_CLK_DIV_R_CLK_DIV_DATA, baz); + let bar = udma_sdio_csr.rf(utra::udma_sdio::REG_CLK_DIV_R_CLK_DIV_VALID); + udma_sdio_csr.rmwf(utra::udma_sdio::REG_CLK_DIV_R_CLK_DIV_VALID, bar); + let mut baz = udma_sdio_csr.zf(utra::udma_sdio::REG_CLK_DIV_R_CLK_DIV_VALID, bar); + baz |= udma_sdio_csr.ms(utra::udma_sdio::REG_CLK_DIV_R_CLK_DIV_VALID, 1); + udma_sdio_csr.wfo(utra::udma_sdio::REG_CLK_DIV_R_CLK_DIV_VALID, baz); + + let foo = udma_sdio_csr.r(utra::udma_sdio::REG_STATUS); + udma_sdio_csr.wo(utra::udma_sdio::REG_STATUS, foo); + let bar = udma_sdio_csr.rf(utra::udma_sdio::REG_STATUS_R_EOT); + udma_sdio_csr.rmwf(utra::udma_sdio::REG_STATUS_R_EOT, bar); + let mut baz = udma_sdio_csr.zf(utra::udma_sdio::REG_STATUS_R_EOT, bar); + baz |= udma_sdio_csr.ms(utra::udma_sdio::REG_STATUS_R_EOT, 1); + udma_sdio_csr.wfo(utra::udma_sdio::REG_STATUS_R_EOT, baz); + let bar = udma_sdio_csr.rf(utra::udma_sdio::REG_STATUS_R_ERR); + udma_sdio_csr.rmwf(utra::udma_sdio::REG_STATUS_R_ERR, bar); + let mut baz = udma_sdio_csr.zf(utra::udma_sdio::REG_STATUS_R_ERR, bar); + baz |= udma_sdio_csr.ms(utra::udma_sdio::REG_STATUS_R_ERR, 1); + udma_sdio_csr.wfo(utra::udma_sdio::REG_STATUS_R_ERR, baz); + + let foo = udma_sdio_csr.r(utra::udma_sdio::REG_DATA_TIMEOUT); + udma_sdio_csr.wo(utra::udma_sdio::REG_DATA_TIMEOUT, foo); + let bar = udma_sdio_csr.rf(utra::udma_sdio::REG_DATA_TIMEOUT_R_DATA_TIMEOUT); + udma_sdio_csr.rmwf(utra::udma_sdio::REG_DATA_TIMEOUT_R_DATA_TIMEOUT, bar); + let mut baz = udma_sdio_csr.zf(utra::udma_sdio::REG_DATA_TIMEOUT_R_DATA_TIMEOUT, bar); + baz |= udma_sdio_csr.ms(utra::udma_sdio::REG_DATA_TIMEOUT_R_DATA_TIMEOUT, 1); + udma_sdio_csr.wfo(utra::udma_sdio::REG_DATA_TIMEOUT_R_DATA_TIMEOUT, baz); } #[test] #[ignore] - fn compile_check_udma_i2s_1_csr() { + fn compile_check_udma_i2s_csr() { use super::*; - let mut udma_i2s_1_csr = CSR::new(HW_UDMA_I2S_1_BASE as *mut u32); + let mut udma_i2s_csr = CSR::new(HW_UDMA_I2S_BASE as *mut u32); - let foo = udma_i2s_1_csr.r(utra::udma_i2s_1::REG_RX_SADDR); - udma_i2s_1_csr.wo(utra::udma_i2s_1::REG_RX_SADDR, foo); - let bar = udma_i2s_1_csr.rf(utra::udma_i2s_1::REG_RX_SADDR_R_RX_STARTADDR); - udma_i2s_1_csr.rmwf(utra::udma_i2s_1::REG_RX_SADDR_R_RX_STARTADDR, bar); - let mut baz = udma_i2s_1_csr.zf(utra::udma_i2s_1::REG_RX_SADDR_R_RX_STARTADDR, bar); - baz |= udma_i2s_1_csr.ms(utra::udma_i2s_1::REG_RX_SADDR_R_RX_STARTADDR, 1); - udma_i2s_1_csr.wfo(utra::udma_i2s_1::REG_RX_SADDR_R_RX_STARTADDR, baz); + let foo = udma_i2s_csr.r(utra::udma_i2s::REG_RX_SADDR); + udma_i2s_csr.wo(utra::udma_i2s::REG_RX_SADDR, foo); + let bar = udma_i2s_csr.rf(utra::udma_i2s::REG_RX_SADDR_R_RX_STARTADDR); + udma_i2s_csr.rmwf(utra::udma_i2s::REG_RX_SADDR_R_RX_STARTADDR, bar); + let mut baz = udma_i2s_csr.zf(utra::udma_i2s::REG_RX_SADDR_R_RX_STARTADDR, bar); + baz |= udma_i2s_csr.ms(utra::udma_i2s::REG_RX_SADDR_R_RX_STARTADDR, 1); + udma_i2s_csr.wfo(utra::udma_i2s::REG_RX_SADDR_R_RX_STARTADDR, baz); - let foo = udma_i2s_1_csr.r(utra::udma_i2s_1::REG_RX_SIZE); - udma_i2s_1_csr.wo(utra::udma_i2s_1::REG_RX_SIZE, foo); - let bar = udma_i2s_1_csr.rf(utra::udma_i2s_1::REG_RX_SIZE_R_RX_SIZE); - udma_i2s_1_csr.rmwf(utra::udma_i2s_1::REG_RX_SIZE_R_RX_SIZE, bar); - let mut baz = udma_i2s_1_csr.zf(utra::udma_i2s_1::REG_RX_SIZE_R_RX_SIZE, bar); - baz |= udma_i2s_1_csr.ms(utra::udma_i2s_1::REG_RX_SIZE_R_RX_SIZE, 1); - udma_i2s_1_csr.wfo(utra::udma_i2s_1::REG_RX_SIZE_R_RX_SIZE, baz); + let foo = udma_i2s_csr.r(utra::udma_i2s::REG_RX_SIZE); + udma_i2s_csr.wo(utra::udma_i2s::REG_RX_SIZE, foo); + let bar = udma_i2s_csr.rf(utra::udma_i2s::REG_RX_SIZE_R_RX_SIZE); + udma_i2s_csr.rmwf(utra::udma_i2s::REG_RX_SIZE_R_RX_SIZE, bar); + let mut baz = udma_i2s_csr.zf(utra::udma_i2s::REG_RX_SIZE_R_RX_SIZE, bar); + baz |= udma_i2s_csr.ms(utra::udma_i2s::REG_RX_SIZE_R_RX_SIZE, 1); + udma_i2s_csr.wfo(utra::udma_i2s::REG_RX_SIZE_R_RX_SIZE, baz); - let foo = udma_i2s_1_csr.r(utra::udma_i2s_1::REG_RX_CFG); - udma_i2s_1_csr.wo(utra::udma_i2s_1::REG_RX_CFG, foo); - let bar = udma_i2s_1_csr.rf(utra::udma_i2s_1::REG_RX_CFG_R_RX_CONTINUOUS); - udma_i2s_1_csr.rmwf(utra::udma_i2s_1::REG_RX_CFG_R_RX_CONTINUOUS, bar); - let mut baz = udma_i2s_1_csr.zf(utra::udma_i2s_1::REG_RX_CFG_R_RX_CONTINUOUS, bar); - baz |= udma_i2s_1_csr.ms(utra::udma_i2s_1::REG_RX_CFG_R_RX_CONTINUOUS, 1); - udma_i2s_1_csr.wfo(utra::udma_i2s_1::REG_RX_CFG_R_RX_CONTINUOUS, baz); - let bar = udma_i2s_1_csr.rf(utra::udma_i2s_1::REG_RX_CFG_R_RX_DATASIZE); - udma_i2s_1_csr.rmwf(utra::udma_i2s_1::REG_RX_CFG_R_RX_DATASIZE, bar); - let mut baz = udma_i2s_1_csr.zf(utra::udma_i2s_1::REG_RX_CFG_R_RX_DATASIZE, bar); - baz |= udma_i2s_1_csr.ms(utra::udma_i2s_1::REG_RX_CFG_R_RX_DATASIZE, 1); - udma_i2s_1_csr.wfo(utra::udma_i2s_1::REG_RX_CFG_R_RX_DATASIZE, baz); - let bar = udma_i2s_1_csr.rf(utra::udma_i2s_1::REG_RX_CFG_R_RX_EN); - udma_i2s_1_csr.rmwf(utra::udma_i2s_1::REG_RX_CFG_R_RX_EN, bar); - let mut baz = udma_i2s_1_csr.zf(utra::udma_i2s_1::REG_RX_CFG_R_RX_EN, bar); - baz |= udma_i2s_1_csr.ms(utra::udma_i2s_1::REG_RX_CFG_R_RX_EN, 1); - udma_i2s_1_csr.wfo(utra::udma_i2s_1::REG_RX_CFG_R_RX_EN, baz); - let bar = udma_i2s_1_csr.rf(utra::udma_i2s_1::REG_RX_CFG_R_RX_CLR); - udma_i2s_1_csr.rmwf(utra::udma_i2s_1::REG_RX_CFG_R_RX_CLR, bar); - let mut baz = udma_i2s_1_csr.zf(utra::udma_i2s_1::REG_RX_CFG_R_RX_CLR, bar); - baz |= udma_i2s_1_csr.ms(utra::udma_i2s_1::REG_RX_CFG_R_RX_CLR, 1); - udma_i2s_1_csr.wfo(utra::udma_i2s_1::REG_RX_CFG_R_RX_CLR, baz); + let foo = udma_i2s_csr.r(utra::udma_i2s::REG_RX_CFG); + udma_i2s_csr.wo(utra::udma_i2s::REG_RX_CFG, foo); + let bar = udma_i2s_csr.rf(utra::udma_i2s::REG_RX_CFG_R_RX_CONTINUOUS); + udma_i2s_csr.rmwf(utra::udma_i2s::REG_RX_CFG_R_RX_CONTINUOUS, bar); + let mut baz = udma_i2s_csr.zf(utra::udma_i2s::REG_RX_CFG_R_RX_CONTINUOUS, bar); + baz |= udma_i2s_csr.ms(utra::udma_i2s::REG_RX_CFG_R_RX_CONTINUOUS, 1); + udma_i2s_csr.wfo(utra::udma_i2s::REG_RX_CFG_R_RX_CONTINUOUS, baz); + let bar = udma_i2s_csr.rf(utra::udma_i2s::REG_RX_CFG_R_RX_DATASIZE); + udma_i2s_csr.rmwf(utra::udma_i2s::REG_RX_CFG_R_RX_DATASIZE, bar); + let mut baz = udma_i2s_csr.zf(utra::udma_i2s::REG_RX_CFG_R_RX_DATASIZE, bar); + baz |= udma_i2s_csr.ms(utra::udma_i2s::REG_RX_CFG_R_RX_DATASIZE, 1); + udma_i2s_csr.wfo(utra::udma_i2s::REG_RX_CFG_R_RX_DATASIZE, baz); + let bar = udma_i2s_csr.rf(utra::udma_i2s::REG_RX_CFG_R_RX_EN); + udma_i2s_csr.rmwf(utra::udma_i2s::REG_RX_CFG_R_RX_EN, bar); + let mut baz = udma_i2s_csr.zf(utra::udma_i2s::REG_RX_CFG_R_RX_EN, bar); + baz |= udma_i2s_csr.ms(utra::udma_i2s::REG_RX_CFG_R_RX_EN, 1); + udma_i2s_csr.wfo(utra::udma_i2s::REG_RX_CFG_R_RX_EN, baz); + let bar = udma_i2s_csr.rf(utra::udma_i2s::REG_RX_CFG_R_RX_CLR); + udma_i2s_csr.rmwf(utra::udma_i2s::REG_RX_CFG_R_RX_CLR, bar); + let mut baz = udma_i2s_csr.zf(utra::udma_i2s::REG_RX_CFG_R_RX_CLR, bar); + baz |= udma_i2s_csr.ms(utra::udma_i2s::REG_RX_CFG_R_RX_CLR, 1); + udma_i2s_csr.wfo(utra::udma_i2s::REG_RX_CFG_R_RX_CLR, baz); - let foo = udma_i2s_1_csr.r(utra::udma_i2s_1::REG_TX_SADDR); - udma_i2s_1_csr.wo(utra::udma_i2s_1::REG_TX_SADDR, foo); - let bar = udma_i2s_1_csr.rf(utra::udma_i2s_1::REG_TX_SADDR_R_TX_STARTADDR); - udma_i2s_1_csr.rmwf(utra::udma_i2s_1::REG_TX_SADDR_R_TX_STARTADDR, bar); - let mut baz = udma_i2s_1_csr.zf(utra::udma_i2s_1::REG_TX_SADDR_R_TX_STARTADDR, bar); - baz |= udma_i2s_1_csr.ms(utra::udma_i2s_1::REG_TX_SADDR_R_TX_STARTADDR, 1); - udma_i2s_1_csr.wfo(utra::udma_i2s_1::REG_TX_SADDR_R_TX_STARTADDR, baz); + let foo = udma_i2s_csr.r(utra::udma_i2s::REG_TX_SADDR); + udma_i2s_csr.wo(utra::udma_i2s::REG_TX_SADDR, foo); + let bar = udma_i2s_csr.rf(utra::udma_i2s::REG_TX_SADDR_R_TX_STARTADDR); + udma_i2s_csr.rmwf(utra::udma_i2s::REG_TX_SADDR_R_TX_STARTADDR, bar); + let mut baz = udma_i2s_csr.zf(utra::udma_i2s::REG_TX_SADDR_R_TX_STARTADDR, bar); + baz |= udma_i2s_csr.ms(utra::udma_i2s::REG_TX_SADDR_R_TX_STARTADDR, 1); + udma_i2s_csr.wfo(utra::udma_i2s::REG_TX_SADDR_R_TX_STARTADDR, baz); - let foo = udma_i2s_1_csr.r(utra::udma_i2s_1::REG_TX_SIZE); - udma_i2s_1_csr.wo(utra::udma_i2s_1::REG_TX_SIZE, foo); - let bar = udma_i2s_1_csr.rf(utra::udma_i2s_1::REG_TX_SIZE_R_TX_SIZE); - udma_i2s_1_csr.rmwf(utra::udma_i2s_1::REG_TX_SIZE_R_TX_SIZE, bar); - let mut baz = udma_i2s_1_csr.zf(utra::udma_i2s_1::REG_TX_SIZE_R_TX_SIZE, bar); - baz |= udma_i2s_1_csr.ms(utra::udma_i2s_1::REG_TX_SIZE_R_TX_SIZE, 1); - udma_i2s_1_csr.wfo(utra::udma_i2s_1::REG_TX_SIZE_R_TX_SIZE, baz); + let foo = udma_i2s_csr.r(utra::udma_i2s::REG_TX_SIZE); + udma_i2s_csr.wo(utra::udma_i2s::REG_TX_SIZE, foo); + let bar = udma_i2s_csr.rf(utra::udma_i2s::REG_TX_SIZE_R_TX_SIZE); + udma_i2s_csr.rmwf(utra::udma_i2s::REG_TX_SIZE_R_TX_SIZE, bar); + let mut baz = udma_i2s_csr.zf(utra::udma_i2s::REG_TX_SIZE_R_TX_SIZE, bar); + baz |= udma_i2s_csr.ms(utra::udma_i2s::REG_TX_SIZE_R_TX_SIZE, 1); + udma_i2s_csr.wfo(utra::udma_i2s::REG_TX_SIZE_R_TX_SIZE, baz); - let foo = udma_i2s_1_csr.r(utra::udma_i2s_1::REG_TX_CFG); - udma_i2s_1_csr.wo(utra::udma_i2s_1::REG_TX_CFG, foo); - let bar = udma_i2s_1_csr.rf(utra::udma_i2s_1::REG_TX_CFG_R_TX_CONTINUOUS); - udma_i2s_1_csr.rmwf(utra::udma_i2s_1::REG_TX_CFG_R_TX_CONTINUOUS, bar); - let mut baz = udma_i2s_1_csr.zf(utra::udma_i2s_1::REG_TX_CFG_R_TX_CONTINUOUS, bar); - baz |= udma_i2s_1_csr.ms(utra::udma_i2s_1::REG_TX_CFG_R_TX_CONTINUOUS, 1); - udma_i2s_1_csr.wfo(utra::udma_i2s_1::REG_TX_CFG_R_TX_CONTINUOUS, baz); - let bar = udma_i2s_1_csr.rf(utra::udma_i2s_1::REG_TX_CFG_R_TX_DATASIZE); - udma_i2s_1_csr.rmwf(utra::udma_i2s_1::REG_TX_CFG_R_TX_DATASIZE, bar); - let mut baz = udma_i2s_1_csr.zf(utra::udma_i2s_1::REG_TX_CFG_R_TX_DATASIZE, bar); - baz |= udma_i2s_1_csr.ms(utra::udma_i2s_1::REG_TX_CFG_R_TX_DATASIZE, 1); - udma_i2s_1_csr.wfo(utra::udma_i2s_1::REG_TX_CFG_R_TX_DATASIZE, baz); - let bar = udma_i2s_1_csr.rf(utra::udma_i2s_1::REG_TX_CFG_R_TX_EN); - udma_i2s_1_csr.rmwf(utra::udma_i2s_1::REG_TX_CFG_R_TX_EN, bar); - let mut baz = udma_i2s_1_csr.zf(utra::udma_i2s_1::REG_TX_CFG_R_TX_EN, bar); - baz |= udma_i2s_1_csr.ms(utra::udma_i2s_1::REG_TX_CFG_R_TX_EN, 1); - udma_i2s_1_csr.wfo(utra::udma_i2s_1::REG_TX_CFG_R_TX_EN, baz); - let bar = udma_i2s_1_csr.rf(utra::udma_i2s_1::REG_TX_CFG_R_TX_CLR); - udma_i2s_1_csr.rmwf(utra::udma_i2s_1::REG_TX_CFG_R_TX_CLR, bar); - let mut baz = udma_i2s_1_csr.zf(utra::udma_i2s_1::REG_TX_CFG_R_TX_CLR, bar); - baz |= udma_i2s_1_csr.ms(utra::udma_i2s_1::REG_TX_CFG_R_TX_CLR, 1); - udma_i2s_1_csr.wfo(utra::udma_i2s_1::REG_TX_CFG_R_TX_CLR, baz); + let foo = udma_i2s_csr.r(utra::udma_i2s::REG_TX_CFG); + udma_i2s_csr.wo(utra::udma_i2s::REG_TX_CFG, foo); + let bar = udma_i2s_csr.rf(utra::udma_i2s::REG_TX_CFG_R_TX_CONTINUOUS); + udma_i2s_csr.rmwf(utra::udma_i2s::REG_TX_CFG_R_TX_CONTINUOUS, bar); + let mut baz = udma_i2s_csr.zf(utra::udma_i2s::REG_TX_CFG_R_TX_CONTINUOUS, bar); + baz |= udma_i2s_csr.ms(utra::udma_i2s::REG_TX_CFG_R_TX_CONTINUOUS, 1); + udma_i2s_csr.wfo(utra::udma_i2s::REG_TX_CFG_R_TX_CONTINUOUS, baz); + let bar = udma_i2s_csr.rf(utra::udma_i2s::REG_TX_CFG_R_TX_DATASIZE); + udma_i2s_csr.rmwf(utra::udma_i2s::REG_TX_CFG_R_TX_DATASIZE, bar); + let mut baz = udma_i2s_csr.zf(utra::udma_i2s::REG_TX_CFG_R_TX_DATASIZE, bar); + baz |= udma_i2s_csr.ms(utra::udma_i2s::REG_TX_CFG_R_TX_DATASIZE, 1); + udma_i2s_csr.wfo(utra::udma_i2s::REG_TX_CFG_R_TX_DATASIZE, baz); + let bar = udma_i2s_csr.rf(utra::udma_i2s::REG_TX_CFG_R_TX_EN); + udma_i2s_csr.rmwf(utra::udma_i2s::REG_TX_CFG_R_TX_EN, bar); + let mut baz = udma_i2s_csr.zf(utra::udma_i2s::REG_TX_CFG_R_TX_EN, bar); + baz |= udma_i2s_csr.ms(utra::udma_i2s::REG_TX_CFG_R_TX_EN, 1); + udma_i2s_csr.wfo(utra::udma_i2s::REG_TX_CFG_R_TX_EN, baz); + let bar = udma_i2s_csr.rf(utra::udma_i2s::REG_TX_CFG_R_TX_CLR); + udma_i2s_csr.rmwf(utra::udma_i2s::REG_TX_CFG_R_TX_CLR, bar); + let mut baz = udma_i2s_csr.zf(utra::udma_i2s::REG_TX_CFG_R_TX_CLR, bar); + baz |= udma_i2s_csr.ms(utra::udma_i2s::REG_TX_CFG_R_TX_CLR, 1); + udma_i2s_csr.wfo(utra::udma_i2s::REG_TX_CFG_R_TX_CLR, baz); - let foo = udma_i2s_1_csr.r(utra::udma_i2s_1::REG_I2S_CLKCFG_SETUP); - udma_i2s_1_csr.wo(utra::udma_i2s_1::REG_I2S_CLKCFG_SETUP, foo); - let bar = udma_i2s_1_csr.rf(utra::udma_i2s_1::REG_I2S_CLKCFG_SETUP_R_MASTER_GEN_CLK_DIV); - udma_i2s_1_csr.rmwf(utra::udma_i2s_1::REG_I2S_CLKCFG_SETUP_R_MASTER_GEN_CLK_DIV, bar); - let mut baz = udma_i2s_1_csr.zf(utra::udma_i2s_1::REG_I2S_CLKCFG_SETUP_R_MASTER_GEN_CLK_DIV, bar); - baz |= udma_i2s_1_csr.ms(utra::udma_i2s_1::REG_I2S_CLKCFG_SETUP_R_MASTER_GEN_CLK_DIV, 1); - udma_i2s_1_csr.wfo(utra::udma_i2s_1::REG_I2S_CLKCFG_SETUP_R_MASTER_GEN_CLK_DIV, baz); - let bar = udma_i2s_1_csr.rf(utra::udma_i2s_1::REG_I2S_CLKCFG_SETUP_R_SLAVE_GEN_CLK_DIV); - udma_i2s_1_csr.rmwf(utra::udma_i2s_1::REG_I2S_CLKCFG_SETUP_R_SLAVE_GEN_CLK_DIV, bar); - let mut baz = udma_i2s_1_csr.zf(utra::udma_i2s_1::REG_I2S_CLKCFG_SETUP_R_SLAVE_GEN_CLK_DIV, bar); - baz |= udma_i2s_1_csr.ms(utra::udma_i2s_1::REG_I2S_CLKCFG_SETUP_R_SLAVE_GEN_CLK_DIV, 1); - udma_i2s_1_csr.wfo(utra::udma_i2s_1::REG_I2S_CLKCFG_SETUP_R_SLAVE_GEN_CLK_DIV, baz); - let bar = udma_i2s_1_csr.rf(utra::udma_i2s_1::REG_I2S_CLKCFG_SETUP_R_COMMON_GEN_CLK_DIV); - udma_i2s_1_csr.rmwf(utra::udma_i2s_1::REG_I2S_CLKCFG_SETUP_R_COMMON_GEN_CLK_DIV, bar); - let mut baz = udma_i2s_1_csr.zf(utra::udma_i2s_1::REG_I2S_CLKCFG_SETUP_R_COMMON_GEN_CLK_DIV, bar); - baz |= udma_i2s_1_csr.ms(utra::udma_i2s_1::REG_I2S_CLKCFG_SETUP_R_COMMON_GEN_CLK_DIV, 1); - udma_i2s_1_csr.wfo(utra::udma_i2s_1::REG_I2S_CLKCFG_SETUP_R_COMMON_GEN_CLK_DIV, baz); - let bar = udma_i2s_1_csr.rf(utra::udma_i2s_1::REG_I2S_CLKCFG_SETUP_R_SLAVE_CLK_EN); - udma_i2s_1_csr.rmwf(utra::udma_i2s_1::REG_I2S_CLKCFG_SETUP_R_SLAVE_CLK_EN, bar); - let mut baz = udma_i2s_1_csr.zf(utra::udma_i2s_1::REG_I2S_CLKCFG_SETUP_R_SLAVE_CLK_EN, bar); - baz |= udma_i2s_1_csr.ms(utra::udma_i2s_1::REG_I2S_CLKCFG_SETUP_R_SLAVE_CLK_EN, 1); - udma_i2s_1_csr.wfo(utra::udma_i2s_1::REG_I2S_CLKCFG_SETUP_R_SLAVE_CLK_EN, baz); - let bar = udma_i2s_1_csr.rf(utra::udma_i2s_1::REG_I2S_CLKCFG_SETUP_R_MASTER_CLK_EN); - udma_i2s_1_csr.rmwf(utra::udma_i2s_1::REG_I2S_CLKCFG_SETUP_R_MASTER_CLK_EN, bar); - let mut baz = udma_i2s_1_csr.zf(utra::udma_i2s_1::REG_I2S_CLKCFG_SETUP_R_MASTER_CLK_EN, bar); - baz |= udma_i2s_1_csr.ms(utra::udma_i2s_1::REG_I2S_CLKCFG_SETUP_R_MASTER_CLK_EN, 1); - udma_i2s_1_csr.wfo(utra::udma_i2s_1::REG_I2S_CLKCFG_SETUP_R_MASTER_CLK_EN, baz); - let bar = udma_i2s_1_csr.rf(utra::udma_i2s_1::REG_I2S_CLKCFG_SETUP_R_PDM_CLK_EN); - udma_i2s_1_csr.rmwf(utra::udma_i2s_1::REG_I2S_CLKCFG_SETUP_R_PDM_CLK_EN, bar); - let mut baz = udma_i2s_1_csr.zf(utra::udma_i2s_1::REG_I2S_CLKCFG_SETUP_R_PDM_CLK_EN, bar); - baz |= udma_i2s_1_csr.ms(utra::udma_i2s_1::REG_I2S_CLKCFG_SETUP_R_PDM_CLK_EN, 1); - udma_i2s_1_csr.wfo(utra::udma_i2s_1::REG_I2S_CLKCFG_SETUP_R_PDM_CLK_EN, baz); - let bar = udma_i2s_1_csr.rf(utra::udma_i2s_1::REG_I2S_CLKCFG_SETUP_R_SLAVE_SEL_EXT); - udma_i2s_1_csr.rmwf(utra::udma_i2s_1::REG_I2S_CLKCFG_SETUP_R_SLAVE_SEL_EXT, bar); - let mut baz = udma_i2s_1_csr.zf(utra::udma_i2s_1::REG_I2S_CLKCFG_SETUP_R_SLAVE_SEL_EXT, bar); - baz |= udma_i2s_1_csr.ms(utra::udma_i2s_1::REG_I2S_CLKCFG_SETUP_R_SLAVE_SEL_EXT, 1); - udma_i2s_1_csr.wfo(utra::udma_i2s_1::REG_I2S_CLKCFG_SETUP_R_SLAVE_SEL_EXT, baz); - let bar = udma_i2s_1_csr.rf(utra::udma_i2s_1::REG_I2S_CLKCFG_SETUP_R_SLAVE_SEL_NUM); - udma_i2s_1_csr.rmwf(utra::udma_i2s_1::REG_I2S_CLKCFG_SETUP_R_SLAVE_SEL_NUM, bar); - let mut baz = udma_i2s_1_csr.zf(utra::udma_i2s_1::REG_I2S_CLKCFG_SETUP_R_SLAVE_SEL_NUM, bar); - baz |= udma_i2s_1_csr.ms(utra::udma_i2s_1::REG_I2S_CLKCFG_SETUP_R_SLAVE_SEL_NUM, 1); - udma_i2s_1_csr.wfo(utra::udma_i2s_1::REG_I2S_CLKCFG_SETUP_R_SLAVE_SEL_NUM, baz); - let bar = udma_i2s_1_csr.rf(utra::udma_i2s_1::REG_I2S_CLKCFG_SETUP_R_MASTER_SEL_EXT); - udma_i2s_1_csr.rmwf(utra::udma_i2s_1::REG_I2S_CLKCFG_SETUP_R_MASTER_SEL_EXT, bar); - let mut baz = udma_i2s_1_csr.zf(utra::udma_i2s_1::REG_I2S_CLKCFG_SETUP_R_MASTER_SEL_EXT, bar); - baz |= udma_i2s_1_csr.ms(utra::udma_i2s_1::REG_I2S_CLKCFG_SETUP_R_MASTER_SEL_EXT, 1); - udma_i2s_1_csr.wfo(utra::udma_i2s_1::REG_I2S_CLKCFG_SETUP_R_MASTER_SEL_EXT, baz); - let bar = udma_i2s_1_csr.rf(utra::udma_i2s_1::REG_I2S_CLKCFG_SETUP_R_MASTER_SEL_NUM); - udma_i2s_1_csr.rmwf(utra::udma_i2s_1::REG_I2S_CLKCFG_SETUP_R_MASTER_SEL_NUM, bar); - let mut baz = udma_i2s_1_csr.zf(utra::udma_i2s_1::REG_I2S_CLKCFG_SETUP_R_MASTER_SEL_NUM, bar); - baz |= udma_i2s_1_csr.ms(utra::udma_i2s_1::REG_I2S_CLKCFG_SETUP_R_MASTER_SEL_NUM, 1); - udma_i2s_1_csr.wfo(utra::udma_i2s_1::REG_I2S_CLKCFG_SETUP_R_MASTER_SEL_NUM, baz); + let foo = udma_i2s_csr.r(utra::udma_i2s::REG_I2S_CLKCFG_SETUP); + udma_i2s_csr.wo(utra::udma_i2s::REG_I2S_CLKCFG_SETUP, foo); + let bar = udma_i2s_csr.rf(utra::udma_i2s::REG_I2S_CLKCFG_SETUP_R_MASTER_GEN_CLK_DIV); + udma_i2s_csr.rmwf(utra::udma_i2s::REG_I2S_CLKCFG_SETUP_R_MASTER_GEN_CLK_DIV, bar); + let mut baz = udma_i2s_csr.zf(utra::udma_i2s::REG_I2S_CLKCFG_SETUP_R_MASTER_GEN_CLK_DIV, bar); + baz |= udma_i2s_csr.ms(utra::udma_i2s::REG_I2S_CLKCFG_SETUP_R_MASTER_GEN_CLK_DIV, 1); + udma_i2s_csr.wfo(utra::udma_i2s::REG_I2S_CLKCFG_SETUP_R_MASTER_GEN_CLK_DIV, baz); + let bar = udma_i2s_csr.rf(utra::udma_i2s::REG_I2S_CLKCFG_SETUP_R_SLAVE_GEN_CLK_DIV); + udma_i2s_csr.rmwf(utra::udma_i2s::REG_I2S_CLKCFG_SETUP_R_SLAVE_GEN_CLK_DIV, bar); + let mut baz = udma_i2s_csr.zf(utra::udma_i2s::REG_I2S_CLKCFG_SETUP_R_SLAVE_GEN_CLK_DIV, bar); + baz |= udma_i2s_csr.ms(utra::udma_i2s::REG_I2S_CLKCFG_SETUP_R_SLAVE_GEN_CLK_DIV, 1); + udma_i2s_csr.wfo(utra::udma_i2s::REG_I2S_CLKCFG_SETUP_R_SLAVE_GEN_CLK_DIV, baz); + let bar = udma_i2s_csr.rf(utra::udma_i2s::REG_I2S_CLKCFG_SETUP_R_COMMON_GEN_CLK_DIV); + udma_i2s_csr.rmwf(utra::udma_i2s::REG_I2S_CLKCFG_SETUP_R_COMMON_GEN_CLK_DIV, bar); + let mut baz = udma_i2s_csr.zf(utra::udma_i2s::REG_I2S_CLKCFG_SETUP_R_COMMON_GEN_CLK_DIV, bar); + baz |= udma_i2s_csr.ms(utra::udma_i2s::REG_I2S_CLKCFG_SETUP_R_COMMON_GEN_CLK_DIV, 1); + udma_i2s_csr.wfo(utra::udma_i2s::REG_I2S_CLKCFG_SETUP_R_COMMON_GEN_CLK_DIV, baz); + let bar = udma_i2s_csr.rf(utra::udma_i2s::REG_I2S_CLKCFG_SETUP_R_SLAVE_CLK_EN); + udma_i2s_csr.rmwf(utra::udma_i2s::REG_I2S_CLKCFG_SETUP_R_SLAVE_CLK_EN, bar); + let mut baz = udma_i2s_csr.zf(utra::udma_i2s::REG_I2S_CLKCFG_SETUP_R_SLAVE_CLK_EN, bar); + baz |= udma_i2s_csr.ms(utra::udma_i2s::REG_I2S_CLKCFG_SETUP_R_SLAVE_CLK_EN, 1); + udma_i2s_csr.wfo(utra::udma_i2s::REG_I2S_CLKCFG_SETUP_R_SLAVE_CLK_EN, baz); + let bar = udma_i2s_csr.rf(utra::udma_i2s::REG_I2S_CLKCFG_SETUP_R_MASTER_CLK_EN); + udma_i2s_csr.rmwf(utra::udma_i2s::REG_I2S_CLKCFG_SETUP_R_MASTER_CLK_EN, bar); + let mut baz = udma_i2s_csr.zf(utra::udma_i2s::REG_I2S_CLKCFG_SETUP_R_MASTER_CLK_EN, bar); + baz |= udma_i2s_csr.ms(utra::udma_i2s::REG_I2S_CLKCFG_SETUP_R_MASTER_CLK_EN, 1); + udma_i2s_csr.wfo(utra::udma_i2s::REG_I2S_CLKCFG_SETUP_R_MASTER_CLK_EN, baz); + let bar = udma_i2s_csr.rf(utra::udma_i2s::REG_I2S_CLKCFG_SETUP_R_PDM_CLK_EN); + udma_i2s_csr.rmwf(utra::udma_i2s::REG_I2S_CLKCFG_SETUP_R_PDM_CLK_EN, bar); + let mut baz = udma_i2s_csr.zf(utra::udma_i2s::REG_I2S_CLKCFG_SETUP_R_PDM_CLK_EN, bar); + baz |= udma_i2s_csr.ms(utra::udma_i2s::REG_I2S_CLKCFG_SETUP_R_PDM_CLK_EN, 1); + udma_i2s_csr.wfo(utra::udma_i2s::REG_I2S_CLKCFG_SETUP_R_PDM_CLK_EN, baz); + let bar = udma_i2s_csr.rf(utra::udma_i2s::REG_I2S_CLKCFG_SETUP_R_SLAVE_SEL_EXT); + udma_i2s_csr.rmwf(utra::udma_i2s::REG_I2S_CLKCFG_SETUP_R_SLAVE_SEL_EXT, bar); + let mut baz = udma_i2s_csr.zf(utra::udma_i2s::REG_I2S_CLKCFG_SETUP_R_SLAVE_SEL_EXT, bar); + baz |= udma_i2s_csr.ms(utra::udma_i2s::REG_I2S_CLKCFG_SETUP_R_SLAVE_SEL_EXT, 1); + udma_i2s_csr.wfo(utra::udma_i2s::REG_I2S_CLKCFG_SETUP_R_SLAVE_SEL_EXT, baz); + let bar = udma_i2s_csr.rf(utra::udma_i2s::REG_I2S_CLKCFG_SETUP_R_SLAVE_SEL_NUM); + udma_i2s_csr.rmwf(utra::udma_i2s::REG_I2S_CLKCFG_SETUP_R_SLAVE_SEL_NUM, bar); + let mut baz = udma_i2s_csr.zf(utra::udma_i2s::REG_I2S_CLKCFG_SETUP_R_SLAVE_SEL_NUM, bar); + baz |= udma_i2s_csr.ms(utra::udma_i2s::REG_I2S_CLKCFG_SETUP_R_SLAVE_SEL_NUM, 1); + udma_i2s_csr.wfo(utra::udma_i2s::REG_I2S_CLKCFG_SETUP_R_SLAVE_SEL_NUM, baz); + let bar = udma_i2s_csr.rf(utra::udma_i2s::REG_I2S_CLKCFG_SETUP_R_MASTER_SEL_EXT); + udma_i2s_csr.rmwf(utra::udma_i2s::REG_I2S_CLKCFG_SETUP_R_MASTER_SEL_EXT, bar); + let mut baz = udma_i2s_csr.zf(utra::udma_i2s::REG_I2S_CLKCFG_SETUP_R_MASTER_SEL_EXT, bar); + baz |= udma_i2s_csr.ms(utra::udma_i2s::REG_I2S_CLKCFG_SETUP_R_MASTER_SEL_EXT, 1); + udma_i2s_csr.wfo(utra::udma_i2s::REG_I2S_CLKCFG_SETUP_R_MASTER_SEL_EXT, baz); + let bar = udma_i2s_csr.rf(utra::udma_i2s::REG_I2S_CLKCFG_SETUP_R_MASTER_SEL_NUM); + udma_i2s_csr.rmwf(utra::udma_i2s::REG_I2S_CLKCFG_SETUP_R_MASTER_SEL_NUM, bar); + let mut baz = udma_i2s_csr.zf(utra::udma_i2s::REG_I2S_CLKCFG_SETUP_R_MASTER_SEL_NUM, bar); + baz |= udma_i2s_csr.ms(utra::udma_i2s::REG_I2S_CLKCFG_SETUP_R_MASTER_SEL_NUM, 1); + udma_i2s_csr.wfo(utra::udma_i2s::REG_I2S_CLKCFG_SETUP_R_MASTER_SEL_NUM, baz); - let foo = udma_i2s_1_csr.r(utra::udma_i2s_1::REG_I2S_SLV_SETUP); - udma_i2s_1_csr.wo(utra::udma_i2s_1::REG_I2S_SLV_SETUP, foo); - let bar = udma_i2s_1_csr.rf(utra::udma_i2s_1::REG_I2S_SLV_SETUP_R_SLAVE_I2S_WORDS); - udma_i2s_1_csr.rmwf(utra::udma_i2s_1::REG_I2S_SLV_SETUP_R_SLAVE_I2S_WORDS, bar); - let mut baz = udma_i2s_1_csr.zf(utra::udma_i2s_1::REG_I2S_SLV_SETUP_R_SLAVE_I2S_WORDS, bar); - baz |= udma_i2s_1_csr.ms(utra::udma_i2s_1::REG_I2S_SLV_SETUP_R_SLAVE_I2S_WORDS, 1); - udma_i2s_1_csr.wfo(utra::udma_i2s_1::REG_I2S_SLV_SETUP_R_SLAVE_I2S_WORDS, baz); - let bar = udma_i2s_1_csr.rf(utra::udma_i2s_1::REG_I2S_SLV_SETUP_R_SLAVE_I2S_BITS_WORD); - udma_i2s_1_csr.rmwf(utra::udma_i2s_1::REG_I2S_SLV_SETUP_R_SLAVE_I2S_BITS_WORD, bar); - let mut baz = udma_i2s_1_csr.zf(utra::udma_i2s_1::REG_I2S_SLV_SETUP_R_SLAVE_I2S_BITS_WORD, bar); - baz |= udma_i2s_1_csr.ms(utra::udma_i2s_1::REG_I2S_SLV_SETUP_R_SLAVE_I2S_BITS_WORD, 1); - udma_i2s_1_csr.wfo(utra::udma_i2s_1::REG_I2S_SLV_SETUP_R_SLAVE_I2S_BITS_WORD, baz); - let bar = udma_i2s_1_csr.rf(utra::udma_i2s_1::REG_I2S_SLV_SETUP_R_SLAVE_I2S_LSB_FIRST); - udma_i2s_1_csr.rmwf(utra::udma_i2s_1::REG_I2S_SLV_SETUP_R_SLAVE_I2S_LSB_FIRST, bar); - let mut baz = udma_i2s_1_csr.zf(utra::udma_i2s_1::REG_I2S_SLV_SETUP_R_SLAVE_I2S_LSB_FIRST, bar); - baz |= udma_i2s_1_csr.ms(utra::udma_i2s_1::REG_I2S_SLV_SETUP_R_SLAVE_I2S_LSB_FIRST, 1); - udma_i2s_1_csr.wfo(utra::udma_i2s_1::REG_I2S_SLV_SETUP_R_SLAVE_I2S_LSB_FIRST, baz); - let bar = udma_i2s_1_csr.rf(utra::udma_i2s_1::REG_I2S_SLV_SETUP_R_SLAVE_I2S_2CH); - udma_i2s_1_csr.rmwf(utra::udma_i2s_1::REG_I2S_SLV_SETUP_R_SLAVE_I2S_2CH, bar); - let mut baz = udma_i2s_1_csr.zf(utra::udma_i2s_1::REG_I2S_SLV_SETUP_R_SLAVE_I2S_2CH, bar); - baz |= udma_i2s_1_csr.ms(utra::udma_i2s_1::REG_I2S_SLV_SETUP_R_SLAVE_I2S_2CH, 1); - udma_i2s_1_csr.wfo(utra::udma_i2s_1::REG_I2S_SLV_SETUP_R_SLAVE_I2S_2CH, baz); - let bar = udma_i2s_1_csr.rf(utra::udma_i2s_1::REG_I2S_SLV_SETUP_R_SLAVE_I2S_EN); - udma_i2s_1_csr.rmwf(utra::udma_i2s_1::REG_I2S_SLV_SETUP_R_SLAVE_I2S_EN, bar); - let mut baz = udma_i2s_1_csr.zf(utra::udma_i2s_1::REG_I2S_SLV_SETUP_R_SLAVE_I2S_EN, bar); - baz |= udma_i2s_1_csr.ms(utra::udma_i2s_1::REG_I2S_SLV_SETUP_R_SLAVE_I2S_EN, 1); - udma_i2s_1_csr.wfo(utra::udma_i2s_1::REG_I2S_SLV_SETUP_R_SLAVE_I2S_EN, baz); + let foo = udma_i2s_csr.r(utra::udma_i2s::REG_I2S_SLV_SETUP); + udma_i2s_csr.wo(utra::udma_i2s::REG_I2S_SLV_SETUP, foo); + let bar = udma_i2s_csr.rf(utra::udma_i2s::REG_I2S_SLV_SETUP_R_SLAVE_I2S_WORDS); + udma_i2s_csr.rmwf(utra::udma_i2s::REG_I2S_SLV_SETUP_R_SLAVE_I2S_WORDS, bar); + let mut baz = udma_i2s_csr.zf(utra::udma_i2s::REG_I2S_SLV_SETUP_R_SLAVE_I2S_WORDS, bar); + baz |= udma_i2s_csr.ms(utra::udma_i2s::REG_I2S_SLV_SETUP_R_SLAVE_I2S_WORDS, 1); + udma_i2s_csr.wfo(utra::udma_i2s::REG_I2S_SLV_SETUP_R_SLAVE_I2S_WORDS, baz); + let bar = udma_i2s_csr.rf(utra::udma_i2s::REG_I2S_SLV_SETUP_R_SLAVE_I2S_BITS_WORD); + udma_i2s_csr.rmwf(utra::udma_i2s::REG_I2S_SLV_SETUP_R_SLAVE_I2S_BITS_WORD, bar); + let mut baz = udma_i2s_csr.zf(utra::udma_i2s::REG_I2S_SLV_SETUP_R_SLAVE_I2S_BITS_WORD, bar); + baz |= udma_i2s_csr.ms(utra::udma_i2s::REG_I2S_SLV_SETUP_R_SLAVE_I2S_BITS_WORD, 1); + udma_i2s_csr.wfo(utra::udma_i2s::REG_I2S_SLV_SETUP_R_SLAVE_I2S_BITS_WORD, baz); + let bar = udma_i2s_csr.rf(utra::udma_i2s::REG_I2S_SLV_SETUP_R_SLAVE_I2S_LSB_FIRST); + udma_i2s_csr.rmwf(utra::udma_i2s::REG_I2S_SLV_SETUP_R_SLAVE_I2S_LSB_FIRST, bar); + let mut baz = udma_i2s_csr.zf(utra::udma_i2s::REG_I2S_SLV_SETUP_R_SLAVE_I2S_LSB_FIRST, bar); + baz |= udma_i2s_csr.ms(utra::udma_i2s::REG_I2S_SLV_SETUP_R_SLAVE_I2S_LSB_FIRST, 1); + udma_i2s_csr.wfo(utra::udma_i2s::REG_I2S_SLV_SETUP_R_SLAVE_I2S_LSB_FIRST, baz); + let bar = udma_i2s_csr.rf(utra::udma_i2s::REG_I2S_SLV_SETUP_R_SLAVE_I2S_2CH); + udma_i2s_csr.rmwf(utra::udma_i2s::REG_I2S_SLV_SETUP_R_SLAVE_I2S_2CH, bar); + let mut baz = udma_i2s_csr.zf(utra::udma_i2s::REG_I2S_SLV_SETUP_R_SLAVE_I2S_2CH, bar); + baz |= udma_i2s_csr.ms(utra::udma_i2s::REG_I2S_SLV_SETUP_R_SLAVE_I2S_2CH, 1); + udma_i2s_csr.wfo(utra::udma_i2s::REG_I2S_SLV_SETUP_R_SLAVE_I2S_2CH, baz); + let bar = udma_i2s_csr.rf(utra::udma_i2s::REG_I2S_SLV_SETUP_R_SLAVE_I2S_EN); + udma_i2s_csr.rmwf(utra::udma_i2s::REG_I2S_SLV_SETUP_R_SLAVE_I2S_EN, bar); + let mut baz = udma_i2s_csr.zf(utra::udma_i2s::REG_I2S_SLV_SETUP_R_SLAVE_I2S_EN, bar); + baz |= udma_i2s_csr.ms(utra::udma_i2s::REG_I2S_SLV_SETUP_R_SLAVE_I2S_EN, 1); + udma_i2s_csr.wfo(utra::udma_i2s::REG_I2S_SLV_SETUP_R_SLAVE_I2S_EN, baz); - let foo = udma_i2s_1_csr.r(utra::udma_i2s_1::REG_I2S_MST_SETUP); - udma_i2s_1_csr.wo(utra::udma_i2s_1::REG_I2S_MST_SETUP, foo); - let bar = udma_i2s_1_csr.rf(utra::udma_i2s_1::REG_I2S_MST_SETUP_R_MASTER_I2S_WORDS); - udma_i2s_1_csr.rmwf(utra::udma_i2s_1::REG_I2S_MST_SETUP_R_MASTER_I2S_WORDS, bar); - let mut baz = udma_i2s_1_csr.zf(utra::udma_i2s_1::REG_I2S_MST_SETUP_R_MASTER_I2S_WORDS, bar); - baz |= udma_i2s_1_csr.ms(utra::udma_i2s_1::REG_I2S_MST_SETUP_R_MASTER_I2S_WORDS, 1); - udma_i2s_1_csr.wfo(utra::udma_i2s_1::REG_I2S_MST_SETUP_R_MASTER_I2S_WORDS, baz); - let bar = udma_i2s_1_csr.rf(utra::udma_i2s_1::REG_I2S_MST_SETUP_R_MASTER_I2S_BITS_WORD); - udma_i2s_1_csr.rmwf(utra::udma_i2s_1::REG_I2S_MST_SETUP_R_MASTER_I2S_BITS_WORD, bar); - let mut baz = udma_i2s_1_csr.zf(utra::udma_i2s_1::REG_I2S_MST_SETUP_R_MASTER_I2S_BITS_WORD, bar); - baz |= udma_i2s_1_csr.ms(utra::udma_i2s_1::REG_I2S_MST_SETUP_R_MASTER_I2S_BITS_WORD, 1); - udma_i2s_1_csr.wfo(utra::udma_i2s_1::REG_I2S_MST_SETUP_R_MASTER_I2S_BITS_WORD, baz); - let bar = udma_i2s_1_csr.rf(utra::udma_i2s_1::REG_I2S_MST_SETUP_R_MASTER_I2S_LSB_FIRST); - udma_i2s_1_csr.rmwf(utra::udma_i2s_1::REG_I2S_MST_SETUP_R_MASTER_I2S_LSB_FIRST, bar); - let mut baz = udma_i2s_1_csr.zf(utra::udma_i2s_1::REG_I2S_MST_SETUP_R_MASTER_I2S_LSB_FIRST, bar); - baz |= udma_i2s_1_csr.ms(utra::udma_i2s_1::REG_I2S_MST_SETUP_R_MASTER_I2S_LSB_FIRST, 1); - udma_i2s_1_csr.wfo(utra::udma_i2s_1::REG_I2S_MST_SETUP_R_MASTER_I2S_LSB_FIRST, baz); - let bar = udma_i2s_1_csr.rf(utra::udma_i2s_1::REG_I2S_MST_SETUP_R_MASTER_I2S_2CH); - udma_i2s_1_csr.rmwf(utra::udma_i2s_1::REG_I2S_MST_SETUP_R_MASTER_I2S_2CH, bar); - let mut baz = udma_i2s_1_csr.zf(utra::udma_i2s_1::REG_I2S_MST_SETUP_R_MASTER_I2S_2CH, bar); - baz |= udma_i2s_1_csr.ms(utra::udma_i2s_1::REG_I2S_MST_SETUP_R_MASTER_I2S_2CH, 1); - udma_i2s_1_csr.wfo(utra::udma_i2s_1::REG_I2S_MST_SETUP_R_MASTER_I2S_2CH, baz); - let bar = udma_i2s_1_csr.rf(utra::udma_i2s_1::REG_I2S_MST_SETUP_R_MASTER_I2S_EN); - udma_i2s_1_csr.rmwf(utra::udma_i2s_1::REG_I2S_MST_SETUP_R_MASTER_I2S_EN, bar); - let mut baz = udma_i2s_1_csr.zf(utra::udma_i2s_1::REG_I2S_MST_SETUP_R_MASTER_I2S_EN, bar); - baz |= udma_i2s_1_csr.ms(utra::udma_i2s_1::REG_I2S_MST_SETUP_R_MASTER_I2S_EN, 1); - udma_i2s_1_csr.wfo(utra::udma_i2s_1::REG_I2S_MST_SETUP_R_MASTER_I2S_EN, baz); + let foo = udma_i2s_csr.r(utra::udma_i2s::REG_I2S_MST_SETUP); + udma_i2s_csr.wo(utra::udma_i2s::REG_I2S_MST_SETUP, foo); + let bar = udma_i2s_csr.rf(utra::udma_i2s::REG_I2S_MST_SETUP_R_MASTER_I2S_WORDS); + udma_i2s_csr.rmwf(utra::udma_i2s::REG_I2S_MST_SETUP_R_MASTER_I2S_WORDS, bar); + let mut baz = udma_i2s_csr.zf(utra::udma_i2s::REG_I2S_MST_SETUP_R_MASTER_I2S_WORDS, bar); + baz |= udma_i2s_csr.ms(utra::udma_i2s::REG_I2S_MST_SETUP_R_MASTER_I2S_WORDS, 1); + udma_i2s_csr.wfo(utra::udma_i2s::REG_I2S_MST_SETUP_R_MASTER_I2S_WORDS, baz); + let bar = udma_i2s_csr.rf(utra::udma_i2s::REG_I2S_MST_SETUP_R_MASTER_I2S_BITS_WORD); + udma_i2s_csr.rmwf(utra::udma_i2s::REG_I2S_MST_SETUP_R_MASTER_I2S_BITS_WORD, bar); + let mut baz = udma_i2s_csr.zf(utra::udma_i2s::REG_I2S_MST_SETUP_R_MASTER_I2S_BITS_WORD, bar); + baz |= udma_i2s_csr.ms(utra::udma_i2s::REG_I2S_MST_SETUP_R_MASTER_I2S_BITS_WORD, 1); + udma_i2s_csr.wfo(utra::udma_i2s::REG_I2S_MST_SETUP_R_MASTER_I2S_BITS_WORD, baz); + let bar = udma_i2s_csr.rf(utra::udma_i2s::REG_I2S_MST_SETUP_R_MASTER_I2S_LSB_FIRST); + udma_i2s_csr.rmwf(utra::udma_i2s::REG_I2S_MST_SETUP_R_MASTER_I2S_LSB_FIRST, bar); + let mut baz = udma_i2s_csr.zf(utra::udma_i2s::REG_I2S_MST_SETUP_R_MASTER_I2S_LSB_FIRST, bar); + baz |= udma_i2s_csr.ms(utra::udma_i2s::REG_I2S_MST_SETUP_R_MASTER_I2S_LSB_FIRST, 1); + udma_i2s_csr.wfo(utra::udma_i2s::REG_I2S_MST_SETUP_R_MASTER_I2S_LSB_FIRST, baz); + let bar = udma_i2s_csr.rf(utra::udma_i2s::REG_I2S_MST_SETUP_R_MASTER_I2S_2CH); + udma_i2s_csr.rmwf(utra::udma_i2s::REG_I2S_MST_SETUP_R_MASTER_I2S_2CH, bar); + let mut baz = udma_i2s_csr.zf(utra::udma_i2s::REG_I2S_MST_SETUP_R_MASTER_I2S_2CH, bar); + baz |= udma_i2s_csr.ms(utra::udma_i2s::REG_I2S_MST_SETUP_R_MASTER_I2S_2CH, 1); + udma_i2s_csr.wfo(utra::udma_i2s::REG_I2S_MST_SETUP_R_MASTER_I2S_2CH, baz); + let bar = udma_i2s_csr.rf(utra::udma_i2s::REG_I2S_MST_SETUP_R_MASTER_I2S_EN); + udma_i2s_csr.rmwf(utra::udma_i2s::REG_I2S_MST_SETUP_R_MASTER_I2S_EN, bar); + let mut baz = udma_i2s_csr.zf(utra::udma_i2s::REG_I2S_MST_SETUP_R_MASTER_I2S_EN, bar); + baz |= udma_i2s_csr.ms(utra::udma_i2s::REG_I2S_MST_SETUP_R_MASTER_I2S_EN, 1); + udma_i2s_csr.wfo(utra::udma_i2s::REG_I2S_MST_SETUP_R_MASTER_I2S_EN, baz); - let foo = udma_i2s_1_csr.r(utra::udma_i2s_1::REG_I2S_PDM_SETUP); - udma_i2s_1_csr.wo(utra::udma_i2s_1::REG_I2S_PDM_SETUP, foo); - let bar = udma_i2s_1_csr.rf(utra::udma_i2s_1::REG_I2S_PDM_SETUP_R_SLAVE_PDM_SHIFT); - udma_i2s_1_csr.rmwf(utra::udma_i2s_1::REG_I2S_PDM_SETUP_R_SLAVE_PDM_SHIFT, bar); - let mut baz = udma_i2s_1_csr.zf(utra::udma_i2s_1::REG_I2S_PDM_SETUP_R_SLAVE_PDM_SHIFT, bar); - baz |= udma_i2s_1_csr.ms(utra::udma_i2s_1::REG_I2S_PDM_SETUP_R_SLAVE_PDM_SHIFT, 1); - udma_i2s_1_csr.wfo(utra::udma_i2s_1::REG_I2S_PDM_SETUP_R_SLAVE_PDM_SHIFT, baz); - let bar = udma_i2s_1_csr.rf(utra::udma_i2s_1::REG_I2S_PDM_SETUP_R_SLAVE_PDM_DECIMATION); - udma_i2s_1_csr.rmwf(utra::udma_i2s_1::REG_I2S_PDM_SETUP_R_SLAVE_PDM_DECIMATION, bar); - let mut baz = udma_i2s_1_csr.zf(utra::udma_i2s_1::REG_I2S_PDM_SETUP_R_SLAVE_PDM_DECIMATION, bar); - baz |= udma_i2s_1_csr.ms(utra::udma_i2s_1::REG_I2S_PDM_SETUP_R_SLAVE_PDM_DECIMATION, 1); - udma_i2s_1_csr.wfo(utra::udma_i2s_1::REG_I2S_PDM_SETUP_R_SLAVE_PDM_DECIMATION, baz); - let bar = udma_i2s_1_csr.rf(utra::udma_i2s_1::REG_I2S_PDM_SETUP_R_SLAVE_PDM_MODE); - udma_i2s_1_csr.rmwf(utra::udma_i2s_1::REG_I2S_PDM_SETUP_R_SLAVE_PDM_MODE, bar); - let mut baz = udma_i2s_1_csr.zf(utra::udma_i2s_1::REG_I2S_PDM_SETUP_R_SLAVE_PDM_MODE, bar); - baz |= udma_i2s_1_csr.ms(utra::udma_i2s_1::REG_I2S_PDM_SETUP_R_SLAVE_PDM_MODE, 1); - udma_i2s_1_csr.wfo(utra::udma_i2s_1::REG_I2S_PDM_SETUP_R_SLAVE_PDM_MODE, baz); - let bar = udma_i2s_1_csr.rf(utra::udma_i2s_1::REG_I2S_PDM_SETUP_R_SLAVE_PDM_EN); - udma_i2s_1_csr.rmwf(utra::udma_i2s_1::REG_I2S_PDM_SETUP_R_SLAVE_PDM_EN, bar); - let mut baz = udma_i2s_1_csr.zf(utra::udma_i2s_1::REG_I2S_PDM_SETUP_R_SLAVE_PDM_EN, bar); - baz |= udma_i2s_1_csr.ms(utra::udma_i2s_1::REG_I2S_PDM_SETUP_R_SLAVE_PDM_EN, 1); - udma_i2s_1_csr.wfo(utra::udma_i2s_1::REG_I2S_PDM_SETUP_R_SLAVE_PDM_EN, baz); + let foo = udma_i2s_csr.r(utra::udma_i2s::REG_I2S_PDM_SETUP); + udma_i2s_csr.wo(utra::udma_i2s::REG_I2S_PDM_SETUP, foo); + let bar = udma_i2s_csr.rf(utra::udma_i2s::REG_I2S_PDM_SETUP_R_SLAVE_PDM_SHIFT); + udma_i2s_csr.rmwf(utra::udma_i2s::REG_I2S_PDM_SETUP_R_SLAVE_PDM_SHIFT, bar); + let mut baz = udma_i2s_csr.zf(utra::udma_i2s::REG_I2S_PDM_SETUP_R_SLAVE_PDM_SHIFT, bar); + baz |= udma_i2s_csr.ms(utra::udma_i2s::REG_I2S_PDM_SETUP_R_SLAVE_PDM_SHIFT, 1); + udma_i2s_csr.wfo(utra::udma_i2s::REG_I2S_PDM_SETUP_R_SLAVE_PDM_SHIFT, baz); + let bar = udma_i2s_csr.rf(utra::udma_i2s::REG_I2S_PDM_SETUP_R_SLAVE_PDM_DECIMATION); + udma_i2s_csr.rmwf(utra::udma_i2s::REG_I2S_PDM_SETUP_R_SLAVE_PDM_DECIMATION, bar); + let mut baz = udma_i2s_csr.zf(utra::udma_i2s::REG_I2S_PDM_SETUP_R_SLAVE_PDM_DECIMATION, bar); + baz |= udma_i2s_csr.ms(utra::udma_i2s::REG_I2S_PDM_SETUP_R_SLAVE_PDM_DECIMATION, 1); + udma_i2s_csr.wfo(utra::udma_i2s::REG_I2S_PDM_SETUP_R_SLAVE_PDM_DECIMATION, baz); + let bar = udma_i2s_csr.rf(utra::udma_i2s::REG_I2S_PDM_SETUP_R_SLAVE_PDM_MODE); + udma_i2s_csr.rmwf(utra::udma_i2s::REG_I2S_PDM_SETUP_R_SLAVE_PDM_MODE, bar); + let mut baz = udma_i2s_csr.zf(utra::udma_i2s::REG_I2S_PDM_SETUP_R_SLAVE_PDM_MODE, bar); + baz |= udma_i2s_csr.ms(utra::udma_i2s::REG_I2S_PDM_SETUP_R_SLAVE_PDM_MODE, 1); + udma_i2s_csr.wfo(utra::udma_i2s::REG_I2S_PDM_SETUP_R_SLAVE_PDM_MODE, baz); + let bar = udma_i2s_csr.rf(utra::udma_i2s::REG_I2S_PDM_SETUP_R_SLAVE_PDM_EN); + udma_i2s_csr.rmwf(utra::udma_i2s::REG_I2S_PDM_SETUP_R_SLAVE_PDM_EN, bar); + let mut baz = udma_i2s_csr.zf(utra::udma_i2s::REG_I2S_PDM_SETUP_R_SLAVE_PDM_EN, bar); + baz |= udma_i2s_csr.ms(utra::udma_i2s::REG_I2S_PDM_SETUP_R_SLAVE_PDM_EN, 1); + udma_i2s_csr.wfo(utra::udma_i2s::REG_I2S_PDM_SETUP_R_SLAVE_PDM_EN, baz); } #[test] @@ -14498,6 +17805,16 @@ mod tests { let mut baz = udma_scif_csr.zf(utra::udma_scif::REG_RX_CFG_R_RX_CONTINUOUS, bar); baz |= udma_scif_csr.ms(utra::udma_scif::REG_RX_CFG_R_RX_CONTINUOUS, 1); udma_scif_csr.wfo(utra::udma_scif::REG_RX_CFG_R_RX_CONTINUOUS, baz); + let bar = udma_scif_csr.rf(utra::udma_scif::REG_RX_CFG_R_RX_EN); + udma_scif_csr.rmwf(utra::udma_scif::REG_RX_CFG_R_RX_EN, bar); + let mut baz = udma_scif_csr.zf(utra::udma_scif::REG_RX_CFG_R_RX_EN, bar); + baz |= udma_scif_csr.ms(utra::udma_scif::REG_RX_CFG_R_RX_EN, 1); + udma_scif_csr.wfo(utra::udma_scif::REG_RX_CFG_R_RX_EN, baz); + let bar = udma_scif_csr.rf(utra::udma_scif::REG_RX_CFG_R_RX_CLR); + udma_scif_csr.rmwf(utra::udma_scif::REG_RX_CFG_R_RX_CLR, bar); + let mut baz = udma_scif_csr.zf(utra::udma_scif::REG_RX_CFG_R_RX_CLR, bar); + baz |= udma_scif_csr.ms(utra::udma_scif::REG_RX_CFG_R_RX_CLR, 1); + udma_scif_csr.wfo(utra::udma_scif::REG_RX_CFG_R_RX_CLR, baz); let foo = udma_scif_csr.r(utra::udma_scif::REG_TX_SADDR); udma_scif_csr.wo(utra::udma_scif::REG_TX_SADDR, foo); @@ -14522,6 +17839,16 @@ mod tests { let mut baz = udma_scif_csr.zf(utra::udma_scif::REG_TX_CFG_R_TX_CONTINUOUS, bar); baz |= udma_scif_csr.ms(utra::udma_scif::REG_TX_CFG_R_TX_CONTINUOUS, 1); udma_scif_csr.wfo(utra::udma_scif::REG_TX_CFG_R_TX_CONTINUOUS, baz); + let bar = udma_scif_csr.rf(utra::udma_scif::REG_TX_CFG_R_TX_EN); + udma_scif_csr.rmwf(utra::udma_scif::REG_TX_CFG_R_TX_EN, bar); + let mut baz = udma_scif_csr.zf(utra::udma_scif::REG_TX_CFG_R_TX_EN, bar); + baz |= udma_scif_csr.ms(utra::udma_scif::REG_TX_CFG_R_TX_EN, 1); + udma_scif_csr.wfo(utra::udma_scif::REG_TX_CFG_R_TX_EN, baz); + let bar = udma_scif_csr.rf(utra::udma_scif::REG_TX_CFG_R_TX_CLR); + udma_scif_csr.rmwf(utra::udma_scif::REG_TX_CFG_R_TX_CLR, bar); + let mut baz = udma_scif_csr.zf(utra::udma_scif::REG_TX_CFG_R_TX_CLR, bar); + baz |= udma_scif_csr.ms(utra::udma_scif::REG_TX_CFG_R_TX_CLR, 1); + udma_scif_csr.wfo(utra::udma_scif::REG_TX_CFG_R_TX_CLR, baz); let foo = udma_scif_csr.r(utra::udma_scif::REG_STATUS); udma_scif_csr.wo(utra::udma_scif::REG_STATUS, foo); @@ -14891,5532 +18218,48 @@ mod tests { fn compile_check_udma_adc_csr() { use super::*; let mut udma_adc_csr = CSR::new(HW_UDMA_ADC_BASE as *mut u32); - } - #[test] - #[ignore] - fn compile_check_aes_csr() { - use super::*; - let mut aes_csr = CSR::new(HW_AES_BASE as *mut u32); - - let foo = aes_csr.r(utra::aes::SFR_CRFUNC); - aes_csr.wo(utra::aes::SFR_CRFUNC, foo); - let bar = aes_csr.rf(utra::aes::SFR_CRFUNC_SFR_CRFUNC); - aes_csr.rmwf(utra::aes::SFR_CRFUNC_SFR_CRFUNC, bar); - let mut baz = aes_csr.zf(utra::aes::SFR_CRFUNC_SFR_CRFUNC, bar); - baz |= aes_csr.ms(utra::aes::SFR_CRFUNC_SFR_CRFUNC, 1); - aes_csr.wfo(utra::aes::SFR_CRFUNC_SFR_CRFUNC, baz); - - let foo = aes_csr.r(utra::aes::SFR_AR); - aes_csr.wo(utra::aes::SFR_AR, foo); - let bar = aes_csr.rf(utra::aes::SFR_AR_SFR_AR); - aes_csr.rmwf(utra::aes::SFR_AR_SFR_AR, bar); - let mut baz = aes_csr.zf(utra::aes::SFR_AR_SFR_AR, bar); - baz |= aes_csr.ms(utra::aes::SFR_AR_SFR_AR, 1); - aes_csr.wfo(utra::aes::SFR_AR_SFR_AR, baz); - - let foo = aes_csr.r(utra::aes::SFR_SRMFSM); - aes_csr.wo(utra::aes::SFR_SRMFSM, foo); - let bar = aes_csr.rf(utra::aes::SFR_SRMFSM_SFR_SRMFSM); - aes_csr.rmwf(utra::aes::SFR_SRMFSM_SFR_SRMFSM, bar); - let mut baz = aes_csr.zf(utra::aes::SFR_SRMFSM_SFR_SRMFSM, bar); - baz |= aes_csr.ms(utra::aes::SFR_SRMFSM_SFR_SRMFSM, 1); - aes_csr.wfo(utra::aes::SFR_SRMFSM_SFR_SRMFSM, baz); - - let foo = aes_csr.r(utra::aes::SFR_FR); - aes_csr.wo(utra::aes::SFR_FR, foo); - let bar = aes_csr.rf(utra::aes::SFR_FR_MFSM_DONE); - aes_csr.rmwf(utra::aes::SFR_FR_MFSM_DONE, bar); - let mut baz = aes_csr.zf(utra::aes::SFR_FR_MFSM_DONE, bar); - baz |= aes_csr.ms(utra::aes::SFR_FR_MFSM_DONE, 1); - aes_csr.wfo(utra::aes::SFR_FR_MFSM_DONE, baz); - let bar = aes_csr.rf(utra::aes::SFR_FR_ACORE_DONE); - aes_csr.rmwf(utra::aes::SFR_FR_ACORE_DONE, bar); - let mut baz = aes_csr.zf(utra::aes::SFR_FR_ACORE_DONE, bar); - baz |= aes_csr.ms(utra::aes::SFR_FR_ACORE_DONE, 1); - aes_csr.wfo(utra::aes::SFR_FR_ACORE_DONE, baz); - let bar = aes_csr.rf(utra::aes::SFR_FR_CHNLO_DONE); - aes_csr.rmwf(utra::aes::SFR_FR_CHNLO_DONE, bar); - let mut baz = aes_csr.zf(utra::aes::SFR_FR_CHNLO_DONE, bar); - baz |= aes_csr.ms(utra::aes::SFR_FR_CHNLO_DONE, 1); - aes_csr.wfo(utra::aes::SFR_FR_CHNLO_DONE, baz); - let bar = aes_csr.rf(utra::aes::SFR_FR_CHNLI_DONE); - aes_csr.rmwf(utra::aes::SFR_FR_CHNLI_DONE, bar); - let mut baz = aes_csr.zf(utra::aes::SFR_FR_CHNLI_DONE, bar); - baz |= aes_csr.ms(utra::aes::SFR_FR_CHNLI_DONE, 1); - aes_csr.wfo(utra::aes::SFR_FR_CHNLI_DONE, baz); - - let foo = aes_csr.r(utra::aes::SFR_OPT); - aes_csr.wo(utra::aes::SFR_OPT, foo); - let bar = aes_csr.rf(utra::aes::SFR_OPT_OPT_KLEN0); - aes_csr.rmwf(utra::aes::SFR_OPT_OPT_KLEN0, bar); - let mut baz = aes_csr.zf(utra::aes::SFR_OPT_OPT_KLEN0, bar); - baz |= aes_csr.ms(utra::aes::SFR_OPT_OPT_KLEN0, 1); - aes_csr.wfo(utra::aes::SFR_OPT_OPT_KLEN0, baz); - let bar = aes_csr.rf(utra::aes::SFR_OPT_OPT_MODE0); - aes_csr.rmwf(utra::aes::SFR_OPT_OPT_MODE0, bar); - let mut baz = aes_csr.zf(utra::aes::SFR_OPT_OPT_MODE0, bar); - baz |= aes_csr.ms(utra::aes::SFR_OPT_OPT_MODE0, 1); - aes_csr.wfo(utra::aes::SFR_OPT_OPT_MODE0, baz); - let bar = aes_csr.rf(utra::aes::SFR_OPT_OPT_IFSTART0); - aes_csr.rmwf(utra::aes::SFR_OPT_OPT_IFSTART0, bar); - let mut baz = aes_csr.zf(utra::aes::SFR_OPT_OPT_IFSTART0, bar); - baz |= aes_csr.ms(utra::aes::SFR_OPT_OPT_IFSTART0, 1); - aes_csr.wfo(utra::aes::SFR_OPT_OPT_IFSTART0, baz); - - let foo = aes_csr.r(utra::aes::SFR_OPT1); - aes_csr.wo(utra::aes::SFR_OPT1, foo); - let bar = aes_csr.rf(utra::aes::SFR_OPT1_SFR_OPT1); - aes_csr.rmwf(utra::aes::SFR_OPT1_SFR_OPT1, bar); - let mut baz = aes_csr.zf(utra::aes::SFR_OPT1_SFR_OPT1, bar); - baz |= aes_csr.ms(utra::aes::SFR_OPT1_SFR_OPT1, 1); - aes_csr.wfo(utra::aes::SFR_OPT1_SFR_OPT1, baz); - - let foo = aes_csr.r(utra::aes::SFR_OPTLTX); - aes_csr.wo(utra::aes::SFR_OPTLTX, foo); - let bar = aes_csr.rf(utra::aes::SFR_OPTLTX_SFR_OPTLTX); - aes_csr.rmwf(utra::aes::SFR_OPTLTX_SFR_OPTLTX, bar); - let mut baz = aes_csr.zf(utra::aes::SFR_OPTLTX_SFR_OPTLTX, bar); - baz |= aes_csr.ms(utra::aes::SFR_OPTLTX_SFR_OPTLTX, 1); - aes_csr.wfo(utra::aes::SFR_OPTLTX_SFR_OPTLTX, baz); - - let foo = aes_csr.r(utra::aes::SFR_MASKSEED); - aes_csr.wo(utra::aes::SFR_MASKSEED, foo); - let bar = aes_csr.rf(utra::aes::SFR_MASKSEED_SFR_MASKSEED); - aes_csr.rmwf(utra::aes::SFR_MASKSEED_SFR_MASKSEED, bar); - let mut baz = aes_csr.zf(utra::aes::SFR_MASKSEED_SFR_MASKSEED, bar); - baz |= aes_csr.ms(utra::aes::SFR_MASKSEED_SFR_MASKSEED, 1); - aes_csr.wfo(utra::aes::SFR_MASKSEED_SFR_MASKSEED, baz); - - let foo = aes_csr.r(utra::aes::SFR_MASKSEEDAR); - aes_csr.wo(utra::aes::SFR_MASKSEEDAR, foo); - let bar = aes_csr.rf(utra::aes::SFR_MASKSEEDAR_SFR_MASKSEEDAR); - aes_csr.rmwf(utra::aes::SFR_MASKSEEDAR_SFR_MASKSEEDAR, bar); - let mut baz = aes_csr.zf(utra::aes::SFR_MASKSEEDAR_SFR_MASKSEEDAR, bar); - baz |= aes_csr.ms(utra::aes::SFR_MASKSEEDAR_SFR_MASKSEEDAR, 1); - aes_csr.wfo(utra::aes::SFR_MASKSEEDAR_SFR_MASKSEEDAR, baz); - - let foo = aes_csr.r(utra::aes::SFR_SEGPTR_PTRID_IV); - aes_csr.wo(utra::aes::SFR_SEGPTR_PTRID_IV, foo); - let bar = aes_csr.rf(utra::aes::SFR_SEGPTR_PTRID_IV_PTRID_IV); - aes_csr.rmwf(utra::aes::SFR_SEGPTR_PTRID_IV_PTRID_IV, bar); - let mut baz = aes_csr.zf(utra::aes::SFR_SEGPTR_PTRID_IV_PTRID_IV, bar); - baz |= aes_csr.ms(utra::aes::SFR_SEGPTR_PTRID_IV_PTRID_IV, 1); - aes_csr.wfo(utra::aes::SFR_SEGPTR_PTRID_IV_PTRID_IV, baz); - - let foo = aes_csr.r(utra::aes::SFR_SEGPTR_PTRID_AKEY); - aes_csr.wo(utra::aes::SFR_SEGPTR_PTRID_AKEY, foo); - let bar = aes_csr.rf(utra::aes::SFR_SEGPTR_PTRID_AKEY_PTRID_AKEY); - aes_csr.rmwf(utra::aes::SFR_SEGPTR_PTRID_AKEY_PTRID_AKEY, bar); - let mut baz = aes_csr.zf(utra::aes::SFR_SEGPTR_PTRID_AKEY_PTRID_AKEY, bar); - baz |= aes_csr.ms(utra::aes::SFR_SEGPTR_PTRID_AKEY_PTRID_AKEY, 1); - aes_csr.wfo(utra::aes::SFR_SEGPTR_PTRID_AKEY_PTRID_AKEY, baz); - - let foo = aes_csr.r(utra::aes::SFR_SEGPTR_PTRID_AIB); - aes_csr.wo(utra::aes::SFR_SEGPTR_PTRID_AIB, foo); - let bar = aes_csr.rf(utra::aes::SFR_SEGPTR_PTRID_AIB_PTRID_AIB); - aes_csr.rmwf(utra::aes::SFR_SEGPTR_PTRID_AIB_PTRID_AIB, bar); - let mut baz = aes_csr.zf(utra::aes::SFR_SEGPTR_PTRID_AIB_PTRID_AIB, bar); - baz |= aes_csr.ms(utra::aes::SFR_SEGPTR_PTRID_AIB_PTRID_AIB, 1); - aes_csr.wfo(utra::aes::SFR_SEGPTR_PTRID_AIB_PTRID_AIB, baz); - - let foo = aes_csr.r(utra::aes::SFR_SEGPTR_PTRID_AOB); - aes_csr.wo(utra::aes::SFR_SEGPTR_PTRID_AOB, foo); - let bar = aes_csr.rf(utra::aes::SFR_SEGPTR_PTRID_AOB_PTRID_AOB); - aes_csr.rmwf(utra::aes::SFR_SEGPTR_PTRID_AOB_PTRID_AOB, bar); - let mut baz = aes_csr.zf(utra::aes::SFR_SEGPTR_PTRID_AOB_PTRID_AOB, bar); - baz |= aes_csr.ms(utra::aes::SFR_SEGPTR_PTRID_AOB_PTRID_AOB, 1); - aes_csr.wfo(utra::aes::SFR_SEGPTR_PTRID_AOB_PTRID_AOB, baz); - } - - #[test] - #[ignore] - fn compile_check_combohash_csr() { - use super::*; - let mut combohash_csr = CSR::new(HW_COMBOHASH_BASE as *mut u32); - - let foo = combohash_csr.r(utra::combohash::SFR_CRFUNC); - combohash_csr.wo(utra::combohash::SFR_CRFUNC, foo); - let bar = combohash_csr.rf(utra::combohash::SFR_CRFUNC_CR_FUNC); - combohash_csr.rmwf(utra::combohash::SFR_CRFUNC_CR_FUNC, bar); - let mut baz = combohash_csr.zf(utra::combohash::SFR_CRFUNC_CR_FUNC, bar); - baz |= combohash_csr.ms(utra::combohash::SFR_CRFUNC_CR_FUNC, 1); - combohash_csr.wfo(utra::combohash::SFR_CRFUNC_CR_FUNC, baz); - - let foo = combohash_csr.r(utra::combohash::SFR_AR); - combohash_csr.wo(utra::combohash::SFR_AR, foo); - let bar = combohash_csr.rf(utra::combohash::SFR_AR_SFR_AR); - combohash_csr.rmwf(utra::combohash::SFR_AR_SFR_AR, bar); - let mut baz = combohash_csr.zf(utra::combohash::SFR_AR_SFR_AR, bar); - baz |= combohash_csr.ms(utra::combohash::SFR_AR_SFR_AR, 1); - combohash_csr.wfo(utra::combohash::SFR_AR_SFR_AR, baz); - - let foo = combohash_csr.r(utra::combohash::SFR_SRMFSM); - combohash_csr.wo(utra::combohash::SFR_SRMFSM, foo); - let bar = combohash_csr.rf(utra::combohash::SFR_SRMFSM_MFSM); - combohash_csr.rmwf(utra::combohash::SFR_SRMFSM_MFSM, bar); - let mut baz = combohash_csr.zf(utra::combohash::SFR_SRMFSM_MFSM, bar); - baz |= combohash_csr.ms(utra::combohash::SFR_SRMFSM_MFSM, 1); - combohash_csr.wfo(utra::combohash::SFR_SRMFSM_MFSM, baz); - - let foo = combohash_csr.r(utra::combohash::SFR_FR); - combohash_csr.wo(utra::combohash::SFR_FR, foo); - let bar = combohash_csr.rf(utra::combohash::SFR_FR_MFSM_DONE); - combohash_csr.rmwf(utra::combohash::SFR_FR_MFSM_DONE, bar); - let mut baz = combohash_csr.zf(utra::combohash::SFR_FR_MFSM_DONE, bar); - baz |= combohash_csr.ms(utra::combohash::SFR_FR_MFSM_DONE, 1); - combohash_csr.wfo(utra::combohash::SFR_FR_MFSM_DONE, baz); - let bar = combohash_csr.rf(utra::combohash::SFR_FR_HASH_DONE); - combohash_csr.rmwf(utra::combohash::SFR_FR_HASH_DONE, bar); - let mut baz = combohash_csr.zf(utra::combohash::SFR_FR_HASH_DONE, bar); - baz |= combohash_csr.ms(utra::combohash::SFR_FR_HASH_DONE, 1); - combohash_csr.wfo(utra::combohash::SFR_FR_HASH_DONE, baz); - let bar = combohash_csr.rf(utra::combohash::SFR_FR_CHNLO_DONE); - combohash_csr.rmwf(utra::combohash::SFR_FR_CHNLO_DONE, bar); - let mut baz = combohash_csr.zf(utra::combohash::SFR_FR_CHNLO_DONE, bar); - baz |= combohash_csr.ms(utra::combohash::SFR_FR_CHNLO_DONE, 1); - combohash_csr.wfo(utra::combohash::SFR_FR_CHNLO_DONE, baz); - let bar = combohash_csr.rf(utra::combohash::SFR_FR_CHNLI_DONE); - combohash_csr.rmwf(utra::combohash::SFR_FR_CHNLI_DONE, bar); - let mut baz = combohash_csr.zf(utra::combohash::SFR_FR_CHNLI_DONE, bar); - baz |= combohash_csr.ms(utra::combohash::SFR_FR_CHNLI_DONE, 1); - combohash_csr.wfo(utra::combohash::SFR_FR_CHNLI_DONE, baz); - let bar = combohash_csr.rf(utra::combohash::SFR_FR_CHKDONE); - combohash_csr.rmwf(utra::combohash::SFR_FR_CHKDONE, bar); - let mut baz = combohash_csr.zf(utra::combohash::SFR_FR_CHKDONE, bar); - baz |= combohash_csr.ms(utra::combohash::SFR_FR_CHKDONE, 1); - combohash_csr.wfo(utra::combohash::SFR_FR_CHKDONE, baz); - let bar = combohash_csr.rf(utra::combohash::SFR_FR_CHKPASS); - combohash_csr.rmwf(utra::combohash::SFR_FR_CHKPASS, bar); - let mut baz = combohash_csr.zf(utra::combohash::SFR_FR_CHKPASS, bar); - baz |= combohash_csr.ms(utra::combohash::SFR_FR_CHKPASS, 1); - combohash_csr.wfo(utra::combohash::SFR_FR_CHKPASS, baz); - - let foo = combohash_csr.r(utra::combohash::SFR_OPT1); - combohash_csr.wo(utra::combohash::SFR_OPT1, foo); - let bar = combohash_csr.rf(utra::combohash::SFR_OPT1_CR_OPT_HASHCNT); - combohash_csr.rmwf(utra::combohash::SFR_OPT1_CR_OPT_HASHCNT, bar); - let mut baz = combohash_csr.zf(utra::combohash::SFR_OPT1_CR_OPT_HASHCNT, bar); - baz |= combohash_csr.ms(utra::combohash::SFR_OPT1_CR_OPT_HASHCNT, 1); - combohash_csr.wfo(utra::combohash::SFR_OPT1_CR_OPT_HASHCNT, baz); - - let foo = combohash_csr.r(utra::combohash::SFR_OPT2); - combohash_csr.wo(utra::combohash::SFR_OPT2, foo); - let bar = combohash_csr.rf(utra::combohash::SFR_OPT2_CR_OPT_SCRTCHK); - combohash_csr.rmwf(utra::combohash::SFR_OPT2_CR_OPT_SCRTCHK, bar); - let mut baz = combohash_csr.zf(utra::combohash::SFR_OPT2_CR_OPT_SCRTCHK, bar); - baz |= combohash_csr.ms(utra::combohash::SFR_OPT2_CR_OPT_SCRTCHK, 1); - combohash_csr.wfo(utra::combohash::SFR_OPT2_CR_OPT_SCRTCHK, baz); - let bar = combohash_csr.rf(utra::combohash::SFR_OPT2_CR_OPT_IFSOB); - combohash_csr.rmwf(utra::combohash::SFR_OPT2_CR_OPT_IFSOB, bar); - let mut baz = combohash_csr.zf(utra::combohash::SFR_OPT2_CR_OPT_IFSOB, bar); - baz |= combohash_csr.ms(utra::combohash::SFR_OPT2_CR_OPT_IFSOB, 1); - combohash_csr.wfo(utra::combohash::SFR_OPT2_CR_OPT_IFSOB, baz); - let bar = combohash_csr.rf(utra::combohash::SFR_OPT2_CR_OPT_IFSTART); - combohash_csr.rmwf(utra::combohash::SFR_OPT2_CR_OPT_IFSTART, bar); - let mut baz = combohash_csr.zf(utra::combohash::SFR_OPT2_CR_OPT_IFSTART, bar); - baz |= combohash_csr.ms(utra::combohash::SFR_OPT2_CR_OPT_IFSTART, 1); - combohash_csr.wfo(utra::combohash::SFR_OPT2_CR_OPT_IFSTART, baz); - - let foo = combohash_csr.r(utra::combohash::SFR_OPT3); - combohash_csr.wo(utra::combohash::SFR_OPT3, foo); - let bar = combohash_csr.rf(utra::combohash::SFR_OPT3_SFR_OPT3); - combohash_csr.rmwf(utra::combohash::SFR_OPT3_SFR_OPT3, bar); - let mut baz = combohash_csr.zf(utra::combohash::SFR_OPT3_SFR_OPT3, bar); - baz |= combohash_csr.ms(utra::combohash::SFR_OPT3_SFR_OPT3, 1); - combohash_csr.wfo(utra::combohash::SFR_OPT3_SFR_OPT3, baz); - - let foo = combohash_csr.r(utra::combohash::SFR_BLKT0); - combohash_csr.wo(utra::combohash::SFR_BLKT0, foo); - let bar = combohash_csr.rf(utra::combohash::SFR_BLKT0_SFR_BLKT0); - combohash_csr.rmwf(utra::combohash::SFR_BLKT0_SFR_BLKT0, bar); - let mut baz = combohash_csr.zf(utra::combohash::SFR_BLKT0_SFR_BLKT0, bar); - baz |= combohash_csr.ms(utra::combohash::SFR_BLKT0_SFR_BLKT0, 1); - combohash_csr.wfo(utra::combohash::SFR_BLKT0_SFR_BLKT0, baz); - - let foo = combohash_csr.r(utra::combohash::SFR_SEGPTR_SEGID_LKEY); - combohash_csr.wo(utra::combohash::SFR_SEGPTR_SEGID_LKEY, foo); - let bar = combohash_csr.rf(utra::combohash::SFR_SEGPTR_SEGID_LKEY_SEGID_LKEY); - combohash_csr.rmwf(utra::combohash::SFR_SEGPTR_SEGID_LKEY_SEGID_LKEY, bar); - let mut baz = combohash_csr.zf(utra::combohash::SFR_SEGPTR_SEGID_LKEY_SEGID_LKEY, bar); - baz |= combohash_csr.ms(utra::combohash::SFR_SEGPTR_SEGID_LKEY_SEGID_LKEY, 1); - combohash_csr.wfo(utra::combohash::SFR_SEGPTR_SEGID_LKEY_SEGID_LKEY, baz); - - let foo = combohash_csr.r(utra::combohash::SFR_SEGPTR_SEGID_KEY); - combohash_csr.wo(utra::combohash::SFR_SEGPTR_SEGID_KEY, foo); - let bar = combohash_csr.rf(utra::combohash::SFR_SEGPTR_SEGID_KEY_SEGID_KEY); - combohash_csr.rmwf(utra::combohash::SFR_SEGPTR_SEGID_KEY_SEGID_KEY, bar); - let mut baz = combohash_csr.zf(utra::combohash::SFR_SEGPTR_SEGID_KEY_SEGID_KEY, bar); - baz |= combohash_csr.ms(utra::combohash::SFR_SEGPTR_SEGID_KEY_SEGID_KEY, 1); - combohash_csr.wfo(utra::combohash::SFR_SEGPTR_SEGID_KEY_SEGID_KEY, baz); - - let foo = combohash_csr.r(utra::combohash::SFR_SEGPTR_SEGID_SCRT); - combohash_csr.wo(utra::combohash::SFR_SEGPTR_SEGID_SCRT, foo); - let bar = combohash_csr.rf(utra::combohash::SFR_SEGPTR_SEGID_SCRT_SEGID_SCRT); - combohash_csr.rmwf(utra::combohash::SFR_SEGPTR_SEGID_SCRT_SEGID_SCRT, bar); - let mut baz = combohash_csr.zf(utra::combohash::SFR_SEGPTR_SEGID_SCRT_SEGID_SCRT, bar); - baz |= combohash_csr.ms(utra::combohash::SFR_SEGPTR_SEGID_SCRT_SEGID_SCRT, 1); - combohash_csr.wfo(utra::combohash::SFR_SEGPTR_SEGID_SCRT_SEGID_SCRT, baz); - - let foo = combohash_csr.r(utra::combohash::SFR_SEGPTR_SEGID_MSG); - combohash_csr.wo(utra::combohash::SFR_SEGPTR_SEGID_MSG, foo); - let bar = combohash_csr.rf(utra::combohash::SFR_SEGPTR_SEGID_MSG_SEGID_MSG); - combohash_csr.rmwf(utra::combohash::SFR_SEGPTR_SEGID_MSG_SEGID_MSG, bar); - let mut baz = combohash_csr.zf(utra::combohash::SFR_SEGPTR_SEGID_MSG_SEGID_MSG, bar); - baz |= combohash_csr.ms(utra::combohash::SFR_SEGPTR_SEGID_MSG_SEGID_MSG, 1); - combohash_csr.wfo(utra::combohash::SFR_SEGPTR_SEGID_MSG_SEGID_MSG, baz); - - let foo = combohash_csr.r(utra::combohash::SFR_SEGPTR_SEGID_HOUT); - combohash_csr.wo(utra::combohash::SFR_SEGPTR_SEGID_HOUT, foo); - let bar = combohash_csr.rf(utra::combohash::SFR_SEGPTR_SEGID_HOUT_SEGID_HOUT); - combohash_csr.rmwf(utra::combohash::SFR_SEGPTR_SEGID_HOUT_SEGID_HOUT, bar); - let mut baz = combohash_csr.zf(utra::combohash::SFR_SEGPTR_SEGID_HOUT_SEGID_HOUT, bar); - baz |= combohash_csr.ms(utra::combohash::SFR_SEGPTR_SEGID_HOUT_SEGID_HOUT, 1); - combohash_csr.wfo(utra::combohash::SFR_SEGPTR_SEGID_HOUT_SEGID_HOUT, baz); - - let foo = combohash_csr.r(utra::combohash::SFR_SEGPTR_SEGID_HOUT2); - combohash_csr.wo(utra::combohash::SFR_SEGPTR_SEGID_HOUT2, foo); - let bar = combohash_csr.rf(utra::combohash::SFR_SEGPTR_SEGID_HOUT2_SEGID_HOUT2); - combohash_csr.rmwf(utra::combohash::SFR_SEGPTR_SEGID_HOUT2_SEGID_HOUT2, bar); - let mut baz = combohash_csr.zf(utra::combohash::SFR_SEGPTR_SEGID_HOUT2_SEGID_HOUT2, bar); - baz |= combohash_csr.ms(utra::combohash::SFR_SEGPTR_SEGID_HOUT2_SEGID_HOUT2, 1); - combohash_csr.wfo(utra::combohash::SFR_SEGPTR_SEGID_HOUT2_SEGID_HOUT2, baz); - } - - #[test] - #[ignore] - fn compile_check_pke_csr() { - use super::*; - let mut pke_csr = CSR::new(HW_PKE_BASE as *mut u32); - - let foo = pke_csr.r(utra::pke::SFR_CRFUNC); - pke_csr.wo(utra::pke::SFR_CRFUNC, foo); - let bar = pke_csr.rf(utra::pke::SFR_CRFUNC_CR_FUNC); - pke_csr.rmwf(utra::pke::SFR_CRFUNC_CR_FUNC, bar); - let mut baz = pke_csr.zf(utra::pke::SFR_CRFUNC_CR_FUNC, bar); - baz |= pke_csr.ms(utra::pke::SFR_CRFUNC_CR_FUNC, 1); - pke_csr.wfo(utra::pke::SFR_CRFUNC_CR_FUNC, baz); - let bar = pke_csr.rf(utra::pke::SFR_CRFUNC_CR_PCOREIR); - pke_csr.rmwf(utra::pke::SFR_CRFUNC_CR_PCOREIR, bar); - let mut baz = pke_csr.zf(utra::pke::SFR_CRFUNC_CR_PCOREIR, bar); - baz |= pke_csr.ms(utra::pke::SFR_CRFUNC_CR_PCOREIR, 1); - pke_csr.wfo(utra::pke::SFR_CRFUNC_CR_PCOREIR, baz); - - let foo = pke_csr.r(utra::pke::SFR_AR); - pke_csr.wo(utra::pke::SFR_AR, foo); - let bar = pke_csr.rf(utra::pke::SFR_AR_SFR_AR); - pke_csr.rmwf(utra::pke::SFR_AR_SFR_AR, bar); - let mut baz = pke_csr.zf(utra::pke::SFR_AR_SFR_AR, bar); - baz |= pke_csr.ms(utra::pke::SFR_AR_SFR_AR, 1); - pke_csr.wfo(utra::pke::SFR_AR_SFR_AR, baz); - - let foo = pke_csr.r(utra::pke::SFR_SRMFSM); - pke_csr.wo(utra::pke::SFR_SRMFSM, foo); - let bar = pke_csr.rf(utra::pke::SFR_SRMFSM_MFSM); - pke_csr.rmwf(utra::pke::SFR_SRMFSM_MFSM, bar); - let mut baz = pke_csr.zf(utra::pke::SFR_SRMFSM_MFSM, bar); - baz |= pke_csr.ms(utra::pke::SFR_SRMFSM_MFSM, 1); - pke_csr.wfo(utra::pke::SFR_SRMFSM_MFSM, baz); - let bar = pke_csr.rf(utra::pke::SFR_SRMFSM_MODINVREADY); - pke_csr.rmwf(utra::pke::SFR_SRMFSM_MODINVREADY, bar); - let mut baz = pke_csr.zf(utra::pke::SFR_SRMFSM_MODINVREADY, bar); - baz |= pke_csr.ms(utra::pke::SFR_SRMFSM_MODINVREADY, 1); - pke_csr.wfo(utra::pke::SFR_SRMFSM_MODINVREADY, baz); - - let foo = pke_csr.r(utra::pke::SFR_FR); - pke_csr.wo(utra::pke::SFR_FR, foo); - let bar = pke_csr.rf(utra::pke::SFR_FR_MFSM_DONE); - pke_csr.rmwf(utra::pke::SFR_FR_MFSM_DONE, bar); - let mut baz = pke_csr.zf(utra::pke::SFR_FR_MFSM_DONE, bar); - baz |= pke_csr.ms(utra::pke::SFR_FR_MFSM_DONE, 1); - pke_csr.wfo(utra::pke::SFR_FR_MFSM_DONE, baz); - let bar = pke_csr.rf(utra::pke::SFR_FR_PCORE_DONE); - pke_csr.rmwf(utra::pke::SFR_FR_PCORE_DONE, bar); - let mut baz = pke_csr.zf(utra::pke::SFR_FR_PCORE_DONE, bar); - baz |= pke_csr.ms(utra::pke::SFR_FR_PCORE_DONE, 1); - pke_csr.wfo(utra::pke::SFR_FR_PCORE_DONE, baz); - let bar = pke_csr.rf(utra::pke::SFR_FR_CHNLO_DONE); - pke_csr.rmwf(utra::pke::SFR_FR_CHNLO_DONE, bar); - let mut baz = pke_csr.zf(utra::pke::SFR_FR_CHNLO_DONE, bar); - baz |= pke_csr.ms(utra::pke::SFR_FR_CHNLO_DONE, 1); - pke_csr.wfo(utra::pke::SFR_FR_CHNLO_DONE, baz); - let bar = pke_csr.rf(utra::pke::SFR_FR_CHNLI_DONE); - pke_csr.rmwf(utra::pke::SFR_FR_CHNLI_DONE, bar); - let mut baz = pke_csr.zf(utra::pke::SFR_FR_CHNLI_DONE, bar); - baz |= pke_csr.ms(utra::pke::SFR_FR_CHNLI_DONE, 1); - pke_csr.wfo(utra::pke::SFR_FR_CHNLI_DONE, baz); - let bar = pke_csr.rf(utra::pke::SFR_FR_CHNLX_DONE); - pke_csr.rmwf(utra::pke::SFR_FR_CHNLX_DONE, bar); - let mut baz = pke_csr.zf(utra::pke::SFR_FR_CHNLX_DONE, bar); - baz |= pke_csr.ms(utra::pke::SFR_FR_CHNLX_DONE, 1); - pke_csr.wfo(utra::pke::SFR_FR_CHNLX_DONE, baz); - - let foo = pke_csr.r(utra::pke::SFR_OPTNW); - pke_csr.wo(utra::pke::SFR_OPTNW, foo); - let bar = pke_csr.rf(utra::pke::SFR_OPTNW_SFR_OPTNW); - pke_csr.rmwf(utra::pke::SFR_OPTNW_SFR_OPTNW, bar); - let mut baz = pke_csr.zf(utra::pke::SFR_OPTNW_SFR_OPTNW, bar); - baz |= pke_csr.ms(utra::pke::SFR_OPTNW_SFR_OPTNW, 1); - pke_csr.wfo(utra::pke::SFR_OPTNW_SFR_OPTNW, baz); - - let foo = pke_csr.r(utra::pke::SFR_OPTEW); - pke_csr.wo(utra::pke::SFR_OPTEW, foo); - let bar = pke_csr.rf(utra::pke::SFR_OPTEW_SFR_OPTEW); - pke_csr.rmwf(utra::pke::SFR_OPTEW_SFR_OPTEW, bar); - let mut baz = pke_csr.zf(utra::pke::SFR_OPTEW_SFR_OPTEW, bar); - baz |= pke_csr.ms(utra::pke::SFR_OPTEW_SFR_OPTEW, 1); - pke_csr.wfo(utra::pke::SFR_OPTEW_SFR_OPTEW, baz); - - let foo = pke_csr.r(utra::pke::SFR_OPTRW); - pke_csr.wo(utra::pke::SFR_OPTRW, foo); - let bar = pke_csr.rf(utra::pke::SFR_OPTRW_SFR_OPTRW); - pke_csr.rmwf(utra::pke::SFR_OPTRW_SFR_OPTRW, bar); - let mut baz = pke_csr.zf(utra::pke::SFR_OPTRW_SFR_OPTRW, bar); - baz |= pke_csr.ms(utra::pke::SFR_OPTRW_SFR_OPTRW, 1); - pke_csr.wfo(utra::pke::SFR_OPTRW_SFR_OPTRW, baz); - - let foo = pke_csr.r(utra::pke::SFR_OPTLTX); - pke_csr.wo(utra::pke::SFR_OPTLTX, foo); - let bar = pke_csr.rf(utra::pke::SFR_OPTLTX_SFR_OPTLTX); - pke_csr.rmwf(utra::pke::SFR_OPTLTX_SFR_OPTLTX, bar); - let mut baz = pke_csr.zf(utra::pke::SFR_OPTLTX_SFR_OPTLTX, bar); - baz |= pke_csr.ms(utra::pke::SFR_OPTLTX_SFR_OPTLTX, 1); - pke_csr.wfo(utra::pke::SFR_OPTLTX_SFR_OPTLTX, baz); - - let foo = pke_csr.r(utra::pke::SFR_OPTMASK); - pke_csr.wo(utra::pke::SFR_OPTMASK, foo); - let bar = pke_csr.rf(utra::pke::SFR_OPTMASK_SFR_OPTMASK); - pke_csr.rmwf(utra::pke::SFR_OPTMASK_SFR_OPTMASK, bar); - let mut baz = pke_csr.zf(utra::pke::SFR_OPTMASK_SFR_OPTMASK, bar); - baz |= pke_csr.ms(utra::pke::SFR_OPTMASK_SFR_OPTMASK, 1); - pke_csr.wfo(utra::pke::SFR_OPTMASK_SFR_OPTMASK, baz); - - let foo = pke_csr.r(utra::pke::SFR_SEGPTR_PTRID_PCON); - pke_csr.wo(utra::pke::SFR_SEGPTR_PTRID_PCON, foo); - let bar = pke_csr.rf(utra::pke::SFR_SEGPTR_PTRID_PCON_PTRID_PCON); - pke_csr.rmwf(utra::pke::SFR_SEGPTR_PTRID_PCON_PTRID_PCON, bar); - let mut baz = pke_csr.zf(utra::pke::SFR_SEGPTR_PTRID_PCON_PTRID_PCON, bar); - baz |= pke_csr.ms(utra::pke::SFR_SEGPTR_PTRID_PCON_PTRID_PCON, 1); - pke_csr.wfo(utra::pke::SFR_SEGPTR_PTRID_PCON_PTRID_PCON, baz); - - let foo = pke_csr.r(utra::pke::SFR_SEGPTR_PTRID_PIB0); - pke_csr.wo(utra::pke::SFR_SEGPTR_PTRID_PIB0, foo); - let bar = pke_csr.rf(utra::pke::SFR_SEGPTR_PTRID_PIB0_PTRID_PIB0); - pke_csr.rmwf(utra::pke::SFR_SEGPTR_PTRID_PIB0_PTRID_PIB0, bar); - let mut baz = pke_csr.zf(utra::pke::SFR_SEGPTR_PTRID_PIB0_PTRID_PIB0, bar); - baz |= pke_csr.ms(utra::pke::SFR_SEGPTR_PTRID_PIB0_PTRID_PIB0, 1); - pke_csr.wfo(utra::pke::SFR_SEGPTR_PTRID_PIB0_PTRID_PIB0, baz); - - let foo = pke_csr.r(utra::pke::SFR_SEGPTR_PTRID_PIB1); - pke_csr.wo(utra::pke::SFR_SEGPTR_PTRID_PIB1, foo); - let bar = pke_csr.rf(utra::pke::SFR_SEGPTR_PTRID_PIB1_PTRID_PIB1); - pke_csr.rmwf(utra::pke::SFR_SEGPTR_PTRID_PIB1_PTRID_PIB1, bar); - let mut baz = pke_csr.zf(utra::pke::SFR_SEGPTR_PTRID_PIB1_PTRID_PIB1, bar); - baz |= pke_csr.ms(utra::pke::SFR_SEGPTR_PTRID_PIB1_PTRID_PIB1, 1); - pke_csr.wfo(utra::pke::SFR_SEGPTR_PTRID_PIB1_PTRID_PIB1, baz); - - let foo = pke_csr.r(utra::pke::SFR_SEGPTR_PTRID_PKB); - pke_csr.wo(utra::pke::SFR_SEGPTR_PTRID_PKB, foo); - let bar = pke_csr.rf(utra::pke::SFR_SEGPTR_PTRID_PKB_PTRID_PKB); - pke_csr.rmwf(utra::pke::SFR_SEGPTR_PTRID_PKB_PTRID_PKB, bar); - let mut baz = pke_csr.zf(utra::pke::SFR_SEGPTR_PTRID_PKB_PTRID_PKB, bar); - baz |= pke_csr.ms(utra::pke::SFR_SEGPTR_PTRID_PKB_PTRID_PKB, 1); - pke_csr.wfo(utra::pke::SFR_SEGPTR_PTRID_PKB_PTRID_PKB, baz); - - let foo = pke_csr.r(utra::pke::SFR_SEGPTR_PTRID_POB); - pke_csr.wo(utra::pke::SFR_SEGPTR_PTRID_POB, foo); - let bar = pke_csr.rf(utra::pke::SFR_SEGPTR_PTRID_POB_PTRID_POB); - pke_csr.rmwf(utra::pke::SFR_SEGPTR_PTRID_POB_PTRID_POB, bar); - let mut baz = pke_csr.zf(utra::pke::SFR_SEGPTR_PTRID_POB_PTRID_POB, bar); - baz |= pke_csr.ms(utra::pke::SFR_SEGPTR_PTRID_POB_PTRID_POB, 1); - pke_csr.wfo(utra::pke::SFR_SEGPTR_PTRID_POB_PTRID_POB, baz); - } - - #[test] - #[ignore] - fn compile_check_scedma_csr() { - use super::*; - let mut scedma_csr = CSR::new(HW_SCEDMA_BASE as *mut u32); - - let foo = scedma_csr.r(utra::scedma::SFR_SCHSTART_AR); - scedma_csr.wo(utra::scedma::SFR_SCHSTART_AR, foo); - let bar = scedma_csr.rf(utra::scedma::SFR_SCHSTART_AR_SFR_SCHSTART_AR); - scedma_csr.rmwf(utra::scedma::SFR_SCHSTART_AR_SFR_SCHSTART_AR, bar); - let mut baz = scedma_csr.zf(utra::scedma::SFR_SCHSTART_AR_SFR_SCHSTART_AR, bar); - baz |= scedma_csr.ms(utra::scedma::SFR_SCHSTART_AR_SFR_SCHSTART_AR, 1); - scedma_csr.wfo(utra::scedma::SFR_SCHSTART_AR_SFR_SCHSTART_AR, baz); - - let foo = scedma_csr.r(utra::scedma::SFR_XCH_FUNC); - scedma_csr.wo(utra::scedma::SFR_XCH_FUNC, foo); - let bar = scedma_csr.rf(utra::scedma::SFR_XCH_FUNC_SFR_XCH_FUNC); - scedma_csr.rmwf(utra::scedma::SFR_XCH_FUNC_SFR_XCH_FUNC, bar); - let mut baz = scedma_csr.zf(utra::scedma::SFR_XCH_FUNC_SFR_XCH_FUNC, bar); - baz |= scedma_csr.ms(utra::scedma::SFR_XCH_FUNC_SFR_XCH_FUNC, 1); - scedma_csr.wfo(utra::scedma::SFR_XCH_FUNC_SFR_XCH_FUNC, baz); - - let foo = scedma_csr.r(utra::scedma::SFR_XCH_OPT); - scedma_csr.wo(utra::scedma::SFR_XCH_OPT, foo); - let bar = scedma_csr.rf(utra::scedma::SFR_XCH_OPT_SFR_XCH_OPT); - scedma_csr.rmwf(utra::scedma::SFR_XCH_OPT_SFR_XCH_OPT, bar); - let mut baz = scedma_csr.zf(utra::scedma::SFR_XCH_OPT_SFR_XCH_OPT, bar); - baz |= scedma_csr.ms(utra::scedma::SFR_XCH_OPT_SFR_XCH_OPT, 1); - scedma_csr.wfo(utra::scedma::SFR_XCH_OPT_SFR_XCH_OPT, baz); - - let foo = scedma_csr.r(utra::scedma::SFR_XCH_AXSTART); - scedma_csr.wo(utra::scedma::SFR_XCH_AXSTART, foo); - let bar = scedma_csr.rf(utra::scedma::SFR_XCH_AXSTART_SFR_XCH_AXSTART); - scedma_csr.rmwf(utra::scedma::SFR_XCH_AXSTART_SFR_XCH_AXSTART, bar); - let mut baz = scedma_csr.zf(utra::scedma::SFR_XCH_AXSTART_SFR_XCH_AXSTART, bar); - baz |= scedma_csr.ms(utra::scedma::SFR_XCH_AXSTART_SFR_XCH_AXSTART, 1); - scedma_csr.wfo(utra::scedma::SFR_XCH_AXSTART_SFR_XCH_AXSTART, baz); - - let foo = scedma_csr.r(utra::scedma::SFR_XCH_SEGID); - scedma_csr.wo(utra::scedma::SFR_XCH_SEGID, foo); - let bar = scedma_csr.rf(utra::scedma::SFR_XCH_SEGID_SFR_XCH_SEGID); - scedma_csr.rmwf(utra::scedma::SFR_XCH_SEGID_SFR_XCH_SEGID, bar); - let mut baz = scedma_csr.zf(utra::scedma::SFR_XCH_SEGID_SFR_XCH_SEGID, bar); - baz |= scedma_csr.ms(utra::scedma::SFR_XCH_SEGID_SFR_XCH_SEGID, 1); - scedma_csr.wfo(utra::scedma::SFR_XCH_SEGID_SFR_XCH_SEGID, baz); - - let foo = scedma_csr.r(utra::scedma::SFR_XCH_SEGSTART); - scedma_csr.wo(utra::scedma::SFR_XCH_SEGSTART, foo); - let bar = scedma_csr.rf(utra::scedma::SFR_XCH_SEGSTART_XCHCR_SEGSTART); - scedma_csr.rmwf(utra::scedma::SFR_XCH_SEGSTART_XCHCR_SEGSTART, bar); - let mut baz = scedma_csr.zf(utra::scedma::SFR_XCH_SEGSTART_XCHCR_SEGSTART, bar); - baz |= scedma_csr.ms(utra::scedma::SFR_XCH_SEGSTART_XCHCR_SEGSTART, 1); - scedma_csr.wfo(utra::scedma::SFR_XCH_SEGSTART_XCHCR_SEGSTART, baz); - - let foo = scedma_csr.r(utra::scedma::SFR_XCH_TRANSIZE); - scedma_csr.wo(utra::scedma::SFR_XCH_TRANSIZE, foo); - let bar = scedma_csr.rf(utra::scedma::SFR_XCH_TRANSIZE_XCHCR_TRANSIZE); - scedma_csr.rmwf(utra::scedma::SFR_XCH_TRANSIZE_XCHCR_TRANSIZE, bar); - let mut baz = scedma_csr.zf(utra::scedma::SFR_XCH_TRANSIZE_XCHCR_TRANSIZE, bar); - baz |= scedma_csr.ms(utra::scedma::SFR_XCH_TRANSIZE_XCHCR_TRANSIZE, 1); - scedma_csr.wfo(utra::scedma::SFR_XCH_TRANSIZE_XCHCR_TRANSIZE, baz); - - let foo = scedma_csr.r(utra::scedma::SFR_SCH_FUNC); - scedma_csr.wo(utra::scedma::SFR_SCH_FUNC, foo); - let bar = scedma_csr.rf(utra::scedma::SFR_SCH_FUNC_SFR_SCH_FUNC); - scedma_csr.rmwf(utra::scedma::SFR_SCH_FUNC_SFR_SCH_FUNC, bar); - let mut baz = scedma_csr.zf(utra::scedma::SFR_SCH_FUNC_SFR_SCH_FUNC, bar); - baz |= scedma_csr.ms(utra::scedma::SFR_SCH_FUNC_SFR_SCH_FUNC, 1); - scedma_csr.wfo(utra::scedma::SFR_SCH_FUNC_SFR_SCH_FUNC, baz); - - let foo = scedma_csr.r(utra::scedma::SFR_SCH_OPT); - scedma_csr.wo(utra::scedma::SFR_SCH_OPT, foo); - let bar = scedma_csr.rf(utra::scedma::SFR_SCH_OPT_SFR_SCH_OPT); - scedma_csr.rmwf(utra::scedma::SFR_SCH_OPT_SFR_SCH_OPT, bar); - let mut baz = scedma_csr.zf(utra::scedma::SFR_SCH_OPT_SFR_SCH_OPT, bar); - baz |= scedma_csr.ms(utra::scedma::SFR_SCH_OPT_SFR_SCH_OPT, 1); - scedma_csr.wfo(utra::scedma::SFR_SCH_OPT_SFR_SCH_OPT, baz); - - let foo = scedma_csr.r(utra::scedma::SFR_SCH_AXSTART); - scedma_csr.wo(utra::scedma::SFR_SCH_AXSTART, foo); - let bar = scedma_csr.rf(utra::scedma::SFR_SCH_AXSTART_SFR_SCH_AXSTART); - scedma_csr.rmwf(utra::scedma::SFR_SCH_AXSTART_SFR_SCH_AXSTART, bar); - let mut baz = scedma_csr.zf(utra::scedma::SFR_SCH_AXSTART_SFR_SCH_AXSTART, bar); - baz |= scedma_csr.ms(utra::scedma::SFR_SCH_AXSTART_SFR_SCH_AXSTART, 1); - scedma_csr.wfo(utra::scedma::SFR_SCH_AXSTART_SFR_SCH_AXSTART, baz); - - let foo = scedma_csr.r(utra::scedma::SFR_SCH_SEGID); - scedma_csr.wo(utra::scedma::SFR_SCH_SEGID, foo); - let bar = scedma_csr.rf(utra::scedma::SFR_SCH_SEGID_SFR_SCH_SEGID); - scedma_csr.rmwf(utra::scedma::SFR_SCH_SEGID_SFR_SCH_SEGID, bar); - let mut baz = scedma_csr.zf(utra::scedma::SFR_SCH_SEGID_SFR_SCH_SEGID, bar); - baz |= scedma_csr.ms(utra::scedma::SFR_SCH_SEGID_SFR_SCH_SEGID, 1); - scedma_csr.wfo(utra::scedma::SFR_SCH_SEGID_SFR_SCH_SEGID, baz); - - let foo = scedma_csr.r(utra::scedma::SFR_SCH_SEGSTART); - scedma_csr.wo(utra::scedma::SFR_SCH_SEGSTART, foo); - let bar = scedma_csr.rf(utra::scedma::SFR_SCH_SEGSTART_SCHCR_SEGSTART); - scedma_csr.rmwf(utra::scedma::SFR_SCH_SEGSTART_SCHCR_SEGSTART, bar); - let mut baz = scedma_csr.zf(utra::scedma::SFR_SCH_SEGSTART_SCHCR_SEGSTART, bar); - baz |= scedma_csr.ms(utra::scedma::SFR_SCH_SEGSTART_SCHCR_SEGSTART, 1); - scedma_csr.wfo(utra::scedma::SFR_SCH_SEGSTART_SCHCR_SEGSTART, baz); - - let foo = scedma_csr.r(utra::scedma::SFR_SCH_TRANSIZE); - scedma_csr.wo(utra::scedma::SFR_SCH_TRANSIZE, foo); - let bar = scedma_csr.rf(utra::scedma::SFR_SCH_TRANSIZE_SCHCR_TRANSIZE); - scedma_csr.rmwf(utra::scedma::SFR_SCH_TRANSIZE_SCHCR_TRANSIZE, bar); - let mut baz = scedma_csr.zf(utra::scedma::SFR_SCH_TRANSIZE_SCHCR_TRANSIZE, bar); - baz |= scedma_csr.ms(utra::scedma::SFR_SCH_TRANSIZE_SCHCR_TRANSIZE, 1); - scedma_csr.wfo(utra::scedma::SFR_SCH_TRANSIZE_SCHCR_TRANSIZE, baz); - - let foo = scedma_csr.r(utra::scedma::SFR_ICH_OPT); - scedma_csr.wo(utra::scedma::SFR_ICH_OPT, foo); - let bar = scedma_csr.rf(utra::scedma::SFR_ICH_OPT_SFR_ICH_OPT); - scedma_csr.rmwf(utra::scedma::SFR_ICH_OPT_SFR_ICH_OPT, bar); - let mut baz = scedma_csr.zf(utra::scedma::SFR_ICH_OPT_SFR_ICH_OPT, bar); - baz |= scedma_csr.ms(utra::scedma::SFR_ICH_OPT_SFR_ICH_OPT, 1); - scedma_csr.wfo(utra::scedma::SFR_ICH_OPT_SFR_ICH_OPT, baz); - - let foo = scedma_csr.r(utra::scedma::SFR_ICH_SEGID); - scedma_csr.wo(utra::scedma::SFR_ICH_SEGID, foo); - let bar = scedma_csr.rf(utra::scedma::SFR_ICH_SEGID_SFR_ICH_SEGID); - scedma_csr.rmwf(utra::scedma::SFR_ICH_SEGID_SFR_ICH_SEGID, bar); - let mut baz = scedma_csr.zf(utra::scedma::SFR_ICH_SEGID_SFR_ICH_SEGID, bar); - baz |= scedma_csr.ms(utra::scedma::SFR_ICH_SEGID_SFR_ICH_SEGID, 1); - scedma_csr.wfo(utra::scedma::SFR_ICH_SEGID_SFR_ICH_SEGID, baz); - - let foo = scedma_csr.r(utra::scedma::SFR_ICH_RPSTART); - scedma_csr.wo(utra::scedma::SFR_ICH_RPSTART, foo); - let bar = scedma_csr.rf(utra::scedma::SFR_ICH_RPSTART_ICHCR_RPSTART); - scedma_csr.rmwf(utra::scedma::SFR_ICH_RPSTART_ICHCR_RPSTART, bar); - let mut baz = scedma_csr.zf(utra::scedma::SFR_ICH_RPSTART_ICHCR_RPSTART, bar); - baz |= scedma_csr.ms(utra::scedma::SFR_ICH_RPSTART_ICHCR_RPSTART, 1); - scedma_csr.wfo(utra::scedma::SFR_ICH_RPSTART_ICHCR_RPSTART, baz); - - let foo = scedma_csr.r(utra::scedma::SFR_ICH_WPSTART); - scedma_csr.wo(utra::scedma::SFR_ICH_WPSTART, foo); - let bar = scedma_csr.rf(utra::scedma::SFR_ICH_WPSTART_ICHCR_WPSTART); - scedma_csr.rmwf(utra::scedma::SFR_ICH_WPSTART_ICHCR_WPSTART, bar); - let mut baz = scedma_csr.zf(utra::scedma::SFR_ICH_WPSTART_ICHCR_WPSTART, bar); - baz |= scedma_csr.ms(utra::scedma::SFR_ICH_WPSTART_ICHCR_WPSTART, 1); - scedma_csr.wfo(utra::scedma::SFR_ICH_WPSTART_ICHCR_WPSTART, baz); - - let foo = scedma_csr.r(utra::scedma::SFR_ICH_TRANSIZE); - scedma_csr.wo(utra::scedma::SFR_ICH_TRANSIZE, foo); - let bar = scedma_csr.rf(utra::scedma::SFR_ICH_TRANSIZE_ICHCR_TRANSIZE); - scedma_csr.rmwf(utra::scedma::SFR_ICH_TRANSIZE_ICHCR_TRANSIZE, bar); - let mut baz = scedma_csr.zf(utra::scedma::SFR_ICH_TRANSIZE_ICHCR_TRANSIZE, bar); - baz |= scedma_csr.ms(utra::scedma::SFR_ICH_TRANSIZE_ICHCR_TRANSIZE, 1); - scedma_csr.wfo(utra::scedma::SFR_ICH_TRANSIZE_ICHCR_TRANSIZE, baz); - } - - #[test] - #[ignore] - fn compile_check_sce_glbsfr_csr() { - use super::*; - let mut sce_glbsfr_csr = CSR::new(HW_SCE_GLBSFR_BASE as *mut u32); - - let foo = sce_glbsfr_csr.r(utra::sce_glbsfr::SFR_SCEMODE); - sce_glbsfr_csr.wo(utra::sce_glbsfr::SFR_SCEMODE, foo); - let bar = sce_glbsfr_csr.rf(utra::sce_glbsfr::SFR_SCEMODE_CR_SCEMODE); - sce_glbsfr_csr.rmwf(utra::sce_glbsfr::SFR_SCEMODE_CR_SCEMODE, bar); - let mut baz = sce_glbsfr_csr.zf(utra::sce_glbsfr::SFR_SCEMODE_CR_SCEMODE, bar); - baz |= sce_glbsfr_csr.ms(utra::sce_glbsfr::SFR_SCEMODE_CR_SCEMODE, 1); - sce_glbsfr_csr.wfo(utra::sce_glbsfr::SFR_SCEMODE_CR_SCEMODE, baz); - - let foo = sce_glbsfr_csr.r(utra::sce_glbsfr::SFR_SUBEN); - sce_glbsfr_csr.wo(utra::sce_glbsfr::SFR_SUBEN, foo); - let bar = sce_glbsfr_csr.rf(utra::sce_glbsfr::SFR_SUBEN_CR_SUBEN); - sce_glbsfr_csr.rmwf(utra::sce_glbsfr::SFR_SUBEN_CR_SUBEN, bar); - let mut baz = sce_glbsfr_csr.zf(utra::sce_glbsfr::SFR_SUBEN_CR_SUBEN, bar); - baz |= sce_glbsfr_csr.ms(utra::sce_glbsfr::SFR_SUBEN_CR_SUBEN, 1); - sce_glbsfr_csr.wfo(utra::sce_glbsfr::SFR_SUBEN_CR_SUBEN, baz); - - let foo = sce_glbsfr_csr.r(utra::sce_glbsfr::SFR_AHBS); - sce_glbsfr_csr.wo(utra::sce_glbsfr::SFR_AHBS, foo); - let bar = sce_glbsfr_csr.rf(utra::sce_glbsfr::SFR_AHBS_CR_AHBSOPT); - sce_glbsfr_csr.rmwf(utra::sce_glbsfr::SFR_AHBS_CR_AHBSOPT, bar); - let mut baz = sce_glbsfr_csr.zf(utra::sce_glbsfr::SFR_AHBS_CR_AHBSOPT, bar); - baz |= sce_glbsfr_csr.ms(utra::sce_glbsfr::SFR_AHBS_CR_AHBSOPT, 1); - sce_glbsfr_csr.wfo(utra::sce_glbsfr::SFR_AHBS_CR_AHBSOPT, baz); - - let foo = sce_glbsfr_csr.r(utra::sce_glbsfr::SFR_SRBUSY); - sce_glbsfr_csr.wo(utra::sce_glbsfr::SFR_SRBUSY, foo); - let bar = sce_glbsfr_csr.rf(utra::sce_glbsfr::SFR_SRBUSY_SR_BUSY); - sce_glbsfr_csr.rmwf(utra::sce_glbsfr::SFR_SRBUSY_SR_BUSY, bar); - let mut baz = sce_glbsfr_csr.zf(utra::sce_glbsfr::SFR_SRBUSY_SR_BUSY, bar); - baz |= sce_glbsfr_csr.ms(utra::sce_glbsfr::SFR_SRBUSY_SR_BUSY, 1); - sce_glbsfr_csr.wfo(utra::sce_glbsfr::SFR_SRBUSY_SR_BUSY, baz); - - let foo = sce_glbsfr_csr.r(utra::sce_glbsfr::SFR_FRDONE); - sce_glbsfr_csr.wo(utra::sce_glbsfr::SFR_FRDONE, foo); - let bar = sce_glbsfr_csr.rf(utra::sce_glbsfr::SFR_FRDONE_FR_DONE); - sce_glbsfr_csr.rmwf(utra::sce_glbsfr::SFR_FRDONE_FR_DONE, bar); - let mut baz = sce_glbsfr_csr.zf(utra::sce_glbsfr::SFR_FRDONE_FR_DONE, bar); - baz |= sce_glbsfr_csr.ms(utra::sce_glbsfr::SFR_FRDONE_FR_DONE, 1); - sce_glbsfr_csr.wfo(utra::sce_glbsfr::SFR_FRDONE_FR_DONE, baz); - - let foo = sce_glbsfr_csr.r(utra::sce_glbsfr::SFR_FRERR); - sce_glbsfr_csr.wo(utra::sce_glbsfr::SFR_FRERR, foo); - let bar = sce_glbsfr_csr.rf(utra::sce_glbsfr::SFR_FRERR_FR_ERR); - sce_glbsfr_csr.rmwf(utra::sce_glbsfr::SFR_FRERR_FR_ERR, bar); - let mut baz = sce_glbsfr_csr.zf(utra::sce_glbsfr::SFR_FRERR_FR_ERR, bar); - baz |= sce_glbsfr_csr.ms(utra::sce_glbsfr::SFR_FRERR_FR_ERR, 1); - sce_glbsfr_csr.wfo(utra::sce_glbsfr::SFR_FRERR_FR_ERR, baz); - - let foo = sce_glbsfr_csr.r(utra::sce_glbsfr::SFR_ARCLR); - sce_glbsfr_csr.wo(utra::sce_glbsfr::SFR_ARCLR, foo); - let bar = sce_glbsfr_csr.rf(utra::sce_glbsfr::SFR_ARCLR_AR_CLRRAM); - sce_glbsfr_csr.rmwf(utra::sce_glbsfr::SFR_ARCLR_AR_CLRRAM, bar); - let mut baz = sce_glbsfr_csr.zf(utra::sce_glbsfr::SFR_ARCLR_AR_CLRRAM, bar); - baz |= sce_glbsfr_csr.ms(utra::sce_glbsfr::SFR_ARCLR_AR_CLRRAM, 1); - sce_glbsfr_csr.wfo(utra::sce_glbsfr::SFR_ARCLR_AR_CLRRAM, baz); - - let foo = sce_glbsfr_csr.r(utra::sce_glbsfr::SFR_FRACERR); - sce_glbsfr_csr.wo(utra::sce_glbsfr::SFR_FRACERR, foo); - let bar = sce_glbsfr_csr.rf(utra::sce_glbsfr::SFR_FRACERR_FR_ACERR); - sce_glbsfr_csr.rmwf(utra::sce_glbsfr::SFR_FRACERR_FR_ACERR, bar); - let mut baz = sce_glbsfr_csr.zf(utra::sce_glbsfr::SFR_FRACERR_FR_ACERR, bar); - baz |= sce_glbsfr_csr.ms(utra::sce_glbsfr::SFR_FRACERR_FR_ACERR, 1); - sce_glbsfr_csr.wfo(utra::sce_glbsfr::SFR_FRACERR_FR_ACERR, baz); - - let foo = sce_glbsfr_csr.r(utra::sce_glbsfr::SFR_TICKCNT); - sce_glbsfr_csr.wo(utra::sce_glbsfr::SFR_TICKCNT, foo); - let bar = sce_glbsfr_csr.rf(utra::sce_glbsfr::SFR_TICKCNT_SFR_TICKCNT); - sce_glbsfr_csr.rmwf(utra::sce_glbsfr::SFR_TICKCNT_SFR_TICKCNT, bar); - let mut baz = sce_glbsfr_csr.zf(utra::sce_glbsfr::SFR_TICKCNT_SFR_TICKCNT, bar); - baz |= sce_glbsfr_csr.ms(utra::sce_glbsfr::SFR_TICKCNT_SFR_TICKCNT, 1); - sce_glbsfr_csr.wfo(utra::sce_glbsfr::SFR_TICKCNT_SFR_TICKCNT, baz); - - let foo = sce_glbsfr_csr.r(utra::sce_glbsfr::SFR_FFEN); - sce_glbsfr_csr.wo(utra::sce_glbsfr::SFR_FFEN, foo); - let bar = sce_glbsfr_csr.rf(utra::sce_glbsfr::SFR_FFEN_CR_FFEN); - sce_glbsfr_csr.rmwf(utra::sce_glbsfr::SFR_FFEN_CR_FFEN, bar); - let mut baz = sce_glbsfr_csr.zf(utra::sce_glbsfr::SFR_FFEN_CR_FFEN, bar); - baz |= sce_glbsfr_csr.ms(utra::sce_glbsfr::SFR_FFEN_CR_FFEN, 1); - sce_glbsfr_csr.wfo(utra::sce_glbsfr::SFR_FFEN_CR_FFEN, baz); - - let foo = sce_glbsfr_csr.r(utra::sce_glbsfr::SFR_FFCLR); - sce_glbsfr_csr.wo(utra::sce_glbsfr::SFR_FFCLR, foo); - let bar = sce_glbsfr_csr.rf(utra::sce_glbsfr::SFR_FFCLR_AR_FFCLR); - sce_glbsfr_csr.rmwf(utra::sce_glbsfr::SFR_FFCLR_AR_FFCLR, bar); - let mut baz = sce_glbsfr_csr.zf(utra::sce_glbsfr::SFR_FFCLR_AR_FFCLR, bar); - baz |= sce_glbsfr_csr.ms(utra::sce_glbsfr::SFR_FFCLR_AR_FFCLR, 1); - sce_glbsfr_csr.wfo(utra::sce_glbsfr::SFR_FFCLR_AR_FFCLR, baz); - - let foo = sce_glbsfr_csr.r(utra::sce_glbsfr::SFR_FFCNT_SR_FF0); - sce_glbsfr_csr.wo(utra::sce_glbsfr::SFR_FFCNT_SR_FF0, foo); - let bar = sce_glbsfr_csr.rf(utra::sce_glbsfr::SFR_FFCNT_SR_FF0_SR_FF0); - sce_glbsfr_csr.rmwf(utra::sce_glbsfr::SFR_FFCNT_SR_FF0_SR_FF0, bar); - let mut baz = sce_glbsfr_csr.zf(utra::sce_glbsfr::SFR_FFCNT_SR_FF0_SR_FF0, bar); - baz |= sce_glbsfr_csr.ms(utra::sce_glbsfr::SFR_FFCNT_SR_FF0_SR_FF0, 1); - sce_glbsfr_csr.wfo(utra::sce_glbsfr::SFR_FFCNT_SR_FF0_SR_FF0, baz); - - let foo = sce_glbsfr_csr.r(utra::sce_glbsfr::SFR_FFCNT_SR_FF1); - sce_glbsfr_csr.wo(utra::sce_glbsfr::SFR_FFCNT_SR_FF1, foo); - let bar = sce_glbsfr_csr.rf(utra::sce_glbsfr::SFR_FFCNT_SR_FF1_SR_FF1); - sce_glbsfr_csr.rmwf(utra::sce_glbsfr::SFR_FFCNT_SR_FF1_SR_FF1, bar); - let mut baz = sce_glbsfr_csr.zf(utra::sce_glbsfr::SFR_FFCNT_SR_FF1_SR_FF1, bar); - baz |= sce_glbsfr_csr.ms(utra::sce_glbsfr::SFR_FFCNT_SR_FF1_SR_FF1, 1); - sce_glbsfr_csr.wfo(utra::sce_glbsfr::SFR_FFCNT_SR_FF1_SR_FF1, baz); - - let foo = sce_glbsfr_csr.r(utra::sce_glbsfr::SFR_FFCNT_SR_FF2); - sce_glbsfr_csr.wo(utra::sce_glbsfr::SFR_FFCNT_SR_FF2, foo); - let bar = sce_glbsfr_csr.rf(utra::sce_glbsfr::SFR_FFCNT_SR_FF2_SR_FF2); - sce_glbsfr_csr.rmwf(utra::sce_glbsfr::SFR_FFCNT_SR_FF2_SR_FF2, bar); - let mut baz = sce_glbsfr_csr.zf(utra::sce_glbsfr::SFR_FFCNT_SR_FF2_SR_FF2, bar); - baz |= sce_glbsfr_csr.ms(utra::sce_glbsfr::SFR_FFCNT_SR_FF2_SR_FF2, 1); - sce_glbsfr_csr.wfo(utra::sce_glbsfr::SFR_FFCNT_SR_FF2_SR_FF2, baz); - - let foo = sce_glbsfr_csr.r(utra::sce_glbsfr::SFR_FFCNT_SR_FF3); - sce_glbsfr_csr.wo(utra::sce_glbsfr::SFR_FFCNT_SR_FF3, foo); - let bar = sce_glbsfr_csr.rf(utra::sce_glbsfr::SFR_FFCNT_SR_FF3_SR_FF3); - sce_glbsfr_csr.rmwf(utra::sce_glbsfr::SFR_FFCNT_SR_FF3_SR_FF3, bar); - let mut baz = sce_glbsfr_csr.zf(utra::sce_glbsfr::SFR_FFCNT_SR_FF3_SR_FF3, bar); - baz |= sce_glbsfr_csr.ms(utra::sce_glbsfr::SFR_FFCNT_SR_FF3_SR_FF3, 1); - sce_glbsfr_csr.wfo(utra::sce_glbsfr::SFR_FFCNT_SR_FF3_SR_FF3, baz); - - let foo = sce_glbsfr_csr.r(utra::sce_glbsfr::SFR_FFCNT_SR_FF4); - sce_glbsfr_csr.wo(utra::sce_glbsfr::SFR_FFCNT_SR_FF4, foo); - let bar = sce_glbsfr_csr.rf(utra::sce_glbsfr::SFR_FFCNT_SR_FF4_SR_FF4); - sce_glbsfr_csr.rmwf(utra::sce_glbsfr::SFR_FFCNT_SR_FF4_SR_FF4, bar); - let mut baz = sce_glbsfr_csr.zf(utra::sce_glbsfr::SFR_FFCNT_SR_FF4_SR_FF4, bar); - baz |= sce_glbsfr_csr.ms(utra::sce_glbsfr::SFR_FFCNT_SR_FF4_SR_FF4, 1); - sce_glbsfr_csr.wfo(utra::sce_glbsfr::SFR_FFCNT_SR_FF4_SR_FF4, baz); - - let foo = sce_glbsfr_csr.r(utra::sce_glbsfr::SFR_FFCNT_SR_FF5); - sce_glbsfr_csr.wo(utra::sce_glbsfr::SFR_FFCNT_SR_FF5, foo); - let bar = sce_glbsfr_csr.rf(utra::sce_glbsfr::SFR_FFCNT_SR_FF5_SR_FF5); - sce_glbsfr_csr.rmwf(utra::sce_glbsfr::SFR_FFCNT_SR_FF5_SR_FF5, bar); - let mut baz = sce_glbsfr_csr.zf(utra::sce_glbsfr::SFR_FFCNT_SR_FF5_SR_FF5, bar); - baz |= sce_glbsfr_csr.ms(utra::sce_glbsfr::SFR_FFCNT_SR_FF5_SR_FF5, 1); - sce_glbsfr_csr.wfo(utra::sce_glbsfr::SFR_FFCNT_SR_FF5_SR_FF5, baz); - - let foo = sce_glbsfr_csr.r(utra::sce_glbsfr::SFR_TS); - sce_glbsfr_csr.wo(utra::sce_glbsfr::SFR_TS, foo); - let bar = sce_glbsfr_csr.rf(utra::sce_glbsfr::SFR_TS_CR_TS); - sce_glbsfr_csr.rmwf(utra::sce_glbsfr::SFR_TS_CR_TS, bar); - let mut baz = sce_glbsfr_csr.zf(utra::sce_glbsfr::SFR_TS_CR_TS, bar); - baz |= sce_glbsfr_csr.ms(utra::sce_glbsfr::SFR_TS_CR_TS, 1); - sce_glbsfr_csr.wfo(utra::sce_glbsfr::SFR_TS_CR_TS, baz); - } - - #[test] - #[ignore] - fn compile_check_trng_csr() { - use super::*; - let mut trng_csr = CSR::new(HW_TRNG_BASE as *mut u32); - - let foo = trng_csr.r(utra::trng::SFR_CRSRC); - trng_csr.wo(utra::trng::SFR_CRSRC, foo); - let bar = trng_csr.rf(utra::trng::SFR_CRSRC_SFR_CRSRC); - trng_csr.rmwf(utra::trng::SFR_CRSRC_SFR_CRSRC, bar); - let mut baz = trng_csr.zf(utra::trng::SFR_CRSRC_SFR_CRSRC, bar); - baz |= trng_csr.ms(utra::trng::SFR_CRSRC_SFR_CRSRC, 1); - trng_csr.wfo(utra::trng::SFR_CRSRC_SFR_CRSRC, baz); - - let foo = trng_csr.r(utra::trng::SFR_CRANA); - trng_csr.wo(utra::trng::SFR_CRANA, foo); - let bar = trng_csr.rf(utra::trng::SFR_CRANA_SFR_CRANA); - trng_csr.rmwf(utra::trng::SFR_CRANA_SFR_CRANA, bar); - let mut baz = trng_csr.zf(utra::trng::SFR_CRANA_SFR_CRANA, bar); - baz |= trng_csr.ms(utra::trng::SFR_CRANA_SFR_CRANA, 1); - trng_csr.wfo(utra::trng::SFR_CRANA_SFR_CRANA, baz); - - let foo = trng_csr.r(utra::trng::SFR_PP); - trng_csr.wo(utra::trng::SFR_PP, foo); - let bar = trng_csr.rf(utra::trng::SFR_PP_SFR_PP); - trng_csr.rmwf(utra::trng::SFR_PP_SFR_PP, bar); - let mut baz = trng_csr.zf(utra::trng::SFR_PP_SFR_PP, bar); - baz |= trng_csr.ms(utra::trng::SFR_PP_SFR_PP, 1); - trng_csr.wfo(utra::trng::SFR_PP_SFR_PP, baz); - - let foo = trng_csr.r(utra::trng::SFR_OPT); - trng_csr.wo(utra::trng::SFR_OPT, foo); - let bar = trng_csr.rf(utra::trng::SFR_OPT_SFR_OPT); - trng_csr.rmwf(utra::trng::SFR_OPT_SFR_OPT, bar); - let mut baz = trng_csr.zf(utra::trng::SFR_OPT_SFR_OPT, bar); - baz |= trng_csr.ms(utra::trng::SFR_OPT_SFR_OPT, 1); - trng_csr.wfo(utra::trng::SFR_OPT_SFR_OPT, baz); - - let foo = trng_csr.r(utra::trng::SFR_SR); - trng_csr.wo(utra::trng::SFR_SR, foo); - let bar = trng_csr.rf(utra::trng::SFR_SR_SR_RNG); - trng_csr.rmwf(utra::trng::SFR_SR_SR_RNG, bar); - let mut baz = trng_csr.zf(utra::trng::SFR_SR_SR_RNG, bar); - baz |= trng_csr.ms(utra::trng::SFR_SR_SR_RNG, 1); - trng_csr.wfo(utra::trng::SFR_SR_SR_RNG, baz); - - let foo = trng_csr.r(utra::trng::SFR_AR_GEN); - trng_csr.wo(utra::trng::SFR_AR_GEN, foo); - let bar = trng_csr.rf(utra::trng::SFR_AR_GEN_SFR_AR_GEN); - trng_csr.rmwf(utra::trng::SFR_AR_GEN_SFR_AR_GEN, bar); - let mut baz = trng_csr.zf(utra::trng::SFR_AR_GEN_SFR_AR_GEN, bar); - baz |= trng_csr.ms(utra::trng::SFR_AR_GEN_SFR_AR_GEN, 1); - trng_csr.wfo(utra::trng::SFR_AR_GEN_SFR_AR_GEN, baz); - - let foo = trng_csr.r(utra::trng::SFR_FR); - trng_csr.wo(utra::trng::SFR_FR, foo); - let bar = trng_csr.rf(utra::trng::SFR_FR_SFR_FR); - trng_csr.rmwf(utra::trng::SFR_FR_SFR_FR, bar); - let mut baz = trng_csr.zf(utra::trng::SFR_FR_SFR_FR, bar); - baz |= trng_csr.ms(utra::trng::SFR_FR_SFR_FR, 1); - trng_csr.wfo(utra::trng::SFR_FR_SFR_FR, baz); - - let foo = trng_csr.r(utra::trng::SFR_DRPSZ); - trng_csr.wo(utra::trng::SFR_DRPSZ, foo); - let bar = trng_csr.rf(utra::trng::SFR_DRPSZ_SFR_DRPSZ); - trng_csr.rmwf(utra::trng::SFR_DRPSZ_SFR_DRPSZ, bar); - let mut baz = trng_csr.zf(utra::trng::SFR_DRPSZ_SFR_DRPSZ, bar); - baz |= trng_csr.ms(utra::trng::SFR_DRPSZ_SFR_DRPSZ, 1); - trng_csr.wfo(utra::trng::SFR_DRPSZ_SFR_DRPSZ, baz); - - let foo = trng_csr.r(utra::trng::SFR_DRGEN); - trng_csr.wo(utra::trng::SFR_DRGEN, foo); - let bar = trng_csr.rf(utra::trng::SFR_DRGEN_SFR_DRGEN); - trng_csr.rmwf(utra::trng::SFR_DRGEN_SFR_DRGEN, bar); - let mut baz = trng_csr.zf(utra::trng::SFR_DRGEN_SFR_DRGEN, bar); - baz |= trng_csr.ms(utra::trng::SFR_DRGEN_SFR_DRGEN, 1); - trng_csr.wfo(utra::trng::SFR_DRGEN_SFR_DRGEN, baz); - - let foo = trng_csr.r(utra::trng::SFR_DRRESEED); - trng_csr.wo(utra::trng::SFR_DRRESEED, foo); - let bar = trng_csr.rf(utra::trng::SFR_DRRESEED_SFR_DRRESEED); - trng_csr.rmwf(utra::trng::SFR_DRRESEED_SFR_DRRESEED, bar); - let mut baz = trng_csr.zf(utra::trng::SFR_DRRESEED_SFR_DRRESEED, bar); - baz |= trng_csr.ms(utra::trng::SFR_DRRESEED_SFR_DRRESEED, 1); - trng_csr.wfo(utra::trng::SFR_DRRESEED_SFR_DRRESEED, baz); - - let foo = trng_csr.r(utra::trng::SFR_BUF); - trng_csr.wo(utra::trng::SFR_BUF, foo); - let bar = trng_csr.rf(utra::trng::SFR_BUF_SFR_BUF); - trng_csr.rmwf(utra::trng::SFR_BUF_SFR_BUF, bar); - let mut baz = trng_csr.zf(utra::trng::SFR_BUF_SFR_BUF, bar); - baz |= trng_csr.ms(utra::trng::SFR_BUF_SFR_BUF, 1); - trng_csr.wfo(utra::trng::SFR_BUF_SFR_BUF, baz); - - let foo = trng_csr.r(utra::trng::SFR_CHAIN_RNGCHAINEN0); - trng_csr.wo(utra::trng::SFR_CHAIN_RNGCHAINEN0, foo); - let bar = trng_csr.rf(utra::trng::SFR_CHAIN_RNGCHAINEN0_RNGCHAINEN0); - trng_csr.rmwf(utra::trng::SFR_CHAIN_RNGCHAINEN0_RNGCHAINEN0, bar); - let mut baz = trng_csr.zf(utra::trng::SFR_CHAIN_RNGCHAINEN0_RNGCHAINEN0, bar); - baz |= trng_csr.ms(utra::trng::SFR_CHAIN_RNGCHAINEN0_RNGCHAINEN0, 1); - trng_csr.wfo(utra::trng::SFR_CHAIN_RNGCHAINEN0_RNGCHAINEN0, baz); - - let foo = trng_csr.r(utra::trng::SFR_CHAIN_RNGCHAINEN1); - trng_csr.wo(utra::trng::SFR_CHAIN_RNGCHAINEN1, foo); - let bar = trng_csr.rf(utra::trng::SFR_CHAIN_RNGCHAINEN1_RNGCHAINEN1); - trng_csr.rmwf(utra::trng::SFR_CHAIN_RNGCHAINEN1_RNGCHAINEN1, bar); - let mut baz = trng_csr.zf(utra::trng::SFR_CHAIN_RNGCHAINEN1_RNGCHAINEN1, bar); - baz |= trng_csr.ms(utra::trng::SFR_CHAIN_RNGCHAINEN1_RNGCHAINEN1, 1); - trng_csr.wfo(utra::trng::SFR_CHAIN_RNGCHAINEN1_RNGCHAINEN1, baz); - } - - #[test] - #[ignore] - fn compile_check_alu_csr() { - use super::*; - let mut alu_csr = CSR::new(HW_ALU_BASE as *mut u32); - } - - #[test] - #[ignore] - fn compile_check_duart_csr() { - use super::*; - let mut duart_csr = CSR::new(HW_DUART_BASE as *mut u32); - - let foo = duart_csr.r(utra::duart::SFR_TXD); - duart_csr.wo(utra::duart::SFR_TXD, foo); - let bar = duart_csr.rf(utra::duart::SFR_TXD_SFR_TXD); - duart_csr.rmwf(utra::duart::SFR_TXD_SFR_TXD, bar); - let mut baz = duart_csr.zf(utra::duart::SFR_TXD_SFR_TXD, bar); - baz |= duart_csr.ms(utra::duart::SFR_TXD_SFR_TXD, 1); - duart_csr.wfo(utra::duart::SFR_TXD_SFR_TXD, baz); - - let foo = duart_csr.r(utra::duart::SFR_CR); - duart_csr.wo(utra::duart::SFR_CR, foo); - let bar = duart_csr.rf(utra::duart::SFR_CR_SFR_CR); - duart_csr.rmwf(utra::duart::SFR_CR_SFR_CR, bar); - let mut baz = duart_csr.zf(utra::duart::SFR_CR_SFR_CR, bar); - baz |= duart_csr.ms(utra::duart::SFR_CR_SFR_CR, 1); - duart_csr.wfo(utra::duart::SFR_CR_SFR_CR, baz); - - let foo = duart_csr.r(utra::duart::SFR_SR); - duart_csr.wo(utra::duart::SFR_SR, foo); - let bar = duart_csr.rf(utra::duart::SFR_SR_SFR_SR); - duart_csr.rmwf(utra::duart::SFR_SR_SFR_SR, bar); - let mut baz = duart_csr.zf(utra::duart::SFR_SR_SFR_SR, bar); - baz |= duart_csr.ms(utra::duart::SFR_SR_SFR_SR, 1); - duart_csr.wfo(utra::duart::SFR_SR_SFR_SR, baz); - - let foo = duart_csr.r(utra::duart::SFR_ETUC); - duart_csr.wo(utra::duart::SFR_ETUC, foo); - let bar = duart_csr.rf(utra::duart::SFR_ETUC_SFR_ETUC); - duart_csr.rmwf(utra::duart::SFR_ETUC_SFR_ETUC, bar); - let mut baz = duart_csr.zf(utra::duart::SFR_ETUC_SFR_ETUC, bar); - baz |= duart_csr.ms(utra::duart::SFR_ETUC_SFR_ETUC, 1); - duart_csr.wfo(utra::duart::SFR_ETUC_SFR_ETUC, baz); - } - - #[test] - #[ignore] - fn compile_check_wdg_intf_csr() { - use super::*; - let mut wdg_intf_csr = CSR::new(HW_WDG_INTF_BASE as *mut u32); - } - - #[test] - #[ignore] - fn compile_check_timer_intf_csr() { - use super::*; - let mut timer_intf_csr = CSR::new(HW_TIMER_INTF_BASE as *mut u32); - } - - #[test] - #[ignore] - fn compile_check_evc_csr() { - use super::*; - let mut evc_csr = CSR::new(HW_EVC_BASE as *mut u32); - - let foo = evc_csr.r(utra::evc::SFR_CM7EVSEL_CM7EVSEL0); - evc_csr.wo(utra::evc::SFR_CM7EVSEL_CM7EVSEL0, foo); - let bar = evc_csr.rf(utra::evc::SFR_CM7EVSEL_CM7EVSEL0_CM7EVSEL0); - evc_csr.rmwf(utra::evc::SFR_CM7EVSEL_CM7EVSEL0_CM7EVSEL0, bar); - let mut baz = evc_csr.zf(utra::evc::SFR_CM7EVSEL_CM7EVSEL0_CM7EVSEL0, bar); - baz |= evc_csr.ms(utra::evc::SFR_CM7EVSEL_CM7EVSEL0_CM7EVSEL0, 1); - evc_csr.wfo(utra::evc::SFR_CM7EVSEL_CM7EVSEL0_CM7EVSEL0, baz); - - let foo = evc_csr.r(utra::evc::SFR_CM7EVSEL_CM7EVSEL1); - evc_csr.wo(utra::evc::SFR_CM7EVSEL_CM7EVSEL1, foo); - let bar = evc_csr.rf(utra::evc::SFR_CM7EVSEL_CM7EVSEL1_CM7EVSEL1); - evc_csr.rmwf(utra::evc::SFR_CM7EVSEL_CM7EVSEL1_CM7EVSEL1, bar); - let mut baz = evc_csr.zf(utra::evc::SFR_CM7EVSEL_CM7EVSEL1_CM7EVSEL1, bar); - baz |= evc_csr.ms(utra::evc::SFR_CM7EVSEL_CM7EVSEL1_CM7EVSEL1, 1); - evc_csr.wfo(utra::evc::SFR_CM7EVSEL_CM7EVSEL1_CM7EVSEL1, baz); - - let foo = evc_csr.r(utra::evc::SFR_CM7EVSEL_CM7EVSEL2); - evc_csr.wo(utra::evc::SFR_CM7EVSEL_CM7EVSEL2, foo); - let bar = evc_csr.rf(utra::evc::SFR_CM7EVSEL_CM7EVSEL2_CM7EVSEL2); - evc_csr.rmwf(utra::evc::SFR_CM7EVSEL_CM7EVSEL2_CM7EVSEL2, bar); - let mut baz = evc_csr.zf(utra::evc::SFR_CM7EVSEL_CM7EVSEL2_CM7EVSEL2, bar); - baz |= evc_csr.ms(utra::evc::SFR_CM7EVSEL_CM7EVSEL2_CM7EVSEL2, 1); - evc_csr.wfo(utra::evc::SFR_CM7EVSEL_CM7EVSEL2_CM7EVSEL2, baz); - - let foo = evc_csr.r(utra::evc::SFR_CM7EVSEL_CM7EVSEL3); - evc_csr.wo(utra::evc::SFR_CM7EVSEL_CM7EVSEL3, foo); - let bar = evc_csr.rf(utra::evc::SFR_CM7EVSEL_CM7EVSEL3_CM7EVSEL3); - evc_csr.rmwf(utra::evc::SFR_CM7EVSEL_CM7EVSEL3_CM7EVSEL3, bar); - let mut baz = evc_csr.zf(utra::evc::SFR_CM7EVSEL_CM7EVSEL3_CM7EVSEL3, bar); - baz |= evc_csr.ms(utra::evc::SFR_CM7EVSEL_CM7EVSEL3_CM7EVSEL3, 1); - evc_csr.wfo(utra::evc::SFR_CM7EVSEL_CM7EVSEL3_CM7EVSEL3, baz); - - let foo = evc_csr.r(utra::evc::SFR_CM7EVSEL_CM7EVSEL4); - evc_csr.wo(utra::evc::SFR_CM7EVSEL_CM7EVSEL4, foo); - let bar = evc_csr.rf(utra::evc::SFR_CM7EVSEL_CM7EVSEL4_CM7EVSEL4); - evc_csr.rmwf(utra::evc::SFR_CM7EVSEL_CM7EVSEL4_CM7EVSEL4, bar); - let mut baz = evc_csr.zf(utra::evc::SFR_CM7EVSEL_CM7EVSEL4_CM7EVSEL4, bar); - baz |= evc_csr.ms(utra::evc::SFR_CM7EVSEL_CM7EVSEL4_CM7EVSEL4, 1); - evc_csr.wfo(utra::evc::SFR_CM7EVSEL_CM7EVSEL4_CM7EVSEL4, baz); - - let foo = evc_csr.r(utra::evc::SFR_CM7EVSEL_CM7EVSEL5); - evc_csr.wo(utra::evc::SFR_CM7EVSEL_CM7EVSEL5, foo); - let bar = evc_csr.rf(utra::evc::SFR_CM7EVSEL_CM7EVSEL5_CM7EVSEL5); - evc_csr.rmwf(utra::evc::SFR_CM7EVSEL_CM7EVSEL5_CM7EVSEL5, bar); - let mut baz = evc_csr.zf(utra::evc::SFR_CM7EVSEL_CM7EVSEL5_CM7EVSEL5, bar); - baz |= evc_csr.ms(utra::evc::SFR_CM7EVSEL_CM7EVSEL5_CM7EVSEL5, 1); - evc_csr.wfo(utra::evc::SFR_CM7EVSEL_CM7EVSEL5_CM7EVSEL5, baz); - - let foo = evc_csr.r(utra::evc::SFR_CM7EVSEL_CM7EVSEL6); - evc_csr.wo(utra::evc::SFR_CM7EVSEL_CM7EVSEL6, foo); - let bar = evc_csr.rf(utra::evc::SFR_CM7EVSEL_CM7EVSEL6_CM7EVSEL6); - evc_csr.rmwf(utra::evc::SFR_CM7EVSEL_CM7EVSEL6_CM7EVSEL6, bar); - let mut baz = evc_csr.zf(utra::evc::SFR_CM7EVSEL_CM7EVSEL6_CM7EVSEL6, bar); - baz |= evc_csr.ms(utra::evc::SFR_CM7EVSEL_CM7EVSEL6_CM7EVSEL6, 1); - evc_csr.wfo(utra::evc::SFR_CM7EVSEL_CM7EVSEL6_CM7EVSEL6, baz); - - let foo = evc_csr.r(utra::evc::SFR_CM7EVSEL_CM7EVSEL7); - evc_csr.wo(utra::evc::SFR_CM7EVSEL_CM7EVSEL7, foo); - let bar = evc_csr.rf(utra::evc::SFR_CM7EVSEL_CM7EVSEL7_CM7EVSEL7); - evc_csr.rmwf(utra::evc::SFR_CM7EVSEL_CM7EVSEL7_CM7EVSEL7, bar); - let mut baz = evc_csr.zf(utra::evc::SFR_CM7EVSEL_CM7EVSEL7_CM7EVSEL7, bar); - baz |= evc_csr.ms(utra::evc::SFR_CM7EVSEL_CM7EVSEL7_CM7EVSEL7, 1); - evc_csr.wfo(utra::evc::SFR_CM7EVSEL_CM7EVSEL7_CM7EVSEL7, baz); - - let foo = evc_csr.r(utra::evc::SFR_CM7EVEN); - evc_csr.wo(utra::evc::SFR_CM7EVEN, foo); - let bar = evc_csr.rf(utra::evc::SFR_CM7EVEN_CM7EVEN); - evc_csr.rmwf(utra::evc::SFR_CM7EVEN_CM7EVEN, bar); - let mut baz = evc_csr.zf(utra::evc::SFR_CM7EVEN_CM7EVEN, bar); - baz |= evc_csr.ms(utra::evc::SFR_CM7EVEN_CM7EVEN, 1); - evc_csr.wfo(utra::evc::SFR_CM7EVEN_CM7EVEN, baz); - - let foo = evc_csr.r(utra::evc::SFR_CM7EVFR); - evc_csr.wo(utra::evc::SFR_CM7EVFR, foo); - let bar = evc_csr.rf(utra::evc::SFR_CM7EVFR_CM7EVS); - evc_csr.rmwf(utra::evc::SFR_CM7EVFR_CM7EVS, bar); - let mut baz = evc_csr.zf(utra::evc::SFR_CM7EVFR_CM7EVS, bar); - baz |= evc_csr.ms(utra::evc::SFR_CM7EVFR_CM7EVS, 1); - evc_csr.wfo(utra::evc::SFR_CM7EVFR_CM7EVS, baz); - - let foo = evc_csr.r(utra::evc::SFR_TMREVSEL); - evc_csr.wo(utra::evc::SFR_TMREVSEL, foo); - let bar = evc_csr.rf(utra::evc::SFR_TMREVSEL_TMR_EVSEL); - evc_csr.rmwf(utra::evc::SFR_TMREVSEL_TMR_EVSEL, bar); - let mut baz = evc_csr.zf(utra::evc::SFR_TMREVSEL_TMR_EVSEL, bar); - baz |= evc_csr.ms(utra::evc::SFR_TMREVSEL_TMR_EVSEL, 1); - evc_csr.wfo(utra::evc::SFR_TMREVSEL_TMR_EVSEL, baz); - - let foo = evc_csr.r(utra::evc::SFR_PWMEVSEL); - evc_csr.wo(utra::evc::SFR_PWMEVSEL, foo); - let bar = evc_csr.rf(utra::evc::SFR_PWMEVSEL_PWM_EVSEL); - evc_csr.rmwf(utra::evc::SFR_PWMEVSEL_PWM_EVSEL, bar); - let mut baz = evc_csr.zf(utra::evc::SFR_PWMEVSEL_PWM_EVSEL, bar); - baz |= evc_csr.ms(utra::evc::SFR_PWMEVSEL_PWM_EVSEL, 1); - evc_csr.wfo(utra::evc::SFR_PWMEVSEL_PWM_EVSEL, baz); - - let foo = evc_csr.r(utra::evc::SFR_IFEVEN_IFEVEN0); - evc_csr.wo(utra::evc::SFR_IFEVEN_IFEVEN0, foo); - let bar = evc_csr.rf(utra::evc::SFR_IFEVEN_IFEVEN0_IFEVEN0); - evc_csr.rmwf(utra::evc::SFR_IFEVEN_IFEVEN0_IFEVEN0, bar); - let mut baz = evc_csr.zf(utra::evc::SFR_IFEVEN_IFEVEN0_IFEVEN0, bar); - baz |= evc_csr.ms(utra::evc::SFR_IFEVEN_IFEVEN0_IFEVEN0, 1); - evc_csr.wfo(utra::evc::SFR_IFEVEN_IFEVEN0_IFEVEN0, baz); - - let foo = evc_csr.r(utra::evc::SFR_IFEVEN_IFEVEN1); - evc_csr.wo(utra::evc::SFR_IFEVEN_IFEVEN1, foo); - let bar = evc_csr.rf(utra::evc::SFR_IFEVEN_IFEVEN1_IFEVEN1); - evc_csr.rmwf(utra::evc::SFR_IFEVEN_IFEVEN1_IFEVEN1, bar); - let mut baz = evc_csr.zf(utra::evc::SFR_IFEVEN_IFEVEN1_IFEVEN1, bar); - baz |= evc_csr.ms(utra::evc::SFR_IFEVEN_IFEVEN1_IFEVEN1, 1); - evc_csr.wfo(utra::evc::SFR_IFEVEN_IFEVEN1_IFEVEN1, baz); - - let foo = evc_csr.r(utra::evc::SFR_IFEVEN_IFEVEN2); - evc_csr.wo(utra::evc::SFR_IFEVEN_IFEVEN2, foo); - let bar = evc_csr.rf(utra::evc::SFR_IFEVEN_IFEVEN2_IFEVEN2); - evc_csr.rmwf(utra::evc::SFR_IFEVEN_IFEVEN2_IFEVEN2, bar); - let mut baz = evc_csr.zf(utra::evc::SFR_IFEVEN_IFEVEN2_IFEVEN2, bar); - baz |= evc_csr.ms(utra::evc::SFR_IFEVEN_IFEVEN2_IFEVEN2, 1); - evc_csr.wfo(utra::evc::SFR_IFEVEN_IFEVEN2_IFEVEN2, baz); - - let foo = evc_csr.r(utra::evc::SFR_IFEVEN_IFEVEN3); - evc_csr.wo(utra::evc::SFR_IFEVEN_IFEVEN3, foo); - let bar = evc_csr.rf(utra::evc::SFR_IFEVEN_IFEVEN3_IFEVEN3); - evc_csr.rmwf(utra::evc::SFR_IFEVEN_IFEVEN3_IFEVEN3, bar); - let mut baz = evc_csr.zf(utra::evc::SFR_IFEVEN_IFEVEN3_IFEVEN3, bar); - baz |= evc_csr.ms(utra::evc::SFR_IFEVEN_IFEVEN3_IFEVEN3, 1); - evc_csr.wfo(utra::evc::SFR_IFEVEN_IFEVEN3_IFEVEN3, baz); - - let foo = evc_csr.r(utra::evc::SFR_IFEVEN_IFEVEN4); - evc_csr.wo(utra::evc::SFR_IFEVEN_IFEVEN4, foo); - let bar = evc_csr.rf(utra::evc::SFR_IFEVEN_IFEVEN4_IFEVEN4); - evc_csr.rmwf(utra::evc::SFR_IFEVEN_IFEVEN4_IFEVEN4, bar); - let mut baz = evc_csr.zf(utra::evc::SFR_IFEVEN_IFEVEN4_IFEVEN4, bar); - baz |= evc_csr.ms(utra::evc::SFR_IFEVEN_IFEVEN4_IFEVEN4, 1); - evc_csr.wfo(utra::evc::SFR_IFEVEN_IFEVEN4_IFEVEN4, baz); - - let foo = evc_csr.r(utra::evc::SFR_IFEVEN_IFEVEN5); - evc_csr.wo(utra::evc::SFR_IFEVEN_IFEVEN5, foo); - let bar = evc_csr.rf(utra::evc::SFR_IFEVEN_IFEVEN5_IFEVEN5); - evc_csr.rmwf(utra::evc::SFR_IFEVEN_IFEVEN5_IFEVEN5, bar); - let mut baz = evc_csr.zf(utra::evc::SFR_IFEVEN_IFEVEN5_IFEVEN5, bar); - baz |= evc_csr.ms(utra::evc::SFR_IFEVEN_IFEVEN5_IFEVEN5, 1); - evc_csr.wfo(utra::evc::SFR_IFEVEN_IFEVEN5_IFEVEN5, baz); - - let foo = evc_csr.r(utra::evc::SFR_IFEVEN_IFEVEN6); - evc_csr.wo(utra::evc::SFR_IFEVEN_IFEVEN6, foo); - let bar = evc_csr.rf(utra::evc::SFR_IFEVEN_IFEVEN6_IFEVEN6); - evc_csr.rmwf(utra::evc::SFR_IFEVEN_IFEVEN6_IFEVEN6, bar); - let mut baz = evc_csr.zf(utra::evc::SFR_IFEVEN_IFEVEN6_IFEVEN6, bar); - baz |= evc_csr.ms(utra::evc::SFR_IFEVEN_IFEVEN6_IFEVEN6, 1); - evc_csr.wfo(utra::evc::SFR_IFEVEN_IFEVEN6_IFEVEN6, baz); - - let foo = evc_csr.r(utra::evc::SFR_IFEVEN_IFEVEN7); - evc_csr.wo(utra::evc::SFR_IFEVEN_IFEVEN7, foo); - let bar = evc_csr.rf(utra::evc::SFR_IFEVEN_IFEVEN7_IFEVEN7); - evc_csr.rmwf(utra::evc::SFR_IFEVEN_IFEVEN7_IFEVEN7, bar); - let mut baz = evc_csr.zf(utra::evc::SFR_IFEVEN_IFEVEN7_IFEVEN7, bar); - baz |= evc_csr.ms(utra::evc::SFR_IFEVEN_IFEVEN7_IFEVEN7, 1); - evc_csr.wfo(utra::evc::SFR_IFEVEN_IFEVEN7_IFEVEN7, baz); - - let foo = evc_csr.r(utra::evc::SFR_IFEVERRFR); - evc_csr.wo(utra::evc::SFR_IFEVERRFR, foo); - let bar = evc_csr.rf(utra::evc::SFR_IFEVERRFR_IFEV_ERRS); - evc_csr.rmwf(utra::evc::SFR_IFEVERRFR_IFEV_ERRS, bar); - let mut baz = evc_csr.zf(utra::evc::SFR_IFEVERRFR_IFEV_ERRS, bar); - baz |= evc_csr.ms(utra::evc::SFR_IFEVERRFR_IFEV_ERRS, 1); - evc_csr.wfo(utra::evc::SFR_IFEVERRFR_IFEV_ERRS, baz); - - let foo = evc_csr.r(utra::evc::SFR_CM7ERRFR); - evc_csr.wo(utra::evc::SFR_CM7ERRFR, foo); - let bar = evc_csr.rf(utra::evc::SFR_CM7ERRFR_ERRIN); - evc_csr.rmwf(utra::evc::SFR_CM7ERRFR_ERRIN, bar); - let mut baz = evc_csr.zf(utra::evc::SFR_CM7ERRFR_ERRIN, bar); - baz |= evc_csr.ms(utra::evc::SFR_CM7ERRFR_ERRIN, 1); - evc_csr.wfo(utra::evc::SFR_CM7ERRFR_ERRIN, baz); - } - - #[test] - #[ignore] - fn compile_check_sysctrl_csr() { - use super::*; - let mut sysctrl_csr = CSR::new(HW_SYSCTRL_BASE as *mut u32); - - let foo = sysctrl_csr.r(utra::sysctrl::SFR_CGUSEC); - sysctrl_csr.wo(utra::sysctrl::SFR_CGUSEC, foo); - let bar = sysctrl_csr.rf(utra::sysctrl::SFR_CGUSEC_SFR_CGUSEC); - sysctrl_csr.rmwf(utra::sysctrl::SFR_CGUSEC_SFR_CGUSEC, bar); - let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_CGUSEC_SFR_CGUSEC, bar); - baz |= sysctrl_csr.ms(utra::sysctrl::SFR_CGUSEC_SFR_CGUSEC, 1); - sysctrl_csr.wfo(utra::sysctrl::SFR_CGUSEC_SFR_CGUSEC, baz); - - let foo = sysctrl_csr.r(utra::sysctrl::SFR_CGULP); - sysctrl_csr.wo(utra::sysctrl::SFR_CGULP, foo); - let bar = sysctrl_csr.rf(utra::sysctrl::SFR_CGULP_SFR_CGULP); - sysctrl_csr.rmwf(utra::sysctrl::SFR_CGULP_SFR_CGULP, bar); - let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_CGULP_SFR_CGULP, bar); - baz |= sysctrl_csr.ms(utra::sysctrl::SFR_CGULP_SFR_CGULP, 1); - sysctrl_csr.wfo(utra::sysctrl::SFR_CGULP_SFR_CGULP, baz); - - let foo = sysctrl_csr.r(utra::sysctrl::SFR_SEED); - sysctrl_csr.wo(utra::sysctrl::SFR_SEED, foo); - let bar = sysctrl_csr.rf(utra::sysctrl::SFR_SEED_SFR_SEED); - sysctrl_csr.rmwf(utra::sysctrl::SFR_SEED_SFR_SEED, bar); - let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_SEED_SFR_SEED, bar); - baz |= sysctrl_csr.ms(utra::sysctrl::SFR_SEED_SFR_SEED, 1); - sysctrl_csr.wfo(utra::sysctrl::SFR_SEED_SFR_SEED, baz); - - let foo = sysctrl_csr.r(utra::sysctrl::SFR_SEEDAR); - sysctrl_csr.wo(utra::sysctrl::SFR_SEEDAR, foo); - let bar = sysctrl_csr.rf(utra::sysctrl::SFR_SEEDAR_SFR_SEEDAR); - sysctrl_csr.rmwf(utra::sysctrl::SFR_SEEDAR_SFR_SEEDAR, bar); - let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_SEEDAR_SFR_SEEDAR, bar); - baz |= sysctrl_csr.ms(utra::sysctrl::SFR_SEEDAR_SFR_SEEDAR, 1); - sysctrl_csr.wfo(utra::sysctrl::SFR_SEEDAR_SFR_SEEDAR, baz); - - let foo = sysctrl_csr.r(utra::sysctrl::SFR_CGUSEL0); - sysctrl_csr.wo(utra::sysctrl::SFR_CGUSEL0, foo); - let bar = sysctrl_csr.rf(utra::sysctrl::SFR_CGUSEL0_SFR_CGUSEL0); - sysctrl_csr.rmwf(utra::sysctrl::SFR_CGUSEL0_SFR_CGUSEL0, bar); - let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_CGUSEL0_SFR_CGUSEL0, bar); - baz |= sysctrl_csr.ms(utra::sysctrl::SFR_CGUSEL0_SFR_CGUSEL0, 1); - sysctrl_csr.wfo(utra::sysctrl::SFR_CGUSEL0_SFR_CGUSEL0, baz); - - let foo = sysctrl_csr.r(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_0); - sysctrl_csr.wo(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_0, foo); - let bar = sysctrl_csr.rf(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_0_CFGFDCR_0_4_0); - sysctrl_csr.rmwf(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_0_CFGFDCR_0_4_0, bar); - let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_0_CFGFDCR_0_4_0, bar); - baz |= sysctrl_csr.ms(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_0_CFGFDCR_0_4_0, 1); - sysctrl_csr.wfo(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_0_CFGFDCR_0_4_0, baz); - - let foo = sysctrl_csr.r(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_1); - sysctrl_csr.wo(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_1, foo); - let bar = sysctrl_csr.rf(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_1_CFGFDCR_0_4_1); - sysctrl_csr.rmwf(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_1_CFGFDCR_0_4_1, bar); - let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_1_CFGFDCR_0_4_1, bar); - baz |= sysctrl_csr.ms(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_1_CFGFDCR_0_4_1, 1); - sysctrl_csr.wfo(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_1_CFGFDCR_0_4_1, baz); - - let foo = sysctrl_csr.r(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_2); - sysctrl_csr.wo(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_2, foo); - let bar = sysctrl_csr.rf(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_2_CFGFDCR_0_4_2); - sysctrl_csr.rmwf(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_2_CFGFDCR_0_4_2, bar); - let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_2_CFGFDCR_0_4_2, bar); - baz |= sysctrl_csr.ms(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_2_CFGFDCR_0_4_2, 1); - sysctrl_csr.wfo(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_2_CFGFDCR_0_4_2, baz); - - let foo = sysctrl_csr.r(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_3); - sysctrl_csr.wo(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_3, foo); - let bar = sysctrl_csr.rf(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_3_CFGFDCR_0_4_3); - sysctrl_csr.rmwf(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_3_CFGFDCR_0_4_3, bar); - let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_3_CFGFDCR_0_4_3, bar); - baz |= sysctrl_csr.ms(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_3_CFGFDCR_0_4_3, 1); - sysctrl_csr.wfo(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_3_CFGFDCR_0_4_3, baz); - - let foo = sysctrl_csr.r(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_4); - sysctrl_csr.wo(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_4, foo); - let bar = sysctrl_csr.rf(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_4_CFGFDCR_0_4_4); - sysctrl_csr.rmwf(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_4_CFGFDCR_0_4_4, bar); - let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_4_CFGFDCR_0_4_4, bar); - baz |= sysctrl_csr.ms(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_4_CFGFDCR_0_4_4, 1); - sysctrl_csr.wfo(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_4_CFGFDCR_0_4_4, baz); - - let foo = sysctrl_csr.r(utra::sysctrl::SFR_CGUFDAO); - sysctrl_csr.wo(utra::sysctrl::SFR_CGUFDAO, foo); - let bar = sysctrl_csr.rf(utra::sysctrl::SFR_CGUFDAO_CFGFDCR); - sysctrl_csr.rmwf(utra::sysctrl::SFR_CGUFDAO_CFGFDCR, bar); - let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_CGUFDAO_CFGFDCR, bar); - baz |= sysctrl_csr.ms(utra::sysctrl::SFR_CGUFDAO_CFGFDCR, 1); - sysctrl_csr.wfo(utra::sysctrl::SFR_CGUFDAO_CFGFDCR, baz); - - let foo = sysctrl_csr.r(utra::sysctrl::SFR_CGUSET); - sysctrl_csr.wo(utra::sysctrl::SFR_CGUSET, foo); - let bar = sysctrl_csr.rf(utra::sysctrl::SFR_CGUSET_SFR_CGUSET); - sysctrl_csr.rmwf(utra::sysctrl::SFR_CGUSET_SFR_CGUSET, bar); - let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_CGUSET_SFR_CGUSET, bar); - baz |= sysctrl_csr.ms(utra::sysctrl::SFR_CGUSET_SFR_CGUSET, 1); - sysctrl_csr.wfo(utra::sysctrl::SFR_CGUSET_SFR_CGUSET, baz); - - let foo = sysctrl_csr.r(utra::sysctrl::SFR_CGUSEL1); - sysctrl_csr.wo(utra::sysctrl::SFR_CGUSEL1, foo); - let bar = sysctrl_csr.rf(utra::sysctrl::SFR_CGUSEL1_SFR_CGUSEL1); - sysctrl_csr.rmwf(utra::sysctrl::SFR_CGUSEL1_SFR_CGUSEL1, bar); - let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_CGUSEL1_SFR_CGUSEL1, bar); - baz |= sysctrl_csr.ms(utra::sysctrl::SFR_CGUSEL1_SFR_CGUSEL1, 1); - sysctrl_csr.wfo(utra::sysctrl::SFR_CGUSEL1_SFR_CGUSEL1, baz); - - let foo = sysctrl_csr.r(utra::sysctrl::SFR_CGUFDPKE); - sysctrl_csr.wo(utra::sysctrl::SFR_CGUFDPKE, foo); - let bar = sysctrl_csr.rf(utra::sysctrl::SFR_CGUFDPKE_SFR_CGUFDPKE); - sysctrl_csr.rmwf(utra::sysctrl::SFR_CGUFDPKE_SFR_CGUFDPKE, bar); - let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_CGUFDPKE_SFR_CGUFDPKE, bar); - baz |= sysctrl_csr.ms(utra::sysctrl::SFR_CGUFDPKE_SFR_CGUFDPKE, 1); - sysctrl_csr.wfo(utra::sysctrl::SFR_CGUFDPKE_SFR_CGUFDPKE, baz); - - let foo = sysctrl_csr.r(utra::sysctrl::SFR_CGUFSSR_FSFREQ0); - sysctrl_csr.wo(utra::sysctrl::SFR_CGUFSSR_FSFREQ0, foo); - let bar = sysctrl_csr.rf(utra::sysctrl::SFR_CGUFSSR_FSFREQ0_FSFREQ0); - sysctrl_csr.rmwf(utra::sysctrl::SFR_CGUFSSR_FSFREQ0_FSFREQ0, bar); - let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_CGUFSSR_FSFREQ0_FSFREQ0, bar); - baz |= sysctrl_csr.ms(utra::sysctrl::SFR_CGUFSSR_FSFREQ0_FSFREQ0, 1); - sysctrl_csr.wfo(utra::sysctrl::SFR_CGUFSSR_FSFREQ0_FSFREQ0, baz); - - let foo = sysctrl_csr.r(utra::sysctrl::SFR_CGUFSSR_FSFREQ1); - sysctrl_csr.wo(utra::sysctrl::SFR_CGUFSSR_FSFREQ1, foo); - let bar = sysctrl_csr.rf(utra::sysctrl::SFR_CGUFSSR_FSFREQ1_FSFREQ1); - sysctrl_csr.rmwf(utra::sysctrl::SFR_CGUFSSR_FSFREQ1_FSFREQ1, bar); - let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_CGUFSSR_FSFREQ1_FSFREQ1, bar); - baz |= sysctrl_csr.ms(utra::sysctrl::SFR_CGUFSSR_FSFREQ1_FSFREQ1, 1); - sysctrl_csr.wfo(utra::sysctrl::SFR_CGUFSSR_FSFREQ1_FSFREQ1, baz); - - let foo = sysctrl_csr.r(utra::sysctrl::SFR_CGUFSSR_FSFREQ2); - sysctrl_csr.wo(utra::sysctrl::SFR_CGUFSSR_FSFREQ2, foo); - let bar = sysctrl_csr.rf(utra::sysctrl::SFR_CGUFSSR_FSFREQ2_FSFREQ2); - sysctrl_csr.rmwf(utra::sysctrl::SFR_CGUFSSR_FSFREQ2_FSFREQ2, bar); - let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_CGUFSSR_FSFREQ2_FSFREQ2, bar); - baz |= sysctrl_csr.ms(utra::sysctrl::SFR_CGUFSSR_FSFREQ2_FSFREQ2, 1); - sysctrl_csr.wfo(utra::sysctrl::SFR_CGUFSSR_FSFREQ2_FSFREQ2, baz); - - let foo = sysctrl_csr.r(utra::sysctrl::SFR_CGUFSSR_FSFREQ3); - sysctrl_csr.wo(utra::sysctrl::SFR_CGUFSSR_FSFREQ3, foo); - let bar = sysctrl_csr.rf(utra::sysctrl::SFR_CGUFSSR_FSFREQ3_FSFREQ3); - sysctrl_csr.rmwf(utra::sysctrl::SFR_CGUFSSR_FSFREQ3_FSFREQ3, bar); - let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_CGUFSSR_FSFREQ3_FSFREQ3, bar); - baz |= sysctrl_csr.ms(utra::sysctrl::SFR_CGUFSSR_FSFREQ3_FSFREQ3, 1); - sysctrl_csr.wfo(utra::sysctrl::SFR_CGUFSSR_FSFREQ3_FSFREQ3, baz); - - let foo = sysctrl_csr.r(utra::sysctrl::SFR_CGUFSVLD); - sysctrl_csr.wo(utra::sysctrl::SFR_CGUFSVLD, foo); - let bar = sysctrl_csr.rf(utra::sysctrl::SFR_CGUFSVLD_SFR_CGUFSVLD); - sysctrl_csr.rmwf(utra::sysctrl::SFR_CGUFSVLD_SFR_CGUFSVLD, bar); - let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_CGUFSVLD_SFR_CGUFSVLD, bar); - baz |= sysctrl_csr.ms(utra::sysctrl::SFR_CGUFSVLD_SFR_CGUFSVLD, 1); - sysctrl_csr.wfo(utra::sysctrl::SFR_CGUFSVLD_SFR_CGUFSVLD, baz); - - let foo = sysctrl_csr.r(utra::sysctrl::SFR_CGUFSCR); - sysctrl_csr.wo(utra::sysctrl::SFR_CGUFSCR, foo); - let bar = sysctrl_csr.rf(utra::sysctrl::SFR_CGUFSCR_SFR_CGUFSCR); - sysctrl_csr.rmwf(utra::sysctrl::SFR_CGUFSCR_SFR_CGUFSCR, bar); - let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_CGUFSCR_SFR_CGUFSCR, bar); - baz |= sysctrl_csr.ms(utra::sysctrl::SFR_CGUFSCR_SFR_CGUFSCR, 1); - sysctrl_csr.wfo(utra::sysctrl::SFR_CGUFSCR_SFR_CGUFSCR, baz); - - let foo = sysctrl_csr.r(utra::sysctrl::SFR_ACLKGR); - sysctrl_csr.wo(utra::sysctrl::SFR_ACLKGR, foo); - let bar = sysctrl_csr.rf(utra::sysctrl::SFR_ACLKGR_SFR_ACLKGR); - sysctrl_csr.rmwf(utra::sysctrl::SFR_ACLKGR_SFR_ACLKGR, bar); - let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_ACLKGR_SFR_ACLKGR, bar); - baz |= sysctrl_csr.ms(utra::sysctrl::SFR_ACLKGR_SFR_ACLKGR, 1); - sysctrl_csr.wfo(utra::sysctrl::SFR_ACLKGR_SFR_ACLKGR, baz); - - let foo = sysctrl_csr.r(utra::sysctrl::SFR_HCLKGR); - sysctrl_csr.wo(utra::sysctrl::SFR_HCLKGR, foo); - let bar = sysctrl_csr.rf(utra::sysctrl::SFR_HCLKGR_SFR_HCLKGR); - sysctrl_csr.rmwf(utra::sysctrl::SFR_HCLKGR_SFR_HCLKGR, bar); - let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_HCLKGR_SFR_HCLKGR, bar); - baz |= sysctrl_csr.ms(utra::sysctrl::SFR_HCLKGR_SFR_HCLKGR, 1); - sysctrl_csr.wfo(utra::sysctrl::SFR_HCLKGR_SFR_HCLKGR, baz); - - let foo = sysctrl_csr.r(utra::sysctrl::SFR_ICLKGR); - sysctrl_csr.wo(utra::sysctrl::SFR_ICLKGR, foo); - let bar = sysctrl_csr.rf(utra::sysctrl::SFR_ICLKGR_SFR_ICLKGR); - sysctrl_csr.rmwf(utra::sysctrl::SFR_ICLKGR_SFR_ICLKGR, bar); - let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_ICLKGR_SFR_ICLKGR, bar); - baz |= sysctrl_csr.ms(utra::sysctrl::SFR_ICLKGR_SFR_ICLKGR, 1); - sysctrl_csr.wfo(utra::sysctrl::SFR_ICLKGR_SFR_ICLKGR, baz); - - let foo = sysctrl_csr.r(utra::sysctrl::SFR_PCLKGR); - sysctrl_csr.wo(utra::sysctrl::SFR_PCLKGR, foo); - let bar = sysctrl_csr.rf(utra::sysctrl::SFR_PCLKGR_SFR_PCLKGR); - sysctrl_csr.rmwf(utra::sysctrl::SFR_PCLKGR_SFR_PCLKGR, bar); - let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_PCLKGR_SFR_PCLKGR, bar); - baz |= sysctrl_csr.ms(utra::sysctrl::SFR_PCLKGR_SFR_PCLKGR, 1); - sysctrl_csr.wfo(utra::sysctrl::SFR_PCLKGR_SFR_PCLKGR, baz); - - let foo = sysctrl_csr.r(utra::sysctrl::SFR_RCURST0); - sysctrl_csr.wo(utra::sysctrl::SFR_RCURST0, foo); - let bar = sysctrl_csr.rf(utra::sysctrl::SFR_RCURST0_SFR_RCURST0); - sysctrl_csr.rmwf(utra::sysctrl::SFR_RCURST0_SFR_RCURST0, bar); - let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_RCURST0_SFR_RCURST0, bar); - baz |= sysctrl_csr.ms(utra::sysctrl::SFR_RCURST0_SFR_RCURST0, 1); - sysctrl_csr.wfo(utra::sysctrl::SFR_RCURST0_SFR_RCURST0, baz); - - let foo = sysctrl_csr.r(utra::sysctrl::SFR_RCURST1); - sysctrl_csr.wo(utra::sysctrl::SFR_RCURST1, foo); - let bar = sysctrl_csr.rf(utra::sysctrl::SFR_RCURST1_SFR_RCURST1); - sysctrl_csr.rmwf(utra::sysctrl::SFR_RCURST1_SFR_RCURST1, bar); - let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_RCURST1_SFR_RCURST1, bar); - baz |= sysctrl_csr.ms(utra::sysctrl::SFR_RCURST1_SFR_RCURST1, 1); - sysctrl_csr.wfo(utra::sysctrl::SFR_RCURST1_SFR_RCURST1, baz); - - let foo = sysctrl_csr.r(utra::sysctrl::SFR_RCUSRCFR); - sysctrl_csr.wo(utra::sysctrl::SFR_RCUSRCFR, foo); - let bar = sysctrl_csr.rf(utra::sysctrl::SFR_RCUSRCFR_SFR_RCUSRCFR); - sysctrl_csr.rmwf(utra::sysctrl::SFR_RCUSRCFR_SFR_RCUSRCFR, bar); - let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_RCUSRCFR_SFR_RCUSRCFR, bar); - baz |= sysctrl_csr.ms(utra::sysctrl::SFR_RCUSRCFR_SFR_RCUSRCFR, 1); - sysctrl_csr.wfo(utra::sysctrl::SFR_RCUSRCFR_SFR_RCUSRCFR, baz); - - let foo = sysctrl_csr.r(utra::sysctrl::SFR_IPCARIPFLOW); - sysctrl_csr.wo(utra::sysctrl::SFR_IPCARIPFLOW, foo); - let bar = sysctrl_csr.rf(utra::sysctrl::SFR_IPCARIPFLOW_SFR_IPCARIPFLOW); - sysctrl_csr.rmwf(utra::sysctrl::SFR_IPCARIPFLOW_SFR_IPCARIPFLOW, bar); - let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_IPCARIPFLOW_SFR_IPCARIPFLOW, bar); - baz |= sysctrl_csr.ms(utra::sysctrl::SFR_IPCARIPFLOW_SFR_IPCARIPFLOW, 1); - sysctrl_csr.wfo(utra::sysctrl::SFR_IPCARIPFLOW_SFR_IPCARIPFLOW, baz); - - let foo = sysctrl_csr.r(utra::sysctrl::SFR_IPCEN); - sysctrl_csr.wo(utra::sysctrl::SFR_IPCEN, foo); - let bar = sysctrl_csr.rf(utra::sysctrl::SFR_IPCEN_SFR_IPCEN); - sysctrl_csr.rmwf(utra::sysctrl::SFR_IPCEN_SFR_IPCEN, bar); - let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_IPCEN_SFR_IPCEN, bar); - baz |= sysctrl_csr.ms(utra::sysctrl::SFR_IPCEN_SFR_IPCEN, 1); - sysctrl_csr.wfo(utra::sysctrl::SFR_IPCEN_SFR_IPCEN, baz); - - let foo = sysctrl_csr.r(utra::sysctrl::SFR_IPCLPEN); - sysctrl_csr.wo(utra::sysctrl::SFR_IPCLPEN, foo); - let bar = sysctrl_csr.rf(utra::sysctrl::SFR_IPCLPEN_SFR_IPCLPEN); - sysctrl_csr.rmwf(utra::sysctrl::SFR_IPCLPEN_SFR_IPCLPEN, bar); - let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_IPCLPEN_SFR_IPCLPEN, bar); - baz |= sysctrl_csr.ms(utra::sysctrl::SFR_IPCLPEN_SFR_IPCLPEN, 1); - sysctrl_csr.wfo(utra::sysctrl::SFR_IPCLPEN_SFR_IPCLPEN, baz); - - let foo = sysctrl_csr.r(utra::sysctrl::SFR_IPCOSC); - sysctrl_csr.wo(utra::sysctrl::SFR_IPCOSC, foo); - let bar = sysctrl_csr.rf(utra::sysctrl::SFR_IPCOSC_SFR_IPCOSC); - sysctrl_csr.rmwf(utra::sysctrl::SFR_IPCOSC_SFR_IPCOSC, bar); - let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_IPCOSC_SFR_IPCOSC, bar); - baz |= sysctrl_csr.ms(utra::sysctrl::SFR_IPCOSC_SFR_IPCOSC, 1); - sysctrl_csr.wfo(utra::sysctrl::SFR_IPCOSC_SFR_IPCOSC, baz); - - let foo = sysctrl_csr.r(utra::sysctrl::SFR_IPCPLLMN); - sysctrl_csr.wo(utra::sysctrl::SFR_IPCPLLMN, foo); - let bar = sysctrl_csr.rf(utra::sysctrl::SFR_IPCPLLMN_SFR_IPCPLLMN); - sysctrl_csr.rmwf(utra::sysctrl::SFR_IPCPLLMN_SFR_IPCPLLMN, bar); - let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_IPCPLLMN_SFR_IPCPLLMN, bar); - baz |= sysctrl_csr.ms(utra::sysctrl::SFR_IPCPLLMN_SFR_IPCPLLMN, 1); - sysctrl_csr.wfo(utra::sysctrl::SFR_IPCPLLMN_SFR_IPCPLLMN, baz); - - let foo = sysctrl_csr.r(utra::sysctrl::SFR_IPCPLLF); - sysctrl_csr.wo(utra::sysctrl::SFR_IPCPLLF, foo); - let bar = sysctrl_csr.rf(utra::sysctrl::SFR_IPCPLLF_SFR_IPCPLLF); - sysctrl_csr.rmwf(utra::sysctrl::SFR_IPCPLLF_SFR_IPCPLLF, bar); - let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_IPCPLLF_SFR_IPCPLLF, bar); - baz |= sysctrl_csr.ms(utra::sysctrl::SFR_IPCPLLF_SFR_IPCPLLF, 1); - sysctrl_csr.wfo(utra::sysctrl::SFR_IPCPLLF_SFR_IPCPLLF, baz); - - let foo = sysctrl_csr.r(utra::sysctrl::SFR_IPCPLLQ); - sysctrl_csr.wo(utra::sysctrl::SFR_IPCPLLQ, foo); - let bar = sysctrl_csr.rf(utra::sysctrl::SFR_IPCPLLQ_SFR_IPCPLLQ); - sysctrl_csr.rmwf(utra::sysctrl::SFR_IPCPLLQ_SFR_IPCPLLQ, bar); - let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_IPCPLLQ_SFR_IPCPLLQ, bar); - baz |= sysctrl_csr.ms(utra::sysctrl::SFR_IPCPLLQ_SFR_IPCPLLQ, 1); - sysctrl_csr.wfo(utra::sysctrl::SFR_IPCPLLQ_SFR_IPCPLLQ, baz); - - let foo = sysctrl_csr.r(utra::sysctrl::SFR_IPCCR); - sysctrl_csr.wo(utra::sysctrl::SFR_IPCCR, foo); - let bar = sysctrl_csr.rf(utra::sysctrl::SFR_IPCCR_SFR_IPCCR); - sysctrl_csr.rmwf(utra::sysctrl::SFR_IPCCR_SFR_IPCCR, bar); - let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_IPCCR_SFR_IPCCR, bar); - baz |= sysctrl_csr.ms(utra::sysctrl::SFR_IPCCR_SFR_IPCCR, 1); - sysctrl_csr.wfo(utra::sysctrl::SFR_IPCCR_SFR_IPCCR, baz); - } - - #[test] - #[ignore] - fn compile_check_apb_thru_csr() { - use super::*; - let mut apb_thru_csr = CSR::new(HW_APB_THRU_BASE as *mut u32); - } - - #[test] - #[ignore] - fn compile_check_iox_csr() { - use super::*; - let mut iox_csr = CSR::new(HW_IOX_BASE as *mut u32); - - let foo = iox_csr.r(utra::iox::SFR_AFSEL_CRAFSEL0); - iox_csr.wo(utra::iox::SFR_AFSEL_CRAFSEL0, foo); - let bar = iox_csr.rf(utra::iox::SFR_AFSEL_CRAFSEL0_CRAFSEL0); - iox_csr.rmwf(utra::iox::SFR_AFSEL_CRAFSEL0_CRAFSEL0, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_AFSEL_CRAFSEL0_CRAFSEL0, bar); - baz |= iox_csr.ms(utra::iox::SFR_AFSEL_CRAFSEL0_CRAFSEL0, 1); - iox_csr.wfo(utra::iox::SFR_AFSEL_CRAFSEL0_CRAFSEL0, baz); - - let foo = iox_csr.r(utra::iox::SFR_AFSEL_CRAFSEL1); - iox_csr.wo(utra::iox::SFR_AFSEL_CRAFSEL1, foo); - let bar = iox_csr.rf(utra::iox::SFR_AFSEL_CRAFSEL1_CRAFSEL1); - iox_csr.rmwf(utra::iox::SFR_AFSEL_CRAFSEL1_CRAFSEL1, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_AFSEL_CRAFSEL1_CRAFSEL1, bar); - baz |= iox_csr.ms(utra::iox::SFR_AFSEL_CRAFSEL1_CRAFSEL1, 1); - iox_csr.wfo(utra::iox::SFR_AFSEL_CRAFSEL1_CRAFSEL1, baz); - - let foo = iox_csr.r(utra::iox::SFR_AFSEL_CRAFSEL2); - iox_csr.wo(utra::iox::SFR_AFSEL_CRAFSEL2, foo); - let bar = iox_csr.rf(utra::iox::SFR_AFSEL_CRAFSEL2_CRAFSEL2); - iox_csr.rmwf(utra::iox::SFR_AFSEL_CRAFSEL2_CRAFSEL2, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_AFSEL_CRAFSEL2_CRAFSEL2, bar); - baz |= iox_csr.ms(utra::iox::SFR_AFSEL_CRAFSEL2_CRAFSEL2, 1); - iox_csr.wfo(utra::iox::SFR_AFSEL_CRAFSEL2_CRAFSEL2, baz); - - let foo = iox_csr.r(utra::iox::SFR_AFSEL_CRAFSEL3); - iox_csr.wo(utra::iox::SFR_AFSEL_CRAFSEL3, foo); - let bar = iox_csr.rf(utra::iox::SFR_AFSEL_CRAFSEL3_CRAFSEL3); - iox_csr.rmwf(utra::iox::SFR_AFSEL_CRAFSEL3_CRAFSEL3, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_AFSEL_CRAFSEL3_CRAFSEL3, bar); - baz |= iox_csr.ms(utra::iox::SFR_AFSEL_CRAFSEL3_CRAFSEL3, 1); - iox_csr.wfo(utra::iox::SFR_AFSEL_CRAFSEL3_CRAFSEL3, baz); - - let foo = iox_csr.r(utra::iox::SFR_AFSEL_CRAFSEL4); - iox_csr.wo(utra::iox::SFR_AFSEL_CRAFSEL4, foo); - let bar = iox_csr.rf(utra::iox::SFR_AFSEL_CRAFSEL4_CRAFSEL4); - iox_csr.rmwf(utra::iox::SFR_AFSEL_CRAFSEL4_CRAFSEL4, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_AFSEL_CRAFSEL4_CRAFSEL4, bar); - baz |= iox_csr.ms(utra::iox::SFR_AFSEL_CRAFSEL4_CRAFSEL4, 1); - iox_csr.wfo(utra::iox::SFR_AFSEL_CRAFSEL4_CRAFSEL4, baz); - - let foo = iox_csr.r(utra::iox::SFR_AFSEL_CRAFSEL5); - iox_csr.wo(utra::iox::SFR_AFSEL_CRAFSEL5, foo); - let bar = iox_csr.rf(utra::iox::SFR_AFSEL_CRAFSEL5_CRAFSEL5); - iox_csr.rmwf(utra::iox::SFR_AFSEL_CRAFSEL5_CRAFSEL5, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_AFSEL_CRAFSEL5_CRAFSEL5, bar); - baz |= iox_csr.ms(utra::iox::SFR_AFSEL_CRAFSEL5_CRAFSEL5, 1); - iox_csr.wfo(utra::iox::SFR_AFSEL_CRAFSEL5_CRAFSEL5, baz); - - let foo = iox_csr.r(utra::iox::SFR_AFSEL_CRAFSEL6); - iox_csr.wo(utra::iox::SFR_AFSEL_CRAFSEL6, foo); - let bar = iox_csr.rf(utra::iox::SFR_AFSEL_CRAFSEL6_CRAFSEL6); - iox_csr.rmwf(utra::iox::SFR_AFSEL_CRAFSEL6_CRAFSEL6, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_AFSEL_CRAFSEL6_CRAFSEL6, bar); - baz |= iox_csr.ms(utra::iox::SFR_AFSEL_CRAFSEL6_CRAFSEL6, 1); - iox_csr.wfo(utra::iox::SFR_AFSEL_CRAFSEL6_CRAFSEL6, baz); - - let foo = iox_csr.r(utra::iox::SFR_AFSEL_CRAFSEL7); - iox_csr.wo(utra::iox::SFR_AFSEL_CRAFSEL7, foo); - let bar = iox_csr.rf(utra::iox::SFR_AFSEL_CRAFSEL7_CRAFSEL7); - iox_csr.rmwf(utra::iox::SFR_AFSEL_CRAFSEL7_CRAFSEL7, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_AFSEL_CRAFSEL7_CRAFSEL7, bar); - baz |= iox_csr.ms(utra::iox::SFR_AFSEL_CRAFSEL7_CRAFSEL7, 1); - iox_csr.wfo(utra::iox::SFR_AFSEL_CRAFSEL7_CRAFSEL7, baz); - - let foo = iox_csr.r(utra::iox::SFR_AFSEL_CRAFSEL8); - iox_csr.wo(utra::iox::SFR_AFSEL_CRAFSEL8, foo); - let bar = iox_csr.rf(utra::iox::SFR_AFSEL_CRAFSEL8_CRAFSEL8); - iox_csr.rmwf(utra::iox::SFR_AFSEL_CRAFSEL8_CRAFSEL8, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_AFSEL_CRAFSEL8_CRAFSEL8, bar); - baz |= iox_csr.ms(utra::iox::SFR_AFSEL_CRAFSEL8_CRAFSEL8, 1); - iox_csr.wfo(utra::iox::SFR_AFSEL_CRAFSEL8_CRAFSEL8, baz); - - let foo = iox_csr.r(utra::iox::SFR_AFSEL_CRAFSEL9); - iox_csr.wo(utra::iox::SFR_AFSEL_CRAFSEL9, foo); - let bar = iox_csr.rf(utra::iox::SFR_AFSEL_CRAFSEL9_CRAFSEL9); - iox_csr.rmwf(utra::iox::SFR_AFSEL_CRAFSEL9_CRAFSEL9, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_AFSEL_CRAFSEL9_CRAFSEL9, bar); - baz |= iox_csr.ms(utra::iox::SFR_AFSEL_CRAFSEL9_CRAFSEL9, 1); - iox_csr.wfo(utra::iox::SFR_AFSEL_CRAFSEL9_CRAFSEL9, baz); - - let foo = iox_csr.r(utra::iox::SFR_AFSEL_CRAFSEL10); - iox_csr.wo(utra::iox::SFR_AFSEL_CRAFSEL10, foo); - let bar = iox_csr.rf(utra::iox::SFR_AFSEL_CRAFSEL10_CRAFSEL10); - iox_csr.rmwf(utra::iox::SFR_AFSEL_CRAFSEL10_CRAFSEL10, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_AFSEL_CRAFSEL10_CRAFSEL10, bar); - baz |= iox_csr.ms(utra::iox::SFR_AFSEL_CRAFSEL10_CRAFSEL10, 1); - iox_csr.wfo(utra::iox::SFR_AFSEL_CRAFSEL10_CRAFSEL10, baz); - - let foo = iox_csr.r(utra::iox::SFR_AFSEL_CRAFSEL11); - iox_csr.wo(utra::iox::SFR_AFSEL_CRAFSEL11, foo); - let bar = iox_csr.rf(utra::iox::SFR_AFSEL_CRAFSEL11_CRAFSEL11); - iox_csr.rmwf(utra::iox::SFR_AFSEL_CRAFSEL11_CRAFSEL11, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_AFSEL_CRAFSEL11_CRAFSEL11, bar); - baz |= iox_csr.ms(utra::iox::SFR_AFSEL_CRAFSEL11_CRAFSEL11, 1); - iox_csr.wfo(utra::iox::SFR_AFSEL_CRAFSEL11_CRAFSEL11, baz); - - let foo = iox_csr.r(utra::iox::SFR_INTCR_CRINT0); - iox_csr.wo(utra::iox::SFR_INTCR_CRINT0, foo); - let bar = iox_csr.rf(utra::iox::SFR_INTCR_CRINT0_CRINT0); - iox_csr.rmwf(utra::iox::SFR_INTCR_CRINT0_CRINT0, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_INTCR_CRINT0_CRINT0, bar); - baz |= iox_csr.ms(utra::iox::SFR_INTCR_CRINT0_CRINT0, 1); - iox_csr.wfo(utra::iox::SFR_INTCR_CRINT0_CRINT0, baz); - - let foo = iox_csr.r(utra::iox::SFR_INTCR_CRINT1); - iox_csr.wo(utra::iox::SFR_INTCR_CRINT1, foo); - let bar = iox_csr.rf(utra::iox::SFR_INTCR_CRINT1_CRINT1); - iox_csr.rmwf(utra::iox::SFR_INTCR_CRINT1_CRINT1, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_INTCR_CRINT1_CRINT1, bar); - baz |= iox_csr.ms(utra::iox::SFR_INTCR_CRINT1_CRINT1, 1); - iox_csr.wfo(utra::iox::SFR_INTCR_CRINT1_CRINT1, baz); - - let foo = iox_csr.r(utra::iox::SFR_INTCR_CRINT2); - iox_csr.wo(utra::iox::SFR_INTCR_CRINT2, foo); - let bar = iox_csr.rf(utra::iox::SFR_INTCR_CRINT2_CRINT2); - iox_csr.rmwf(utra::iox::SFR_INTCR_CRINT2_CRINT2, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_INTCR_CRINT2_CRINT2, bar); - baz |= iox_csr.ms(utra::iox::SFR_INTCR_CRINT2_CRINT2, 1); - iox_csr.wfo(utra::iox::SFR_INTCR_CRINT2_CRINT2, baz); - - let foo = iox_csr.r(utra::iox::SFR_INTCR_CRINT3); - iox_csr.wo(utra::iox::SFR_INTCR_CRINT3, foo); - let bar = iox_csr.rf(utra::iox::SFR_INTCR_CRINT3_CRINT3); - iox_csr.rmwf(utra::iox::SFR_INTCR_CRINT3_CRINT3, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_INTCR_CRINT3_CRINT3, bar); - baz |= iox_csr.ms(utra::iox::SFR_INTCR_CRINT3_CRINT3, 1); - iox_csr.wfo(utra::iox::SFR_INTCR_CRINT3_CRINT3, baz); - - let foo = iox_csr.r(utra::iox::SFR_INTCR_CRINT4); - iox_csr.wo(utra::iox::SFR_INTCR_CRINT4, foo); - let bar = iox_csr.rf(utra::iox::SFR_INTCR_CRINT4_CRINT4); - iox_csr.rmwf(utra::iox::SFR_INTCR_CRINT4_CRINT4, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_INTCR_CRINT4_CRINT4, bar); - baz |= iox_csr.ms(utra::iox::SFR_INTCR_CRINT4_CRINT4, 1); - iox_csr.wfo(utra::iox::SFR_INTCR_CRINT4_CRINT4, baz); - - let foo = iox_csr.r(utra::iox::SFR_INTCR_CRINT5); - iox_csr.wo(utra::iox::SFR_INTCR_CRINT5, foo); - let bar = iox_csr.rf(utra::iox::SFR_INTCR_CRINT5_CRINT5); - iox_csr.rmwf(utra::iox::SFR_INTCR_CRINT5_CRINT5, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_INTCR_CRINT5_CRINT5, bar); - baz |= iox_csr.ms(utra::iox::SFR_INTCR_CRINT5_CRINT5, 1); - iox_csr.wfo(utra::iox::SFR_INTCR_CRINT5_CRINT5, baz); - - let foo = iox_csr.r(utra::iox::SFR_INTCR_CRINT6); - iox_csr.wo(utra::iox::SFR_INTCR_CRINT6, foo); - let bar = iox_csr.rf(utra::iox::SFR_INTCR_CRINT6_CRINT6); - iox_csr.rmwf(utra::iox::SFR_INTCR_CRINT6_CRINT6, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_INTCR_CRINT6_CRINT6, bar); - baz |= iox_csr.ms(utra::iox::SFR_INTCR_CRINT6_CRINT6, 1); - iox_csr.wfo(utra::iox::SFR_INTCR_CRINT6_CRINT6, baz); - - let foo = iox_csr.r(utra::iox::SFR_INTCR_CRINT7); - iox_csr.wo(utra::iox::SFR_INTCR_CRINT7, foo); - let bar = iox_csr.rf(utra::iox::SFR_INTCR_CRINT7_CRINT7); - iox_csr.rmwf(utra::iox::SFR_INTCR_CRINT7_CRINT7, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_INTCR_CRINT7_CRINT7, bar); - baz |= iox_csr.ms(utra::iox::SFR_INTCR_CRINT7_CRINT7, 1); - iox_csr.wfo(utra::iox::SFR_INTCR_CRINT7_CRINT7, baz); - - let foo = iox_csr.r(utra::iox::SFR_INTFR); - iox_csr.wo(utra::iox::SFR_INTFR, foo); - let bar = iox_csr.rf(utra::iox::SFR_INTFR_FRINT); - iox_csr.rmwf(utra::iox::SFR_INTFR_FRINT, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_INTFR_FRINT, bar); - baz |= iox_csr.ms(utra::iox::SFR_INTFR_FRINT, 1); - iox_csr.wfo(utra::iox::SFR_INTFR_FRINT, baz); - - let foo = iox_csr.r(utra::iox::SFR_GPIOOUT_CRGO0); - iox_csr.wo(utra::iox::SFR_GPIOOUT_CRGO0, foo); - let bar = iox_csr.rf(utra::iox::SFR_GPIOOUT_CRGO0_CRGO0); - iox_csr.rmwf(utra::iox::SFR_GPIOOUT_CRGO0_CRGO0, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_GPIOOUT_CRGO0_CRGO0, bar); - baz |= iox_csr.ms(utra::iox::SFR_GPIOOUT_CRGO0_CRGO0, 1); - iox_csr.wfo(utra::iox::SFR_GPIOOUT_CRGO0_CRGO0, baz); - - let foo = iox_csr.r(utra::iox::SFR_GPIOOUT_CRGO1); - iox_csr.wo(utra::iox::SFR_GPIOOUT_CRGO1, foo); - let bar = iox_csr.rf(utra::iox::SFR_GPIOOUT_CRGO1_CRGO1); - iox_csr.rmwf(utra::iox::SFR_GPIOOUT_CRGO1_CRGO1, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_GPIOOUT_CRGO1_CRGO1, bar); - baz |= iox_csr.ms(utra::iox::SFR_GPIOOUT_CRGO1_CRGO1, 1); - iox_csr.wfo(utra::iox::SFR_GPIOOUT_CRGO1_CRGO1, baz); - - let foo = iox_csr.r(utra::iox::SFR_GPIOOUT_CRGO2); - iox_csr.wo(utra::iox::SFR_GPIOOUT_CRGO2, foo); - let bar = iox_csr.rf(utra::iox::SFR_GPIOOUT_CRGO2_CRGO2); - iox_csr.rmwf(utra::iox::SFR_GPIOOUT_CRGO2_CRGO2, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_GPIOOUT_CRGO2_CRGO2, bar); - baz |= iox_csr.ms(utra::iox::SFR_GPIOOUT_CRGO2_CRGO2, 1); - iox_csr.wfo(utra::iox::SFR_GPIOOUT_CRGO2_CRGO2, baz); - - let foo = iox_csr.r(utra::iox::SFR_GPIOOUT_CRGO3); - iox_csr.wo(utra::iox::SFR_GPIOOUT_CRGO3, foo); - let bar = iox_csr.rf(utra::iox::SFR_GPIOOUT_CRGO3_CRGO3); - iox_csr.rmwf(utra::iox::SFR_GPIOOUT_CRGO3_CRGO3, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_GPIOOUT_CRGO3_CRGO3, bar); - baz |= iox_csr.ms(utra::iox::SFR_GPIOOUT_CRGO3_CRGO3, 1); - iox_csr.wfo(utra::iox::SFR_GPIOOUT_CRGO3_CRGO3, baz); - - let foo = iox_csr.r(utra::iox::SFR_GPIOOUT_CRGO4); - iox_csr.wo(utra::iox::SFR_GPIOOUT_CRGO4, foo); - let bar = iox_csr.rf(utra::iox::SFR_GPIOOUT_CRGO4_CRGO4); - iox_csr.rmwf(utra::iox::SFR_GPIOOUT_CRGO4_CRGO4, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_GPIOOUT_CRGO4_CRGO4, bar); - baz |= iox_csr.ms(utra::iox::SFR_GPIOOUT_CRGO4_CRGO4, 1); - iox_csr.wfo(utra::iox::SFR_GPIOOUT_CRGO4_CRGO4, baz); - - let foo = iox_csr.r(utra::iox::SFR_GPIOOUT_CRGO5); - iox_csr.wo(utra::iox::SFR_GPIOOUT_CRGO5, foo); - let bar = iox_csr.rf(utra::iox::SFR_GPIOOUT_CRGO5_CRGO5); - iox_csr.rmwf(utra::iox::SFR_GPIOOUT_CRGO5_CRGO5, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_GPIOOUT_CRGO5_CRGO5, bar); - baz |= iox_csr.ms(utra::iox::SFR_GPIOOUT_CRGO5_CRGO5, 1); - iox_csr.wfo(utra::iox::SFR_GPIOOUT_CRGO5_CRGO5, baz); - - let foo = iox_csr.r(utra::iox::SFR_GPIOOE_CRGOE0); - iox_csr.wo(utra::iox::SFR_GPIOOE_CRGOE0, foo); - let bar = iox_csr.rf(utra::iox::SFR_GPIOOE_CRGOE0_CRGOE0); - iox_csr.rmwf(utra::iox::SFR_GPIOOE_CRGOE0_CRGOE0, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_GPIOOE_CRGOE0_CRGOE0, bar); - baz |= iox_csr.ms(utra::iox::SFR_GPIOOE_CRGOE0_CRGOE0, 1); - iox_csr.wfo(utra::iox::SFR_GPIOOE_CRGOE0_CRGOE0, baz); - - let foo = iox_csr.r(utra::iox::SFR_GPIOOE_CRGOE1); - iox_csr.wo(utra::iox::SFR_GPIOOE_CRGOE1, foo); - let bar = iox_csr.rf(utra::iox::SFR_GPIOOE_CRGOE1_CRGOE1); - iox_csr.rmwf(utra::iox::SFR_GPIOOE_CRGOE1_CRGOE1, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_GPIOOE_CRGOE1_CRGOE1, bar); - baz |= iox_csr.ms(utra::iox::SFR_GPIOOE_CRGOE1_CRGOE1, 1); - iox_csr.wfo(utra::iox::SFR_GPIOOE_CRGOE1_CRGOE1, baz); - - let foo = iox_csr.r(utra::iox::SFR_GPIOOE_CRGOE2); - iox_csr.wo(utra::iox::SFR_GPIOOE_CRGOE2, foo); - let bar = iox_csr.rf(utra::iox::SFR_GPIOOE_CRGOE2_CRGOE2); - iox_csr.rmwf(utra::iox::SFR_GPIOOE_CRGOE2_CRGOE2, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_GPIOOE_CRGOE2_CRGOE2, bar); - baz |= iox_csr.ms(utra::iox::SFR_GPIOOE_CRGOE2_CRGOE2, 1); - iox_csr.wfo(utra::iox::SFR_GPIOOE_CRGOE2_CRGOE2, baz); - - let foo = iox_csr.r(utra::iox::SFR_GPIOOE_CRGOE3); - iox_csr.wo(utra::iox::SFR_GPIOOE_CRGOE3, foo); - let bar = iox_csr.rf(utra::iox::SFR_GPIOOE_CRGOE3_CRGOE3); - iox_csr.rmwf(utra::iox::SFR_GPIOOE_CRGOE3_CRGOE3, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_GPIOOE_CRGOE3_CRGOE3, bar); - baz |= iox_csr.ms(utra::iox::SFR_GPIOOE_CRGOE3_CRGOE3, 1); - iox_csr.wfo(utra::iox::SFR_GPIOOE_CRGOE3_CRGOE3, baz); - - let foo = iox_csr.r(utra::iox::SFR_GPIOOE_CRGOE4); - iox_csr.wo(utra::iox::SFR_GPIOOE_CRGOE4, foo); - let bar = iox_csr.rf(utra::iox::SFR_GPIOOE_CRGOE4_CRGOE4); - iox_csr.rmwf(utra::iox::SFR_GPIOOE_CRGOE4_CRGOE4, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_GPIOOE_CRGOE4_CRGOE4, bar); - baz |= iox_csr.ms(utra::iox::SFR_GPIOOE_CRGOE4_CRGOE4, 1); - iox_csr.wfo(utra::iox::SFR_GPIOOE_CRGOE4_CRGOE4, baz); - - let foo = iox_csr.r(utra::iox::SFR_GPIOOE_CRGOE5); - iox_csr.wo(utra::iox::SFR_GPIOOE_CRGOE5, foo); - let bar = iox_csr.rf(utra::iox::SFR_GPIOOE_CRGOE5_CRGOE5); - iox_csr.rmwf(utra::iox::SFR_GPIOOE_CRGOE5_CRGOE5, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_GPIOOE_CRGOE5_CRGOE5, bar); - baz |= iox_csr.ms(utra::iox::SFR_GPIOOE_CRGOE5_CRGOE5, 1); - iox_csr.wfo(utra::iox::SFR_GPIOOE_CRGOE5_CRGOE5, baz); - - let foo = iox_csr.r(utra::iox::SFR_GPIOPU_CRGPU0); - iox_csr.wo(utra::iox::SFR_GPIOPU_CRGPU0, foo); - let bar = iox_csr.rf(utra::iox::SFR_GPIOPU_CRGPU0_CRGPU0); - iox_csr.rmwf(utra::iox::SFR_GPIOPU_CRGPU0_CRGPU0, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_GPIOPU_CRGPU0_CRGPU0, bar); - baz |= iox_csr.ms(utra::iox::SFR_GPIOPU_CRGPU0_CRGPU0, 1); - iox_csr.wfo(utra::iox::SFR_GPIOPU_CRGPU0_CRGPU0, baz); - - let foo = iox_csr.r(utra::iox::SFR_GPIOPU_CRGPU1); - iox_csr.wo(utra::iox::SFR_GPIOPU_CRGPU1, foo); - let bar = iox_csr.rf(utra::iox::SFR_GPIOPU_CRGPU1_CRGPU1); - iox_csr.rmwf(utra::iox::SFR_GPIOPU_CRGPU1_CRGPU1, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_GPIOPU_CRGPU1_CRGPU1, bar); - baz |= iox_csr.ms(utra::iox::SFR_GPIOPU_CRGPU1_CRGPU1, 1); - iox_csr.wfo(utra::iox::SFR_GPIOPU_CRGPU1_CRGPU1, baz); - - let foo = iox_csr.r(utra::iox::SFR_GPIOPU_CRGPU2); - iox_csr.wo(utra::iox::SFR_GPIOPU_CRGPU2, foo); - let bar = iox_csr.rf(utra::iox::SFR_GPIOPU_CRGPU2_CRGPU2); - iox_csr.rmwf(utra::iox::SFR_GPIOPU_CRGPU2_CRGPU2, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_GPIOPU_CRGPU2_CRGPU2, bar); - baz |= iox_csr.ms(utra::iox::SFR_GPIOPU_CRGPU2_CRGPU2, 1); - iox_csr.wfo(utra::iox::SFR_GPIOPU_CRGPU2_CRGPU2, baz); - - let foo = iox_csr.r(utra::iox::SFR_GPIOPU_CRGPU3); - iox_csr.wo(utra::iox::SFR_GPIOPU_CRGPU3, foo); - let bar = iox_csr.rf(utra::iox::SFR_GPIOPU_CRGPU3_CRGPU3); - iox_csr.rmwf(utra::iox::SFR_GPIOPU_CRGPU3_CRGPU3, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_GPIOPU_CRGPU3_CRGPU3, bar); - baz |= iox_csr.ms(utra::iox::SFR_GPIOPU_CRGPU3_CRGPU3, 1); - iox_csr.wfo(utra::iox::SFR_GPIOPU_CRGPU3_CRGPU3, baz); - - let foo = iox_csr.r(utra::iox::SFR_GPIOPU_CRGPU4); - iox_csr.wo(utra::iox::SFR_GPIOPU_CRGPU4, foo); - let bar = iox_csr.rf(utra::iox::SFR_GPIOPU_CRGPU4_CRGPU4); - iox_csr.rmwf(utra::iox::SFR_GPIOPU_CRGPU4_CRGPU4, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_GPIOPU_CRGPU4_CRGPU4, bar); - baz |= iox_csr.ms(utra::iox::SFR_GPIOPU_CRGPU4_CRGPU4, 1); - iox_csr.wfo(utra::iox::SFR_GPIOPU_CRGPU4_CRGPU4, baz); - - let foo = iox_csr.r(utra::iox::SFR_GPIOPU_CRGPU5); - iox_csr.wo(utra::iox::SFR_GPIOPU_CRGPU5, foo); - let bar = iox_csr.rf(utra::iox::SFR_GPIOPU_CRGPU5_CRGPU5); - iox_csr.rmwf(utra::iox::SFR_GPIOPU_CRGPU5_CRGPU5, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_GPIOPU_CRGPU5_CRGPU5, bar); - baz |= iox_csr.ms(utra::iox::SFR_GPIOPU_CRGPU5_CRGPU5, 1); - iox_csr.wfo(utra::iox::SFR_GPIOPU_CRGPU5_CRGPU5, baz); - - let foo = iox_csr.r(utra::iox::SFR_GPIOIN_SRGI0); - iox_csr.wo(utra::iox::SFR_GPIOIN_SRGI0, foo); - let bar = iox_csr.rf(utra::iox::SFR_GPIOIN_SRGI0_SRGI0); - iox_csr.rmwf(utra::iox::SFR_GPIOIN_SRGI0_SRGI0, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_GPIOIN_SRGI0_SRGI0, bar); - baz |= iox_csr.ms(utra::iox::SFR_GPIOIN_SRGI0_SRGI0, 1); - iox_csr.wfo(utra::iox::SFR_GPIOIN_SRGI0_SRGI0, baz); - - let foo = iox_csr.r(utra::iox::SFR_GPIOIN_SRGI1); - iox_csr.wo(utra::iox::SFR_GPIOIN_SRGI1, foo); - let bar = iox_csr.rf(utra::iox::SFR_GPIOIN_SRGI1_SRGI1); - iox_csr.rmwf(utra::iox::SFR_GPIOIN_SRGI1_SRGI1, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_GPIOIN_SRGI1_SRGI1, bar); - baz |= iox_csr.ms(utra::iox::SFR_GPIOIN_SRGI1_SRGI1, 1); - iox_csr.wfo(utra::iox::SFR_GPIOIN_SRGI1_SRGI1, baz); - - let foo = iox_csr.r(utra::iox::SFR_GPIOIN_SRGI2); - iox_csr.wo(utra::iox::SFR_GPIOIN_SRGI2, foo); - let bar = iox_csr.rf(utra::iox::SFR_GPIOIN_SRGI2_SRGI2); - iox_csr.rmwf(utra::iox::SFR_GPIOIN_SRGI2_SRGI2, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_GPIOIN_SRGI2_SRGI2, bar); - baz |= iox_csr.ms(utra::iox::SFR_GPIOIN_SRGI2_SRGI2, 1); - iox_csr.wfo(utra::iox::SFR_GPIOIN_SRGI2_SRGI2, baz); - - let foo = iox_csr.r(utra::iox::SFR_GPIOIN_SRGI3); - iox_csr.wo(utra::iox::SFR_GPIOIN_SRGI3, foo); - let bar = iox_csr.rf(utra::iox::SFR_GPIOIN_SRGI3_SRGI3); - iox_csr.rmwf(utra::iox::SFR_GPIOIN_SRGI3_SRGI3, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_GPIOIN_SRGI3_SRGI3, bar); - baz |= iox_csr.ms(utra::iox::SFR_GPIOIN_SRGI3_SRGI3, 1); - iox_csr.wfo(utra::iox::SFR_GPIOIN_SRGI3_SRGI3, baz); - - let foo = iox_csr.r(utra::iox::SFR_GPIOIN_SRGI4); - iox_csr.wo(utra::iox::SFR_GPIOIN_SRGI4, foo); - let bar = iox_csr.rf(utra::iox::SFR_GPIOIN_SRGI4_SRGI4); - iox_csr.rmwf(utra::iox::SFR_GPIOIN_SRGI4_SRGI4, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_GPIOIN_SRGI4_SRGI4, bar); - baz |= iox_csr.ms(utra::iox::SFR_GPIOIN_SRGI4_SRGI4, 1); - iox_csr.wfo(utra::iox::SFR_GPIOIN_SRGI4_SRGI4, baz); - - let foo = iox_csr.r(utra::iox::SFR_GPIOIN_SRGI5); - iox_csr.wo(utra::iox::SFR_GPIOIN_SRGI5, foo); - let bar = iox_csr.rf(utra::iox::SFR_GPIOIN_SRGI5_SRGI5); - iox_csr.rmwf(utra::iox::SFR_GPIOIN_SRGI5_SRGI5, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_GPIOIN_SRGI5_SRGI5, bar); - baz |= iox_csr.ms(utra::iox::SFR_GPIOIN_SRGI5_SRGI5, 1); - iox_csr.wfo(utra::iox::SFR_GPIOIN_SRGI5_SRGI5, baz); - - let foo = iox_csr.r(utra::iox::SFR_PIOSEL); - iox_csr.wo(utra::iox::SFR_PIOSEL, foo); - let bar = iox_csr.rf(utra::iox::SFR_PIOSEL_PIOSEL); - iox_csr.rmwf(utra::iox::SFR_PIOSEL_PIOSEL, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_PIOSEL_PIOSEL, bar); - baz |= iox_csr.ms(utra::iox::SFR_PIOSEL_PIOSEL, 1); - iox_csr.wfo(utra::iox::SFR_PIOSEL_PIOSEL, baz); - - let foo = iox_csr.r(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL0); - iox_csr.wo(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL0, foo); - let bar = iox_csr.rf(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL0_CR_CFG_SCHMSEL0); - iox_csr.rmwf(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL0_CR_CFG_SCHMSEL0, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL0_CR_CFG_SCHMSEL0, bar); - baz |= iox_csr.ms(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL0_CR_CFG_SCHMSEL0, 1); - iox_csr.wfo(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL0_CR_CFG_SCHMSEL0, baz); - - let foo = iox_csr.r(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL1); - iox_csr.wo(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL1, foo); - let bar = iox_csr.rf(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL1_CR_CFG_SCHMSEL1); - iox_csr.rmwf(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL1_CR_CFG_SCHMSEL1, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL1_CR_CFG_SCHMSEL1, bar); - baz |= iox_csr.ms(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL1_CR_CFG_SCHMSEL1, 1); - iox_csr.wfo(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL1_CR_CFG_SCHMSEL1, baz); - - let foo = iox_csr.r(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL2); - iox_csr.wo(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL2, foo); - let bar = iox_csr.rf(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL2_CR_CFG_SCHMSEL2); - iox_csr.rmwf(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL2_CR_CFG_SCHMSEL2, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL2_CR_CFG_SCHMSEL2, bar); - baz |= iox_csr.ms(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL2_CR_CFG_SCHMSEL2, 1); - iox_csr.wfo(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL2_CR_CFG_SCHMSEL2, baz); - - let foo = iox_csr.r(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL3); - iox_csr.wo(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL3, foo); - let bar = iox_csr.rf(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL3_CR_CFG_SCHMSEL3); - iox_csr.rmwf(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL3_CR_CFG_SCHMSEL3, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL3_CR_CFG_SCHMSEL3, bar); - baz |= iox_csr.ms(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL3_CR_CFG_SCHMSEL3, 1); - iox_csr.wfo(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL3_CR_CFG_SCHMSEL3, baz); - - let foo = iox_csr.r(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL4); - iox_csr.wo(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL4, foo); - let bar = iox_csr.rf(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL4_CR_CFG_SCHMSEL4); - iox_csr.rmwf(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL4_CR_CFG_SCHMSEL4, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL4_CR_CFG_SCHMSEL4, bar); - baz |= iox_csr.ms(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL4_CR_CFG_SCHMSEL4, 1); - iox_csr.wfo(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL4_CR_CFG_SCHMSEL4, baz); - - let foo = iox_csr.r(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL5); - iox_csr.wo(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL5, foo); - let bar = iox_csr.rf(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL5_CR_CFG_SCHMSEL5); - iox_csr.rmwf(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL5_CR_CFG_SCHMSEL5, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL5_CR_CFG_SCHMSEL5, bar); - baz |= iox_csr.ms(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL5_CR_CFG_SCHMSEL5, 1); - iox_csr.wfo(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL5_CR_CFG_SCHMSEL5, baz); - - let foo = iox_csr.r(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW0); - iox_csr.wo(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW0, foo); - let bar = iox_csr.rf(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW0_CR_CFG_SLEWSLOW0); - iox_csr.rmwf(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW0_CR_CFG_SLEWSLOW0, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW0_CR_CFG_SLEWSLOW0, bar); - baz |= iox_csr.ms(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW0_CR_CFG_SLEWSLOW0, 1); - iox_csr.wfo(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW0_CR_CFG_SLEWSLOW0, baz); - - let foo = iox_csr.r(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW1); - iox_csr.wo(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW1, foo); - let bar = iox_csr.rf(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW1_CR_CFG_SLEWSLOW1); - iox_csr.rmwf(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW1_CR_CFG_SLEWSLOW1, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW1_CR_CFG_SLEWSLOW1, bar); - baz |= iox_csr.ms(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW1_CR_CFG_SLEWSLOW1, 1); - iox_csr.wfo(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW1_CR_CFG_SLEWSLOW1, baz); - - let foo = iox_csr.r(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW2); - iox_csr.wo(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW2, foo); - let bar = iox_csr.rf(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW2_CR_CFG_SLEWSLOW2); - iox_csr.rmwf(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW2_CR_CFG_SLEWSLOW2, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW2_CR_CFG_SLEWSLOW2, bar); - baz |= iox_csr.ms(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW2_CR_CFG_SLEWSLOW2, 1); - iox_csr.wfo(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW2_CR_CFG_SLEWSLOW2, baz); - - let foo = iox_csr.r(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW3); - iox_csr.wo(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW3, foo); - let bar = iox_csr.rf(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW3_CR_CFG_SLEWSLOW3); - iox_csr.rmwf(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW3_CR_CFG_SLEWSLOW3, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW3_CR_CFG_SLEWSLOW3, bar); - baz |= iox_csr.ms(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW3_CR_CFG_SLEWSLOW3, 1); - iox_csr.wfo(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW3_CR_CFG_SLEWSLOW3, baz); - - let foo = iox_csr.r(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW4); - iox_csr.wo(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW4, foo); - let bar = iox_csr.rf(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW4_CR_CFG_SLEWSLOW4); - iox_csr.rmwf(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW4_CR_CFG_SLEWSLOW4, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW4_CR_CFG_SLEWSLOW4, bar); - baz |= iox_csr.ms(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW4_CR_CFG_SLEWSLOW4, 1); - iox_csr.wfo(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW4_CR_CFG_SLEWSLOW4, baz); - - let foo = iox_csr.r(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW5); - iox_csr.wo(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW5, foo); - let bar = iox_csr.rf(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW5_CR_CFG_SLEWSLOW5); - iox_csr.rmwf(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW5_CR_CFG_SLEWSLOW5, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW5_CR_CFG_SLEWSLOW5, bar); - baz |= iox_csr.ms(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW5_CR_CFG_SLEWSLOW5, 1); - iox_csr.wfo(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW5_CR_CFG_SLEWSLOW5, baz); - - let foo = iox_csr.r(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL0); - iox_csr.wo(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL0, foo); - let bar = iox_csr.rf(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL0_CR_CFG_DRVSEL0); - iox_csr.rmwf(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL0_CR_CFG_DRVSEL0, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL0_CR_CFG_DRVSEL0, bar); - baz |= iox_csr.ms(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL0_CR_CFG_DRVSEL0, 1); - iox_csr.wfo(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL0_CR_CFG_DRVSEL0, baz); - - let foo = iox_csr.r(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL1); - iox_csr.wo(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL1, foo); - let bar = iox_csr.rf(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL1_CR_CFG_DRVSEL1); - iox_csr.rmwf(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL1_CR_CFG_DRVSEL1, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL1_CR_CFG_DRVSEL1, bar); - baz |= iox_csr.ms(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL1_CR_CFG_DRVSEL1, 1); - iox_csr.wfo(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL1_CR_CFG_DRVSEL1, baz); - - let foo = iox_csr.r(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL2); - iox_csr.wo(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL2, foo); - let bar = iox_csr.rf(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL2_CR_CFG_DRVSEL2); - iox_csr.rmwf(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL2_CR_CFG_DRVSEL2, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL2_CR_CFG_DRVSEL2, bar); - baz |= iox_csr.ms(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL2_CR_CFG_DRVSEL2, 1); - iox_csr.wfo(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL2_CR_CFG_DRVSEL2, baz); - - let foo = iox_csr.r(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL3); - iox_csr.wo(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL3, foo); - let bar = iox_csr.rf(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL3_CR_CFG_DRVSEL3); - iox_csr.rmwf(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL3_CR_CFG_DRVSEL3, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL3_CR_CFG_DRVSEL3, bar); - baz |= iox_csr.ms(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL3_CR_CFG_DRVSEL3, 1); - iox_csr.wfo(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL3_CR_CFG_DRVSEL3, baz); - - let foo = iox_csr.r(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL4); - iox_csr.wo(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL4, foo); - let bar = iox_csr.rf(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL4_CR_CFG_DRVSEL4); - iox_csr.rmwf(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL4_CR_CFG_DRVSEL4, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL4_CR_CFG_DRVSEL4, bar); - baz |= iox_csr.ms(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL4_CR_CFG_DRVSEL4, 1); - iox_csr.wfo(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL4_CR_CFG_DRVSEL4, baz); - - let foo = iox_csr.r(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL5); - iox_csr.wo(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL5, foo); - let bar = iox_csr.rf(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL5_CR_CFG_DRVSEL5); - iox_csr.rmwf(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL5_CR_CFG_DRVSEL5, bar); - let mut baz = iox_csr.zf(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL5_CR_CFG_DRVSEL5, bar); - baz |= iox_csr.ms(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL5_CR_CFG_DRVSEL5, 1); - iox_csr.wfo(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL5_CR_CFG_DRVSEL5, baz); - } - - #[test] - #[ignore] - fn compile_check_pwm_csr() { - use super::*; - let mut pwm_csr = CSR::new(HW_PWM_BASE as *mut u32); - } - - #[test] - #[ignore] - fn compile_check_sddc_csr() { - use super::*; - let mut sddc_csr = CSR::new(HW_SDDC_BASE as *mut u32); - - let foo = sddc_csr.r(utra::sddc::SFR_IO); - sddc_csr.wo(utra::sddc::SFR_IO, foo); - let bar = sddc_csr.rf(utra::sddc::SFR_IO_SFR_IO); - sddc_csr.rmwf(utra::sddc::SFR_IO_SFR_IO, bar); - let mut baz = sddc_csr.zf(utra::sddc::SFR_IO_SFR_IO, bar); - baz |= sddc_csr.ms(utra::sddc::SFR_IO_SFR_IO, 1); - sddc_csr.wfo(utra::sddc::SFR_IO_SFR_IO, baz); - - let foo = sddc_csr.r(utra::sddc::SFR_AR); - sddc_csr.wo(utra::sddc::SFR_AR, foo); - let bar = sddc_csr.rf(utra::sddc::SFR_AR_SFR_AR); - sddc_csr.rmwf(utra::sddc::SFR_AR_SFR_AR, bar); - let mut baz = sddc_csr.zf(utra::sddc::SFR_AR_SFR_AR, bar); - baz |= sddc_csr.ms(utra::sddc::SFR_AR_SFR_AR, 1); - sddc_csr.wfo(utra::sddc::SFR_AR_SFR_AR, baz); - - let foo = sddc_csr.r(utra::sddc::CR_OCR); - sddc_csr.wo(utra::sddc::CR_OCR, foo); - let bar = sddc_csr.rf(utra::sddc::CR_OCR_CR_OCR); - sddc_csr.rmwf(utra::sddc::CR_OCR_CR_OCR, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_OCR_CR_OCR, bar); - baz |= sddc_csr.ms(utra::sddc::CR_OCR_CR_OCR, 1); - sddc_csr.wfo(utra::sddc::CR_OCR_CR_OCR, baz); - - let foo = sddc_csr.r(utra::sddc::CR_RDFFTHRES); - sddc_csr.wo(utra::sddc::CR_RDFFTHRES, foo); - let bar = sddc_csr.rf(utra::sddc::CR_RDFFTHRES_CR_RDFFTHRES); - sddc_csr.rmwf(utra::sddc::CR_RDFFTHRES_CR_RDFFTHRES, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_RDFFTHRES_CR_RDFFTHRES, bar); - baz |= sddc_csr.ms(utra::sddc::CR_RDFFTHRES_CR_RDFFTHRES, 1); - sddc_csr.wfo(utra::sddc::CR_RDFFTHRES_CR_RDFFTHRES, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REV); - sddc_csr.wo(utra::sddc::CR_REV, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REV_CFG_REG_SD_SPEC_REVISION); - sddc_csr.rmwf(utra::sddc::CR_REV_CFG_REG_SD_SPEC_REVISION, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REV_CFG_REG_SD_SPEC_REVISION, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REV_CFG_REG_SD_SPEC_REVISION, 1); - sddc_csr.wfo(utra::sddc::CR_REV_CFG_REG_SD_SPEC_REVISION, baz); - let bar = sddc_csr.rf(utra::sddc::CR_REV_CFG_REG_CCCR_SDIO_REVISION); - sddc_csr.rmwf(utra::sddc::CR_REV_CFG_REG_CCCR_SDIO_REVISION, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REV_CFG_REG_CCCR_SDIO_REVISION, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REV_CFG_REG_CCCR_SDIO_REVISION, 1); - sddc_csr.wfo(utra::sddc::CR_REV_CFG_REG_CCCR_SDIO_REVISION, baz); - - let foo = sddc_csr.r(utra::sddc::CR_BACSA); - sddc_csr.wo(utra::sddc::CR_BACSA, foo); - let bar = sddc_csr.rf(utra::sddc::CR_BACSA_CFG_BASE_ADDR_CSA); - sddc_csr.rmwf(utra::sddc::CR_BACSA_CFG_BASE_ADDR_CSA, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_BACSA_CFG_BASE_ADDR_CSA, bar); - baz |= sddc_csr.ms(utra::sddc::CR_BACSA_CFG_BASE_ADDR_CSA, 1); - sddc_csr.wfo(utra::sddc::CR_BACSA_CFG_BASE_ADDR_CSA, baz); - - let foo = sddc_csr.r(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC0); - sddc_csr.wo(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC0, foo); - let bar = sddc_csr.rf(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC0_CFG_BASE_ADDR_IO_FUNC0); - sddc_csr.rmwf(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC0_CFG_BASE_ADDR_IO_FUNC0, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC0_CFG_BASE_ADDR_IO_FUNC0, bar); - baz |= sddc_csr.ms(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC0_CFG_BASE_ADDR_IO_FUNC0, 1); - sddc_csr.wfo(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC0_CFG_BASE_ADDR_IO_FUNC0, baz); - - let foo = sddc_csr.r(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC1); - sddc_csr.wo(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC1, foo); - let bar = sddc_csr.rf(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC1_CFG_BASE_ADDR_IO_FUNC1); - sddc_csr.rmwf(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC1_CFG_BASE_ADDR_IO_FUNC1, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC1_CFG_BASE_ADDR_IO_FUNC1, bar); - baz |= sddc_csr.ms(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC1_CFG_BASE_ADDR_IO_FUNC1, 1); - sddc_csr.wfo(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC1_CFG_BASE_ADDR_IO_FUNC1, baz); - - let foo = sddc_csr.r(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC2); - sddc_csr.wo(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC2, foo); - let bar = sddc_csr.rf(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC2_CFG_BASE_ADDR_IO_FUNC2); - sddc_csr.rmwf(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC2_CFG_BASE_ADDR_IO_FUNC2, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC2_CFG_BASE_ADDR_IO_FUNC2, bar); - baz |= sddc_csr.ms(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC2_CFG_BASE_ADDR_IO_FUNC2, 1); - sddc_csr.wfo(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC2_CFG_BASE_ADDR_IO_FUNC2, baz); - - let foo = sddc_csr.r(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC3); - sddc_csr.wo(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC3, foo); - let bar = sddc_csr.rf(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC3_CFG_BASE_ADDR_IO_FUNC3); - sddc_csr.rmwf(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC3_CFG_BASE_ADDR_IO_FUNC3, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC3_CFG_BASE_ADDR_IO_FUNC3, bar); - baz |= sddc_csr.ms(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC3_CFG_BASE_ADDR_IO_FUNC3, 1); - sddc_csr.wfo(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC3_CFG_BASE_ADDR_IO_FUNC3, baz); - - let foo = sddc_csr.r(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC4); - sddc_csr.wo(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC4, foo); - let bar = sddc_csr.rf(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC4_CFG_BASE_ADDR_IO_FUNC4); - sddc_csr.rmwf(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC4_CFG_BASE_ADDR_IO_FUNC4, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC4_CFG_BASE_ADDR_IO_FUNC4, bar); - baz |= sddc_csr.ms(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC4_CFG_BASE_ADDR_IO_FUNC4, 1); - sddc_csr.wfo(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC4_CFG_BASE_ADDR_IO_FUNC4, baz); - - let foo = sddc_csr.r(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC5); - sddc_csr.wo(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC5, foo); - let bar = sddc_csr.rf(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC5_CFG_BASE_ADDR_IO_FUNC5); - sddc_csr.rmwf(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC5_CFG_BASE_ADDR_IO_FUNC5, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC5_CFG_BASE_ADDR_IO_FUNC5, bar); - baz |= sddc_csr.ms(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC5_CFG_BASE_ADDR_IO_FUNC5, 1); - sddc_csr.wfo(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC5_CFG_BASE_ADDR_IO_FUNC5, baz); - - let foo = sddc_csr.r(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC6); - sddc_csr.wo(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC6, foo); - let bar = sddc_csr.rf(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC6_CFG_BASE_ADDR_IO_FUNC6); - sddc_csr.rmwf(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC6_CFG_BASE_ADDR_IO_FUNC6, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC6_CFG_BASE_ADDR_IO_FUNC6, bar); - baz |= sddc_csr.ms(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC6_CFG_BASE_ADDR_IO_FUNC6, 1); - sddc_csr.wfo(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC6_CFG_BASE_ADDR_IO_FUNC6, baz); - - let foo = sddc_csr.r(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC7); - sddc_csr.wo(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC7, foo); - let bar = sddc_csr.rf(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC7_CFG_BASE_ADDR_IO_FUNC7); - sddc_csr.rmwf(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC7_CFG_BASE_ADDR_IO_FUNC7, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC7_CFG_BASE_ADDR_IO_FUNC7, bar); - baz |= sddc_csr.ms(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC7_CFG_BASE_ADDR_IO_FUNC7, 1); - sddc_csr.wfo(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC7_CFG_BASE_ADDR_IO_FUNC7, baz); - - let foo = sddc_csr.r(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR0); - sddc_csr.wo(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR0, foo); - let bar = sddc_csr.rf(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR0_CFG_REG_FUNC_CIS_PTR0); - sddc_csr.rmwf(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR0_CFG_REG_FUNC_CIS_PTR0, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR0_CFG_REG_FUNC_CIS_PTR0, bar); - baz |= sddc_csr.ms(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR0_CFG_REG_FUNC_CIS_PTR0, 1); - sddc_csr.wfo(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR0_CFG_REG_FUNC_CIS_PTR0, baz); - - let foo = sddc_csr.r(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR1); - sddc_csr.wo(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR1, foo); - let bar = sddc_csr.rf(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR1_CFG_REG_FUNC_CIS_PTR1); - sddc_csr.rmwf(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR1_CFG_REG_FUNC_CIS_PTR1, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR1_CFG_REG_FUNC_CIS_PTR1, bar); - baz |= sddc_csr.ms(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR1_CFG_REG_FUNC_CIS_PTR1, 1); - sddc_csr.wfo(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR1_CFG_REG_FUNC_CIS_PTR1, baz); - - let foo = sddc_csr.r(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR2); - sddc_csr.wo(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR2, foo); - let bar = sddc_csr.rf(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR2_CFG_REG_FUNC_CIS_PTR2); - sddc_csr.rmwf(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR2_CFG_REG_FUNC_CIS_PTR2, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR2_CFG_REG_FUNC_CIS_PTR2, bar); - baz |= sddc_csr.ms(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR2_CFG_REG_FUNC_CIS_PTR2, 1); - sddc_csr.wfo(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR2_CFG_REG_FUNC_CIS_PTR2, baz); - - let foo = sddc_csr.r(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR3); - sddc_csr.wo(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR3, foo); - let bar = sddc_csr.rf(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR3_CFG_REG_FUNC_CIS_PTR3); - sddc_csr.rmwf(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR3_CFG_REG_FUNC_CIS_PTR3, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR3_CFG_REG_FUNC_CIS_PTR3, bar); - baz |= sddc_csr.ms(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR3_CFG_REG_FUNC_CIS_PTR3, 1); - sddc_csr.wfo(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR3_CFG_REG_FUNC_CIS_PTR3, baz); - - let foo = sddc_csr.r(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR4); - sddc_csr.wo(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR4, foo); - let bar = sddc_csr.rf(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR4_CFG_REG_FUNC_CIS_PTR4); - sddc_csr.rmwf(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR4_CFG_REG_FUNC_CIS_PTR4, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR4_CFG_REG_FUNC_CIS_PTR4, bar); - baz |= sddc_csr.ms(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR4_CFG_REG_FUNC_CIS_PTR4, 1); - sddc_csr.wfo(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR4_CFG_REG_FUNC_CIS_PTR4, baz); - - let foo = sddc_csr.r(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR5); - sddc_csr.wo(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR5, foo); - let bar = sddc_csr.rf(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR5_CFG_REG_FUNC_CIS_PTR5); - sddc_csr.rmwf(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR5_CFG_REG_FUNC_CIS_PTR5, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR5_CFG_REG_FUNC_CIS_PTR5, bar); - baz |= sddc_csr.ms(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR5_CFG_REG_FUNC_CIS_PTR5, 1); - sddc_csr.wfo(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR5_CFG_REG_FUNC_CIS_PTR5, baz); - - let foo = sddc_csr.r(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR6); - sddc_csr.wo(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR6, foo); - let bar = sddc_csr.rf(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR6_CFG_REG_FUNC_CIS_PTR6); - sddc_csr.rmwf(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR6_CFG_REG_FUNC_CIS_PTR6, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR6_CFG_REG_FUNC_CIS_PTR6, bar); - baz |= sddc_csr.ms(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR6_CFG_REG_FUNC_CIS_PTR6, 1); - sddc_csr.wfo(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR6_CFG_REG_FUNC_CIS_PTR6, baz); - - let foo = sddc_csr.r(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR7); - sddc_csr.wo(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR7, foo); - let bar = sddc_csr.rf(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR7_CFG_REG_FUNC_CIS_PTR7); - sddc_csr.rmwf(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR7_CFG_REG_FUNC_CIS_PTR7, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR7_CFG_REG_FUNC_CIS_PTR7, bar); - baz |= sddc_csr.ms(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR7_CFG_REG_FUNC_CIS_PTR7, 1); - sddc_csr.wfo(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR7_CFG_REG_FUNC_CIS_PTR7, baz); - - let foo = sddc_csr.r(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE0); - sddc_csr.wo(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE0, foo); - let bar = sddc_csr.rf(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE0_CFG_REG_FUNC_EXT_STD_CODE0); - sddc_csr.rmwf(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE0_CFG_REG_FUNC_EXT_STD_CODE0, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE0_CFG_REG_FUNC_EXT_STD_CODE0, bar); - baz |= sddc_csr.ms(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE0_CFG_REG_FUNC_EXT_STD_CODE0, 1); - sddc_csr.wfo(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE0_CFG_REG_FUNC_EXT_STD_CODE0, baz); - - let foo = sddc_csr.r(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE1); - sddc_csr.wo(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE1, foo); - let bar = sddc_csr.rf(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE1_CFG_REG_FUNC_EXT_STD_CODE1); - sddc_csr.rmwf(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE1_CFG_REG_FUNC_EXT_STD_CODE1, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE1_CFG_REG_FUNC_EXT_STD_CODE1, bar); - baz |= sddc_csr.ms(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE1_CFG_REG_FUNC_EXT_STD_CODE1, 1); - sddc_csr.wfo(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE1_CFG_REG_FUNC_EXT_STD_CODE1, baz); - - let foo = sddc_csr.r(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE2); - sddc_csr.wo(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE2, foo); - let bar = sddc_csr.rf(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE2_CFG_REG_FUNC_EXT_STD_CODE2); - sddc_csr.rmwf(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE2_CFG_REG_FUNC_EXT_STD_CODE2, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE2_CFG_REG_FUNC_EXT_STD_CODE2, bar); - baz |= sddc_csr.ms(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE2_CFG_REG_FUNC_EXT_STD_CODE2, 1); - sddc_csr.wfo(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE2_CFG_REG_FUNC_EXT_STD_CODE2, baz); - - let foo = sddc_csr.r(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE3); - sddc_csr.wo(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE3, foo); - let bar = sddc_csr.rf(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE3_CFG_REG_FUNC_EXT_STD_CODE3); - sddc_csr.rmwf(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE3_CFG_REG_FUNC_EXT_STD_CODE3, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE3_CFG_REG_FUNC_EXT_STD_CODE3, bar); - baz |= sddc_csr.ms(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE3_CFG_REG_FUNC_EXT_STD_CODE3, 1); - sddc_csr.wfo(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE3_CFG_REG_FUNC_EXT_STD_CODE3, baz); - - let foo = sddc_csr.r(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE4); - sddc_csr.wo(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE4, foo); - let bar = sddc_csr.rf(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE4_CFG_REG_FUNC_EXT_STD_CODE4); - sddc_csr.rmwf(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE4_CFG_REG_FUNC_EXT_STD_CODE4, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE4_CFG_REG_FUNC_EXT_STD_CODE4, bar); - baz |= sddc_csr.ms(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE4_CFG_REG_FUNC_EXT_STD_CODE4, 1); - sddc_csr.wfo(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE4_CFG_REG_FUNC_EXT_STD_CODE4, baz); - - let foo = sddc_csr.r(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE5); - sddc_csr.wo(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE5, foo); - let bar = sddc_csr.rf(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE5_CFG_REG_FUNC_EXT_STD_CODE5); - sddc_csr.rmwf(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE5_CFG_REG_FUNC_EXT_STD_CODE5, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE5_CFG_REG_FUNC_EXT_STD_CODE5, bar); - baz |= sddc_csr.ms(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE5_CFG_REG_FUNC_EXT_STD_CODE5, 1); - sddc_csr.wfo(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE5_CFG_REG_FUNC_EXT_STD_CODE5, baz); - - let foo = sddc_csr.r(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE6); - sddc_csr.wo(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE6, foo); - let bar = sddc_csr.rf(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE6_CFG_REG_FUNC_EXT_STD_CODE6); - sddc_csr.rmwf(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE6_CFG_REG_FUNC_EXT_STD_CODE6, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE6_CFG_REG_FUNC_EXT_STD_CODE6, bar); - baz |= sddc_csr.ms(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE6_CFG_REG_FUNC_EXT_STD_CODE6, 1); - sddc_csr.wfo(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE6_CFG_REG_FUNC_EXT_STD_CODE6, baz); - - let foo = sddc_csr.r(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE7); - sddc_csr.wo(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE7, foo); - let bar = sddc_csr.rf(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE7_CFG_REG_FUNC_EXT_STD_CODE7); - sddc_csr.rmwf(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE7_CFG_REG_FUNC_EXT_STD_CODE7, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE7_CFG_REG_FUNC_EXT_STD_CODE7, bar); - baz |= sddc_csr.ms(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE7_CFG_REG_FUNC_EXT_STD_CODE7, 1); - sddc_csr.wfo(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE7_CFG_REG_FUNC_EXT_STD_CODE7, baz); - - let foo = sddc_csr.r(utra::sddc::CR_WRITE_PROTECT); - sddc_csr.wo(utra::sddc::CR_WRITE_PROTECT, foo); - let bar = sddc_csr.rf(utra::sddc::CR_WRITE_PROTECT_CR_WRITE_PROTECT); - sddc_csr.rmwf(utra::sddc::CR_WRITE_PROTECT_CR_WRITE_PROTECT, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_WRITE_PROTECT_CR_WRITE_PROTECT, bar); - baz |= sddc_csr.ms(utra::sddc::CR_WRITE_PROTECT_CR_WRITE_PROTECT, 1); - sddc_csr.wfo(utra::sddc::CR_WRITE_PROTECT_CR_WRITE_PROTECT, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_DSR); - sddc_csr.wo(utra::sddc::CR_REG_DSR, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_DSR_CR_REG_DSR); - sddc_csr.rmwf(utra::sddc::CR_REG_DSR_CR_REG_DSR, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_DSR_CR_REG_DSR, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_DSR_CR_REG_DSR, 1); - sddc_csr.wfo(utra::sddc::CR_REG_DSR_CR_REG_DSR, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_CID_CFG_REG_CID0); - sddc_csr.wo(utra::sddc::CR_REG_CID_CFG_REG_CID0, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_CID_CFG_REG_CID0_CFG_REG_CID0); - sddc_csr.rmwf(utra::sddc::CR_REG_CID_CFG_REG_CID0_CFG_REG_CID0, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_CID_CFG_REG_CID0_CFG_REG_CID0, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_CID_CFG_REG_CID0_CFG_REG_CID0, 1); - sddc_csr.wfo(utra::sddc::CR_REG_CID_CFG_REG_CID0_CFG_REG_CID0, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_CID_CFG_REG_CID1); - sddc_csr.wo(utra::sddc::CR_REG_CID_CFG_REG_CID1, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_CID_CFG_REG_CID1_CFG_REG_CID1); - sddc_csr.rmwf(utra::sddc::CR_REG_CID_CFG_REG_CID1_CFG_REG_CID1, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_CID_CFG_REG_CID1_CFG_REG_CID1, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_CID_CFG_REG_CID1_CFG_REG_CID1, 1); - sddc_csr.wfo(utra::sddc::CR_REG_CID_CFG_REG_CID1_CFG_REG_CID1, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_CID_CFG_REG_CID2); - sddc_csr.wo(utra::sddc::CR_REG_CID_CFG_REG_CID2, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_CID_CFG_REG_CID2_CFG_REG_CID2); - sddc_csr.rmwf(utra::sddc::CR_REG_CID_CFG_REG_CID2_CFG_REG_CID2, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_CID_CFG_REG_CID2_CFG_REG_CID2, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_CID_CFG_REG_CID2_CFG_REG_CID2, 1); - sddc_csr.wfo(utra::sddc::CR_REG_CID_CFG_REG_CID2_CFG_REG_CID2, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_CID_CFG_REG_CID3); - sddc_csr.wo(utra::sddc::CR_REG_CID_CFG_REG_CID3, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_CID_CFG_REG_CID3_CFG_REG_CID3); - sddc_csr.rmwf(utra::sddc::CR_REG_CID_CFG_REG_CID3_CFG_REG_CID3, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_CID_CFG_REG_CID3_CFG_REG_CID3, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_CID_CFG_REG_CID3_CFG_REG_CID3, 1); - sddc_csr.wfo(utra::sddc::CR_REG_CID_CFG_REG_CID3_CFG_REG_CID3, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_CSD_CFG_REG_CSD0); - sddc_csr.wo(utra::sddc::CR_REG_CSD_CFG_REG_CSD0, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_CSD_CFG_REG_CSD0_CFG_REG_CSD0); - sddc_csr.rmwf(utra::sddc::CR_REG_CSD_CFG_REG_CSD0_CFG_REG_CSD0, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_CSD_CFG_REG_CSD0_CFG_REG_CSD0, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_CSD_CFG_REG_CSD0_CFG_REG_CSD0, 1); - sddc_csr.wfo(utra::sddc::CR_REG_CSD_CFG_REG_CSD0_CFG_REG_CSD0, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_CSD_CFG_REG_CSD1); - sddc_csr.wo(utra::sddc::CR_REG_CSD_CFG_REG_CSD1, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_CSD_CFG_REG_CSD1_CFG_REG_CSD1); - sddc_csr.rmwf(utra::sddc::CR_REG_CSD_CFG_REG_CSD1_CFG_REG_CSD1, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_CSD_CFG_REG_CSD1_CFG_REG_CSD1, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_CSD_CFG_REG_CSD1_CFG_REG_CSD1, 1); - sddc_csr.wfo(utra::sddc::CR_REG_CSD_CFG_REG_CSD1_CFG_REG_CSD1, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_CSD_CFG_REG_CSD2); - sddc_csr.wo(utra::sddc::CR_REG_CSD_CFG_REG_CSD2, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_CSD_CFG_REG_CSD2_CFG_REG_CSD2); - sddc_csr.rmwf(utra::sddc::CR_REG_CSD_CFG_REG_CSD2_CFG_REG_CSD2, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_CSD_CFG_REG_CSD2_CFG_REG_CSD2, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_CSD_CFG_REG_CSD2_CFG_REG_CSD2, 1); - sddc_csr.wfo(utra::sddc::CR_REG_CSD_CFG_REG_CSD2_CFG_REG_CSD2, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_CSD_CFG_REG_CSD3); - sddc_csr.wo(utra::sddc::CR_REG_CSD_CFG_REG_CSD3, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_CSD_CFG_REG_CSD3_CFG_REG_CSD3); - sddc_csr.rmwf(utra::sddc::CR_REG_CSD_CFG_REG_CSD3_CFG_REG_CSD3, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_CSD_CFG_REG_CSD3_CFG_REG_CSD3, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_CSD_CFG_REG_CSD3_CFG_REG_CSD3, 1); - sddc_csr.wfo(utra::sddc::CR_REG_CSD_CFG_REG_CSD3_CFG_REG_CSD3, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_SCR_CFG_REG_SCR0); - sddc_csr.wo(utra::sddc::CR_REG_SCR_CFG_REG_SCR0, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_SCR_CFG_REG_SCR0_CFG_REG_SCR0); - sddc_csr.rmwf(utra::sddc::CR_REG_SCR_CFG_REG_SCR0_CFG_REG_SCR0, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_SCR_CFG_REG_SCR0_CFG_REG_SCR0, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_SCR_CFG_REG_SCR0_CFG_REG_SCR0, 1); - sddc_csr.wfo(utra::sddc::CR_REG_SCR_CFG_REG_SCR0_CFG_REG_SCR0, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_SCR_CFG_REG_SCR1); - sddc_csr.wo(utra::sddc::CR_REG_SCR_CFG_REG_SCR1, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_SCR_CFG_REG_SCR1_CFG_REG_SCR1); - sddc_csr.rmwf(utra::sddc::CR_REG_SCR_CFG_REG_SCR1_CFG_REG_SCR1, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_SCR_CFG_REG_SCR1_CFG_REG_SCR1, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_SCR_CFG_REG_SCR1_CFG_REG_SCR1, 1); - sddc_csr.wfo(utra::sddc::CR_REG_SCR_CFG_REG_SCR1_CFG_REG_SCR1, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS0); - sddc_csr.wo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS0, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS0_CFG_REG_SD_STATUS0); - sddc_csr.rmwf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS0_CFG_REG_SD_STATUS0, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS0_CFG_REG_SD_STATUS0, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS0_CFG_REG_SD_STATUS0, 1); - sddc_csr.wfo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS0_CFG_REG_SD_STATUS0, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS1); - sddc_csr.wo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS1, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS1_CFG_REG_SD_STATUS1); - sddc_csr.rmwf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS1_CFG_REG_SD_STATUS1, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS1_CFG_REG_SD_STATUS1, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS1_CFG_REG_SD_STATUS1, 1); - sddc_csr.wfo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS1_CFG_REG_SD_STATUS1, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS2); - sddc_csr.wo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS2, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS2_CFG_REG_SD_STATUS2); - sddc_csr.rmwf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS2_CFG_REG_SD_STATUS2, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS2_CFG_REG_SD_STATUS2, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS2_CFG_REG_SD_STATUS2, 1); - sddc_csr.wfo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS2_CFG_REG_SD_STATUS2, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS3); - sddc_csr.wo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS3, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS3_CFG_REG_SD_STATUS3); - sddc_csr.rmwf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS3_CFG_REG_SD_STATUS3, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS3_CFG_REG_SD_STATUS3, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS3_CFG_REG_SD_STATUS3, 1); - sddc_csr.wfo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS3_CFG_REG_SD_STATUS3, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS4); - sddc_csr.wo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS4, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS4_CFG_REG_SD_STATUS4); - sddc_csr.rmwf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS4_CFG_REG_SD_STATUS4, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS4_CFG_REG_SD_STATUS4, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS4_CFG_REG_SD_STATUS4, 1); - sddc_csr.wfo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS4_CFG_REG_SD_STATUS4, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS5); - sddc_csr.wo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS5, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS5_CFG_REG_SD_STATUS5); - sddc_csr.rmwf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS5_CFG_REG_SD_STATUS5, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS5_CFG_REG_SD_STATUS5, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS5_CFG_REG_SD_STATUS5, 1); - sddc_csr.wfo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS5_CFG_REG_SD_STATUS5, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS6); - sddc_csr.wo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS6, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS6_CFG_REG_SD_STATUS6); - sddc_csr.rmwf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS6_CFG_REG_SD_STATUS6, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS6_CFG_REG_SD_STATUS6, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS6_CFG_REG_SD_STATUS6, 1); - sddc_csr.wfo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS6_CFG_REG_SD_STATUS6, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS7); - sddc_csr.wo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS7, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS7_CFG_REG_SD_STATUS7); - sddc_csr.rmwf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS7_CFG_REG_SD_STATUS7, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS7_CFG_REG_SD_STATUS7, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS7_CFG_REG_SD_STATUS7, 1); - sddc_csr.wfo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS7_CFG_REG_SD_STATUS7, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS8); - sddc_csr.wo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS8, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS8_CFG_REG_SD_STATUS8); - sddc_csr.rmwf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS8_CFG_REG_SD_STATUS8, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS8_CFG_REG_SD_STATUS8, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS8_CFG_REG_SD_STATUS8, 1); - sddc_csr.wfo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS8_CFG_REG_SD_STATUS8, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS9); - sddc_csr.wo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS9, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS9_CFG_REG_SD_STATUS9); - sddc_csr.rmwf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS9_CFG_REG_SD_STATUS9, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS9_CFG_REG_SD_STATUS9, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS9_CFG_REG_SD_STATUS9, 1); - sddc_csr.wfo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS9_CFG_REG_SD_STATUS9, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS10); - sddc_csr.wo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS10, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS10_CFG_REG_SD_STATUS10); - sddc_csr.rmwf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS10_CFG_REG_SD_STATUS10, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS10_CFG_REG_SD_STATUS10, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS10_CFG_REG_SD_STATUS10, 1); - sddc_csr.wfo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS10_CFG_REG_SD_STATUS10, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS11); - sddc_csr.wo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS11, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS11_CFG_REG_SD_STATUS11); - sddc_csr.rmwf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS11_CFG_REG_SD_STATUS11, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS11_CFG_REG_SD_STATUS11, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS11_CFG_REG_SD_STATUS11, 1); - sddc_csr.wfo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS11_CFG_REG_SD_STATUS11, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS12); - sddc_csr.wo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS12, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS12_CFG_REG_SD_STATUS12); - sddc_csr.rmwf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS12_CFG_REG_SD_STATUS12, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS12_CFG_REG_SD_STATUS12, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS12_CFG_REG_SD_STATUS12, 1); - sddc_csr.wfo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS12_CFG_REG_SD_STATUS12, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS13); - sddc_csr.wo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS13, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS13_CFG_REG_SD_STATUS13); - sddc_csr.rmwf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS13_CFG_REG_SD_STATUS13, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS13_CFG_REG_SD_STATUS13, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS13_CFG_REG_SD_STATUS13, 1); - sddc_csr.wfo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS13_CFG_REG_SD_STATUS13, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS14); - sddc_csr.wo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS14, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS14_CFG_REG_SD_STATUS14); - sddc_csr.rmwf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS14_CFG_REG_SD_STATUS14, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS14_CFG_REG_SD_STATUS14, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS14_CFG_REG_SD_STATUS14, 1); - sddc_csr.wfo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS14_CFG_REG_SD_STATUS14, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS15); - sddc_csr.wo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS15, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS15_CFG_REG_SD_STATUS15); - sddc_csr.rmwf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS15_CFG_REG_SD_STATUS15, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS15_CFG_REG_SD_STATUS15, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS15_CFG_REG_SD_STATUS15, 1); - sddc_csr.wfo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS15_CFG_REG_SD_STATUS15, baz); - - let foo = sddc_csr.r(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC0); - sddc_csr.wo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC0, foo); - let bar = sddc_csr.rf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC0_CFG_BASE_ADDR_MEM_FUNC0); - sddc_csr.rmwf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC0_CFG_BASE_ADDR_MEM_FUNC0, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC0_CFG_BASE_ADDR_MEM_FUNC0, bar); - baz |= sddc_csr.ms(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC0_CFG_BASE_ADDR_MEM_FUNC0, 1); - sddc_csr.wfo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC0_CFG_BASE_ADDR_MEM_FUNC0, baz); - - let foo = sddc_csr.r(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC1); - sddc_csr.wo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC1, foo); - let bar = sddc_csr.rf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC1_CFG_BASE_ADDR_MEM_FUNC1); - sddc_csr.rmwf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC1_CFG_BASE_ADDR_MEM_FUNC1, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC1_CFG_BASE_ADDR_MEM_FUNC1, bar); - baz |= sddc_csr.ms(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC1_CFG_BASE_ADDR_MEM_FUNC1, 1); - sddc_csr.wfo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC1_CFG_BASE_ADDR_MEM_FUNC1, baz); - - let foo = sddc_csr.r(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC2); - sddc_csr.wo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC2, foo); - let bar = sddc_csr.rf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC2_CFG_BASE_ADDR_MEM_FUNC2); - sddc_csr.rmwf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC2_CFG_BASE_ADDR_MEM_FUNC2, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC2_CFG_BASE_ADDR_MEM_FUNC2, bar); - baz |= sddc_csr.ms(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC2_CFG_BASE_ADDR_MEM_FUNC2, 1); - sddc_csr.wfo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC2_CFG_BASE_ADDR_MEM_FUNC2, baz); - - let foo = sddc_csr.r(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC3); - sddc_csr.wo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC3, foo); - let bar = sddc_csr.rf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC3_CFG_BASE_ADDR_MEM_FUNC3); - sddc_csr.rmwf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC3_CFG_BASE_ADDR_MEM_FUNC3, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC3_CFG_BASE_ADDR_MEM_FUNC3, bar); - baz |= sddc_csr.ms(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC3_CFG_BASE_ADDR_MEM_FUNC3, 1); - sddc_csr.wfo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC3_CFG_BASE_ADDR_MEM_FUNC3, baz); - - let foo = sddc_csr.r(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC4); - sddc_csr.wo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC4, foo); - let bar = sddc_csr.rf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC4_CFG_BASE_ADDR_MEM_FUNC4); - sddc_csr.rmwf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC4_CFG_BASE_ADDR_MEM_FUNC4, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC4_CFG_BASE_ADDR_MEM_FUNC4, bar); - baz |= sddc_csr.ms(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC4_CFG_BASE_ADDR_MEM_FUNC4, 1); - sddc_csr.wfo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC4_CFG_BASE_ADDR_MEM_FUNC4, baz); - - let foo = sddc_csr.r(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC5); - sddc_csr.wo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC5, foo); - let bar = sddc_csr.rf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC5_CFG_BASE_ADDR_MEM_FUNC5); - sddc_csr.rmwf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC5_CFG_BASE_ADDR_MEM_FUNC5, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC5_CFG_BASE_ADDR_MEM_FUNC5, bar); - baz |= sddc_csr.ms(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC5_CFG_BASE_ADDR_MEM_FUNC5, 1); - sddc_csr.wfo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC5_CFG_BASE_ADDR_MEM_FUNC5, baz); - - let foo = sddc_csr.r(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC6); - sddc_csr.wo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC6, foo); - let bar = sddc_csr.rf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC6_CFG_BASE_ADDR_MEM_FUNC6); - sddc_csr.rmwf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC6_CFG_BASE_ADDR_MEM_FUNC6, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC6_CFG_BASE_ADDR_MEM_FUNC6, bar); - baz |= sddc_csr.ms(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC6_CFG_BASE_ADDR_MEM_FUNC6, 1); - sddc_csr.wfo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC6_CFG_BASE_ADDR_MEM_FUNC6, baz); - - let foo = sddc_csr.r(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC7); - sddc_csr.wo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC7, foo); - let bar = sddc_csr.rf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC7_CFG_BASE_ADDR_MEM_FUNC7); - sddc_csr.rmwf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC7_CFG_BASE_ADDR_MEM_FUNC7, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC7_CFG_BASE_ADDR_MEM_FUNC7, bar); - baz |= sddc_csr.ms(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC7_CFG_BASE_ADDR_MEM_FUNC7, 1); - sddc_csr.wfo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC7_CFG_BASE_ADDR_MEM_FUNC7, baz); - - let foo = sddc_csr.r(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC8); - sddc_csr.wo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC8, foo); - let bar = sddc_csr.rf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC8_CFG_BASE_ADDR_MEM_FUNC8); - sddc_csr.rmwf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC8_CFG_BASE_ADDR_MEM_FUNC8, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC8_CFG_BASE_ADDR_MEM_FUNC8, bar); - baz |= sddc_csr.ms(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC8_CFG_BASE_ADDR_MEM_FUNC8, 1); - sddc_csr.wfo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC8_CFG_BASE_ADDR_MEM_FUNC8, baz); - - let foo = sddc_csr.r(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC9); - sddc_csr.wo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC9, foo); - let bar = sddc_csr.rf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC9_CFG_BASE_ADDR_MEM_FUNC9); - sddc_csr.rmwf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC9_CFG_BASE_ADDR_MEM_FUNC9, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC9_CFG_BASE_ADDR_MEM_FUNC9, bar); - baz |= sddc_csr.ms(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC9_CFG_BASE_ADDR_MEM_FUNC9, 1); - sddc_csr.wfo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC9_CFG_BASE_ADDR_MEM_FUNC9, baz); - - let foo = sddc_csr.r(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC10); - sddc_csr.wo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC10, foo); - let bar = sddc_csr.rf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC10_CFG_BASE_ADDR_MEM_FUNC10); - sddc_csr.rmwf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC10_CFG_BASE_ADDR_MEM_FUNC10, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC10_CFG_BASE_ADDR_MEM_FUNC10, bar); - baz |= sddc_csr.ms(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC10_CFG_BASE_ADDR_MEM_FUNC10, 1); - sddc_csr.wfo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC10_CFG_BASE_ADDR_MEM_FUNC10, baz); - - let foo = sddc_csr.r(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC11); - sddc_csr.wo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC11, foo); - let bar = sddc_csr.rf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC11_CFG_BASE_ADDR_MEM_FUNC11); - sddc_csr.rmwf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC11_CFG_BASE_ADDR_MEM_FUNC11, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC11_CFG_BASE_ADDR_MEM_FUNC11, bar); - baz |= sddc_csr.ms(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC11_CFG_BASE_ADDR_MEM_FUNC11, 1); - sddc_csr.wfo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC11_CFG_BASE_ADDR_MEM_FUNC11, baz); - - let foo = sddc_csr.r(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC12); - sddc_csr.wo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC12, foo); - let bar = sddc_csr.rf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC12_CFG_BASE_ADDR_MEM_FUNC12); - sddc_csr.rmwf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC12_CFG_BASE_ADDR_MEM_FUNC12, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC12_CFG_BASE_ADDR_MEM_FUNC12, bar); - baz |= sddc_csr.ms(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC12_CFG_BASE_ADDR_MEM_FUNC12, 1); - sddc_csr.wfo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC12_CFG_BASE_ADDR_MEM_FUNC12, baz); - - let foo = sddc_csr.r(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC13); - sddc_csr.wo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC13, foo); - let bar = sddc_csr.rf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC13_CFG_BASE_ADDR_MEM_FUNC13); - sddc_csr.rmwf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC13_CFG_BASE_ADDR_MEM_FUNC13, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC13_CFG_BASE_ADDR_MEM_FUNC13, bar); - baz |= sddc_csr.ms(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC13_CFG_BASE_ADDR_MEM_FUNC13, 1); - sddc_csr.wfo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC13_CFG_BASE_ADDR_MEM_FUNC13, baz); - - let foo = sddc_csr.r(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC14); - sddc_csr.wo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC14, foo); - let bar = sddc_csr.rf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC14_CFG_BASE_ADDR_MEM_FUNC14); - sddc_csr.rmwf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC14_CFG_BASE_ADDR_MEM_FUNC14, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC14_CFG_BASE_ADDR_MEM_FUNC14, bar); - baz |= sddc_csr.ms(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC14_CFG_BASE_ADDR_MEM_FUNC14, 1); - sddc_csr.wfo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC14_CFG_BASE_ADDR_MEM_FUNC14, baz); - - let foo = sddc_csr.r(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC15); - sddc_csr.wo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC15, foo); - let bar = sddc_csr.rf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC15_CFG_BASE_ADDR_MEM_FUNC15); - sddc_csr.rmwf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC15_CFG_BASE_ADDR_MEM_FUNC15, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC15_CFG_BASE_ADDR_MEM_FUNC15, bar); - baz |= sddc_csr.ms(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC15_CFG_BASE_ADDR_MEM_FUNC15, 1); - sddc_csr.wfo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC15_CFG_BASE_ADDR_MEM_FUNC15, baz); - - let foo = sddc_csr.r(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC16); - sddc_csr.wo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC16, foo); - let bar = sddc_csr.rf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC16_CFG_BASE_ADDR_MEM_FUNC16); - sddc_csr.rmwf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC16_CFG_BASE_ADDR_MEM_FUNC16, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC16_CFG_BASE_ADDR_MEM_FUNC16, bar); - baz |= sddc_csr.ms(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC16_CFG_BASE_ADDR_MEM_FUNC16, 1); - sddc_csr.wfo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC16_CFG_BASE_ADDR_MEM_FUNC16, baz); - - let foo = sddc_csr.r(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC17); - sddc_csr.wo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC17, foo); - let bar = sddc_csr.rf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC17_CFG_BASE_ADDR_MEM_FUNC17); - sddc_csr.rmwf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC17_CFG_BASE_ADDR_MEM_FUNC17, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC17_CFG_BASE_ADDR_MEM_FUNC17, bar); - baz |= sddc_csr.ms(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC17_CFG_BASE_ADDR_MEM_FUNC17, 1); - sddc_csr.wfo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC17_CFG_BASE_ADDR_MEM_FUNC17, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE0); - sddc_csr.wo(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE0, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE0_CFG_REG_FUNC_ISDIO_INTERFACE_CODE0); - sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE0_CFG_REG_FUNC_ISDIO_INTERFACE_CODE0, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE0_CFG_REG_FUNC_ISDIO_INTERFACE_CODE0, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE0_CFG_REG_FUNC_ISDIO_INTERFACE_CODE0, 1); - sddc_csr.wfo(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE0_CFG_REG_FUNC_ISDIO_INTERFACE_CODE0, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE1); - sddc_csr.wo(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE1, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE1_CFG_REG_FUNC_ISDIO_INTERFACE_CODE1); - sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE1_CFG_REG_FUNC_ISDIO_INTERFACE_CODE1, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE1_CFG_REG_FUNC_ISDIO_INTERFACE_CODE1, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE1_CFG_REG_FUNC_ISDIO_INTERFACE_CODE1, 1); - sddc_csr.wfo(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE1_CFG_REG_FUNC_ISDIO_INTERFACE_CODE1, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE2); - sddc_csr.wo(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE2, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE2_CFG_REG_FUNC_ISDIO_INTERFACE_CODE2); - sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE2_CFG_REG_FUNC_ISDIO_INTERFACE_CODE2, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE2_CFG_REG_FUNC_ISDIO_INTERFACE_CODE2, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE2_CFG_REG_FUNC_ISDIO_INTERFACE_CODE2, 1); - sddc_csr.wfo(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE2_CFG_REG_FUNC_ISDIO_INTERFACE_CODE2, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE3); - sddc_csr.wo(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE3, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE3_CFG_REG_FUNC_ISDIO_INTERFACE_CODE3); - sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE3_CFG_REG_FUNC_ISDIO_INTERFACE_CODE3, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE3_CFG_REG_FUNC_ISDIO_INTERFACE_CODE3, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE3_CFG_REG_FUNC_ISDIO_INTERFACE_CODE3, 1); - sddc_csr.wfo(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE3_CFG_REG_FUNC_ISDIO_INTERFACE_CODE3, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE4); - sddc_csr.wo(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE4, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE4_CFG_REG_FUNC_ISDIO_INTERFACE_CODE4); - sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE4_CFG_REG_FUNC_ISDIO_INTERFACE_CODE4, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE4_CFG_REG_FUNC_ISDIO_INTERFACE_CODE4, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE4_CFG_REG_FUNC_ISDIO_INTERFACE_CODE4, 1); - sddc_csr.wfo(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE4_CFG_REG_FUNC_ISDIO_INTERFACE_CODE4, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE5); - sddc_csr.wo(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE5, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE5_CFG_REG_FUNC_ISDIO_INTERFACE_CODE5); - sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE5_CFG_REG_FUNC_ISDIO_INTERFACE_CODE5, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE5_CFG_REG_FUNC_ISDIO_INTERFACE_CODE5, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE5_CFG_REG_FUNC_ISDIO_INTERFACE_CODE5, 1); - sddc_csr.wfo(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE5_CFG_REG_FUNC_ISDIO_INTERFACE_CODE5, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE6); - sddc_csr.wo(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE6, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE6_CFG_REG_FUNC_ISDIO_INTERFACE_CODE6); - sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE6_CFG_REG_FUNC_ISDIO_INTERFACE_CODE6, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE6_CFG_REG_FUNC_ISDIO_INTERFACE_CODE6, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE6_CFG_REG_FUNC_ISDIO_INTERFACE_CODE6, 1); - sddc_csr.wfo(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE6_CFG_REG_FUNC_ISDIO_INTERFACE_CODE6, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE0); - sddc_csr.wo(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE0, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE0_CFG_REG_FUNC_MANUFACT_CODE0); - sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE0_CFG_REG_FUNC_MANUFACT_CODE0, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE0_CFG_REG_FUNC_MANUFACT_CODE0, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE0_CFG_REG_FUNC_MANUFACT_CODE0, 1); - sddc_csr.wfo(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE0_CFG_REG_FUNC_MANUFACT_CODE0, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE1); - sddc_csr.wo(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE1, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE1_CFG_REG_FUNC_MANUFACT_CODE1); - sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE1_CFG_REG_FUNC_MANUFACT_CODE1, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE1_CFG_REG_FUNC_MANUFACT_CODE1, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE1_CFG_REG_FUNC_MANUFACT_CODE1, 1); - sddc_csr.wfo(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE1_CFG_REG_FUNC_MANUFACT_CODE1, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE2); - sddc_csr.wo(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE2, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE2_CFG_REG_FUNC_MANUFACT_CODE2); - sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE2_CFG_REG_FUNC_MANUFACT_CODE2, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE2_CFG_REG_FUNC_MANUFACT_CODE2, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE2_CFG_REG_FUNC_MANUFACT_CODE2, 1); - sddc_csr.wfo(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE2_CFG_REG_FUNC_MANUFACT_CODE2, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE3); - sddc_csr.wo(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE3, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE3_CFG_REG_FUNC_MANUFACT_CODE3); - sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE3_CFG_REG_FUNC_MANUFACT_CODE3, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE3_CFG_REG_FUNC_MANUFACT_CODE3, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE3_CFG_REG_FUNC_MANUFACT_CODE3, 1); - sddc_csr.wfo(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE3_CFG_REG_FUNC_MANUFACT_CODE3, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE4); - sddc_csr.wo(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE4, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE4_CFG_REG_FUNC_MANUFACT_CODE4); - sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE4_CFG_REG_FUNC_MANUFACT_CODE4, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE4_CFG_REG_FUNC_MANUFACT_CODE4, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE4_CFG_REG_FUNC_MANUFACT_CODE4, 1); - sddc_csr.wfo(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE4_CFG_REG_FUNC_MANUFACT_CODE4, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE5); - sddc_csr.wo(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE5, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE5_CFG_REG_FUNC_MANUFACT_CODE5); - sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE5_CFG_REG_FUNC_MANUFACT_CODE5, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE5_CFG_REG_FUNC_MANUFACT_CODE5, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE5_CFG_REG_FUNC_MANUFACT_CODE5, 1); - sddc_csr.wfo(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE5_CFG_REG_FUNC_MANUFACT_CODE5, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE6); - sddc_csr.wo(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE6, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE6_CFG_REG_FUNC_MANUFACT_CODE6); - sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE6_CFG_REG_FUNC_MANUFACT_CODE6, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE6_CFG_REG_FUNC_MANUFACT_CODE6, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE6_CFG_REG_FUNC_MANUFACT_CODE6, 1); - sddc_csr.wfo(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE6_CFG_REG_FUNC_MANUFACT_CODE6, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO0); - sddc_csr.wo(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO0, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO0_CFG_REG_FUNC_MANUFACT_INFO0); - sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO0_CFG_REG_FUNC_MANUFACT_INFO0, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO0_CFG_REG_FUNC_MANUFACT_INFO0, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO0_CFG_REG_FUNC_MANUFACT_INFO0, 1); - sddc_csr.wfo(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO0_CFG_REG_FUNC_MANUFACT_INFO0, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO1); - sddc_csr.wo(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO1, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO1_CFG_REG_FUNC_MANUFACT_INFO1); - sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO1_CFG_REG_FUNC_MANUFACT_INFO1, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO1_CFG_REG_FUNC_MANUFACT_INFO1, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO1_CFG_REG_FUNC_MANUFACT_INFO1, 1); - sddc_csr.wfo(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO1_CFG_REG_FUNC_MANUFACT_INFO1, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO2); - sddc_csr.wo(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO2, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO2_CFG_REG_FUNC_MANUFACT_INFO2); - sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO2_CFG_REG_FUNC_MANUFACT_INFO2, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO2_CFG_REG_FUNC_MANUFACT_INFO2, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO2_CFG_REG_FUNC_MANUFACT_INFO2, 1); - sddc_csr.wfo(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO2_CFG_REG_FUNC_MANUFACT_INFO2, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO3); - sddc_csr.wo(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO3, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO3_CFG_REG_FUNC_MANUFACT_INFO3); - sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO3_CFG_REG_FUNC_MANUFACT_INFO3, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO3_CFG_REG_FUNC_MANUFACT_INFO3, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO3_CFG_REG_FUNC_MANUFACT_INFO3, 1); - sddc_csr.wfo(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO3_CFG_REG_FUNC_MANUFACT_INFO3, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO4); - sddc_csr.wo(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO4, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO4_CFG_REG_FUNC_MANUFACT_INFO4); - sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO4_CFG_REG_FUNC_MANUFACT_INFO4, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO4_CFG_REG_FUNC_MANUFACT_INFO4, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO4_CFG_REG_FUNC_MANUFACT_INFO4, 1); - sddc_csr.wfo(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO4_CFG_REG_FUNC_MANUFACT_INFO4, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO5); - sddc_csr.wo(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO5, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO5_CFG_REG_FUNC_MANUFACT_INFO5); - sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO5_CFG_REG_FUNC_MANUFACT_INFO5, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO5_CFG_REG_FUNC_MANUFACT_INFO5, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO5_CFG_REG_FUNC_MANUFACT_INFO5, 1); - sddc_csr.wfo(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO5_CFG_REG_FUNC_MANUFACT_INFO5, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO6); - sddc_csr.wo(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO6, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO6_CFG_REG_FUNC_MANUFACT_INFO6); - sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO6_CFG_REG_FUNC_MANUFACT_INFO6, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO6_CFG_REG_FUNC_MANUFACT_INFO6, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO6_CFG_REG_FUNC_MANUFACT_INFO6, 1); - sddc_csr.wfo(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO6_CFG_REG_FUNC_MANUFACT_INFO6, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE0); - sddc_csr.wo(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE0, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE0_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE0); - sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE0_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE0, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE0_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE0, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE0_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE0, 1); - sddc_csr.wfo(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE0_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE0, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE1); - sddc_csr.wo(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE1, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE1_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE1); - sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE1_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE1, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE1_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE1, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE1_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE1, 1); - sddc_csr.wfo(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE1_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE1, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE2); - sddc_csr.wo(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE2, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE2_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE2); - sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE2_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE2, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE2_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE2, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE2_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE2, 1); - sddc_csr.wfo(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE2_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE2, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE3); - sddc_csr.wo(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE3, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE3_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE3); - sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE3_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE3, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE3_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE3, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE3_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE3, 1); - sddc_csr.wfo(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE3_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE3, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE4); - sddc_csr.wo(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE4, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE4_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE4); - sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE4_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE4, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE4_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE4, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE4_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE4, 1); - sddc_csr.wfo(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE4_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE4, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE5); - sddc_csr.wo(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE5, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE5_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE5); - sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE5_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE5, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE5_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE5, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE5_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE5, 1); - sddc_csr.wfo(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE5_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE5, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE6); - sddc_csr.wo(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE6, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE6_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE6); - sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE6_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE6, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE6_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE6, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE6_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE6, 1); - sddc_csr.wfo(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE6_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE6, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO0); - sddc_csr.wo(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO0, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO0_CFG_REG_FUNC_INFO0); - sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO0_CFG_REG_FUNC_INFO0, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO0_CFG_REG_FUNC_INFO0, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO0_CFG_REG_FUNC_INFO0, 1); - sddc_csr.wfo(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO0_CFG_REG_FUNC_INFO0, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO1); - sddc_csr.wo(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO1, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO1_CFG_REG_FUNC_INFO1); - sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO1_CFG_REG_FUNC_INFO1, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO1_CFG_REG_FUNC_INFO1, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO1_CFG_REG_FUNC_INFO1, 1); - sddc_csr.wfo(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO1_CFG_REG_FUNC_INFO1, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO2); - sddc_csr.wo(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO2, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO2_CFG_REG_FUNC_INFO2); - sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO2_CFG_REG_FUNC_INFO2, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO2_CFG_REG_FUNC_INFO2, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO2_CFG_REG_FUNC_INFO2, 1); - sddc_csr.wfo(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO2_CFG_REG_FUNC_INFO2, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO3); - sddc_csr.wo(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO3, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO3_CFG_REG_FUNC_INFO3); - sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO3_CFG_REG_FUNC_INFO3, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO3_CFG_REG_FUNC_INFO3, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO3_CFG_REG_FUNC_INFO3, 1); - sddc_csr.wfo(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO3_CFG_REG_FUNC_INFO3, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO4); - sddc_csr.wo(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO4, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO4_CFG_REG_FUNC_INFO4); - sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO4_CFG_REG_FUNC_INFO4, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO4_CFG_REG_FUNC_INFO4, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO4_CFG_REG_FUNC_INFO4, 1); - sddc_csr.wfo(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO4_CFG_REG_FUNC_INFO4, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO5); - sddc_csr.wo(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO5, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO5_CFG_REG_FUNC_INFO5); - sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO5_CFG_REG_FUNC_INFO5, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO5_CFG_REG_FUNC_INFO5, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO5_CFG_REG_FUNC_INFO5, 1); - sddc_csr.wfo(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO5_CFG_REG_FUNC_INFO5, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO6); - sddc_csr.wo(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO6, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO6_CFG_REG_FUNC_INFO6); - sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO6_CFG_REG_FUNC_INFO6, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO6_CFG_REG_FUNC_INFO6, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO6_CFG_REG_FUNC_INFO6, 1); - sddc_csr.wfo(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO6_CFG_REG_FUNC_INFO6, baz); - - let foo = sddc_csr.r(utra::sddc::CR_REG_UHS_1_SUPPORT); - sddc_csr.wo(utra::sddc::CR_REG_UHS_1_SUPPORT, foo); - let bar = sddc_csr.rf(utra::sddc::CR_REG_UHS_1_SUPPORT_CFG_REG_MAX_CURRENT); - sddc_csr.rmwf(utra::sddc::CR_REG_UHS_1_SUPPORT_CFG_REG_MAX_CURRENT, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_UHS_1_SUPPORT_CFG_REG_MAX_CURRENT, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_UHS_1_SUPPORT_CFG_REG_MAX_CURRENT, 1); - sddc_csr.wfo(utra::sddc::CR_REG_UHS_1_SUPPORT_CFG_REG_MAX_CURRENT, baz); - let bar = sddc_csr.rf(utra::sddc::CR_REG_UHS_1_SUPPORT_CFG_REG_DATA_STRC_VERSION); - sddc_csr.rmwf(utra::sddc::CR_REG_UHS_1_SUPPORT_CFG_REG_DATA_STRC_VERSION, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_UHS_1_SUPPORT_CFG_REG_DATA_STRC_VERSION, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_UHS_1_SUPPORT_CFG_REG_DATA_STRC_VERSION, 1); - sddc_csr.wfo(utra::sddc::CR_REG_UHS_1_SUPPORT_CFG_REG_DATA_STRC_VERSION, baz); - let bar = sddc_csr.rf(utra::sddc::CR_REG_UHS_1_SUPPORT_CFG_REG_UHS_1_SUPPORT); - sddc_csr.rmwf(utra::sddc::CR_REG_UHS_1_SUPPORT_CFG_REG_UHS_1_SUPPORT, bar); - let mut baz = sddc_csr.zf(utra::sddc::CR_REG_UHS_1_SUPPORT_CFG_REG_UHS_1_SUPPORT, bar); - baz |= sddc_csr.ms(utra::sddc::CR_REG_UHS_1_SUPPORT_CFG_REG_UHS_1_SUPPORT, 1); - sddc_csr.wfo(utra::sddc::CR_REG_UHS_1_SUPPORT_CFG_REG_UHS_1_SUPPORT, baz); - } - - #[test] - #[ignore] - fn compile_check_rp_pio_csr() { - use super::*; - let mut rp_pio_csr = CSR::new(HW_RP_PIO_BASE as *mut u32); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_CTRL); - rp_pio_csr.wo(utra::rp_pio::SFR_CTRL, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_CTRL_EN); - rp_pio_csr.rmwf(utra::rp_pio::SFR_CTRL_EN, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_CTRL_EN, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_CTRL_EN, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_CTRL_EN, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_CTRL_RESTART); - rp_pio_csr.rmwf(utra::rp_pio::SFR_CTRL_RESTART, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_CTRL_RESTART, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_CTRL_RESTART, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_CTRL_RESTART, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_CTRL_CLKDIV_RESTART); - rp_pio_csr.rmwf(utra::rp_pio::SFR_CTRL_CLKDIV_RESTART, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_CTRL_CLKDIV_RESTART, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_CTRL_CLKDIV_RESTART, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_CTRL_CLKDIV_RESTART, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_FSTAT); - rp_pio_csr.wo(utra::rp_pio::SFR_FSTAT, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FSTAT_RX_FULL); - rp_pio_csr.rmwf(utra::rp_pio::SFR_FSTAT_RX_FULL, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FSTAT_RX_FULL, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FSTAT_RX_FULL, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_FSTAT_RX_FULL, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FSTAT_CONSTANT0); - rp_pio_csr.rmwf(utra::rp_pio::SFR_FSTAT_CONSTANT0, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FSTAT_CONSTANT0, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FSTAT_CONSTANT0, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_FSTAT_CONSTANT0, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FSTAT_RX_EMPTY); - rp_pio_csr.rmwf(utra::rp_pio::SFR_FSTAT_RX_EMPTY, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FSTAT_RX_EMPTY, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FSTAT_RX_EMPTY, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_FSTAT_RX_EMPTY, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FSTAT_CONSTANT1); - rp_pio_csr.rmwf(utra::rp_pio::SFR_FSTAT_CONSTANT1, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FSTAT_CONSTANT1, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FSTAT_CONSTANT1, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_FSTAT_CONSTANT1, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FSTAT_TX_FULL); - rp_pio_csr.rmwf(utra::rp_pio::SFR_FSTAT_TX_FULL, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FSTAT_TX_FULL, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FSTAT_TX_FULL, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_FSTAT_TX_FULL, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FSTAT_CONSTANT2); - rp_pio_csr.rmwf(utra::rp_pio::SFR_FSTAT_CONSTANT2, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FSTAT_CONSTANT2, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FSTAT_CONSTANT2, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_FSTAT_CONSTANT2, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FSTAT_TX_EMPTY); - rp_pio_csr.rmwf(utra::rp_pio::SFR_FSTAT_TX_EMPTY, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FSTAT_TX_EMPTY, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FSTAT_TX_EMPTY, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_FSTAT_TX_EMPTY, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FSTAT_CONSTANT3); - rp_pio_csr.rmwf(utra::rp_pio::SFR_FSTAT_CONSTANT3, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FSTAT_CONSTANT3, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FSTAT_CONSTANT3, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_FSTAT_CONSTANT3, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_FDEBUG); - rp_pio_csr.wo(utra::rp_pio::SFR_FDEBUG, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FDEBUG_RXSTALL); - rp_pio_csr.rmwf(utra::rp_pio::SFR_FDEBUG_RXSTALL, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FDEBUG_RXSTALL, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FDEBUG_RXSTALL, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_FDEBUG_RXSTALL, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FDEBUG_NC_DBG3); - rp_pio_csr.rmwf(utra::rp_pio::SFR_FDEBUG_NC_DBG3, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FDEBUG_NC_DBG3, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FDEBUG_NC_DBG3, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_FDEBUG_NC_DBG3, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FDEBUG_RXUNDER); - rp_pio_csr.rmwf(utra::rp_pio::SFR_FDEBUG_RXUNDER, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FDEBUG_RXUNDER, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FDEBUG_RXUNDER, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_FDEBUG_RXUNDER, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FDEBUG_NC_DBG2); - rp_pio_csr.rmwf(utra::rp_pio::SFR_FDEBUG_NC_DBG2, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FDEBUG_NC_DBG2, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FDEBUG_NC_DBG2, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_FDEBUG_NC_DBG2, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FDEBUG_TXOVER); - rp_pio_csr.rmwf(utra::rp_pio::SFR_FDEBUG_TXOVER, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FDEBUG_TXOVER, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FDEBUG_TXOVER, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_FDEBUG_TXOVER, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FDEBUG_NC_DBG1); - rp_pio_csr.rmwf(utra::rp_pio::SFR_FDEBUG_NC_DBG1, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FDEBUG_NC_DBG1, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FDEBUG_NC_DBG1, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_FDEBUG_NC_DBG1, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FDEBUG_TXSTALL); - rp_pio_csr.rmwf(utra::rp_pio::SFR_FDEBUG_TXSTALL, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FDEBUG_TXSTALL, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FDEBUG_TXSTALL, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_FDEBUG_TXSTALL, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FDEBUG_NC_DBG0); - rp_pio_csr.rmwf(utra::rp_pio::SFR_FDEBUG_NC_DBG0, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FDEBUG_NC_DBG0, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FDEBUG_NC_DBG0, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_FDEBUG_NC_DBG0, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_FLEVEL); - rp_pio_csr.wo(utra::rp_pio::SFR_FLEVEL, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FLEVEL_TX_LEVEL0); - rp_pio_csr.rmwf(utra::rp_pio::SFR_FLEVEL_TX_LEVEL0, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FLEVEL_TX_LEVEL0, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FLEVEL_TX_LEVEL0, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_FLEVEL_TX_LEVEL0, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FLEVEL_CONSTANT0); - rp_pio_csr.rmwf(utra::rp_pio::SFR_FLEVEL_CONSTANT0, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FLEVEL_CONSTANT0, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FLEVEL_CONSTANT0, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_FLEVEL_CONSTANT0, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FLEVEL_RX_LEVEL0); - rp_pio_csr.rmwf(utra::rp_pio::SFR_FLEVEL_RX_LEVEL0, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FLEVEL_RX_LEVEL0, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FLEVEL_RX_LEVEL0, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_FLEVEL_RX_LEVEL0, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FLEVEL_CONSTANT1); - rp_pio_csr.rmwf(utra::rp_pio::SFR_FLEVEL_CONSTANT1, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FLEVEL_CONSTANT1, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FLEVEL_CONSTANT1, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_FLEVEL_CONSTANT1, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FLEVEL_TX_LEVEL1); - rp_pio_csr.rmwf(utra::rp_pio::SFR_FLEVEL_TX_LEVEL1, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FLEVEL_TX_LEVEL1, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FLEVEL_TX_LEVEL1, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_FLEVEL_TX_LEVEL1, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FLEVEL_CONSTANT2); - rp_pio_csr.rmwf(utra::rp_pio::SFR_FLEVEL_CONSTANT2, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FLEVEL_CONSTANT2, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FLEVEL_CONSTANT2, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_FLEVEL_CONSTANT2, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FLEVEL_RX_LEVEL1); - rp_pio_csr.rmwf(utra::rp_pio::SFR_FLEVEL_RX_LEVEL1, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FLEVEL_RX_LEVEL1, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FLEVEL_RX_LEVEL1, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_FLEVEL_RX_LEVEL1, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FLEVEL_CONSTANT3); - rp_pio_csr.rmwf(utra::rp_pio::SFR_FLEVEL_CONSTANT3, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FLEVEL_CONSTANT3, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FLEVEL_CONSTANT3, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_FLEVEL_CONSTANT3, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FLEVEL_TX_LEVEL2); - rp_pio_csr.rmwf(utra::rp_pio::SFR_FLEVEL_TX_LEVEL2, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FLEVEL_TX_LEVEL2, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FLEVEL_TX_LEVEL2, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_FLEVEL_TX_LEVEL2, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FLEVEL_CONSTANT4); - rp_pio_csr.rmwf(utra::rp_pio::SFR_FLEVEL_CONSTANT4, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FLEVEL_CONSTANT4, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FLEVEL_CONSTANT4, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_FLEVEL_CONSTANT4, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FLEVEL_RX_LEVEL2); - rp_pio_csr.rmwf(utra::rp_pio::SFR_FLEVEL_RX_LEVEL2, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FLEVEL_RX_LEVEL2, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FLEVEL_RX_LEVEL2, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_FLEVEL_RX_LEVEL2, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FLEVEL_CONSTANT5); - rp_pio_csr.rmwf(utra::rp_pio::SFR_FLEVEL_CONSTANT5, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FLEVEL_CONSTANT5, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FLEVEL_CONSTANT5, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_FLEVEL_CONSTANT5, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FLEVEL_TX_LEVEL3); - rp_pio_csr.rmwf(utra::rp_pio::SFR_FLEVEL_TX_LEVEL3, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FLEVEL_TX_LEVEL3, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FLEVEL_TX_LEVEL3, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_FLEVEL_TX_LEVEL3, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FLEVEL_CONSTANT6); - rp_pio_csr.rmwf(utra::rp_pio::SFR_FLEVEL_CONSTANT6, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FLEVEL_CONSTANT6, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FLEVEL_CONSTANT6, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_FLEVEL_CONSTANT6, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FLEVEL_RX_LEVEL3); - rp_pio_csr.rmwf(utra::rp_pio::SFR_FLEVEL_RX_LEVEL3, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FLEVEL_RX_LEVEL3, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FLEVEL_RX_LEVEL3, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_FLEVEL_RX_LEVEL3, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FLEVEL_CONSTANT7); - rp_pio_csr.rmwf(utra::rp_pio::SFR_FLEVEL_CONSTANT7, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FLEVEL_CONSTANT7, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FLEVEL_CONSTANT7, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_FLEVEL_CONSTANT7, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_TXF0); - rp_pio_csr.wo(utra::rp_pio::SFR_TXF0, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_TXF0_FDIN); - rp_pio_csr.rmwf(utra::rp_pio::SFR_TXF0_FDIN, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_TXF0_FDIN, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_TXF0_FDIN, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_TXF0_FDIN, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_TXF1); - rp_pio_csr.wo(utra::rp_pio::SFR_TXF1, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_TXF1_FDIN); - rp_pio_csr.rmwf(utra::rp_pio::SFR_TXF1_FDIN, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_TXF1_FDIN, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_TXF1_FDIN, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_TXF1_FDIN, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_TXF2); - rp_pio_csr.wo(utra::rp_pio::SFR_TXF2, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_TXF2_FDIN); - rp_pio_csr.rmwf(utra::rp_pio::SFR_TXF2_FDIN, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_TXF2_FDIN, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_TXF2_FDIN, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_TXF2_FDIN, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_TXF3); - rp_pio_csr.wo(utra::rp_pio::SFR_TXF3, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_TXF3_FDIN); - rp_pio_csr.rmwf(utra::rp_pio::SFR_TXF3_FDIN, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_TXF3_FDIN, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_TXF3_FDIN, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_TXF3_FDIN, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_RXF0); - rp_pio_csr.wo(utra::rp_pio::SFR_RXF0, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_RXF0_PDOUT); - rp_pio_csr.rmwf(utra::rp_pio::SFR_RXF0_PDOUT, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_RXF0_PDOUT, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_RXF0_PDOUT, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_RXF0_PDOUT, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_RXF1); - rp_pio_csr.wo(utra::rp_pio::SFR_RXF1, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_RXF1_PDOUT); - rp_pio_csr.rmwf(utra::rp_pio::SFR_RXF1_PDOUT, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_RXF1_PDOUT, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_RXF1_PDOUT, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_RXF1_PDOUT, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_RXF2); - rp_pio_csr.wo(utra::rp_pio::SFR_RXF2, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_RXF2_PDOUT); - rp_pio_csr.rmwf(utra::rp_pio::SFR_RXF2_PDOUT, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_RXF2_PDOUT, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_RXF2_PDOUT, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_RXF2_PDOUT, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_RXF3); - rp_pio_csr.wo(utra::rp_pio::SFR_RXF3, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_RXF3_PDOUT); - rp_pio_csr.rmwf(utra::rp_pio::SFR_RXF3_PDOUT, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_RXF3_PDOUT, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_RXF3_PDOUT, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_RXF3_PDOUT, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_IRQ); - rp_pio_csr.wo(utra::rp_pio::SFR_IRQ, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_IRQ_SFR_IRQ); - rp_pio_csr.rmwf(utra::rp_pio::SFR_IRQ_SFR_IRQ, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_IRQ_SFR_IRQ, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_IRQ_SFR_IRQ, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_IRQ_SFR_IRQ, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_IRQ_FORCE); - rp_pio_csr.wo(utra::rp_pio::SFR_IRQ_FORCE, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_IRQ_FORCE_SFR_IRQ_FORCE); - rp_pio_csr.rmwf(utra::rp_pio::SFR_IRQ_FORCE_SFR_IRQ_FORCE, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_IRQ_FORCE_SFR_IRQ_FORCE, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_IRQ_FORCE_SFR_IRQ_FORCE, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_IRQ_FORCE_SFR_IRQ_FORCE, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_SYNC_BYPASS); - rp_pio_csr.wo(utra::rp_pio::SFR_SYNC_BYPASS, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SYNC_BYPASS_SFR_SYNC_BYPASS); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SYNC_BYPASS_SFR_SYNC_BYPASS, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SYNC_BYPASS_SFR_SYNC_BYPASS, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SYNC_BYPASS_SFR_SYNC_BYPASS, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SYNC_BYPASS_SFR_SYNC_BYPASS, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_DBG_PADOUT); - rp_pio_csr.wo(utra::rp_pio::SFR_DBG_PADOUT, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_DBG_PADOUT_SFR_DBG_PADOUT); - rp_pio_csr.rmwf(utra::rp_pio::SFR_DBG_PADOUT_SFR_DBG_PADOUT, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_DBG_PADOUT_SFR_DBG_PADOUT, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_DBG_PADOUT_SFR_DBG_PADOUT, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_DBG_PADOUT_SFR_DBG_PADOUT, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_DBG_PADOE); - rp_pio_csr.wo(utra::rp_pio::SFR_DBG_PADOE, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_DBG_PADOE_SFR_DBG_PADOE); - rp_pio_csr.rmwf(utra::rp_pio::SFR_DBG_PADOE_SFR_DBG_PADOE, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_DBG_PADOE_SFR_DBG_PADOE, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_DBG_PADOE_SFR_DBG_PADOE, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_DBG_PADOE_SFR_DBG_PADOE, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_DBG_CFGINFO); - rp_pio_csr.wo(utra::rp_pio::SFR_DBG_CFGINFO, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_DBG_CFGINFO_CONSTANT0); - rp_pio_csr.rmwf(utra::rp_pio::SFR_DBG_CFGINFO_CONSTANT0, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_DBG_CFGINFO_CONSTANT0, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_DBG_CFGINFO_CONSTANT0, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_DBG_CFGINFO_CONSTANT0, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_DBG_CFGINFO_CONSTANT1); - rp_pio_csr.rmwf(utra::rp_pio::SFR_DBG_CFGINFO_CONSTANT1, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_DBG_CFGINFO_CONSTANT1, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_DBG_CFGINFO_CONSTANT1, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_DBG_CFGINFO_CONSTANT1, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_DBG_CFGINFO_CONSTANT2); - rp_pio_csr.rmwf(utra::rp_pio::SFR_DBG_CFGINFO_CONSTANT2, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_DBG_CFGINFO_CONSTANT2, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_DBG_CFGINFO_CONSTANT2, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_DBG_CFGINFO_CONSTANT2, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM0); - rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM0, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM0_INSTR); - rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM0_INSTR, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM0_INSTR, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM0_INSTR, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM0_INSTR, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM1); - rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM1, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM1_INSTR); - rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM1_INSTR, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM1_INSTR, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM1_INSTR, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM1_INSTR, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM2); - rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM2, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM2_INSTR); - rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM2_INSTR, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM2_INSTR, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM2_INSTR, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM2_INSTR, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM3); - rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM3, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM3_INSTR); - rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM3_INSTR, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM3_INSTR, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM3_INSTR, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM3_INSTR, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM4); - rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM4, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM4_INSTR); - rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM4_INSTR, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM4_INSTR, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM4_INSTR, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM4_INSTR, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM5); - rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM5, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM5_INSTR); - rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM5_INSTR, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM5_INSTR, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM5_INSTR, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM5_INSTR, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM6); - rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM6, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM6_INSTR); - rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM6_INSTR, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM6_INSTR, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM6_INSTR, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM6_INSTR, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM7); - rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM7, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM7_INSTR); - rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM7_INSTR, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM7_INSTR, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM7_INSTR, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM7_INSTR, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM8); - rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM8, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM8_INSTR); - rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM8_INSTR, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM8_INSTR, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM8_INSTR, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM8_INSTR, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM9); - rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM9, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM9_INSTR); - rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM9_INSTR, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM9_INSTR, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM9_INSTR, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM9_INSTR, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM10); - rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM10, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM10_INSTR); - rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM10_INSTR, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM10_INSTR, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM10_INSTR, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM10_INSTR, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM11); - rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM11, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM11_INSTR); - rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM11_INSTR, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM11_INSTR, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM11_INSTR, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM11_INSTR, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM12); - rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM12, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM12_INSTR); - rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM12_INSTR, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM12_INSTR, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM12_INSTR, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM12_INSTR, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM13); - rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM13, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM13_INSTR); - rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM13_INSTR, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM13_INSTR, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM13_INSTR, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM13_INSTR, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM14); - rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM14, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM14_INSTR); - rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM14_INSTR, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM14_INSTR, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM14_INSTR, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM14_INSTR, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM15); - rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM15, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM15_INSTR); - rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM15_INSTR, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM15_INSTR, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM15_INSTR, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM15_INSTR, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM16); - rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM16, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM16_INSTR); - rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM16_INSTR, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM16_INSTR, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM16_INSTR, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM16_INSTR, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM17); - rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM17, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM17_INSTR); - rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM17_INSTR, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM17_INSTR, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM17_INSTR, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM17_INSTR, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM18); - rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM18, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM18_INSTR); - rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM18_INSTR, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM18_INSTR, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM18_INSTR, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM18_INSTR, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM19); - rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM19, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM19_INSTR); - rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM19_INSTR, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM19_INSTR, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM19_INSTR, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM19_INSTR, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM20); - rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM20, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM20_INSTR); - rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM20_INSTR, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM20_INSTR, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM20_INSTR, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM20_INSTR, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM21); - rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM21, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM21_INSTR); - rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM21_INSTR, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM21_INSTR, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM21_INSTR, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM21_INSTR, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM22); - rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM22, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM22_INSTR); - rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM22_INSTR, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM22_INSTR, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM22_INSTR, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM22_INSTR, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM23); - rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM23, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM23_INSTR); - rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM23_INSTR, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM23_INSTR, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM23_INSTR, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM23_INSTR, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM24); - rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM24, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM24_INSTR); - rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM24_INSTR, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM24_INSTR, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM24_INSTR, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM24_INSTR, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM25); - rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM25, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM25_INSTR); - rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM25_INSTR, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM25_INSTR, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM25_INSTR, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM25_INSTR, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM26); - rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM26, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM26_INSTR); - rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM26_INSTR, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM26_INSTR, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM26_INSTR, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM26_INSTR, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM27); - rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM27, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM27_INSTR); - rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM27_INSTR, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM27_INSTR, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM27_INSTR, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM27_INSTR, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM28); - rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM28, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM28_INSTR); - rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM28_INSTR, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM28_INSTR, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM28_INSTR, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM28_INSTR, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM29); - rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM29, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM29_INSTR); - rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM29_INSTR, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM29_INSTR, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM29_INSTR, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM29_INSTR, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM30); - rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM30, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM30_INSTR); - rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM30_INSTR, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM30_INSTR, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM30_INSTR, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM30_INSTR, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM31); - rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM31, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM31_INSTR); - rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM31_INSTR, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM31_INSTR, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM31_INSTR, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM31_INSTR, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_SM0_CLKDIV); - rp_pio_csr.wo(utra::rp_pio::SFR_SM0_CLKDIV, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_CLKDIV_UNUSED_DIV); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_CLKDIV_UNUSED_DIV, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_CLKDIV_UNUSED_DIV, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_CLKDIV_UNUSED_DIV, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_CLKDIV_UNUSED_DIV, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_CLKDIV_DIV_FRAC); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_CLKDIV_DIV_FRAC, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_CLKDIV_DIV_FRAC, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_CLKDIV_DIV_FRAC, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_CLKDIV_DIV_FRAC, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_CLKDIV_DIV_INT); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_CLKDIV_DIV_INT, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_CLKDIV_DIV_INT, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_CLKDIV_DIV_INT, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_CLKDIV_DIV_INT, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_SM0_EXECCTRL); - rp_pio_csr.wo(utra::rp_pio::SFR_SM0_EXECCTRL, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_EXECCTRL_STATUS_N); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_EXECCTRL_STATUS_N, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_EXECCTRL_STATUS_N, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_EXECCTRL_STATUS_N, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_EXECCTRL_STATUS_N, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_EXECCTRL_STATUS_SEL); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_EXECCTRL_STATUS_SEL, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_EXECCTRL_STATUS_SEL, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_EXECCTRL_STATUS_SEL, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_EXECCTRL_STATUS_SEL, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_EXECCTRL_RESVD_EXEC); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_EXECCTRL_RESVD_EXEC, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_EXECCTRL_RESVD_EXEC, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_EXECCTRL_RESVD_EXEC, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_EXECCTRL_RESVD_EXEC, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_EXECCTRL_WRAP_TARGET); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_EXECCTRL_WRAP_TARGET, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_EXECCTRL_WRAP_TARGET, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_EXECCTRL_WRAP_TARGET, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_EXECCTRL_WRAP_TARGET, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_EXECCTRL_PEND); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_EXECCTRL_PEND, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_EXECCTRL_PEND, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_EXECCTRL_PEND, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_EXECCTRL_PEND, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_EXECCTRL_OUT_STICKY); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_EXECCTRL_OUT_STICKY, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_EXECCTRL_OUT_STICKY, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_EXECCTRL_OUT_STICKY, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_EXECCTRL_OUT_STICKY, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_EXECCTRL_INLINE_OUT_EN); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_EXECCTRL_INLINE_OUT_EN, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_EXECCTRL_INLINE_OUT_EN, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_EXECCTRL_INLINE_OUT_EN, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_EXECCTRL_INLINE_OUT_EN, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_EXECCTRL_OUT_EN_SEL); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_EXECCTRL_OUT_EN_SEL, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_EXECCTRL_OUT_EN_SEL, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_EXECCTRL_OUT_EN_SEL, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_EXECCTRL_OUT_EN_SEL, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_EXECCTRL_JMP_PIN); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_EXECCTRL_JMP_PIN, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_EXECCTRL_JMP_PIN, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_EXECCTRL_JMP_PIN, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_EXECCTRL_JMP_PIN, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_EXECCTRL_SIDE_PINDIR); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_EXECCTRL_SIDE_PINDIR, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_EXECCTRL_SIDE_PINDIR, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_EXECCTRL_SIDE_PINDIR, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_EXECCTRL_SIDE_PINDIR, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_EXECCTRL_SIDESET_ENABLE_BIT); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_EXECCTRL_SIDESET_ENABLE_BIT, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_EXECCTRL_SIDESET_ENABLE_BIT, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_EXECCTRL_SIDESET_ENABLE_BIT, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_EXECCTRL_SIDESET_ENABLE_BIT, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_EXECCTRL_EXEC_STALLED_RO0); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_EXECCTRL_EXEC_STALLED_RO0, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_EXECCTRL_EXEC_STALLED_RO0, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_EXECCTRL_EXEC_STALLED_RO0, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_EXECCTRL_EXEC_STALLED_RO0, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_SM0_SHIFTCTRL); - rp_pio_csr.wo(utra::rp_pio::SFR_SM0_SHIFTCTRL, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_SHIFTCTRL_RESVD_SHIFT); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_SHIFTCTRL_RESVD_SHIFT, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_SHIFTCTRL_RESVD_SHIFT, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_SHIFTCTRL_RESVD_SHIFT, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_SHIFTCTRL_RESVD_SHIFT, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_SHIFTCTRL_AUTO_PUSH); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_SHIFTCTRL_AUTO_PUSH, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_SHIFTCTRL_AUTO_PUSH, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_SHIFTCTRL_AUTO_PUSH, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_SHIFTCTRL_AUTO_PUSH, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_SHIFTCTRL_AUTO_PULL); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_SHIFTCTRL_AUTO_PULL, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_SHIFTCTRL_AUTO_PULL, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_SHIFTCTRL_AUTO_PULL, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_SHIFTCTRL_AUTO_PULL, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_SHIFTCTRL_IN_SHIFT_DIR); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_SHIFTCTRL_IN_SHIFT_DIR, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_SHIFTCTRL_IN_SHIFT_DIR, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_SHIFTCTRL_IN_SHIFT_DIR, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_SHIFTCTRL_IN_SHIFT_DIR, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_SHIFTCTRL_OUT_SHIFT_DIR); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_SHIFTCTRL_OUT_SHIFT_DIR, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_SHIFTCTRL_OUT_SHIFT_DIR, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_SHIFTCTRL_OUT_SHIFT_DIR, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_SHIFTCTRL_OUT_SHIFT_DIR, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_SHIFTCTRL_ISR_THRESHOLD); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_SHIFTCTRL_ISR_THRESHOLD, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_SHIFTCTRL_ISR_THRESHOLD, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_SHIFTCTRL_ISR_THRESHOLD, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_SHIFTCTRL_ISR_THRESHOLD, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_SHIFTCTRL_OSR_THRESHOLD); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_SHIFTCTRL_OSR_THRESHOLD, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_SHIFTCTRL_OSR_THRESHOLD, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_SHIFTCTRL_OSR_THRESHOLD, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_SHIFTCTRL_OSR_THRESHOLD, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_SHIFTCTRL_JOIN_TX); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_SHIFTCTRL_JOIN_TX, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_SHIFTCTRL_JOIN_TX, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_SHIFTCTRL_JOIN_TX, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_SHIFTCTRL_JOIN_TX, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_SHIFTCTRL_JOIN_RX); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_SHIFTCTRL_JOIN_RX, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_SHIFTCTRL_JOIN_RX, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_SHIFTCTRL_JOIN_RX, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_SHIFTCTRL_JOIN_RX, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_SM0_ADDR); - rp_pio_csr.wo(utra::rp_pio::SFR_SM0_ADDR, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_ADDR_PC); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_ADDR_PC, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_ADDR_PC, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_ADDR_PC, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_ADDR_PC, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_SM0_INSTR); - rp_pio_csr.wo(utra::rp_pio::SFR_SM0_INSTR, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_INSTR_IMM_INSTR); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_INSTR_IMM_INSTR, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_INSTR_IMM_INSTR, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_INSTR_IMM_INSTR, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_INSTR_IMM_INSTR, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_SM0_PINCTRL); - rp_pio_csr.wo(utra::rp_pio::SFR_SM0_PINCTRL, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_PINCTRL_PINS_OUT_BASE); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_PINCTRL_PINS_OUT_BASE, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_PINCTRL_PINS_OUT_BASE, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_PINCTRL_PINS_OUT_BASE, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_PINCTRL_PINS_OUT_BASE, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_PINCTRL_PINS_SET_BASE); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_PINCTRL_PINS_SET_BASE, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_PINCTRL_PINS_SET_BASE, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_PINCTRL_PINS_SET_BASE, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_PINCTRL_PINS_SET_BASE, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_PINCTRL_PINS_SIDE_BASE); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_PINCTRL_PINS_SIDE_BASE, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_PINCTRL_PINS_SIDE_BASE, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_PINCTRL_PINS_SIDE_BASE, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_PINCTRL_PINS_SIDE_BASE, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_PINCTRL_PINS_IN_BASE); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_PINCTRL_PINS_IN_BASE, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_PINCTRL_PINS_IN_BASE, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_PINCTRL_PINS_IN_BASE, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_PINCTRL_PINS_IN_BASE, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_PINCTRL_PINS_OUT_COUNT); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_PINCTRL_PINS_OUT_COUNT, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_PINCTRL_PINS_OUT_COUNT, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_PINCTRL_PINS_OUT_COUNT, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_PINCTRL_PINS_OUT_COUNT, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_PINCTRL_PINS_SET_COUNT); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_PINCTRL_PINS_SET_COUNT, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_PINCTRL_PINS_SET_COUNT, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_PINCTRL_PINS_SET_COUNT, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_PINCTRL_PINS_SET_COUNT, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_PINCTRL_PINS_SIDE_COUNT); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_PINCTRL_PINS_SIDE_COUNT, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_PINCTRL_PINS_SIDE_COUNT, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_PINCTRL_PINS_SIDE_COUNT, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_PINCTRL_PINS_SIDE_COUNT, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_SM1_CLKDIV); - rp_pio_csr.wo(utra::rp_pio::SFR_SM1_CLKDIV, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_CLKDIV_UNUSED_DIV); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_CLKDIV_UNUSED_DIV, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_CLKDIV_UNUSED_DIV, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_CLKDIV_UNUSED_DIV, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_CLKDIV_UNUSED_DIV, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_CLKDIV_DIV_FRAC); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_CLKDIV_DIV_FRAC, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_CLKDIV_DIV_FRAC, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_CLKDIV_DIV_FRAC, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_CLKDIV_DIV_FRAC, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_CLKDIV_DIV_INT); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_CLKDIV_DIV_INT, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_CLKDIV_DIV_INT, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_CLKDIV_DIV_INT, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_CLKDIV_DIV_INT, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_SM1_EXECCTRL); - rp_pio_csr.wo(utra::rp_pio::SFR_SM1_EXECCTRL, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_EXECCTRL_STATUS_N); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_EXECCTRL_STATUS_N, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_EXECCTRL_STATUS_N, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_EXECCTRL_STATUS_N, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_EXECCTRL_STATUS_N, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_EXECCTRL_STATUS_SEL); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_EXECCTRL_STATUS_SEL, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_EXECCTRL_STATUS_SEL, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_EXECCTRL_STATUS_SEL, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_EXECCTRL_STATUS_SEL, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_EXECCTRL_RESVD_EXEC); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_EXECCTRL_RESVD_EXEC, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_EXECCTRL_RESVD_EXEC, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_EXECCTRL_RESVD_EXEC, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_EXECCTRL_RESVD_EXEC, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_EXECCTRL_WRAP_TARGET); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_EXECCTRL_WRAP_TARGET, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_EXECCTRL_WRAP_TARGET, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_EXECCTRL_WRAP_TARGET, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_EXECCTRL_WRAP_TARGET, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_EXECCTRL_PEND); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_EXECCTRL_PEND, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_EXECCTRL_PEND, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_EXECCTRL_PEND, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_EXECCTRL_PEND, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_EXECCTRL_OUT_STICKY); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_EXECCTRL_OUT_STICKY, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_EXECCTRL_OUT_STICKY, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_EXECCTRL_OUT_STICKY, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_EXECCTRL_OUT_STICKY, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_EXECCTRL_INLINE_OUT_EN); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_EXECCTRL_INLINE_OUT_EN, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_EXECCTRL_INLINE_OUT_EN, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_EXECCTRL_INLINE_OUT_EN, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_EXECCTRL_INLINE_OUT_EN, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_EXECCTRL_OUT_EN_SEL); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_EXECCTRL_OUT_EN_SEL, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_EXECCTRL_OUT_EN_SEL, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_EXECCTRL_OUT_EN_SEL, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_EXECCTRL_OUT_EN_SEL, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_EXECCTRL_JMP_PIN); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_EXECCTRL_JMP_PIN, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_EXECCTRL_JMP_PIN, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_EXECCTRL_JMP_PIN, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_EXECCTRL_JMP_PIN, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_EXECCTRL_SIDE_PINDIR); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_EXECCTRL_SIDE_PINDIR, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_EXECCTRL_SIDE_PINDIR, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_EXECCTRL_SIDE_PINDIR, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_EXECCTRL_SIDE_PINDIR, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_EXECCTRL_SIDESET_ENABLE_BIT); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_EXECCTRL_SIDESET_ENABLE_BIT, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_EXECCTRL_SIDESET_ENABLE_BIT, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_EXECCTRL_SIDESET_ENABLE_BIT, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_EXECCTRL_SIDESET_ENABLE_BIT, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_EXECCTRL_EXEC_STALLED_RO1); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_EXECCTRL_EXEC_STALLED_RO1, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_EXECCTRL_EXEC_STALLED_RO1, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_EXECCTRL_EXEC_STALLED_RO1, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_EXECCTRL_EXEC_STALLED_RO1, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_SM1_SHIFTCTRL); - rp_pio_csr.wo(utra::rp_pio::SFR_SM1_SHIFTCTRL, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_SHIFTCTRL_RESVD_SHIFT); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_SHIFTCTRL_RESVD_SHIFT, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_SHIFTCTRL_RESVD_SHIFT, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_SHIFTCTRL_RESVD_SHIFT, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_SHIFTCTRL_RESVD_SHIFT, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_SHIFTCTRL_AUTO_PUSH); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_SHIFTCTRL_AUTO_PUSH, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_SHIFTCTRL_AUTO_PUSH, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_SHIFTCTRL_AUTO_PUSH, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_SHIFTCTRL_AUTO_PUSH, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_SHIFTCTRL_AUTO_PULL); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_SHIFTCTRL_AUTO_PULL, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_SHIFTCTRL_AUTO_PULL, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_SHIFTCTRL_AUTO_PULL, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_SHIFTCTRL_AUTO_PULL, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_SHIFTCTRL_IN_SHIFT_DIR); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_SHIFTCTRL_IN_SHIFT_DIR, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_SHIFTCTRL_IN_SHIFT_DIR, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_SHIFTCTRL_IN_SHIFT_DIR, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_SHIFTCTRL_IN_SHIFT_DIR, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_SHIFTCTRL_OUT_SHIFT_DIR); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_SHIFTCTRL_OUT_SHIFT_DIR, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_SHIFTCTRL_OUT_SHIFT_DIR, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_SHIFTCTRL_OUT_SHIFT_DIR, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_SHIFTCTRL_OUT_SHIFT_DIR, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_SHIFTCTRL_ISR_THRESHOLD); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_SHIFTCTRL_ISR_THRESHOLD, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_SHIFTCTRL_ISR_THRESHOLD, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_SHIFTCTRL_ISR_THRESHOLD, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_SHIFTCTRL_ISR_THRESHOLD, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_SHIFTCTRL_OSR_THRESHOLD); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_SHIFTCTRL_OSR_THRESHOLD, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_SHIFTCTRL_OSR_THRESHOLD, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_SHIFTCTRL_OSR_THRESHOLD, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_SHIFTCTRL_OSR_THRESHOLD, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_SHIFTCTRL_JOIN_TX); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_SHIFTCTRL_JOIN_TX, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_SHIFTCTRL_JOIN_TX, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_SHIFTCTRL_JOIN_TX, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_SHIFTCTRL_JOIN_TX, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_SHIFTCTRL_JOIN_RX); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_SHIFTCTRL_JOIN_RX, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_SHIFTCTRL_JOIN_RX, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_SHIFTCTRL_JOIN_RX, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_SHIFTCTRL_JOIN_RX, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_SM1_ADDR); - rp_pio_csr.wo(utra::rp_pio::SFR_SM1_ADDR, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_ADDR_PC); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_ADDR_PC, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_ADDR_PC, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_ADDR_PC, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_ADDR_PC, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_SM1_INSTR); - rp_pio_csr.wo(utra::rp_pio::SFR_SM1_INSTR, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_INSTR_IMM_INSTR); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_INSTR_IMM_INSTR, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_INSTR_IMM_INSTR, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_INSTR_IMM_INSTR, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_INSTR_IMM_INSTR, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_SM1_PINCTRL); - rp_pio_csr.wo(utra::rp_pio::SFR_SM1_PINCTRL, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_PINCTRL_PINS_OUT_BASE); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_PINCTRL_PINS_OUT_BASE, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_PINCTRL_PINS_OUT_BASE, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_PINCTRL_PINS_OUT_BASE, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_PINCTRL_PINS_OUT_BASE, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_PINCTRL_PINS_SET_BASE); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_PINCTRL_PINS_SET_BASE, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_PINCTRL_PINS_SET_BASE, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_PINCTRL_PINS_SET_BASE, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_PINCTRL_PINS_SET_BASE, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_PINCTRL_PINS_SIDE_BASE); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_PINCTRL_PINS_SIDE_BASE, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_PINCTRL_PINS_SIDE_BASE, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_PINCTRL_PINS_SIDE_BASE, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_PINCTRL_PINS_SIDE_BASE, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_PINCTRL_PINS_IN_BASE); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_PINCTRL_PINS_IN_BASE, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_PINCTRL_PINS_IN_BASE, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_PINCTRL_PINS_IN_BASE, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_PINCTRL_PINS_IN_BASE, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_PINCTRL_PINS_OUT_COUNT); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_PINCTRL_PINS_OUT_COUNT, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_PINCTRL_PINS_OUT_COUNT, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_PINCTRL_PINS_OUT_COUNT, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_PINCTRL_PINS_OUT_COUNT, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_PINCTRL_PINS_SET_COUNT); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_PINCTRL_PINS_SET_COUNT, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_PINCTRL_PINS_SET_COUNT, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_PINCTRL_PINS_SET_COUNT, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_PINCTRL_PINS_SET_COUNT, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_PINCTRL_PINS_SIDE_COUNT); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_PINCTRL_PINS_SIDE_COUNT, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_PINCTRL_PINS_SIDE_COUNT, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_PINCTRL_PINS_SIDE_COUNT, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_PINCTRL_PINS_SIDE_COUNT, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_SM2_CLKDIV); - rp_pio_csr.wo(utra::rp_pio::SFR_SM2_CLKDIV, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_CLKDIV_UNUSED_DIV); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_CLKDIV_UNUSED_DIV, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_CLKDIV_UNUSED_DIV, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_CLKDIV_UNUSED_DIV, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_CLKDIV_UNUSED_DIV, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_CLKDIV_DIV_FRAC); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_CLKDIV_DIV_FRAC, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_CLKDIV_DIV_FRAC, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_CLKDIV_DIV_FRAC, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_CLKDIV_DIV_FRAC, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_CLKDIV_DIV_INT); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_CLKDIV_DIV_INT, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_CLKDIV_DIV_INT, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_CLKDIV_DIV_INT, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_CLKDIV_DIV_INT, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_SM2_EXECCTRL); - rp_pio_csr.wo(utra::rp_pio::SFR_SM2_EXECCTRL, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_EXECCTRL_STATUS_N); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_EXECCTRL_STATUS_N, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_EXECCTRL_STATUS_N, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_EXECCTRL_STATUS_N, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_EXECCTRL_STATUS_N, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_EXECCTRL_STATUS_SEL); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_EXECCTRL_STATUS_SEL, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_EXECCTRL_STATUS_SEL, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_EXECCTRL_STATUS_SEL, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_EXECCTRL_STATUS_SEL, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_EXECCTRL_RESVD_EXEC); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_EXECCTRL_RESVD_EXEC, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_EXECCTRL_RESVD_EXEC, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_EXECCTRL_RESVD_EXEC, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_EXECCTRL_RESVD_EXEC, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_EXECCTRL_WRAP_TARGET); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_EXECCTRL_WRAP_TARGET, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_EXECCTRL_WRAP_TARGET, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_EXECCTRL_WRAP_TARGET, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_EXECCTRL_WRAP_TARGET, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_EXECCTRL_PEND); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_EXECCTRL_PEND, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_EXECCTRL_PEND, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_EXECCTRL_PEND, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_EXECCTRL_PEND, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_EXECCTRL_OUT_STICKY); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_EXECCTRL_OUT_STICKY, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_EXECCTRL_OUT_STICKY, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_EXECCTRL_OUT_STICKY, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_EXECCTRL_OUT_STICKY, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_EXECCTRL_INLINE_OUT_EN); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_EXECCTRL_INLINE_OUT_EN, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_EXECCTRL_INLINE_OUT_EN, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_EXECCTRL_INLINE_OUT_EN, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_EXECCTRL_INLINE_OUT_EN, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_EXECCTRL_OUT_EN_SEL); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_EXECCTRL_OUT_EN_SEL, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_EXECCTRL_OUT_EN_SEL, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_EXECCTRL_OUT_EN_SEL, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_EXECCTRL_OUT_EN_SEL, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_EXECCTRL_JMP_PIN); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_EXECCTRL_JMP_PIN, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_EXECCTRL_JMP_PIN, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_EXECCTRL_JMP_PIN, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_EXECCTRL_JMP_PIN, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_EXECCTRL_SIDE_PINDIR); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_EXECCTRL_SIDE_PINDIR, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_EXECCTRL_SIDE_PINDIR, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_EXECCTRL_SIDE_PINDIR, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_EXECCTRL_SIDE_PINDIR, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_EXECCTRL_SIDESET_ENABLE_BIT); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_EXECCTRL_SIDESET_ENABLE_BIT, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_EXECCTRL_SIDESET_ENABLE_BIT, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_EXECCTRL_SIDESET_ENABLE_BIT, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_EXECCTRL_SIDESET_ENABLE_BIT, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_EXECCTRL_EXEC_STALLED_RO2); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_EXECCTRL_EXEC_STALLED_RO2, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_EXECCTRL_EXEC_STALLED_RO2, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_EXECCTRL_EXEC_STALLED_RO2, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_EXECCTRL_EXEC_STALLED_RO2, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_SM2_SHIFTCTRL); - rp_pio_csr.wo(utra::rp_pio::SFR_SM2_SHIFTCTRL, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_SHIFTCTRL_RESVD_SHIFT); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_SHIFTCTRL_RESVD_SHIFT, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_SHIFTCTRL_RESVD_SHIFT, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_SHIFTCTRL_RESVD_SHIFT, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_SHIFTCTRL_RESVD_SHIFT, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_SHIFTCTRL_AUTO_PUSH); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_SHIFTCTRL_AUTO_PUSH, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_SHIFTCTRL_AUTO_PUSH, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_SHIFTCTRL_AUTO_PUSH, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_SHIFTCTRL_AUTO_PUSH, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_SHIFTCTRL_AUTO_PULL); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_SHIFTCTRL_AUTO_PULL, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_SHIFTCTRL_AUTO_PULL, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_SHIFTCTRL_AUTO_PULL, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_SHIFTCTRL_AUTO_PULL, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_SHIFTCTRL_IN_SHIFT_DIR); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_SHIFTCTRL_IN_SHIFT_DIR, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_SHIFTCTRL_IN_SHIFT_DIR, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_SHIFTCTRL_IN_SHIFT_DIR, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_SHIFTCTRL_IN_SHIFT_DIR, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_SHIFTCTRL_OUT_SHIFT_DIR); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_SHIFTCTRL_OUT_SHIFT_DIR, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_SHIFTCTRL_OUT_SHIFT_DIR, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_SHIFTCTRL_OUT_SHIFT_DIR, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_SHIFTCTRL_OUT_SHIFT_DIR, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_SHIFTCTRL_ISR_THRESHOLD); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_SHIFTCTRL_ISR_THRESHOLD, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_SHIFTCTRL_ISR_THRESHOLD, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_SHIFTCTRL_ISR_THRESHOLD, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_SHIFTCTRL_ISR_THRESHOLD, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_SHIFTCTRL_OSR_THRESHOLD); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_SHIFTCTRL_OSR_THRESHOLD, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_SHIFTCTRL_OSR_THRESHOLD, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_SHIFTCTRL_OSR_THRESHOLD, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_SHIFTCTRL_OSR_THRESHOLD, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_SHIFTCTRL_JOIN_TX); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_SHIFTCTRL_JOIN_TX, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_SHIFTCTRL_JOIN_TX, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_SHIFTCTRL_JOIN_TX, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_SHIFTCTRL_JOIN_TX, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_SHIFTCTRL_JOIN_RX); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_SHIFTCTRL_JOIN_RX, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_SHIFTCTRL_JOIN_RX, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_SHIFTCTRL_JOIN_RX, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_SHIFTCTRL_JOIN_RX, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_SM2_ADDR); - rp_pio_csr.wo(utra::rp_pio::SFR_SM2_ADDR, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_ADDR_PC); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_ADDR_PC, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_ADDR_PC, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_ADDR_PC, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_ADDR_PC, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_SM2_INSTR); - rp_pio_csr.wo(utra::rp_pio::SFR_SM2_INSTR, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_INSTR_IMM_INSTR); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_INSTR_IMM_INSTR, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_INSTR_IMM_INSTR, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_INSTR_IMM_INSTR, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_INSTR_IMM_INSTR, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_SM2_PINCTRL); - rp_pio_csr.wo(utra::rp_pio::SFR_SM2_PINCTRL, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_PINCTRL_PINS_OUT_BASE); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_PINCTRL_PINS_OUT_BASE, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_PINCTRL_PINS_OUT_BASE, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_PINCTRL_PINS_OUT_BASE, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_PINCTRL_PINS_OUT_BASE, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_PINCTRL_PINS_SET_BASE); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_PINCTRL_PINS_SET_BASE, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_PINCTRL_PINS_SET_BASE, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_PINCTRL_PINS_SET_BASE, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_PINCTRL_PINS_SET_BASE, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_PINCTRL_PINS_SIDE_BASE); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_PINCTRL_PINS_SIDE_BASE, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_PINCTRL_PINS_SIDE_BASE, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_PINCTRL_PINS_SIDE_BASE, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_PINCTRL_PINS_SIDE_BASE, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_PINCTRL_PINS_IN_BASE); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_PINCTRL_PINS_IN_BASE, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_PINCTRL_PINS_IN_BASE, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_PINCTRL_PINS_IN_BASE, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_PINCTRL_PINS_IN_BASE, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_PINCTRL_PINS_OUT_COUNT); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_PINCTRL_PINS_OUT_COUNT, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_PINCTRL_PINS_OUT_COUNT, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_PINCTRL_PINS_OUT_COUNT, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_PINCTRL_PINS_OUT_COUNT, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_PINCTRL_PINS_SET_COUNT); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_PINCTRL_PINS_SET_COUNT, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_PINCTRL_PINS_SET_COUNT, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_PINCTRL_PINS_SET_COUNT, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_PINCTRL_PINS_SET_COUNT, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_PINCTRL_PINS_SIDE_COUNT); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_PINCTRL_PINS_SIDE_COUNT, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_PINCTRL_PINS_SIDE_COUNT, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_PINCTRL_PINS_SIDE_COUNT, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_PINCTRL_PINS_SIDE_COUNT, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_SM3_CLKDIV); - rp_pio_csr.wo(utra::rp_pio::SFR_SM3_CLKDIV, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_CLKDIV_UNUSED_DIV); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_CLKDIV_UNUSED_DIV, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_CLKDIV_UNUSED_DIV, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_CLKDIV_UNUSED_DIV, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_CLKDIV_UNUSED_DIV, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_CLKDIV_DIV_FRAC); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_CLKDIV_DIV_FRAC, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_CLKDIV_DIV_FRAC, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_CLKDIV_DIV_FRAC, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_CLKDIV_DIV_FRAC, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_CLKDIV_DIV_INT); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_CLKDIV_DIV_INT, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_CLKDIV_DIV_INT, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_CLKDIV_DIV_INT, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_CLKDIV_DIV_INT, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_SM3_EXECCTRL); - rp_pio_csr.wo(utra::rp_pio::SFR_SM3_EXECCTRL, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_EXECCTRL_STATUS_N); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_EXECCTRL_STATUS_N, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_EXECCTRL_STATUS_N, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_EXECCTRL_STATUS_N, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_EXECCTRL_STATUS_N, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_EXECCTRL_STATUS_SEL); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_EXECCTRL_STATUS_SEL, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_EXECCTRL_STATUS_SEL, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_EXECCTRL_STATUS_SEL, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_EXECCTRL_STATUS_SEL, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_EXECCTRL_RESVD_EXEC); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_EXECCTRL_RESVD_EXEC, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_EXECCTRL_RESVD_EXEC, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_EXECCTRL_RESVD_EXEC, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_EXECCTRL_RESVD_EXEC, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_EXECCTRL_WRAP_TARGET); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_EXECCTRL_WRAP_TARGET, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_EXECCTRL_WRAP_TARGET, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_EXECCTRL_WRAP_TARGET, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_EXECCTRL_WRAP_TARGET, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_EXECCTRL_PEND); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_EXECCTRL_PEND, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_EXECCTRL_PEND, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_EXECCTRL_PEND, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_EXECCTRL_PEND, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_EXECCTRL_OUT_STICKY); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_EXECCTRL_OUT_STICKY, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_EXECCTRL_OUT_STICKY, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_EXECCTRL_OUT_STICKY, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_EXECCTRL_OUT_STICKY, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_EXECCTRL_INLINE_OUT_EN); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_EXECCTRL_INLINE_OUT_EN, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_EXECCTRL_INLINE_OUT_EN, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_EXECCTRL_INLINE_OUT_EN, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_EXECCTRL_INLINE_OUT_EN, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_EXECCTRL_OUT_EN_SEL); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_EXECCTRL_OUT_EN_SEL, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_EXECCTRL_OUT_EN_SEL, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_EXECCTRL_OUT_EN_SEL, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_EXECCTRL_OUT_EN_SEL, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_EXECCTRL_JMP_PIN); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_EXECCTRL_JMP_PIN, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_EXECCTRL_JMP_PIN, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_EXECCTRL_JMP_PIN, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_EXECCTRL_JMP_PIN, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_EXECCTRL_SIDE_PINDIR); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_EXECCTRL_SIDE_PINDIR, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_EXECCTRL_SIDE_PINDIR, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_EXECCTRL_SIDE_PINDIR, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_EXECCTRL_SIDE_PINDIR, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_EXECCTRL_SIDESET_ENABLE_BIT); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_EXECCTRL_SIDESET_ENABLE_BIT, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_EXECCTRL_SIDESET_ENABLE_BIT, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_EXECCTRL_SIDESET_ENABLE_BIT, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_EXECCTRL_SIDESET_ENABLE_BIT, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_EXECCTRL_EXEC_STALLED_RO3); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_EXECCTRL_EXEC_STALLED_RO3, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_EXECCTRL_EXEC_STALLED_RO3, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_EXECCTRL_EXEC_STALLED_RO3, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_EXECCTRL_EXEC_STALLED_RO3, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_SM3_SHIFTCTRL); - rp_pio_csr.wo(utra::rp_pio::SFR_SM3_SHIFTCTRL, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_SHIFTCTRL_RESVD_SHIFT); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_SHIFTCTRL_RESVD_SHIFT, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_SHIFTCTRL_RESVD_SHIFT, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_SHIFTCTRL_RESVD_SHIFT, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_SHIFTCTRL_RESVD_SHIFT, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_SHIFTCTRL_AUTO_PUSH); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_SHIFTCTRL_AUTO_PUSH, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_SHIFTCTRL_AUTO_PUSH, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_SHIFTCTRL_AUTO_PUSH, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_SHIFTCTRL_AUTO_PUSH, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_SHIFTCTRL_AUTO_PULL); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_SHIFTCTRL_AUTO_PULL, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_SHIFTCTRL_AUTO_PULL, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_SHIFTCTRL_AUTO_PULL, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_SHIFTCTRL_AUTO_PULL, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_SHIFTCTRL_IN_SHIFT_DIR); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_SHIFTCTRL_IN_SHIFT_DIR, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_SHIFTCTRL_IN_SHIFT_DIR, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_SHIFTCTRL_IN_SHIFT_DIR, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_SHIFTCTRL_IN_SHIFT_DIR, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_SHIFTCTRL_OUT_SHIFT_DIR); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_SHIFTCTRL_OUT_SHIFT_DIR, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_SHIFTCTRL_OUT_SHIFT_DIR, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_SHIFTCTRL_OUT_SHIFT_DIR, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_SHIFTCTRL_OUT_SHIFT_DIR, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_SHIFTCTRL_ISR_THRESHOLD); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_SHIFTCTRL_ISR_THRESHOLD, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_SHIFTCTRL_ISR_THRESHOLD, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_SHIFTCTRL_ISR_THRESHOLD, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_SHIFTCTRL_ISR_THRESHOLD, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_SHIFTCTRL_OSR_THRESHOLD); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_SHIFTCTRL_OSR_THRESHOLD, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_SHIFTCTRL_OSR_THRESHOLD, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_SHIFTCTRL_OSR_THRESHOLD, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_SHIFTCTRL_OSR_THRESHOLD, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_SHIFTCTRL_JOIN_TX); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_SHIFTCTRL_JOIN_TX, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_SHIFTCTRL_JOIN_TX, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_SHIFTCTRL_JOIN_TX, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_SHIFTCTRL_JOIN_TX, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_SHIFTCTRL_JOIN_RX); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_SHIFTCTRL_JOIN_RX, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_SHIFTCTRL_JOIN_RX, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_SHIFTCTRL_JOIN_RX, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_SHIFTCTRL_JOIN_RX, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_SM3_ADDR); - rp_pio_csr.wo(utra::rp_pio::SFR_SM3_ADDR, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_ADDR_PC); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_ADDR_PC, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_ADDR_PC, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_ADDR_PC, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_ADDR_PC, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_SM3_INSTR); - rp_pio_csr.wo(utra::rp_pio::SFR_SM3_INSTR, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_INSTR_IMM_INSTR); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_INSTR_IMM_INSTR, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_INSTR_IMM_INSTR, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_INSTR_IMM_INSTR, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_INSTR_IMM_INSTR, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_SM3_PINCTRL); - rp_pio_csr.wo(utra::rp_pio::SFR_SM3_PINCTRL, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_PINCTRL_PINS_OUT_BASE); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_PINCTRL_PINS_OUT_BASE, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_PINCTRL_PINS_OUT_BASE, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_PINCTRL_PINS_OUT_BASE, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_PINCTRL_PINS_OUT_BASE, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_PINCTRL_PINS_SET_BASE); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_PINCTRL_PINS_SET_BASE, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_PINCTRL_PINS_SET_BASE, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_PINCTRL_PINS_SET_BASE, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_PINCTRL_PINS_SET_BASE, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_PINCTRL_PINS_SIDE_BASE); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_PINCTRL_PINS_SIDE_BASE, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_PINCTRL_PINS_SIDE_BASE, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_PINCTRL_PINS_SIDE_BASE, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_PINCTRL_PINS_SIDE_BASE, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_PINCTRL_PINS_IN_BASE); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_PINCTRL_PINS_IN_BASE, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_PINCTRL_PINS_IN_BASE, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_PINCTRL_PINS_IN_BASE, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_PINCTRL_PINS_IN_BASE, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_PINCTRL_PINS_OUT_COUNT); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_PINCTRL_PINS_OUT_COUNT, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_PINCTRL_PINS_OUT_COUNT, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_PINCTRL_PINS_OUT_COUNT, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_PINCTRL_PINS_OUT_COUNT, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_PINCTRL_PINS_SET_COUNT); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_PINCTRL_PINS_SET_COUNT, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_PINCTRL_PINS_SET_COUNT, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_PINCTRL_PINS_SET_COUNT, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_PINCTRL_PINS_SET_COUNT, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_PINCTRL_PINS_SIDE_COUNT); - rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_PINCTRL_PINS_SIDE_COUNT, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_PINCTRL_PINS_SIDE_COUNT, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_PINCTRL_PINS_SIDE_COUNT, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_PINCTRL_PINS_SIDE_COUNT, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_INTR); - rp_pio_csr.wo(utra::rp_pio::SFR_INTR, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INTR_INTR_RXNEMPTY); - rp_pio_csr.rmwf(utra::rp_pio::SFR_INTR_INTR_RXNEMPTY, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INTR_INTR_RXNEMPTY, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INTR_INTR_RXNEMPTY, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_INTR_INTR_RXNEMPTY, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INTR_INTR_TXNFULL); - rp_pio_csr.rmwf(utra::rp_pio::SFR_INTR_INTR_TXNFULL, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INTR_INTR_TXNFULL, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INTR_INTR_TXNFULL, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_INTR_INTR_TXNFULL, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INTR_INTR_SM); - rp_pio_csr.rmwf(utra::rp_pio::SFR_INTR_INTR_SM, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INTR_INTR_SM, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INTR_INTR_SM, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_INTR_INTR_SM, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_IRQ0_INTE); - rp_pio_csr.wo(utra::rp_pio::SFR_IRQ0_INTE, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_IRQ0_INTE_IRQ0_INTE_RXNEMPTY); - rp_pio_csr.rmwf(utra::rp_pio::SFR_IRQ0_INTE_IRQ0_INTE_RXNEMPTY, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_IRQ0_INTE_IRQ0_INTE_RXNEMPTY, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_IRQ0_INTE_IRQ0_INTE_RXNEMPTY, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_IRQ0_INTE_IRQ0_INTE_RXNEMPTY, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_IRQ0_INTE_IRQ0_INTE_TXNFULL); - rp_pio_csr.rmwf(utra::rp_pio::SFR_IRQ0_INTE_IRQ0_INTE_TXNFULL, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_IRQ0_INTE_IRQ0_INTE_TXNFULL, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_IRQ0_INTE_IRQ0_INTE_TXNFULL, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_IRQ0_INTE_IRQ0_INTE_TXNFULL, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_IRQ0_INTE_IRQ0_INTE_SM); - rp_pio_csr.rmwf(utra::rp_pio::SFR_IRQ0_INTE_IRQ0_INTE_SM, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_IRQ0_INTE_IRQ0_INTE_SM, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_IRQ0_INTE_IRQ0_INTE_SM, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_IRQ0_INTE_IRQ0_INTE_SM, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_IRQ0_INTF); - rp_pio_csr.wo(utra::rp_pio::SFR_IRQ0_INTF, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_IRQ0_INTF_IRQ0_INTF_RXNEMPTY); - rp_pio_csr.rmwf(utra::rp_pio::SFR_IRQ0_INTF_IRQ0_INTF_RXNEMPTY, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_IRQ0_INTF_IRQ0_INTF_RXNEMPTY, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_IRQ0_INTF_IRQ0_INTF_RXNEMPTY, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_IRQ0_INTF_IRQ0_INTF_RXNEMPTY, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_IRQ0_INTF_IRQ0_INTF_TXNFULL); - rp_pio_csr.rmwf(utra::rp_pio::SFR_IRQ0_INTF_IRQ0_INTF_TXNFULL, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_IRQ0_INTF_IRQ0_INTF_TXNFULL, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_IRQ0_INTF_IRQ0_INTF_TXNFULL, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_IRQ0_INTF_IRQ0_INTF_TXNFULL, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_IRQ0_INTF_IRQ0_INTF_SM); - rp_pio_csr.rmwf(utra::rp_pio::SFR_IRQ0_INTF_IRQ0_INTF_SM, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_IRQ0_INTF_IRQ0_INTF_SM, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_IRQ0_INTF_IRQ0_INTF_SM, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_IRQ0_INTF_IRQ0_INTF_SM, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_IRQ0_INTS); - rp_pio_csr.wo(utra::rp_pio::SFR_IRQ0_INTS, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_IRQ0_INTS_IRQ0_INTS_RXNEMPTY); - rp_pio_csr.rmwf(utra::rp_pio::SFR_IRQ0_INTS_IRQ0_INTS_RXNEMPTY, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_IRQ0_INTS_IRQ0_INTS_RXNEMPTY, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_IRQ0_INTS_IRQ0_INTS_RXNEMPTY, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_IRQ0_INTS_IRQ0_INTS_RXNEMPTY, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_IRQ0_INTS_IRQ0_INTS_TXNFULL); - rp_pio_csr.rmwf(utra::rp_pio::SFR_IRQ0_INTS_IRQ0_INTS_TXNFULL, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_IRQ0_INTS_IRQ0_INTS_TXNFULL, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_IRQ0_INTS_IRQ0_INTS_TXNFULL, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_IRQ0_INTS_IRQ0_INTS_TXNFULL, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_IRQ0_INTS_IRQ0_INTS_SM); - rp_pio_csr.rmwf(utra::rp_pio::SFR_IRQ0_INTS_IRQ0_INTS_SM, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_IRQ0_INTS_IRQ0_INTS_SM, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_IRQ0_INTS_IRQ0_INTS_SM, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_IRQ0_INTS_IRQ0_INTS_SM, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_IRQ1_INTE); - rp_pio_csr.wo(utra::rp_pio::SFR_IRQ1_INTE, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_IRQ1_INTE_IRQ1_INTE_RXNEMPTY); - rp_pio_csr.rmwf(utra::rp_pio::SFR_IRQ1_INTE_IRQ1_INTE_RXNEMPTY, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_IRQ1_INTE_IRQ1_INTE_RXNEMPTY, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_IRQ1_INTE_IRQ1_INTE_RXNEMPTY, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_IRQ1_INTE_IRQ1_INTE_RXNEMPTY, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_IRQ1_INTE_IRQ1_INTE_TXNFULL); - rp_pio_csr.rmwf(utra::rp_pio::SFR_IRQ1_INTE_IRQ1_INTE_TXNFULL, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_IRQ1_INTE_IRQ1_INTE_TXNFULL, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_IRQ1_INTE_IRQ1_INTE_TXNFULL, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_IRQ1_INTE_IRQ1_INTE_TXNFULL, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_IRQ1_INTE_IRQ1_INTE_SM); - rp_pio_csr.rmwf(utra::rp_pio::SFR_IRQ1_INTE_IRQ1_INTE_SM, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_IRQ1_INTE_IRQ1_INTE_SM, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_IRQ1_INTE_IRQ1_INTE_SM, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_IRQ1_INTE_IRQ1_INTE_SM, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_IRQ1_INTF); - rp_pio_csr.wo(utra::rp_pio::SFR_IRQ1_INTF, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_IRQ1_INTF_IRQ1_INTF_RXNEMPTY); - rp_pio_csr.rmwf(utra::rp_pio::SFR_IRQ1_INTF_IRQ1_INTF_RXNEMPTY, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_IRQ1_INTF_IRQ1_INTF_RXNEMPTY, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_IRQ1_INTF_IRQ1_INTF_RXNEMPTY, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_IRQ1_INTF_IRQ1_INTF_RXNEMPTY, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_IRQ1_INTF_IRQ1_INTF_TXNFULL); - rp_pio_csr.rmwf(utra::rp_pio::SFR_IRQ1_INTF_IRQ1_INTF_TXNFULL, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_IRQ1_INTF_IRQ1_INTF_TXNFULL, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_IRQ1_INTF_IRQ1_INTF_TXNFULL, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_IRQ1_INTF_IRQ1_INTF_TXNFULL, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_IRQ1_INTF_IRQ1_INTF_SM); - rp_pio_csr.rmwf(utra::rp_pio::SFR_IRQ1_INTF_IRQ1_INTF_SM, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_IRQ1_INTF_IRQ1_INTF_SM, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_IRQ1_INTF_IRQ1_INTF_SM, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_IRQ1_INTF_IRQ1_INTF_SM, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_IRQ1_INTS); - rp_pio_csr.wo(utra::rp_pio::SFR_IRQ1_INTS, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_IRQ1_INTS_IRQ1_INTS_RXNEMPTY); - rp_pio_csr.rmwf(utra::rp_pio::SFR_IRQ1_INTS_IRQ1_INTS_RXNEMPTY, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_IRQ1_INTS_IRQ1_INTS_RXNEMPTY, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_IRQ1_INTS_IRQ1_INTS_RXNEMPTY, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_IRQ1_INTS_IRQ1_INTS_RXNEMPTY, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_IRQ1_INTS_IRQ1_INTS_TXNFULL); - rp_pio_csr.rmwf(utra::rp_pio::SFR_IRQ1_INTS_IRQ1_INTS_TXNFULL, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_IRQ1_INTS_IRQ1_INTS_TXNFULL, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_IRQ1_INTS_IRQ1_INTS_TXNFULL, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_IRQ1_INTS_IRQ1_INTS_TXNFULL, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_IRQ1_INTS_IRQ1_INTS_SM); - rp_pio_csr.rmwf(utra::rp_pio::SFR_IRQ1_INTS_IRQ1_INTS_SM, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_IRQ1_INTS_IRQ1_INTS_SM, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_IRQ1_INTS_IRQ1_INTS_SM, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_IRQ1_INTS_IRQ1_INTS_SM, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_IO_OE_INV); - rp_pio_csr.wo(utra::rp_pio::SFR_IO_OE_INV, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_IO_OE_INV_SFR_IO_OE_INV); - rp_pio_csr.rmwf(utra::rp_pio::SFR_IO_OE_INV_SFR_IO_OE_INV, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_IO_OE_INV_SFR_IO_OE_INV, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_IO_OE_INV_SFR_IO_OE_INV, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_IO_OE_INV_SFR_IO_OE_INV, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_IO_O_INV); - rp_pio_csr.wo(utra::rp_pio::SFR_IO_O_INV, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_IO_O_INV_SFR_IO_O_INV); - rp_pio_csr.rmwf(utra::rp_pio::SFR_IO_O_INV_SFR_IO_O_INV, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_IO_O_INV_SFR_IO_O_INV, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_IO_O_INV_SFR_IO_O_INV, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_IO_O_INV_SFR_IO_O_INV, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_IO_I_INV); - rp_pio_csr.wo(utra::rp_pio::SFR_IO_I_INV, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_IO_I_INV_SFR_IO_I_INV); - rp_pio_csr.rmwf(utra::rp_pio::SFR_IO_I_INV_SFR_IO_I_INV, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_IO_I_INV_SFR_IO_I_INV, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_IO_I_INV_SFR_IO_I_INV, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_IO_I_INV_SFR_IO_I_INV, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_FIFO_MARGIN); - rp_pio_csr.wo(utra::rp_pio::SFR_FIFO_MARGIN, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_TX_MARGIN0); - rp_pio_csr.rmwf(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_TX_MARGIN0, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_TX_MARGIN0, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_TX_MARGIN0, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_TX_MARGIN0, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_RX_MARGIN0); - rp_pio_csr.rmwf(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_RX_MARGIN0, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_RX_MARGIN0, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_RX_MARGIN0, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_RX_MARGIN0, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_TX_MARGIN1); - rp_pio_csr.rmwf(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_TX_MARGIN1, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_TX_MARGIN1, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_TX_MARGIN1, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_TX_MARGIN1, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_RX_MARGIN1); - rp_pio_csr.rmwf(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_RX_MARGIN1, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_RX_MARGIN1, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_RX_MARGIN1, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_RX_MARGIN1, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_TX_MARGIN2); - rp_pio_csr.rmwf(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_TX_MARGIN2, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_TX_MARGIN2, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_TX_MARGIN2, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_TX_MARGIN2, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_RX_MARGIN2); - rp_pio_csr.rmwf(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_RX_MARGIN2, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_RX_MARGIN2, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_RX_MARGIN2, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_RX_MARGIN2, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_TX_MARGIN3); - rp_pio_csr.rmwf(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_TX_MARGIN3, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_TX_MARGIN3, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_TX_MARGIN3, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_TX_MARGIN3, baz); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_RX_MARGIN3); - rp_pio_csr.rmwf(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_RX_MARGIN3, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_RX_MARGIN3, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_RX_MARGIN3, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_RX_MARGIN3, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_ZERO0); - rp_pio_csr.wo(utra::rp_pio::SFR_ZERO0, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_ZERO0_SFR_ZERO0); - rp_pio_csr.rmwf(utra::rp_pio::SFR_ZERO0_SFR_ZERO0, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_ZERO0_SFR_ZERO0, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_ZERO0_SFR_ZERO0, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_ZERO0_SFR_ZERO0, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_ZERO1); - rp_pio_csr.wo(utra::rp_pio::SFR_ZERO1, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_ZERO1_SFR_ZERO1); - rp_pio_csr.rmwf(utra::rp_pio::SFR_ZERO1_SFR_ZERO1, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_ZERO1_SFR_ZERO1, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_ZERO1_SFR_ZERO1, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_ZERO1_SFR_ZERO1, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_ZERO2); - rp_pio_csr.wo(utra::rp_pio::SFR_ZERO2, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_ZERO2_SFR_ZERO2); - rp_pio_csr.rmwf(utra::rp_pio::SFR_ZERO2_SFR_ZERO2, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_ZERO2_SFR_ZERO2, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_ZERO2_SFR_ZERO2, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_ZERO2_SFR_ZERO2, baz); - - let foo = rp_pio_csr.r(utra::rp_pio::SFR_ZERO3); - rp_pio_csr.wo(utra::rp_pio::SFR_ZERO3, foo); - let bar = rp_pio_csr.rf(utra::rp_pio::SFR_ZERO3_SFR_ZERO3); - rp_pio_csr.rmwf(utra::rp_pio::SFR_ZERO3_SFR_ZERO3, bar); - let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_ZERO3_SFR_ZERO3, bar); - baz |= rp_pio_csr.ms(utra::rp_pio::SFR_ZERO3_SFR_ZERO3, 1); - rp_pio_csr.wfo(utra::rp_pio::SFR_ZERO3_SFR_ZERO3, baz); - } - - #[test] - #[ignore] - fn compile_check_bio_bdma_csr() { - use super::*; - let mut bio_bdma_csr = CSR::new(HW_BIO_BDMA_BASE as *mut u32); - - let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_CTRL); - bio_bdma_csr.wo(utra::bio_bdma::SFR_CTRL, foo); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_CTRL_EN); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_CTRL_EN, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_CTRL_EN, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_CTRL_EN, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_CTRL_EN, baz); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_CTRL_RESTART); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_CTRL_RESTART, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_CTRL_RESTART, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_CTRL_RESTART, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_CTRL_RESTART, baz); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_CTRL_CLKDIV_RESTART); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_CTRL_CLKDIV_RESTART, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_CTRL_CLKDIV_RESTART, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_CTRL_CLKDIV_RESTART, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_CTRL_CLKDIV_RESTART, baz); - - let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_CFGINFO); - bio_bdma_csr.wo(utra::bio_bdma::SFR_CFGINFO, foo); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_CFGINFO_CONSTANT0); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_CFGINFO_CONSTANT0, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_CFGINFO_CONSTANT0, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_CFGINFO_CONSTANT0, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_CFGINFO_CONSTANT0, baz); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_CFGINFO_CONSTANT1); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_CFGINFO_CONSTANT1, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_CFGINFO_CONSTANT1, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_CFGINFO_CONSTANT1, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_CFGINFO_CONSTANT1, baz); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_CFGINFO_CONSTANT2); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_CFGINFO_CONSTANT2, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_CFGINFO_CONSTANT2, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_CFGINFO_CONSTANT2, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_CFGINFO_CONSTANT2, baz); - - let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_CONFIG); - bio_bdma_csr.wo(utra::bio_bdma::SFR_CONFIG, foo); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_CONFIG_SNAP_OUTPUT_TO_WHICH); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_CONFIG_SNAP_OUTPUT_TO_WHICH, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_CONFIG_SNAP_OUTPUT_TO_WHICH, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_CONFIG_SNAP_OUTPUT_TO_WHICH, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_CONFIG_SNAP_OUTPUT_TO_WHICH, baz); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_CONFIG_SNAP_OUTPUT_TO_QUANTUM); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_CONFIG_SNAP_OUTPUT_TO_QUANTUM, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_CONFIG_SNAP_OUTPUT_TO_QUANTUM, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_CONFIG_SNAP_OUTPUT_TO_QUANTUM, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_CONFIG_SNAP_OUTPUT_TO_QUANTUM, baz); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_CONFIG_SNAP_INPUT_TO_WHICH); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_CONFIG_SNAP_INPUT_TO_WHICH, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_CONFIG_SNAP_INPUT_TO_WHICH, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_CONFIG_SNAP_INPUT_TO_WHICH, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_CONFIG_SNAP_INPUT_TO_WHICH, baz); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_CONFIG_SNAP_INPUT_TO_QUANTUM); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_CONFIG_SNAP_INPUT_TO_QUANTUM, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_CONFIG_SNAP_INPUT_TO_QUANTUM, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_CONFIG_SNAP_INPUT_TO_QUANTUM, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_CONFIG_SNAP_INPUT_TO_QUANTUM, baz); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_CONFIG_DISABLE_FILTER_PERI); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_CONFIG_DISABLE_FILTER_PERI, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_CONFIG_DISABLE_FILTER_PERI, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_CONFIG_DISABLE_FILTER_PERI, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_CONFIG_DISABLE_FILTER_PERI, baz); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_CONFIG_DISABLE_FILTER_MEM); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_CONFIG_DISABLE_FILTER_MEM, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_CONFIG_DISABLE_FILTER_MEM, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_CONFIG_DISABLE_FILTER_MEM, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_CONFIG_DISABLE_FILTER_MEM, baz); - - let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_FLEVEL); - bio_bdma_csr.wo(utra::bio_bdma::SFR_FLEVEL, foo); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_FLEVEL_PCLK_REGFIFO_LEVEL0); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_FLEVEL_PCLK_REGFIFO_LEVEL0, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_FLEVEL_PCLK_REGFIFO_LEVEL0, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_FLEVEL_PCLK_REGFIFO_LEVEL0, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_FLEVEL_PCLK_REGFIFO_LEVEL0, baz); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_FLEVEL_PCLK_REGFIFO_LEVEL1); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_FLEVEL_PCLK_REGFIFO_LEVEL1, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_FLEVEL_PCLK_REGFIFO_LEVEL1, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_FLEVEL_PCLK_REGFIFO_LEVEL1, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_FLEVEL_PCLK_REGFIFO_LEVEL1, baz); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_FLEVEL_PCLK_REGFIFO_LEVEL2); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_FLEVEL_PCLK_REGFIFO_LEVEL2, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_FLEVEL_PCLK_REGFIFO_LEVEL2, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_FLEVEL_PCLK_REGFIFO_LEVEL2, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_FLEVEL_PCLK_REGFIFO_LEVEL2, baz); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_FLEVEL_PCLK_REGFIFO_LEVEL3); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_FLEVEL_PCLK_REGFIFO_LEVEL3, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_FLEVEL_PCLK_REGFIFO_LEVEL3, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_FLEVEL_PCLK_REGFIFO_LEVEL3, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_FLEVEL_PCLK_REGFIFO_LEVEL3, baz); - - let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_TXF0); - bio_bdma_csr.wo(utra::bio_bdma::SFR_TXF0, foo); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_TXF0_FDIN); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_TXF0_FDIN, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_TXF0_FDIN, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_TXF0_FDIN, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_TXF0_FDIN, baz); - - let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_TXF1); - bio_bdma_csr.wo(utra::bio_bdma::SFR_TXF1, foo); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_TXF1_FDIN); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_TXF1_FDIN, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_TXF1_FDIN, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_TXF1_FDIN, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_TXF1_FDIN, baz); - - let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_TXF2); - bio_bdma_csr.wo(utra::bio_bdma::SFR_TXF2, foo); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_TXF2_FDIN); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_TXF2_FDIN, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_TXF2_FDIN, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_TXF2_FDIN, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_TXF2_FDIN, baz); - - let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_TXF3); - bio_bdma_csr.wo(utra::bio_bdma::SFR_TXF3, foo); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_TXF3_FDIN); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_TXF3_FDIN, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_TXF3_FDIN, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_TXF3_FDIN, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_TXF3_FDIN, baz); - - let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_RXF0); - bio_bdma_csr.wo(utra::bio_bdma::SFR_RXF0, foo); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_RXF0_FDOUT); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_RXF0_FDOUT, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_RXF0_FDOUT, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_RXF0_FDOUT, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_RXF0_FDOUT, baz); - - let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_RXF1); - bio_bdma_csr.wo(utra::bio_bdma::SFR_RXF1, foo); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_RXF1_FDOUT); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_RXF1_FDOUT, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_RXF1_FDOUT, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_RXF1_FDOUT, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_RXF1_FDOUT, baz); - - let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_RXF2); - bio_bdma_csr.wo(utra::bio_bdma::SFR_RXF2, foo); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_RXF2_FDOUT); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_RXF2_FDOUT, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_RXF2_FDOUT, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_RXF2_FDOUT, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_RXF2_FDOUT, baz); - - let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_RXF3); - bio_bdma_csr.wo(utra::bio_bdma::SFR_RXF3, foo); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_RXF3_FDOUT); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_RXF3_FDOUT, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_RXF3_FDOUT, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_RXF3_FDOUT, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_RXF3_FDOUT, baz); - - let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_ELEVEL); - bio_bdma_csr.wo(utra::bio_bdma::SFR_ELEVEL, foo); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL0); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL0, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL0, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL0, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL0, baz); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL1); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL1, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL1, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL1, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL1, baz); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL2); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL2, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL2, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL2, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL2, baz); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL3); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL3, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL3, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL3, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL3, baz); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL4); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL4, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL4, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL4, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL4, baz); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL5); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL5, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL5, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL5, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL5, baz); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL6); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL6, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL6, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL6, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL6, baz); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL7); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL7, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL7, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL7, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL7, baz); - - let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_ETYPE); - bio_bdma_csr.wo(utra::bio_bdma::SFR_ETYPE, foo); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_ETYPE_FIFO_EVENT_LT_MASK); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_ETYPE_FIFO_EVENT_LT_MASK, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_ETYPE_FIFO_EVENT_LT_MASK, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_ETYPE_FIFO_EVENT_LT_MASK, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_ETYPE_FIFO_EVENT_LT_MASK, baz); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_ETYPE_FIFO_EVENT_EQ_MASK); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_ETYPE_FIFO_EVENT_EQ_MASK, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_ETYPE_FIFO_EVENT_EQ_MASK, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_ETYPE_FIFO_EVENT_EQ_MASK, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_ETYPE_FIFO_EVENT_EQ_MASK, baz); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_ETYPE_FIFO_EVENT_GT_MASK); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_ETYPE_FIFO_EVENT_GT_MASK, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_ETYPE_FIFO_EVENT_GT_MASK, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_ETYPE_FIFO_EVENT_GT_MASK, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_ETYPE_FIFO_EVENT_GT_MASK, baz); - - let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_EVENT_SET); - bio_bdma_csr.wo(utra::bio_bdma::SFR_EVENT_SET, foo); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_EVENT_SET_SFR_EVENT_SET); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_EVENT_SET_SFR_EVENT_SET, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_EVENT_SET_SFR_EVENT_SET, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_EVENT_SET_SFR_EVENT_SET, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_EVENT_SET_SFR_EVENT_SET, baz); - - let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_EVENT_CLR); - bio_bdma_csr.wo(utra::bio_bdma::SFR_EVENT_CLR, foo); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_EVENT_CLR_SFR_EVENT_CLR); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_EVENT_CLR_SFR_EVENT_CLR, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_EVENT_CLR_SFR_EVENT_CLR, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_EVENT_CLR_SFR_EVENT_CLR, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_EVENT_CLR_SFR_EVENT_CLR, baz); - - let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_EVENT_STATUS); - bio_bdma_csr.wo(utra::bio_bdma::SFR_EVENT_STATUS, foo); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_EVENT_STATUS_SFR_EVENT_STATUS); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_EVENT_STATUS_SFR_EVENT_STATUS, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_EVENT_STATUS_SFR_EVENT_STATUS, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_EVENT_STATUS_SFR_EVENT_STATUS, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_EVENT_STATUS_SFR_EVENT_STATUS, baz); - - let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_EXTCLOCK); - bio_bdma_csr.wo(utra::bio_bdma::SFR_EXTCLOCK, foo); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_EXTCLOCK_USE_EXTCLK); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_EXTCLOCK_USE_EXTCLK, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_EXTCLOCK_USE_EXTCLK, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_EXTCLOCK_USE_EXTCLK, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_EXTCLOCK_USE_EXTCLK, baz); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_EXTCLOCK_EXTCLK_GPIO_0); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_EXTCLOCK_EXTCLK_GPIO_0, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_EXTCLOCK_EXTCLK_GPIO_0, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_EXTCLOCK_EXTCLK_GPIO_0, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_EXTCLOCK_EXTCLK_GPIO_0, baz); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_EXTCLOCK_EXTCLK_GPIO_1); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_EXTCLOCK_EXTCLK_GPIO_1, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_EXTCLOCK_EXTCLK_GPIO_1, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_EXTCLOCK_EXTCLK_GPIO_1, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_EXTCLOCK_EXTCLK_GPIO_1, baz); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_EXTCLOCK_EXTCLK_GPIO_2); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_EXTCLOCK_EXTCLK_GPIO_2, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_EXTCLOCK_EXTCLK_GPIO_2, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_EXTCLOCK_EXTCLK_GPIO_2, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_EXTCLOCK_EXTCLK_GPIO_2, baz); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_EXTCLOCK_EXTCLK_GPIO_3); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_EXTCLOCK_EXTCLK_GPIO_3, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_EXTCLOCK_EXTCLK_GPIO_3, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_EXTCLOCK_EXTCLK_GPIO_3, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_EXTCLOCK_EXTCLK_GPIO_3, baz); - - let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_FIFO_CLR); - bio_bdma_csr.wo(utra::bio_bdma::SFR_FIFO_CLR, foo); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_FIFO_CLR_SFR_FIFO_CLR); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_FIFO_CLR_SFR_FIFO_CLR, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_FIFO_CLR_SFR_FIFO_CLR, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_FIFO_CLR_SFR_FIFO_CLR, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_FIFO_CLR_SFR_FIFO_CLR, baz); - - let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_QDIV0); - bio_bdma_csr.wo(utra::bio_bdma::SFR_QDIV0, foo); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_QDIV0_UNUSED_DIV); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_QDIV0_UNUSED_DIV, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_QDIV0_UNUSED_DIV, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_QDIV0_UNUSED_DIV, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_QDIV0_UNUSED_DIV, baz); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_QDIV0_DIV_FRAC); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_QDIV0_DIV_FRAC, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_QDIV0_DIV_FRAC, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_QDIV0_DIV_FRAC, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_QDIV0_DIV_FRAC, baz); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_QDIV0_DIV_INT); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_QDIV0_DIV_INT, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_QDIV0_DIV_INT, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_QDIV0_DIV_INT, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_QDIV0_DIV_INT, baz); - - let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_QDIV1); - bio_bdma_csr.wo(utra::bio_bdma::SFR_QDIV1, foo); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_QDIV1_UNUSED_DIV); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_QDIV1_UNUSED_DIV, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_QDIV1_UNUSED_DIV, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_QDIV1_UNUSED_DIV, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_QDIV1_UNUSED_DIV, baz); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_QDIV1_DIV_FRAC); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_QDIV1_DIV_FRAC, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_QDIV1_DIV_FRAC, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_QDIV1_DIV_FRAC, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_QDIV1_DIV_FRAC, baz); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_QDIV1_DIV_INT); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_QDIV1_DIV_INT, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_QDIV1_DIV_INT, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_QDIV1_DIV_INT, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_QDIV1_DIV_INT, baz); - - let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_QDIV2); - bio_bdma_csr.wo(utra::bio_bdma::SFR_QDIV2, foo); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_QDIV2_UNUSED_DIV); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_QDIV2_UNUSED_DIV, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_QDIV2_UNUSED_DIV, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_QDIV2_UNUSED_DIV, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_QDIV2_UNUSED_DIV, baz); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_QDIV2_DIV_FRAC); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_QDIV2_DIV_FRAC, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_QDIV2_DIV_FRAC, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_QDIV2_DIV_FRAC, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_QDIV2_DIV_FRAC, baz); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_QDIV2_DIV_INT); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_QDIV2_DIV_INT, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_QDIV2_DIV_INT, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_QDIV2_DIV_INT, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_QDIV2_DIV_INT, baz); - - let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_QDIV3); - bio_bdma_csr.wo(utra::bio_bdma::SFR_QDIV3, foo); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_QDIV3_UNUSED_DIV); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_QDIV3_UNUSED_DIV, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_QDIV3_UNUSED_DIV, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_QDIV3_UNUSED_DIV, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_QDIV3_UNUSED_DIV, baz); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_QDIV3_DIV_FRAC); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_QDIV3_DIV_FRAC, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_QDIV3_DIV_FRAC, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_QDIV3_DIV_FRAC, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_QDIV3_DIV_FRAC, baz); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_QDIV3_DIV_INT); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_QDIV3_DIV_INT, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_QDIV3_DIV_INT, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_QDIV3_DIV_INT, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_QDIV3_DIV_INT, baz); - - let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_SYNC_BYPASS); - bio_bdma_csr.wo(utra::bio_bdma::SFR_SYNC_BYPASS, foo); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_SYNC_BYPASS_SFR_SYNC_BYPASS); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_SYNC_BYPASS_SFR_SYNC_BYPASS, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_SYNC_BYPASS_SFR_SYNC_BYPASS, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_SYNC_BYPASS_SFR_SYNC_BYPASS, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_SYNC_BYPASS_SFR_SYNC_BYPASS, baz); - - let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_IO_OE_INV); - bio_bdma_csr.wo(utra::bio_bdma::SFR_IO_OE_INV, foo); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_IO_OE_INV_SFR_IO_OE_INV); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_IO_OE_INV_SFR_IO_OE_INV, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_IO_OE_INV_SFR_IO_OE_INV, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_IO_OE_INV_SFR_IO_OE_INV, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_IO_OE_INV_SFR_IO_OE_INV, baz); - - let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_IO_O_INV); - bio_bdma_csr.wo(utra::bio_bdma::SFR_IO_O_INV, foo); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_IO_O_INV_SFR_IO_O_INV); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_IO_O_INV_SFR_IO_O_INV, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_IO_O_INV_SFR_IO_O_INV, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_IO_O_INV_SFR_IO_O_INV, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_IO_O_INV_SFR_IO_O_INV, baz); - - let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_IO_I_INV); - bio_bdma_csr.wo(utra::bio_bdma::SFR_IO_I_INV, foo); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_IO_I_INV_SFR_IO_I_INV); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_IO_I_INV_SFR_IO_I_INV, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_IO_I_INV_SFR_IO_I_INV, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_IO_I_INV_SFR_IO_I_INV, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_IO_I_INV_SFR_IO_I_INV, baz); - - let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_IRQMASK_0); - bio_bdma_csr.wo(utra::bio_bdma::SFR_IRQMASK_0, foo); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_IRQMASK_0_SFR_IRQMASK_0); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_IRQMASK_0_SFR_IRQMASK_0, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_IRQMASK_0_SFR_IRQMASK_0, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_IRQMASK_0_SFR_IRQMASK_0, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_IRQMASK_0_SFR_IRQMASK_0, baz); - - let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_IRQMASK_1); - bio_bdma_csr.wo(utra::bio_bdma::SFR_IRQMASK_1, foo); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_IRQMASK_1_SFR_IRQMASK_1); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_IRQMASK_1_SFR_IRQMASK_1, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_IRQMASK_1_SFR_IRQMASK_1, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_IRQMASK_1_SFR_IRQMASK_1, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_IRQMASK_1_SFR_IRQMASK_1, baz); - - let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_IRQMASK_2); - bio_bdma_csr.wo(utra::bio_bdma::SFR_IRQMASK_2, foo); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_IRQMASK_2_SFR_IRQMASK_2); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_IRQMASK_2_SFR_IRQMASK_2, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_IRQMASK_2_SFR_IRQMASK_2, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_IRQMASK_2_SFR_IRQMASK_2, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_IRQMASK_2_SFR_IRQMASK_2, baz); - - let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_IRQMASK_3); - bio_bdma_csr.wo(utra::bio_bdma::SFR_IRQMASK_3, foo); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_IRQMASK_3_SFR_IRQMASK_3); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_IRQMASK_3_SFR_IRQMASK_3, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_IRQMASK_3_SFR_IRQMASK_3, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_IRQMASK_3_SFR_IRQMASK_3, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_IRQMASK_3_SFR_IRQMASK_3, baz); - - let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_IRQ_EDGE); - bio_bdma_csr.wo(utra::bio_bdma::SFR_IRQ_EDGE, foo); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_IRQ_EDGE_SFR_IRQ_EDGE); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_IRQ_EDGE_SFR_IRQ_EDGE, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_IRQ_EDGE_SFR_IRQ_EDGE, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_IRQ_EDGE_SFR_IRQ_EDGE, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_IRQ_EDGE_SFR_IRQ_EDGE, baz); - - let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_DBG_PADOUT); - bio_bdma_csr.wo(utra::bio_bdma::SFR_DBG_PADOUT, foo); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_DBG_PADOUT_SFR_DBG_PADOUT); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_DBG_PADOUT_SFR_DBG_PADOUT, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_DBG_PADOUT_SFR_DBG_PADOUT, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_DBG_PADOUT_SFR_DBG_PADOUT, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_DBG_PADOUT_SFR_DBG_PADOUT, baz); - - let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_DBG_PADOE); - bio_bdma_csr.wo(utra::bio_bdma::SFR_DBG_PADOE, foo); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_DBG_PADOE_SFR_DBG_PADOE); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_DBG_PADOE_SFR_DBG_PADOE, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_DBG_PADOE_SFR_DBG_PADOE, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_DBG_PADOE_SFR_DBG_PADOE, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_DBG_PADOE_SFR_DBG_PADOE, baz); - - let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_DBG0); - bio_bdma_csr.wo(utra::bio_bdma::SFR_DBG0, foo); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_DBG0_DBG_PC); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_DBG0_DBG_PC, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_DBG0_DBG_PC, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_DBG0_DBG_PC, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_DBG0_DBG_PC, baz); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_DBG0_TRAP); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_DBG0_TRAP, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_DBG0_TRAP, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_DBG0_TRAP, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_DBG0_TRAP, baz); - - let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_DBG1); - bio_bdma_csr.wo(utra::bio_bdma::SFR_DBG1, foo); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_DBG1_DBG_PC); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_DBG1_DBG_PC, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_DBG1_DBG_PC, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_DBG1_DBG_PC, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_DBG1_DBG_PC, baz); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_DBG1_TRAP); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_DBG1_TRAP, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_DBG1_TRAP, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_DBG1_TRAP, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_DBG1_TRAP, baz); - - let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_DBG2); - bio_bdma_csr.wo(utra::bio_bdma::SFR_DBG2, foo); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_DBG2_DBG_PC); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_DBG2_DBG_PC, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_DBG2_DBG_PC, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_DBG2_DBG_PC, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_DBG2_DBG_PC, baz); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_DBG2_TRAP); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_DBG2_TRAP, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_DBG2_TRAP, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_DBG2_TRAP, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_DBG2_TRAP, baz); - - let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_DBG3); - bio_bdma_csr.wo(utra::bio_bdma::SFR_DBG3, foo); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_DBG3_DBG_PC); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_DBG3_DBG_PC, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_DBG3_DBG_PC, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_DBG3_DBG_PC, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_DBG3_DBG_PC, baz); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_DBG3_TRAP); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_DBG3_TRAP, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_DBG3_TRAP, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_DBG3_TRAP, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_DBG3_TRAP, baz); - - let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_MEM_GUTTER); - bio_bdma_csr.wo(utra::bio_bdma::SFR_MEM_GUTTER, foo); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_MEM_GUTTER_SFR_MEM_GUTTER); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_MEM_GUTTER_SFR_MEM_GUTTER, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_MEM_GUTTER_SFR_MEM_GUTTER, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_MEM_GUTTER_SFR_MEM_GUTTER, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_MEM_GUTTER_SFR_MEM_GUTTER, baz); - - let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_PERI_GUTTER); - bio_bdma_csr.wo(utra::bio_bdma::SFR_PERI_GUTTER, foo); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_PERI_GUTTER_SFR_PERI_GUTTER); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_PERI_GUTTER_SFR_PERI_GUTTER, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_PERI_GUTTER_SFR_PERI_GUTTER, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_PERI_GUTTER_SFR_PERI_GUTTER, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_PERI_GUTTER_SFR_PERI_GUTTER, baz); - - let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP0); - bio_bdma_csr.wo(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP0, foo); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP0_CR_EVMAP0); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP0_CR_EVMAP0, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP0_CR_EVMAP0, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP0_CR_EVMAP0, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP0_CR_EVMAP0, baz); - - let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP1); - bio_bdma_csr.wo(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP1, foo); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP1_CR_EVMAP1); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP1_CR_EVMAP1, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP1_CR_EVMAP1, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP1_CR_EVMAP1, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP1_CR_EVMAP1, baz); - - let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP2); - bio_bdma_csr.wo(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP2, foo); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP2_CR_EVMAP2); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP2_CR_EVMAP2, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP2_CR_EVMAP2, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP2_CR_EVMAP2, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP2_CR_EVMAP2, baz); - - let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP3); - bio_bdma_csr.wo(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP3, foo); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP3_CR_EVMAP3); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP3_CR_EVMAP3, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP3_CR_EVMAP3, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP3_CR_EVMAP3, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP3_CR_EVMAP3, baz); - - let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP4); - bio_bdma_csr.wo(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP4, foo); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP4_CR_EVMAP4); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP4_CR_EVMAP4, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP4_CR_EVMAP4, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP4_CR_EVMAP4, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP4_CR_EVMAP4, baz); - - let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP5); - bio_bdma_csr.wo(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP5, foo); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP5_CR_EVMAP5); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP5_CR_EVMAP5, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP5_CR_EVMAP5, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP5_CR_EVMAP5, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_DMAREQ_MAP_CR_EVMAP5_CR_EVMAP5, baz); - - let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT0); - bio_bdma_csr.wo(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT0, foo); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT0_SR_EVSTAT0); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT0_SR_EVSTAT0, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT0_SR_EVSTAT0, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT0_SR_EVSTAT0, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT0_SR_EVSTAT0, baz); - - let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT1); - bio_bdma_csr.wo(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT1, foo); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT1_SR_EVSTAT1); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT1_SR_EVSTAT1, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT1_SR_EVSTAT1, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT1_SR_EVSTAT1, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT1_SR_EVSTAT1, baz); - - let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT2); - bio_bdma_csr.wo(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT2, foo); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT2_SR_EVSTAT2); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT2_SR_EVSTAT2, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT2_SR_EVSTAT2, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT2_SR_EVSTAT2, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT2_SR_EVSTAT2, baz); - - let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT3); - bio_bdma_csr.wo(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT3, foo); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT3_SR_EVSTAT3); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT3_SR_EVSTAT3, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT3_SR_EVSTAT3, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT3_SR_EVSTAT3, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT3_SR_EVSTAT3, baz); - - let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT4); - bio_bdma_csr.wo(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT4, foo); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT4_SR_EVSTAT4); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT4_SR_EVSTAT4, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT4_SR_EVSTAT4, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT4_SR_EVSTAT4, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT4_SR_EVSTAT4, baz); - - let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT5); - bio_bdma_csr.wo(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT5, foo); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT5_SR_EVSTAT5); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT5_SR_EVSTAT5, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT5_SR_EVSTAT5, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT5_SR_EVSTAT5, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_DMAREQ_STAT_SR_EVSTAT5_SR_EVSTAT5, baz); - - let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_FILTER_BASE_0); - bio_bdma_csr.wo(utra::bio_bdma::SFR_FILTER_BASE_0, foo); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_FILTER_BASE_0_FILTER_BASE); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_FILTER_BASE_0_FILTER_BASE, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_FILTER_BASE_0_FILTER_BASE, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_FILTER_BASE_0_FILTER_BASE, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_FILTER_BASE_0_FILTER_BASE, baz); - - let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_FILTER_BOUNDS_0); - bio_bdma_csr.wo(utra::bio_bdma::SFR_FILTER_BOUNDS_0, foo); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_FILTER_BOUNDS_0_FILTER_BOUNDS); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_FILTER_BOUNDS_0_FILTER_BOUNDS, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_FILTER_BOUNDS_0_FILTER_BOUNDS, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_FILTER_BOUNDS_0_FILTER_BOUNDS, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_FILTER_BOUNDS_0_FILTER_BOUNDS, baz); - - let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_FILTER_BASE_1); - bio_bdma_csr.wo(utra::bio_bdma::SFR_FILTER_BASE_1, foo); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_FILTER_BASE_1_FILTER_BASE); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_FILTER_BASE_1_FILTER_BASE, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_FILTER_BASE_1_FILTER_BASE, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_FILTER_BASE_1_FILTER_BASE, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_FILTER_BASE_1_FILTER_BASE, baz); - - let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_FILTER_BOUNDS_1); - bio_bdma_csr.wo(utra::bio_bdma::SFR_FILTER_BOUNDS_1, foo); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_FILTER_BOUNDS_1_FILTER_BOUNDS); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_FILTER_BOUNDS_1_FILTER_BOUNDS, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_FILTER_BOUNDS_1_FILTER_BOUNDS, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_FILTER_BOUNDS_1_FILTER_BOUNDS, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_FILTER_BOUNDS_1_FILTER_BOUNDS, baz); - - let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_FILTER_BASE_2); - bio_bdma_csr.wo(utra::bio_bdma::SFR_FILTER_BASE_2, foo); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_FILTER_BASE_2_FILTER_BASE); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_FILTER_BASE_2_FILTER_BASE, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_FILTER_BASE_2_FILTER_BASE, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_FILTER_BASE_2_FILTER_BASE, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_FILTER_BASE_2_FILTER_BASE, baz); - - let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_FILTER_BOUNDS_2); - bio_bdma_csr.wo(utra::bio_bdma::SFR_FILTER_BOUNDS_2, foo); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_FILTER_BOUNDS_2_FILTER_BOUNDS); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_FILTER_BOUNDS_2_FILTER_BOUNDS, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_FILTER_BOUNDS_2_FILTER_BOUNDS, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_FILTER_BOUNDS_2_FILTER_BOUNDS, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_FILTER_BOUNDS_2_FILTER_BOUNDS, baz); - - let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_FILTER_BASE_3); - bio_bdma_csr.wo(utra::bio_bdma::SFR_FILTER_BASE_3, foo); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_FILTER_BASE_3_FILTER_BASE); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_FILTER_BASE_3_FILTER_BASE, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_FILTER_BASE_3_FILTER_BASE, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_FILTER_BASE_3_FILTER_BASE, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_FILTER_BASE_3_FILTER_BASE, baz); - - let foo = bio_bdma_csr.r(utra::bio_bdma::SFR_FILTER_BOUNDS_3); - bio_bdma_csr.wo(utra::bio_bdma::SFR_FILTER_BOUNDS_3, foo); - let bar = bio_bdma_csr.rf(utra::bio_bdma::SFR_FILTER_BOUNDS_3_FILTER_BOUNDS); - bio_bdma_csr.rmwf(utra::bio_bdma::SFR_FILTER_BOUNDS_3_FILTER_BOUNDS, bar); - let mut baz = bio_bdma_csr.zf(utra::bio_bdma::SFR_FILTER_BOUNDS_3_FILTER_BOUNDS, bar); - baz |= bio_bdma_csr.ms(utra::bio_bdma::SFR_FILTER_BOUNDS_3_FILTER_BOUNDS, 1); - bio_bdma_csr.wfo(utra::bio_bdma::SFR_FILTER_BOUNDS_3_FILTER_BOUNDS, baz); - } - - #[test] - #[ignore] - fn compile_check_coresub_sramtrm_csr() { - use super::*; - let mut coresub_sramtrm_csr = CSR::new(HW_CORESUB_SRAMTRM_BASE as *mut u32); - - let foo = coresub_sramtrm_csr.r(utra::coresub_sramtrm::SFR_CACHE); - coresub_sramtrm_csr.wo(utra::coresub_sramtrm::SFR_CACHE, foo); - let bar = coresub_sramtrm_csr.rf(utra::coresub_sramtrm::SFR_CACHE_SFR_CACHE); - coresub_sramtrm_csr.rmwf(utra::coresub_sramtrm::SFR_CACHE_SFR_CACHE, bar); - let mut baz = coresub_sramtrm_csr.zf(utra::coresub_sramtrm::SFR_CACHE_SFR_CACHE, bar); - baz |= coresub_sramtrm_csr.ms(utra::coresub_sramtrm::SFR_CACHE_SFR_CACHE, 1); - coresub_sramtrm_csr.wfo(utra::coresub_sramtrm::SFR_CACHE_SFR_CACHE, baz); - - let foo = coresub_sramtrm_csr.r(utra::coresub_sramtrm::SFR_ITCM); - coresub_sramtrm_csr.wo(utra::coresub_sramtrm::SFR_ITCM, foo); - let bar = coresub_sramtrm_csr.rf(utra::coresub_sramtrm::SFR_ITCM_SFR_ITCM); - coresub_sramtrm_csr.rmwf(utra::coresub_sramtrm::SFR_ITCM_SFR_ITCM, bar); - let mut baz = coresub_sramtrm_csr.zf(utra::coresub_sramtrm::SFR_ITCM_SFR_ITCM, bar); - baz |= coresub_sramtrm_csr.ms(utra::coresub_sramtrm::SFR_ITCM_SFR_ITCM, 1); - coresub_sramtrm_csr.wfo(utra::coresub_sramtrm::SFR_ITCM_SFR_ITCM, baz); - - let foo = coresub_sramtrm_csr.r(utra::coresub_sramtrm::SFR_DTCM); - coresub_sramtrm_csr.wo(utra::coresub_sramtrm::SFR_DTCM, foo); - let bar = coresub_sramtrm_csr.rf(utra::coresub_sramtrm::SFR_DTCM_SFR_DTCM); - coresub_sramtrm_csr.rmwf(utra::coresub_sramtrm::SFR_DTCM_SFR_DTCM, bar); - let mut baz = coresub_sramtrm_csr.zf(utra::coresub_sramtrm::SFR_DTCM_SFR_DTCM, bar); - baz |= coresub_sramtrm_csr.ms(utra::coresub_sramtrm::SFR_DTCM_SFR_DTCM, 1); - coresub_sramtrm_csr.wfo(utra::coresub_sramtrm::SFR_DTCM_SFR_DTCM, baz); - - let foo = coresub_sramtrm_csr.r(utra::coresub_sramtrm::SFR_SRAM0); - coresub_sramtrm_csr.wo(utra::coresub_sramtrm::SFR_SRAM0, foo); - let bar = coresub_sramtrm_csr.rf(utra::coresub_sramtrm::SFR_SRAM0_SFR_SRAM0); - coresub_sramtrm_csr.rmwf(utra::coresub_sramtrm::SFR_SRAM0_SFR_SRAM0, bar); - let mut baz = coresub_sramtrm_csr.zf(utra::coresub_sramtrm::SFR_SRAM0_SFR_SRAM0, bar); - baz |= coresub_sramtrm_csr.ms(utra::coresub_sramtrm::SFR_SRAM0_SFR_SRAM0, 1); - coresub_sramtrm_csr.wfo(utra::coresub_sramtrm::SFR_SRAM0_SFR_SRAM0, baz); - - let foo = coresub_sramtrm_csr.r(utra::coresub_sramtrm::SFR_SRAM1); - coresub_sramtrm_csr.wo(utra::coresub_sramtrm::SFR_SRAM1, foo); - let bar = coresub_sramtrm_csr.rf(utra::coresub_sramtrm::SFR_SRAM1_SFR_SRAM1); - coresub_sramtrm_csr.rmwf(utra::coresub_sramtrm::SFR_SRAM1_SFR_SRAM1, bar); - let mut baz = coresub_sramtrm_csr.zf(utra::coresub_sramtrm::SFR_SRAM1_SFR_SRAM1, bar); - baz |= coresub_sramtrm_csr.ms(utra::coresub_sramtrm::SFR_SRAM1_SFR_SRAM1, 1); - coresub_sramtrm_csr.wfo(utra::coresub_sramtrm::SFR_SRAM1_SFR_SRAM1, baz); - - let foo = coresub_sramtrm_csr.r(utra::coresub_sramtrm::SFR_VEXRAM); - coresub_sramtrm_csr.wo(utra::coresub_sramtrm::SFR_VEXRAM, foo); - let bar = coresub_sramtrm_csr.rf(utra::coresub_sramtrm::SFR_VEXRAM_SFR_VEXRAM); - coresub_sramtrm_csr.rmwf(utra::coresub_sramtrm::SFR_VEXRAM_SFR_VEXRAM, bar); - let mut baz = coresub_sramtrm_csr.zf(utra::coresub_sramtrm::SFR_VEXRAM_SFR_VEXRAM, bar); - baz |= coresub_sramtrm_csr.ms(utra::coresub_sramtrm::SFR_VEXRAM_SFR_VEXRAM, 1); - coresub_sramtrm_csr.wfo(utra::coresub_sramtrm::SFR_VEXRAM_SFR_VEXRAM, baz); - - let foo = coresub_sramtrm_csr.r(utra::coresub_sramtrm::SFR_SRAMERR); - coresub_sramtrm_csr.wo(utra::coresub_sramtrm::SFR_SRAMERR, foo); - let bar = coresub_sramtrm_csr.rf(utra::coresub_sramtrm::SFR_SRAMERR_SRAMBANKERR); - coresub_sramtrm_csr.rmwf(utra::coresub_sramtrm::SFR_SRAMERR_SRAMBANKERR, bar); - let mut baz = coresub_sramtrm_csr.zf(utra::coresub_sramtrm::SFR_SRAMERR_SRAMBANKERR, bar); - baz |= coresub_sramtrm_csr.ms(utra::coresub_sramtrm::SFR_SRAMERR_SRAMBANKERR, 1); - coresub_sramtrm_csr.wfo(utra::coresub_sramtrm::SFR_SRAMERR_SRAMBANKERR, baz); - } - - #[test] - #[ignore] - fn compile_check_mdma_csr() { - use super::*; - let mut mdma_csr = CSR::new(HW_MDMA_BASE as *mut u32); - - let foo = mdma_csr.r(utra::mdma::SFR_EVSEL_CR_EVSEL0); - mdma_csr.wo(utra::mdma::SFR_EVSEL_CR_EVSEL0, foo); - let bar = mdma_csr.rf(utra::mdma::SFR_EVSEL_CR_EVSEL0_CR_EVSEL0); - mdma_csr.rmwf(utra::mdma::SFR_EVSEL_CR_EVSEL0_CR_EVSEL0, bar); - let mut baz = mdma_csr.zf(utra::mdma::SFR_EVSEL_CR_EVSEL0_CR_EVSEL0, bar); - baz |= mdma_csr.ms(utra::mdma::SFR_EVSEL_CR_EVSEL0_CR_EVSEL0, 1); - mdma_csr.wfo(utra::mdma::SFR_EVSEL_CR_EVSEL0_CR_EVSEL0, baz); - - let foo = mdma_csr.r(utra::mdma::SFR_EVSEL_CR_EVSEL1); - mdma_csr.wo(utra::mdma::SFR_EVSEL_CR_EVSEL1, foo); - let bar = mdma_csr.rf(utra::mdma::SFR_EVSEL_CR_EVSEL1_CR_EVSEL1); - mdma_csr.rmwf(utra::mdma::SFR_EVSEL_CR_EVSEL1_CR_EVSEL1, bar); - let mut baz = mdma_csr.zf(utra::mdma::SFR_EVSEL_CR_EVSEL1_CR_EVSEL1, bar); - baz |= mdma_csr.ms(utra::mdma::SFR_EVSEL_CR_EVSEL1_CR_EVSEL1, 1); - mdma_csr.wfo(utra::mdma::SFR_EVSEL_CR_EVSEL1_CR_EVSEL1, baz); - - let foo = mdma_csr.r(utra::mdma::SFR_EVSEL_CR_EVSEL2); - mdma_csr.wo(utra::mdma::SFR_EVSEL_CR_EVSEL2, foo); - let bar = mdma_csr.rf(utra::mdma::SFR_EVSEL_CR_EVSEL2_CR_EVSEL2); - mdma_csr.rmwf(utra::mdma::SFR_EVSEL_CR_EVSEL2_CR_EVSEL2, bar); - let mut baz = mdma_csr.zf(utra::mdma::SFR_EVSEL_CR_EVSEL2_CR_EVSEL2, bar); - baz |= mdma_csr.ms(utra::mdma::SFR_EVSEL_CR_EVSEL2_CR_EVSEL2, 1); - mdma_csr.wfo(utra::mdma::SFR_EVSEL_CR_EVSEL2_CR_EVSEL2, baz); - - let foo = mdma_csr.r(utra::mdma::SFR_EVSEL_CR_EVSEL3); - mdma_csr.wo(utra::mdma::SFR_EVSEL_CR_EVSEL3, foo); - let bar = mdma_csr.rf(utra::mdma::SFR_EVSEL_CR_EVSEL3_CR_EVSEL3); - mdma_csr.rmwf(utra::mdma::SFR_EVSEL_CR_EVSEL3_CR_EVSEL3, bar); - let mut baz = mdma_csr.zf(utra::mdma::SFR_EVSEL_CR_EVSEL3_CR_EVSEL3, bar); - baz |= mdma_csr.ms(utra::mdma::SFR_EVSEL_CR_EVSEL3_CR_EVSEL3, 1); - mdma_csr.wfo(utra::mdma::SFR_EVSEL_CR_EVSEL3_CR_EVSEL3, baz); - - let foo = mdma_csr.r(utra::mdma::SFR_EVSEL_CR_EVSEL4); - mdma_csr.wo(utra::mdma::SFR_EVSEL_CR_EVSEL4, foo); - let bar = mdma_csr.rf(utra::mdma::SFR_EVSEL_CR_EVSEL4_CR_EVSEL4); - mdma_csr.rmwf(utra::mdma::SFR_EVSEL_CR_EVSEL4_CR_EVSEL4, bar); - let mut baz = mdma_csr.zf(utra::mdma::SFR_EVSEL_CR_EVSEL4_CR_EVSEL4, bar); - baz |= mdma_csr.ms(utra::mdma::SFR_EVSEL_CR_EVSEL4_CR_EVSEL4, 1); - mdma_csr.wfo(utra::mdma::SFR_EVSEL_CR_EVSEL4_CR_EVSEL4, baz); - - let foo = mdma_csr.r(utra::mdma::SFR_EVSEL_CR_EVSEL5); - mdma_csr.wo(utra::mdma::SFR_EVSEL_CR_EVSEL5, foo); - let bar = mdma_csr.rf(utra::mdma::SFR_EVSEL_CR_EVSEL5_CR_EVSEL5); - mdma_csr.rmwf(utra::mdma::SFR_EVSEL_CR_EVSEL5_CR_EVSEL5, bar); - let mut baz = mdma_csr.zf(utra::mdma::SFR_EVSEL_CR_EVSEL5_CR_EVSEL5, bar); - baz |= mdma_csr.ms(utra::mdma::SFR_EVSEL_CR_EVSEL5_CR_EVSEL5, 1); - mdma_csr.wfo(utra::mdma::SFR_EVSEL_CR_EVSEL5_CR_EVSEL5, baz); - - let foo = mdma_csr.r(utra::mdma::SFR_EVSEL_CR_EVSEL6); - mdma_csr.wo(utra::mdma::SFR_EVSEL_CR_EVSEL6, foo); - let bar = mdma_csr.rf(utra::mdma::SFR_EVSEL_CR_EVSEL6_CR_EVSEL6); - mdma_csr.rmwf(utra::mdma::SFR_EVSEL_CR_EVSEL6_CR_EVSEL6, bar); - let mut baz = mdma_csr.zf(utra::mdma::SFR_EVSEL_CR_EVSEL6_CR_EVSEL6, bar); - baz |= mdma_csr.ms(utra::mdma::SFR_EVSEL_CR_EVSEL6_CR_EVSEL6, 1); - mdma_csr.wfo(utra::mdma::SFR_EVSEL_CR_EVSEL6_CR_EVSEL6, baz); - - let foo = mdma_csr.r(utra::mdma::SFR_EVSEL_CR_EVSEL7); - mdma_csr.wo(utra::mdma::SFR_EVSEL_CR_EVSEL7, foo); - let bar = mdma_csr.rf(utra::mdma::SFR_EVSEL_CR_EVSEL7_CR_EVSEL7); - mdma_csr.rmwf(utra::mdma::SFR_EVSEL_CR_EVSEL7_CR_EVSEL7, bar); - let mut baz = mdma_csr.zf(utra::mdma::SFR_EVSEL_CR_EVSEL7_CR_EVSEL7, bar); - baz |= mdma_csr.ms(utra::mdma::SFR_EVSEL_CR_EVSEL7_CR_EVSEL7, 1); - mdma_csr.wfo(utra::mdma::SFR_EVSEL_CR_EVSEL7_CR_EVSEL7, baz); - - let foo = mdma_csr.r(utra::mdma::SFR_CR_CR_MDMAREQ0); - mdma_csr.wo(utra::mdma::SFR_CR_CR_MDMAREQ0, foo); - let bar = mdma_csr.rf(utra::mdma::SFR_CR_CR_MDMAREQ0_CR_MDMAREQ0); - mdma_csr.rmwf(utra::mdma::SFR_CR_CR_MDMAREQ0_CR_MDMAREQ0, bar); - let mut baz = mdma_csr.zf(utra::mdma::SFR_CR_CR_MDMAREQ0_CR_MDMAREQ0, bar); - baz |= mdma_csr.ms(utra::mdma::SFR_CR_CR_MDMAREQ0_CR_MDMAREQ0, 1); - mdma_csr.wfo(utra::mdma::SFR_CR_CR_MDMAREQ0_CR_MDMAREQ0, baz); - - let foo = mdma_csr.r(utra::mdma::SFR_CR_CR_MDMAREQ1); - mdma_csr.wo(utra::mdma::SFR_CR_CR_MDMAREQ1, foo); - let bar = mdma_csr.rf(utra::mdma::SFR_CR_CR_MDMAREQ1_CR_MDMAREQ1); - mdma_csr.rmwf(utra::mdma::SFR_CR_CR_MDMAREQ1_CR_MDMAREQ1, bar); - let mut baz = mdma_csr.zf(utra::mdma::SFR_CR_CR_MDMAREQ1_CR_MDMAREQ1, bar); - baz |= mdma_csr.ms(utra::mdma::SFR_CR_CR_MDMAREQ1_CR_MDMAREQ1, 1); - mdma_csr.wfo(utra::mdma::SFR_CR_CR_MDMAREQ1_CR_MDMAREQ1, baz); - - let foo = mdma_csr.r(utra::mdma::SFR_CR_CR_MDMAREQ2); - mdma_csr.wo(utra::mdma::SFR_CR_CR_MDMAREQ2, foo); - let bar = mdma_csr.rf(utra::mdma::SFR_CR_CR_MDMAREQ2_CR_MDMAREQ2); - mdma_csr.rmwf(utra::mdma::SFR_CR_CR_MDMAREQ2_CR_MDMAREQ2, bar); - let mut baz = mdma_csr.zf(utra::mdma::SFR_CR_CR_MDMAREQ2_CR_MDMAREQ2, bar); - baz |= mdma_csr.ms(utra::mdma::SFR_CR_CR_MDMAREQ2_CR_MDMAREQ2, 1); - mdma_csr.wfo(utra::mdma::SFR_CR_CR_MDMAREQ2_CR_MDMAREQ2, baz); - - let foo = mdma_csr.r(utra::mdma::SFR_CR_CR_MDMAREQ3); - mdma_csr.wo(utra::mdma::SFR_CR_CR_MDMAREQ3, foo); - let bar = mdma_csr.rf(utra::mdma::SFR_CR_CR_MDMAREQ3_CR_MDMAREQ3); - mdma_csr.rmwf(utra::mdma::SFR_CR_CR_MDMAREQ3_CR_MDMAREQ3, bar); - let mut baz = mdma_csr.zf(utra::mdma::SFR_CR_CR_MDMAREQ3_CR_MDMAREQ3, bar); - baz |= mdma_csr.ms(utra::mdma::SFR_CR_CR_MDMAREQ3_CR_MDMAREQ3, 1); - mdma_csr.wfo(utra::mdma::SFR_CR_CR_MDMAREQ3_CR_MDMAREQ3, baz); - - let foo = mdma_csr.r(utra::mdma::SFR_CR_CR_MDMAREQ4); - mdma_csr.wo(utra::mdma::SFR_CR_CR_MDMAREQ4, foo); - let bar = mdma_csr.rf(utra::mdma::SFR_CR_CR_MDMAREQ4_CR_MDMAREQ4); - mdma_csr.rmwf(utra::mdma::SFR_CR_CR_MDMAREQ4_CR_MDMAREQ4, bar); - let mut baz = mdma_csr.zf(utra::mdma::SFR_CR_CR_MDMAREQ4_CR_MDMAREQ4, bar); - baz |= mdma_csr.ms(utra::mdma::SFR_CR_CR_MDMAREQ4_CR_MDMAREQ4, 1); - mdma_csr.wfo(utra::mdma::SFR_CR_CR_MDMAREQ4_CR_MDMAREQ4, baz); - - let foo = mdma_csr.r(utra::mdma::SFR_CR_CR_MDMAREQ5); - mdma_csr.wo(utra::mdma::SFR_CR_CR_MDMAREQ5, foo); - let bar = mdma_csr.rf(utra::mdma::SFR_CR_CR_MDMAREQ5_CR_MDMAREQ5); - mdma_csr.rmwf(utra::mdma::SFR_CR_CR_MDMAREQ5_CR_MDMAREQ5, bar); - let mut baz = mdma_csr.zf(utra::mdma::SFR_CR_CR_MDMAREQ5_CR_MDMAREQ5, bar); - baz |= mdma_csr.ms(utra::mdma::SFR_CR_CR_MDMAREQ5_CR_MDMAREQ5, 1); - mdma_csr.wfo(utra::mdma::SFR_CR_CR_MDMAREQ5_CR_MDMAREQ5, baz); - - let foo = mdma_csr.r(utra::mdma::SFR_CR_CR_MDMAREQ6); - mdma_csr.wo(utra::mdma::SFR_CR_CR_MDMAREQ6, foo); - let bar = mdma_csr.rf(utra::mdma::SFR_CR_CR_MDMAREQ6_CR_MDMAREQ6); - mdma_csr.rmwf(utra::mdma::SFR_CR_CR_MDMAREQ6_CR_MDMAREQ6, bar); - let mut baz = mdma_csr.zf(utra::mdma::SFR_CR_CR_MDMAREQ6_CR_MDMAREQ6, bar); - baz |= mdma_csr.ms(utra::mdma::SFR_CR_CR_MDMAREQ6_CR_MDMAREQ6, 1); - mdma_csr.wfo(utra::mdma::SFR_CR_CR_MDMAREQ6_CR_MDMAREQ6, baz); - - let foo = mdma_csr.r(utra::mdma::SFR_CR_CR_MDMAREQ7); - mdma_csr.wo(utra::mdma::SFR_CR_CR_MDMAREQ7, foo); - let bar = mdma_csr.rf(utra::mdma::SFR_CR_CR_MDMAREQ7_CR_MDMAREQ7); - mdma_csr.rmwf(utra::mdma::SFR_CR_CR_MDMAREQ7_CR_MDMAREQ7, bar); - let mut baz = mdma_csr.zf(utra::mdma::SFR_CR_CR_MDMAREQ7_CR_MDMAREQ7, bar); - baz |= mdma_csr.ms(utra::mdma::SFR_CR_CR_MDMAREQ7_CR_MDMAREQ7, 1); - mdma_csr.wfo(utra::mdma::SFR_CR_CR_MDMAREQ7_CR_MDMAREQ7, baz); - - let foo = mdma_csr.r(utra::mdma::SFR_SR_SR_MDMAREQ0); - mdma_csr.wo(utra::mdma::SFR_SR_SR_MDMAREQ0, foo); - let bar = mdma_csr.rf(utra::mdma::SFR_SR_SR_MDMAREQ0_SR_MDMAREQ0); - mdma_csr.rmwf(utra::mdma::SFR_SR_SR_MDMAREQ0_SR_MDMAREQ0, bar); - let mut baz = mdma_csr.zf(utra::mdma::SFR_SR_SR_MDMAREQ0_SR_MDMAREQ0, bar); - baz |= mdma_csr.ms(utra::mdma::SFR_SR_SR_MDMAREQ0_SR_MDMAREQ0, 1); - mdma_csr.wfo(utra::mdma::SFR_SR_SR_MDMAREQ0_SR_MDMAREQ0, baz); - - let foo = mdma_csr.r(utra::mdma::SFR_SR_SR_MDMAREQ1); - mdma_csr.wo(utra::mdma::SFR_SR_SR_MDMAREQ1, foo); - let bar = mdma_csr.rf(utra::mdma::SFR_SR_SR_MDMAREQ1_SR_MDMAREQ1); - mdma_csr.rmwf(utra::mdma::SFR_SR_SR_MDMAREQ1_SR_MDMAREQ1, bar); - let mut baz = mdma_csr.zf(utra::mdma::SFR_SR_SR_MDMAREQ1_SR_MDMAREQ1, bar); - baz |= mdma_csr.ms(utra::mdma::SFR_SR_SR_MDMAREQ1_SR_MDMAREQ1, 1); - mdma_csr.wfo(utra::mdma::SFR_SR_SR_MDMAREQ1_SR_MDMAREQ1, baz); - - let foo = mdma_csr.r(utra::mdma::SFR_SR_SR_MDMAREQ2); - mdma_csr.wo(utra::mdma::SFR_SR_SR_MDMAREQ2, foo); - let bar = mdma_csr.rf(utra::mdma::SFR_SR_SR_MDMAREQ2_SR_MDMAREQ2); - mdma_csr.rmwf(utra::mdma::SFR_SR_SR_MDMAREQ2_SR_MDMAREQ2, bar); - let mut baz = mdma_csr.zf(utra::mdma::SFR_SR_SR_MDMAREQ2_SR_MDMAREQ2, bar); - baz |= mdma_csr.ms(utra::mdma::SFR_SR_SR_MDMAREQ2_SR_MDMAREQ2, 1); - mdma_csr.wfo(utra::mdma::SFR_SR_SR_MDMAREQ2_SR_MDMAREQ2, baz); - - let foo = mdma_csr.r(utra::mdma::SFR_SR_SR_MDMAREQ3); - mdma_csr.wo(utra::mdma::SFR_SR_SR_MDMAREQ3, foo); - let bar = mdma_csr.rf(utra::mdma::SFR_SR_SR_MDMAREQ3_SR_MDMAREQ3); - mdma_csr.rmwf(utra::mdma::SFR_SR_SR_MDMAREQ3_SR_MDMAREQ3, bar); - let mut baz = mdma_csr.zf(utra::mdma::SFR_SR_SR_MDMAREQ3_SR_MDMAREQ3, bar); - baz |= mdma_csr.ms(utra::mdma::SFR_SR_SR_MDMAREQ3_SR_MDMAREQ3, 1); - mdma_csr.wfo(utra::mdma::SFR_SR_SR_MDMAREQ3_SR_MDMAREQ3, baz); - - let foo = mdma_csr.r(utra::mdma::SFR_SR_SR_MDMAREQ4); - mdma_csr.wo(utra::mdma::SFR_SR_SR_MDMAREQ4, foo); - let bar = mdma_csr.rf(utra::mdma::SFR_SR_SR_MDMAREQ4_SR_MDMAREQ4); - mdma_csr.rmwf(utra::mdma::SFR_SR_SR_MDMAREQ4_SR_MDMAREQ4, bar); - let mut baz = mdma_csr.zf(utra::mdma::SFR_SR_SR_MDMAREQ4_SR_MDMAREQ4, bar); - baz |= mdma_csr.ms(utra::mdma::SFR_SR_SR_MDMAREQ4_SR_MDMAREQ4, 1); - mdma_csr.wfo(utra::mdma::SFR_SR_SR_MDMAREQ4_SR_MDMAREQ4, baz); - - let foo = mdma_csr.r(utra::mdma::SFR_SR_SR_MDMAREQ5); - mdma_csr.wo(utra::mdma::SFR_SR_SR_MDMAREQ5, foo); - let bar = mdma_csr.rf(utra::mdma::SFR_SR_SR_MDMAREQ5_SR_MDMAREQ5); - mdma_csr.rmwf(utra::mdma::SFR_SR_SR_MDMAREQ5_SR_MDMAREQ5, bar); - let mut baz = mdma_csr.zf(utra::mdma::SFR_SR_SR_MDMAREQ5_SR_MDMAREQ5, bar); - baz |= mdma_csr.ms(utra::mdma::SFR_SR_SR_MDMAREQ5_SR_MDMAREQ5, 1); - mdma_csr.wfo(utra::mdma::SFR_SR_SR_MDMAREQ5_SR_MDMAREQ5, baz); - - let foo = mdma_csr.r(utra::mdma::SFR_SR_SR_MDMAREQ6); - mdma_csr.wo(utra::mdma::SFR_SR_SR_MDMAREQ6, foo); - let bar = mdma_csr.rf(utra::mdma::SFR_SR_SR_MDMAREQ6_SR_MDMAREQ6); - mdma_csr.rmwf(utra::mdma::SFR_SR_SR_MDMAREQ6_SR_MDMAREQ6, bar); - let mut baz = mdma_csr.zf(utra::mdma::SFR_SR_SR_MDMAREQ6_SR_MDMAREQ6, bar); - baz |= mdma_csr.ms(utra::mdma::SFR_SR_SR_MDMAREQ6_SR_MDMAREQ6, 1); - mdma_csr.wfo(utra::mdma::SFR_SR_SR_MDMAREQ6_SR_MDMAREQ6, baz); - - let foo = mdma_csr.r(utra::mdma::SFR_SR_SR_MDMAREQ7); - mdma_csr.wo(utra::mdma::SFR_SR_SR_MDMAREQ7, foo); - let bar = mdma_csr.rf(utra::mdma::SFR_SR_SR_MDMAREQ7_SR_MDMAREQ7); - mdma_csr.rmwf(utra::mdma::SFR_SR_SR_MDMAREQ7_SR_MDMAREQ7, bar); - let mut baz = mdma_csr.zf(utra::mdma::SFR_SR_SR_MDMAREQ7_SR_MDMAREQ7, bar); - baz |= mdma_csr.ms(utra::mdma::SFR_SR_SR_MDMAREQ7_SR_MDMAREQ7, 1); - mdma_csr.wfo(utra::mdma::SFR_SR_SR_MDMAREQ7_SR_MDMAREQ7, baz); - } - - #[test] - #[ignore] - fn compile_check_qfc_csr() { - use super::*; - let mut qfc_csr = CSR::new(HW_QFC_BASE as *mut u32); - - let foo = qfc_csr.r(utra::qfc::SFR_IO); - qfc_csr.wo(utra::qfc::SFR_IO, foo); - let bar = qfc_csr.rf(utra::qfc::SFR_IO_SFR_IO); - qfc_csr.rmwf(utra::qfc::SFR_IO_SFR_IO, bar); - let mut baz = qfc_csr.zf(utra::qfc::SFR_IO_SFR_IO, bar); - baz |= qfc_csr.ms(utra::qfc::SFR_IO_SFR_IO, 1); - qfc_csr.wfo(utra::qfc::SFR_IO_SFR_IO, baz); - - let foo = qfc_csr.r(utra::qfc::SFR_AR); - qfc_csr.wo(utra::qfc::SFR_AR, foo); - let bar = qfc_csr.rf(utra::qfc::SFR_AR_SFR_AR); - qfc_csr.rmwf(utra::qfc::SFR_AR_SFR_AR, bar); - let mut baz = qfc_csr.zf(utra::qfc::SFR_AR_SFR_AR, bar); - baz |= qfc_csr.ms(utra::qfc::SFR_AR_SFR_AR, 1); - qfc_csr.wfo(utra::qfc::SFR_AR_SFR_AR, baz); - - let foo = qfc_csr.r(utra::qfc::SFR_IODRV); - qfc_csr.wo(utra::qfc::SFR_IODRV, foo); - let bar = qfc_csr.rf(utra::qfc::SFR_IODRV_PADDRVSEL); - qfc_csr.rmwf(utra::qfc::SFR_IODRV_PADDRVSEL, bar); - let mut baz = qfc_csr.zf(utra::qfc::SFR_IODRV_PADDRVSEL, bar); - baz |= qfc_csr.ms(utra::qfc::SFR_IODRV_PADDRVSEL, 1); - qfc_csr.wfo(utra::qfc::SFR_IODRV_PADDRVSEL, baz); - - let foo = qfc_csr.r(utra::qfc::CR_XIP_ADDRMODE); - qfc_csr.wo(utra::qfc::CR_XIP_ADDRMODE, foo); - let bar = qfc_csr.rf(utra::qfc::CR_XIP_ADDRMODE_CR_XIP_ADDRMODE); - qfc_csr.rmwf(utra::qfc::CR_XIP_ADDRMODE_CR_XIP_ADDRMODE, bar); - let mut baz = qfc_csr.zf(utra::qfc::CR_XIP_ADDRMODE_CR_XIP_ADDRMODE, bar); - baz |= qfc_csr.ms(utra::qfc::CR_XIP_ADDRMODE_CR_XIP_ADDRMODE, 1); - qfc_csr.wfo(utra::qfc::CR_XIP_ADDRMODE_CR_XIP_ADDRMODE, baz); - - let foo = qfc_csr.r(utra::qfc::CR_XIP_OPCODE); - qfc_csr.wo(utra::qfc::CR_XIP_OPCODE, foo); - let bar = qfc_csr.rf(utra::qfc::CR_XIP_OPCODE_CR_XIP_OPCODE); - qfc_csr.rmwf(utra::qfc::CR_XIP_OPCODE_CR_XIP_OPCODE, bar); - let mut baz = qfc_csr.zf(utra::qfc::CR_XIP_OPCODE_CR_XIP_OPCODE, bar); - baz |= qfc_csr.ms(utra::qfc::CR_XIP_OPCODE_CR_XIP_OPCODE, 1); - qfc_csr.wfo(utra::qfc::CR_XIP_OPCODE_CR_XIP_OPCODE, baz); - - let foo = qfc_csr.r(utra::qfc::CR_XIP_WIDTH); - qfc_csr.wo(utra::qfc::CR_XIP_WIDTH, foo); - let bar = qfc_csr.rf(utra::qfc::CR_XIP_WIDTH_CR_XIP_WIDTH); - qfc_csr.rmwf(utra::qfc::CR_XIP_WIDTH_CR_XIP_WIDTH, bar); - let mut baz = qfc_csr.zf(utra::qfc::CR_XIP_WIDTH_CR_XIP_WIDTH, bar); - baz |= qfc_csr.ms(utra::qfc::CR_XIP_WIDTH_CR_XIP_WIDTH, 1); - qfc_csr.wfo(utra::qfc::CR_XIP_WIDTH_CR_XIP_WIDTH, baz); - - let foo = qfc_csr.r(utra::qfc::CR_XIP_SSEL); - qfc_csr.wo(utra::qfc::CR_XIP_SSEL, foo); - let bar = qfc_csr.rf(utra::qfc::CR_XIP_SSEL_CR_XIP_SSEL); - qfc_csr.rmwf(utra::qfc::CR_XIP_SSEL_CR_XIP_SSEL, bar); - let mut baz = qfc_csr.zf(utra::qfc::CR_XIP_SSEL_CR_XIP_SSEL, bar); - baz |= qfc_csr.ms(utra::qfc::CR_XIP_SSEL_CR_XIP_SSEL, 1); - qfc_csr.wfo(utra::qfc::CR_XIP_SSEL_CR_XIP_SSEL, baz); - - let foo = qfc_csr.r(utra::qfc::CR_XIP_DUMCYC); - qfc_csr.wo(utra::qfc::CR_XIP_DUMCYC, foo); - let bar = qfc_csr.rf(utra::qfc::CR_XIP_DUMCYC_CR_XIP_DUMCYC); - qfc_csr.rmwf(utra::qfc::CR_XIP_DUMCYC_CR_XIP_DUMCYC, bar); - let mut baz = qfc_csr.zf(utra::qfc::CR_XIP_DUMCYC_CR_XIP_DUMCYC, bar); - baz |= qfc_csr.ms(utra::qfc::CR_XIP_DUMCYC_CR_XIP_DUMCYC, 1); - qfc_csr.wfo(utra::qfc::CR_XIP_DUMCYC_CR_XIP_DUMCYC, baz); - - let foo = qfc_csr.r(utra::qfc::CR_XIP_CFG); - qfc_csr.wo(utra::qfc::CR_XIP_CFG, foo); - let bar = qfc_csr.rf(utra::qfc::CR_XIP_CFG_CR_XIP_CFG); - qfc_csr.rmwf(utra::qfc::CR_XIP_CFG_CR_XIP_CFG, bar); - let mut baz = qfc_csr.zf(utra::qfc::CR_XIP_CFG_CR_XIP_CFG, bar); - baz |= qfc_csr.ms(utra::qfc::CR_XIP_CFG_CR_XIP_CFG, 1); - qfc_csr.wfo(utra::qfc::CR_XIP_CFG_CR_XIP_CFG, baz); - - let foo = qfc_csr.r(utra::qfc::CR_AESKEY_AESKEYIN0); - qfc_csr.wo(utra::qfc::CR_AESKEY_AESKEYIN0, foo); - let bar = qfc_csr.rf(utra::qfc::CR_AESKEY_AESKEYIN0_AESKEYIN0); - qfc_csr.rmwf(utra::qfc::CR_AESKEY_AESKEYIN0_AESKEYIN0, bar); - let mut baz = qfc_csr.zf(utra::qfc::CR_AESKEY_AESKEYIN0_AESKEYIN0, bar); - baz |= qfc_csr.ms(utra::qfc::CR_AESKEY_AESKEYIN0_AESKEYIN0, 1); - qfc_csr.wfo(utra::qfc::CR_AESKEY_AESKEYIN0_AESKEYIN0, baz); - - let foo = qfc_csr.r(utra::qfc::CR_AESKEY_AESKEYIN1); - qfc_csr.wo(utra::qfc::CR_AESKEY_AESKEYIN1, foo); - let bar = qfc_csr.rf(utra::qfc::CR_AESKEY_AESKEYIN1_AESKEYIN1); - qfc_csr.rmwf(utra::qfc::CR_AESKEY_AESKEYIN1_AESKEYIN1, bar); - let mut baz = qfc_csr.zf(utra::qfc::CR_AESKEY_AESKEYIN1_AESKEYIN1, bar); - baz |= qfc_csr.ms(utra::qfc::CR_AESKEY_AESKEYIN1_AESKEYIN1, 1); - qfc_csr.wfo(utra::qfc::CR_AESKEY_AESKEYIN1_AESKEYIN1, baz); - - let foo = qfc_csr.r(utra::qfc::CR_AESKEY_AESKEYIN2); - qfc_csr.wo(utra::qfc::CR_AESKEY_AESKEYIN2, foo); - let bar = qfc_csr.rf(utra::qfc::CR_AESKEY_AESKEYIN2_AESKEYIN2); - qfc_csr.rmwf(utra::qfc::CR_AESKEY_AESKEYIN2_AESKEYIN2, bar); - let mut baz = qfc_csr.zf(utra::qfc::CR_AESKEY_AESKEYIN2_AESKEYIN2, bar); - baz |= qfc_csr.ms(utra::qfc::CR_AESKEY_AESKEYIN2_AESKEYIN2, 1); - qfc_csr.wfo(utra::qfc::CR_AESKEY_AESKEYIN2_AESKEYIN2, baz); - - let foo = qfc_csr.r(utra::qfc::CR_AESKEY_AESKEYIN3); - qfc_csr.wo(utra::qfc::CR_AESKEY_AESKEYIN3, foo); - let bar = qfc_csr.rf(utra::qfc::CR_AESKEY_AESKEYIN3_AESKEYIN3); - qfc_csr.rmwf(utra::qfc::CR_AESKEY_AESKEYIN3_AESKEYIN3, bar); - let mut baz = qfc_csr.zf(utra::qfc::CR_AESKEY_AESKEYIN3_AESKEYIN3, bar); - baz |= qfc_csr.ms(utra::qfc::CR_AESKEY_AESKEYIN3_AESKEYIN3, 1); - qfc_csr.wfo(utra::qfc::CR_AESKEY_AESKEYIN3_AESKEYIN3, baz); - - let foo = qfc_csr.r(utra::qfc::CR_AESENA); - qfc_csr.wo(utra::qfc::CR_AESENA, foo); - let bar = qfc_csr.rf(utra::qfc::CR_AESENA_CR_AESENA); - qfc_csr.rmwf(utra::qfc::CR_AESENA_CR_AESENA, bar); - let mut baz = qfc_csr.zf(utra::qfc::CR_AESENA_CR_AESENA, bar); - baz |= qfc_csr.ms(utra::qfc::CR_AESENA_CR_AESENA, 1); - qfc_csr.wfo(utra::qfc::CR_AESENA_CR_AESENA, baz); - } - - #[test] - #[ignore] - fn compile_check_mbox_apb_csr() { - use super::*; - let mut mbox_apb_csr = CSR::new(HW_MBOX_APB_BASE as *mut u32); - - let foo = mbox_apb_csr.r(utra::mbox_apb::SFR_WDATA); - mbox_apb_csr.wo(utra::mbox_apb::SFR_WDATA, foo); - let bar = mbox_apb_csr.rf(utra::mbox_apb::SFR_WDATA_SFR_WDATA); - mbox_apb_csr.rmwf(utra::mbox_apb::SFR_WDATA_SFR_WDATA, bar); - let mut baz = mbox_apb_csr.zf(utra::mbox_apb::SFR_WDATA_SFR_WDATA, bar); - baz |= mbox_apb_csr.ms(utra::mbox_apb::SFR_WDATA_SFR_WDATA, 1); - mbox_apb_csr.wfo(utra::mbox_apb::SFR_WDATA_SFR_WDATA, baz); - - let foo = mbox_apb_csr.r(utra::mbox_apb::SFR_RDATA); - mbox_apb_csr.wo(utra::mbox_apb::SFR_RDATA, foo); - let bar = mbox_apb_csr.rf(utra::mbox_apb::SFR_RDATA_SFR_RDATA); - mbox_apb_csr.rmwf(utra::mbox_apb::SFR_RDATA_SFR_RDATA, bar); - let mut baz = mbox_apb_csr.zf(utra::mbox_apb::SFR_RDATA_SFR_RDATA, bar); - baz |= mbox_apb_csr.ms(utra::mbox_apb::SFR_RDATA_SFR_RDATA, 1); - mbox_apb_csr.wfo(utra::mbox_apb::SFR_RDATA_SFR_RDATA, baz); - - let foo = mbox_apb_csr.r(utra::mbox_apb::SFR_STATUS); - mbox_apb_csr.wo(utra::mbox_apb::SFR_STATUS, foo); - let bar = mbox_apb_csr.rf(utra::mbox_apb::SFR_STATUS_RX_AVAIL); - mbox_apb_csr.rmwf(utra::mbox_apb::SFR_STATUS_RX_AVAIL, bar); - let mut baz = mbox_apb_csr.zf(utra::mbox_apb::SFR_STATUS_RX_AVAIL, bar); - baz |= mbox_apb_csr.ms(utra::mbox_apb::SFR_STATUS_RX_AVAIL, 1); - mbox_apb_csr.wfo(utra::mbox_apb::SFR_STATUS_RX_AVAIL, baz); - let bar = mbox_apb_csr.rf(utra::mbox_apb::SFR_STATUS_TX_FREE); - mbox_apb_csr.rmwf(utra::mbox_apb::SFR_STATUS_TX_FREE, bar); - let mut baz = mbox_apb_csr.zf(utra::mbox_apb::SFR_STATUS_TX_FREE, bar); - baz |= mbox_apb_csr.ms(utra::mbox_apb::SFR_STATUS_TX_FREE, 1); - mbox_apb_csr.wfo(utra::mbox_apb::SFR_STATUS_TX_FREE, baz); - let bar = mbox_apb_csr.rf(utra::mbox_apb::SFR_STATUS_ABORT_IN_PROGRESS); - mbox_apb_csr.rmwf(utra::mbox_apb::SFR_STATUS_ABORT_IN_PROGRESS, bar); - let mut baz = mbox_apb_csr.zf(utra::mbox_apb::SFR_STATUS_ABORT_IN_PROGRESS, bar); - baz |= mbox_apb_csr.ms(utra::mbox_apb::SFR_STATUS_ABORT_IN_PROGRESS, 1); - mbox_apb_csr.wfo(utra::mbox_apb::SFR_STATUS_ABORT_IN_PROGRESS, baz); - let bar = mbox_apb_csr.rf(utra::mbox_apb::SFR_STATUS_ABORT_ACK); - mbox_apb_csr.rmwf(utra::mbox_apb::SFR_STATUS_ABORT_ACK, bar); - let mut baz = mbox_apb_csr.zf(utra::mbox_apb::SFR_STATUS_ABORT_ACK, bar); - baz |= mbox_apb_csr.ms(utra::mbox_apb::SFR_STATUS_ABORT_ACK, 1); - mbox_apb_csr.wfo(utra::mbox_apb::SFR_STATUS_ABORT_ACK, baz); - let bar = mbox_apb_csr.rf(utra::mbox_apb::SFR_STATUS_TX_ERR); - mbox_apb_csr.rmwf(utra::mbox_apb::SFR_STATUS_TX_ERR, bar); - let mut baz = mbox_apb_csr.zf(utra::mbox_apb::SFR_STATUS_TX_ERR, bar); - baz |= mbox_apb_csr.ms(utra::mbox_apb::SFR_STATUS_TX_ERR, 1); - mbox_apb_csr.wfo(utra::mbox_apb::SFR_STATUS_TX_ERR, baz); - let bar = mbox_apb_csr.rf(utra::mbox_apb::SFR_STATUS_RX_ERR); - mbox_apb_csr.rmwf(utra::mbox_apb::SFR_STATUS_RX_ERR, bar); - let mut baz = mbox_apb_csr.zf(utra::mbox_apb::SFR_STATUS_RX_ERR, bar); - baz |= mbox_apb_csr.ms(utra::mbox_apb::SFR_STATUS_RX_ERR, 1); - mbox_apb_csr.wfo(utra::mbox_apb::SFR_STATUS_RX_ERR, baz); - - let foo = mbox_apb_csr.r(utra::mbox_apb::SFR_ABORT); - mbox_apb_csr.wo(utra::mbox_apb::SFR_ABORT, foo); - let bar = mbox_apb_csr.rf(utra::mbox_apb::SFR_ABORT_SFR_ABORT); - mbox_apb_csr.rmwf(utra::mbox_apb::SFR_ABORT_SFR_ABORT, bar); - let mut baz = mbox_apb_csr.zf(utra::mbox_apb::SFR_ABORT_SFR_ABORT, bar); - baz |= mbox_apb_csr.ms(utra::mbox_apb::SFR_ABORT_SFR_ABORT, 1); - mbox_apb_csr.wfo(utra::mbox_apb::SFR_ABORT_SFR_ABORT, baz); - - let foo = mbox_apb_csr.r(utra::mbox_apb::SFR_DONE); - mbox_apb_csr.wo(utra::mbox_apb::SFR_DONE, foo); - let bar = mbox_apb_csr.rf(utra::mbox_apb::SFR_DONE_SFR_DONE); - mbox_apb_csr.rmwf(utra::mbox_apb::SFR_DONE_SFR_DONE, bar); - let mut baz = mbox_apb_csr.zf(utra::mbox_apb::SFR_DONE_SFR_DONE, bar); - baz |= mbox_apb_csr.ms(utra::mbox_apb::SFR_DONE_SFR_DONE, 1); - mbox_apb_csr.wfo(utra::mbox_apb::SFR_DONE_SFR_DONE, baz); - } - - #[test] - #[ignore] - fn compile_check_gluechain_csr() { - use super::*; - let mut gluechain_csr = CSR::new(HW_GLUECHAIN_BASE as *mut u32); - - let foo = gluechain_csr.r(utra::gluechain::SFR_GCMASK); - gluechain_csr.wo(utra::gluechain::SFR_GCMASK, foo); - let bar = gluechain_csr.rf(utra::gluechain::SFR_GCMASK_CR_GCMASK); - gluechain_csr.rmwf(utra::gluechain::SFR_GCMASK_CR_GCMASK, bar); - let mut baz = gluechain_csr.zf(utra::gluechain::SFR_GCMASK_CR_GCMASK, bar); - baz |= gluechain_csr.ms(utra::gluechain::SFR_GCMASK_CR_GCMASK, 1); - gluechain_csr.wfo(utra::gluechain::SFR_GCMASK_CR_GCMASK, baz); - - let foo = gluechain_csr.r(utra::gluechain::SFR_GCSR); - gluechain_csr.wo(utra::gluechain::SFR_GCSR, foo); - let bar = gluechain_csr.rf(utra::gluechain::SFR_GCSR_GLUEREG); - gluechain_csr.rmwf(utra::gluechain::SFR_GCSR_GLUEREG, bar); - let mut baz = gluechain_csr.zf(utra::gluechain::SFR_GCSR_GLUEREG, bar); - baz |= gluechain_csr.ms(utra::gluechain::SFR_GCSR_GLUEREG, 1); - gluechain_csr.wfo(utra::gluechain::SFR_GCSR_GLUEREG, baz); - - let foo = gluechain_csr.r(utra::gluechain::SFR_GCRST); - gluechain_csr.wo(utra::gluechain::SFR_GCRST, foo); - let bar = gluechain_csr.rf(utra::gluechain::SFR_GCRST_GLUERST); - gluechain_csr.rmwf(utra::gluechain::SFR_GCRST_GLUERST, bar); - let mut baz = gluechain_csr.zf(utra::gluechain::SFR_GCRST_GLUERST, bar); - baz |= gluechain_csr.ms(utra::gluechain::SFR_GCRST_GLUERST, 1); - gluechain_csr.wfo(utra::gluechain::SFR_GCRST_GLUERST, baz); - - let foo = gluechain_csr.r(utra::gluechain::SFR_GCTEST); - gluechain_csr.wo(utra::gluechain::SFR_GCTEST, foo); - let bar = gluechain_csr.rf(utra::gluechain::SFR_GCTEST_GLUETEST); - gluechain_csr.rmwf(utra::gluechain::SFR_GCTEST_GLUETEST, bar); - let mut baz = gluechain_csr.zf(utra::gluechain::SFR_GCTEST_GLUETEST, bar); - baz |= gluechain_csr.ms(utra::gluechain::SFR_GCTEST_GLUETEST, 1); - gluechain_csr.wfo(utra::gluechain::SFR_GCTEST_GLUETEST, baz); + let foo = udma_adc_csr.r(utra::udma_adc::REG_RX_SADDR); + udma_adc_csr.wo(utra::udma_adc::REG_RX_SADDR, foo); + let bar = udma_adc_csr.rf(utra::udma_adc::REG_RX_SADDR_R_RX_STARTADDR); + udma_adc_csr.rmwf(utra::udma_adc::REG_RX_SADDR_R_RX_STARTADDR, bar); + let mut baz = udma_adc_csr.zf(utra::udma_adc::REG_RX_SADDR_R_RX_STARTADDR, bar); + baz |= udma_adc_csr.ms(utra::udma_adc::REG_RX_SADDR_R_RX_STARTADDR, 1); + udma_adc_csr.wfo(utra::udma_adc::REG_RX_SADDR_R_RX_STARTADDR, baz); + + let foo = udma_adc_csr.r(utra::udma_adc::REG_RX_SIZE); + udma_adc_csr.wo(utra::udma_adc::REG_RX_SIZE, foo); + let bar = udma_adc_csr.rf(utra::udma_adc::REG_RX_SIZE_R_RX_SIZE); + udma_adc_csr.rmwf(utra::udma_adc::REG_RX_SIZE_R_RX_SIZE, bar); + let mut baz = udma_adc_csr.zf(utra::udma_adc::REG_RX_SIZE_R_RX_SIZE, bar); + baz |= udma_adc_csr.ms(utra::udma_adc::REG_RX_SIZE_R_RX_SIZE, 1); + udma_adc_csr.wfo(utra::udma_adc::REG_RX_SIZE_R_RX_SIZE, baz); + + let foo = udma_adc_csr.r(utra::udma_adc::REG_RX_CFG); + udma_adc_csr.wo(utra::udma_adc::REG_RX_CFG, foo); + let bar = udma_adc_csr.rf(utra::udma_adc::REG_RX_CFG_R_RX_CONTINUOUS); + udma_adc_csr.rmwf(utra::udma_adc::REG_RX_CFG_R_RX_CONTINUOUS, bar); + let mut baz = udma_adc_csr.zf(utra::udma_adc::REG_RX_CFG_R_RX_CONTINUOUS, bar); + baz |= udma_adc_csr.ms(utra::udma_adc::REG_RX_CFG_R_RX_CONTINUOUS, 1); + udma_adc_csr.wfo(utra::udma_adc::REG_RX_CFG_R_RX_CONTINUOUS, baz); + let bar = udma_adc_csr.rf(utra::udma_adc::REG_RX_CFG_R_RX_EN); + udma_adc_csr.rmwf(utra::udma_adc::REG_RX_CFG_R_RX_EN, bar); + let mut baz = udma_adc_csr.zf(utra::udma_adc::REG_RX_CFG_R_RX_EN, bar); + baz |= udma_adc_csr.ms(utra::udma_adc::REG_RX_CFG_R_RX_EN, 1); + udma_adc_csr.wfo(utra::udma_adc::REG_RX_CFG_R_RX_EN, baz); + let bar = udma_adc_csr.rf(utra::udma_adc::REG_RX_CFG_R_RX_CLR); + udma_adc_csr.rmwf(utra::udma_adc::REG_RX_CFG_R_RX_CLR, bar); + let mut baz = udma_adc_csr.zf(utra::udma_adc::REG_RX_CFG_R_RX_CLR, bar); + baz |= udma_adc_csr.ms(utra::udma_adc::REG_RX_CFG_R_RX_CLR, 1); + udma_adc_csr.wfo(utra::udma_adc::REG_RX_CFG_R_RX_CLR, baz); + + let foo = udma_adc_csr.r(utra::udma_adc::REG_CR_ADC); + udma_adc_csr.wo(utra::udma_adc::REG_CR_ADC, foo); + let bar = udma_adc_csr.rf(utra::udma_adc::REG_CR_ADC_CR_ADC); + udma_adc_csr.rmwf(utra::udma_adc::REG_CR_ADC_CR_ADC, bar); + let mut baz = udma_adc_csr.zf(utra::udma_adc::REG_CR_ADC_CR_ADC, bar); + baz |= udma_adc_csr.ms(utra::udma_adc::REG_CR_ADC_CR_ADC, 1); + udma_adc_csr.wfo(utra::udma_adc::REG_CR_ADC_CR_ADC, baz); } #[test] diff --git a/xtask/src/main.rs b/xtask/src/main.rs index 113d483d4..253e82b45 100644 --- a/xtask/src/main.rs +++ b/xtask/src/main.rs @@ -172,6 +172,10 @@ fn main() -> Result<(), Box> { for feature in kern_features { builder.add_kernel_feature(&feature); } + let loader_features = get_flag("--loader-feature")?; + for feature in loader_features { + builder.add_loader_feature(&feature); + } if !language_set { // the default language is english @@ -513,7 +517,7 @@ fn main() -> Result<(), Box> { // ------ Cramium hardware image configs ------ Some("cramium-fpga") | Some("cramium-soc") => { - let board = "board-baosec"; + let board = "board-dabao"; // select the board builder.add_feature(board); builder.add_loader_feature(board); @@ -522,35 +526,14 @@ fn main() -> Result<(), Box> { // placement in flash is a tension between dev convenience and RAM usage. Things in flash // are resident, non-swapable, but end up making the slow kernel burn process take longer. let cramium_flash_pkgs = - ["xous-ticktimer", "xous-log", "xous-names" /* , "usb-device-xous" */].to_vec(); - let cramium_swap_pkgs = ["cram-console", "cram-hal-service"].to_vec(); - // minimal config for USB debugging - // let cramium_swap_pkgs = ["usb-device-xous"].to_vec(); // , "cram-console" - if !builder.is_swap_set() { - builder.set_swap(0, 8 * 1024 * 1024); - } - builder.add_loader_feature("board-bringup"); - // builder.add_loader_feature("spim-test"); - // builder.add_loader_feature("spi-alt-channel"); // this flag, when asserted, uses the J_QSPI - // header. By default, we use JPC7_13 (J_QSPI does not work, for some reason; bit 3 is stuck - // high...) - // builder.add_loader_feature("irq-test"); - // builder.add_loader_feature("usb-test"); - // builder.add_loader_feature("trng-test"); - // builder.add_loader_feature("dump-trng"); - // builder.add_loader_feature("usb"); - // builder.add_loader_feature("qr"); - // builder.add_feature("usb"); // needed if usb-device-xous is selected - builder.add_loader_feature("swap"); - builder.add_kernel_feature("swap"); - builder.add_feature("swap"); + ["xous-ticktimer", "xous-log", "xous-names" /* "cram-hal-service" */].to_vec(); + let cramium_swap_pkgs = [].to_vec(); builder.add_loader_feature("debug-print"); - builder.add_kernel_feature("debug-swap"); // builder.add_kernel_feature("debug-print"); // builder.add_kernel_feature("debug-swap-verbose"); - builder.add_feature("quantum-timer"); + // builder.add_feature("quantum-timer"); // builder.add_feature("auto-trng"); // automatically initialize TRNG tester inside USB stack builder.add_kernel_feature("v2p"); // builder.add_feature("mass-storage"); @@ -564,9 +547,6 @@ fn main() -> Result<(), Box> { }; broken_aes_cleanup = true; - // It is important that this is the first service added, because the swapper *must* be in PID 2 - builder.add_service("xous-swapper", LoaderRegion::Flash); - for service in cramium_flash_pkgs { builder.add_service(service, LoaderRegion::Flash); } @@ -611,10 +591,11 @@ fn main() -> Result<(), Box> { builder.add_kernel_feature("debug-swap"); // builder.add_kernel_feature("debug-print"); // builder.add_kernel_feature("debug-swap-verbose"); - builder.add_feature("quantum-timer"); + // builder.add_feature("quantum-timer"); // this isn't in NTO.. builder.add_kernel_feature("v2p"); builder.add_loader_feature("sram-margin"); builder.add_loader_feature("usb"); + builder.add_loader_feature("updates"); match task.as_deref() { Some("baosec") => builder.target_cramium_soc(), _ => panic!("should be unreachable"),