diff --git a/Cargo.lock b/Cargo.lock index 92ccf0781..19153879a 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -4902,7 +4902,11 @@ dependencies = [ "num-traits", "rkyv", "utralib", +<<<<<<< HEAD "xous", +======= + "xous 0.9.48 (registry+https://github.com/rust-lang/crates.io-index)", +>>>>>>> f10c6b341c4c76f49d3acfb04d88cbe434c449dc "xous-api-log", "xous-api-names", "xous-api-ticktimer", @@ -5068,7 +5072,11 @@ dependencies = [ "usbd_scsi 0.1.1", "utralib", "vcell", +<<<<<<< HEAD "xous", +======= + "xous 0.9.48 (registry+https://github.com/rust-lang/crates.io-index)", +>>>>>>> f10c6b341c4c76f49d3acfb04d88cbe434c449dc "xous-api-log", "xous-api-names", "xous-api-susres", @@ -5093,7 +5101,11 @@ dependencies = [ "usbd-human-interface-device 0.1.1", "utralib", "vcell", +<<<<<<< HEAD "xous", +======= + "xous 0.9.48 (registry+https://github.com/rust-lang/crates.io-index)", +>>>>>>> f10c6b341c4c76f49d3acfb04d88cbe434c449dc "xous-api-log", "xous-api-names", "xous-api-susres", @@ -5156,7 +5168,11 @@ dependencies = [ "typenum", "usb-device", "usbd_mass_storage 0.1.0", +<<<<<<< HEAD "xous", +======= + "xous 0.9.48 (registry+https://github.com/rust-lang/crates.io-index)", +>>>>>>> f10c6b341c4c76f49d3acfb04d88cbe434c449dc "xous-api-ticktimer", ] @@ -5230,7 +5246,11 @@ dependencies = [ "usb-device", "usbd_bulk_only_transport 0.1.0", "usbd_mass_storage 0.1.0", +<<<<<<< HEAD "xous", +======= + "xous 0.9.48 (registry+https://github.com/rust-lang/crates.io-index)", +>>>>>>> f10c6b341c4c76f49d3acfb04d88cbe434c449dc "xous-api-ticktimer", ] @@ -5310,7 +5330,11 @@ dependencies = [ "usbd-human-interface-device 0.2.1", "userprefs", "utralib", +<<<<<<< HEAD "xous", +======= + "xous 0.9.48 (registry+https://github.com/rust-lang/crates.io-index)", +>>>>>>> f10c6b341c4c76f49d3acfb04d88cbe434c449dc "xous-api-log", "xous-api-names", "xous-api-susres", @@ -5866,13 +5890,33 @@ dependencies = [ ] [[package]] +<<<<<<< HEAD name = "xous-api-log" version = "0.1.44" +======= +name = "xous" +version = "0.9.48" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c291e0efc56bc20b4c434ac239b8d6d49bf2ec3bf9cac991fdc0d702e2ff4b2d" +dependencies = [ + "lazy_static", +] + +[[package]] +name = "xous-api-log" +version = "0.1.44" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "797ff15cb41c855dfc21311da441e35cc583baa9ef238627ef33f05912d9367c" +>>>>>>> f10c6b341c4c76f49d3acfb04d88cbe434c449dc dependencies = [ "log", "num-derive", "num-traits", +<<<<<<< HEAD "xous", +======= + "xous 0.9.48 (registry+https://github.com/rust-lang/crates.io-index)", +>>>>>>> f10c6b341c4c76f49d3acfb04d88cbe434c449dc "xous-ipc 0.9.48 (registry+https://github.com/rust-lang/crates.io-index)", ] @@ -5886,7 +5930,11 @@ dependencies = [ "num-derive", "num-traits", "rkyv", +<<<<<<< HEAD "xous", +======= + "xous 0.9.48 (registry+https://github.com/rust-lang/crates.io-index)", +>>>>>>> f10c6b341c4c76f49d3acfb04d88cbe434c449dc "xous-api-log", "xous-ipc 0.9.48 (registry+https://github.com/rust-lang/crates.io-index)", ] @@ -5902,7 +5950,11 @@ dependencies = [ "num-traits", "rkyv", "utralib", +<<<<<<< HEAD "xous", +======= + "xous 0.9.48 (registry+https://github.com/rust-lang/crates.io-index)", +>>>>>>> f10c6b341c4c76f49d3acfb04d88cbe434c449dc "xous-api-log", "xous-api-names", "xous-ipc 0.9.48 (registry+https://github.com/rust-lang/crates.io-index)", @@ -5918,7 +5970,11 @@ dependencies = [ "num-derive", "num-traits", "rkyv", +<<<<<<< HEAD "xous", +======= + "xous 0.9.48 (registry+https://github.com/rust-lang/crates.io-index)", +>>>>>>> f10c6b341c4c76f49d3acfb04d88cbe434c449dc "xous-api-log", "xous-api-names", "xous-api-susres", @@ -5932,7 +5988,11 @@ version = "0.9.48" dependencies = [ "bitflags 1.3.2", "rkyv", +<<<<<<< HEAD "xous", +======= + "xous 0.9.48 (registry+https://github.com/rust-lang/crates.io-index)", +>>>>>>> f10c6b341c4c76f49d3acfb04d88cbe434c449dc ] [[package]] @@ -5943,7 +6003,11 @@ checksum = "9bc1dd2cd7306d496d9606796905d472ca51f7889423363c96c2296506963234" dependencies = [ "bitflags 1.3.2", "rkyv", +<<<<<<< HEAD "xous", +======= + "xous 0.9.48 (registry+https://github.com/rust-lang/crates.io-index)", +>>>>>>> f10c6b341c4c76f49d3acfb04d88cbe434c449dc ] [[package]] @@ -5963,7 +6027,11 @@ dependencies = [ "rand_chacha 0.3.1", "stats_alloc", "utralib", +<<<<<<< HEAD "xous", +======= + "xous 0.9.48 (registry+https://github.com/rust-lang/crates.io-index)", +>>>>>>> f10c6b341c4c76f49d3acfb04d88cbe434c449dc "xous-riscv", ] @@ -5977,7 +6045,11 @@ dependencies = [ "num-traits", "rkyv", "utralib", +<<<<<<< HEAD "xous", +======= + "xous 0.9.48 (registry+https://github.com/rust-lang/crates.io-index)", +>>>>>>> f10c6b341c4c76f49d3acfb04d88cbe434c449dc "xous-api-log", "xous-ipc 0.9.48 (registry+https://github.com/rust-lang/crates.io-index)", ] @@ -5991,7 +6063,11 @@ dependencies = [ "num-traits", "rkyv", "utralib", +<<<<<<< HEAD "xous", +======= + "xous 0.9.48 (registry+https://github.com/rust-lang/crates.io-index)", +>>>>>>> f10c6b341c4c76f49d3acfb04d88cbe434c449dc "xous-api-log", "xous-api-names", "xous-ipc 0.9.48 (registry+https://github.com/rust-lang/crates.io-index)", @@ -6006,7 +6082,11 @@ dependencies = [ "pio", "pio-proc", "utralib", +<<<<<<< HEAD "xous", +======= + "xous 0.9.48 (registry+https://github.com/rust-lang/crates.io-index)", +>>>>>>> f10c6b341c4c76f49d3acfb04d88cbe434c449dc ] [[package]] @@ -6016,7 +6096,11 @@ dependencies = [ "bitfield", "log", "utralib", +<<<<<<< HEAD "xous", +======= + "xous 0.9.48 (registry+https://github.com/rust-lang/crates.io-index)", +>>>>>>> f10c6b341c4c76f49d3acfb04d88cbe434c449dc ] [[package]] @@ -6044,7 +6128,11 @@ dependencies = [ "num-traits", "rkyv", "utralib", +<<<<<<< HEAD "xous", +======= + "xous 0.9.48 (registry+https://github.com/rust-lang/crates.io-index)", +>>>>>>> f10c6b341c4c76f49d3acfb04d88cbe434c449dc "xous-api-log", "xous-api-names", "xous-api-susres", @@ -6061,7 +6149,11 @@ dependencies = [ "num-traits", "rkyv", "utralib", +<<<<<<< HEAD "xous", +======= + "xous 0.9.48 (registry+https://github.com/rust-lang/crates.io-index)", +>>>>>>> f10c6b341c4c76f49d3acfb04d88cbe434c449dc "xous-api-log", "xous-api-names", "xous-api-susres", @@ -6080,7 +6172,11 @@ dependencies = [ "num-derive", "num-traits", "rkyv", +<<<<<<< HEAD "xous", +======= + "xous 0.9.48 (registry+https://github.com/rust-lang/crates.io-index)", +>>>>>>> f10c6b341c4c76f49d3acfb04d88cbe434c449dc "xous-api-names", "xous-ipc 0.9.48 (registry+https://github.com/rust-lang/crates.io-index)", ] diff --git a/libs/xous-pl230/src/pl230_tests/units.rs b/libs/xous-pl230/src/pl230_tests/units.rs index a83da8a02..93bf6ed04 100644 --- a/libs/xous-pl230/src/pl230_tests/units.rs +++ b/libs/xous-pl230/src/pl230_tests/units.rs @@ -12,21 +12,32 @@ pub fn lfsr_next(state: u32) -> u32 { (state << 1) + bit } -pub fn basic_tests (pl230: &mut Pl230) { +pub fn basic_tests (pl230: &mut Pl230) -> bool { report_api("channels", pl230.csr.rf(utra::pl230::STATUS_CHNLS_MINUS1) + 1); //report_api("id0", pl230.csr.r(utra::pl230::PERIPH_ID_0)); //report_api("id1", pl230.csr.r(utra::pl230::PERIPH_ID_1)); //report_api("id2", pl230.csr.r(utra::pl230::PERIPH_ID_2)); - let mut cc_struct = ControlChannels::default(); + + // conjure the DMA control structure in IFRAM0. In order to guarantee Rust + // semantics, it must be initialized to 0: 4 word-sized entries * 8 channels * 2 banks = 4 * 8 * 2 + let init_ptr = utralib::HW_IFRAM0_MEM as *mut u32; + for i in 0..(4*8*2) { + unsafe {init_ptr.add(i).write_volatile(0)}; + } + // safety: we guarantee that the pointer is aligned and initialized + let cc_struct: &mut ControlChannels = unsafe { + (utralib::HW_IFRAM0_MEM as *mut ControlChannels).as_mut().unwrap() + }; // read the status register - report_api("status", pl230.csr.r(utra::pl230::STATUS)); + // report_api("status", pl230.csr.r(utra::pl230::STATUS)); pl230.csr.wfo(utra::pl230::CFG_MASTER_ENABLE, 1); // enable - report_api("status after enable", pl230.csr.r(utra::pl230::STATUS)); + // report_api("status after enable", pl230.csr.r(utra::pl230::STATUS)); + const DMA_LEN: usize = 16; // setup the PL230 to do a simple transfer between two memory regions - let mut region_a = [0u32; 16]; - let region_b = [0u32; 16]; + let mut region_a = [0u32; DMA_LEN]; + let region_b = [0u32; DMA_LEN]; let mut state = 0x1111_1111; for d in region_a.iter_mut() { *d = state; @@ -40,7 +51,7 @@ pub fn basic_tests (pl230: &mut Pl230) { cc.set_src_inc(DmaWidth::Word as u32); cc.set_dst_size(DmaWidth::Word as u32); cc.set_dst_inc(DmaWidth::Word as u32); - cc.set_r_power(ArbitrateAfter::Xfer8 as u32); + cc.set_r_power(ArbitrateAfter::Xfer1024 as u32); cc.set_n_minus_1(region_a.len() as u32 - 1); cc.set_cycle_ctrl(DmaCycleControl::AutoRequest as u32); cc_struct.channels[0].control = cc.0; @@ -49,22 +60,44 @@ pub fn basic_tests (pl230: &mut Pl230) { pl230.csr.wo(utra::pl230::CHNLREQMASKSET, 1); pl230.csr.wo(utra::pl230::CHNLENABLESET, 1); + // report_api("dma_len", DMA_LEN as u32); report_api("baseptr", cc_struct.channels.as_ptr() as u32); - report_api("baseptr[0]", unsafe{cc_struct.channels.as_ptr().read()}.src_end_ptr); - report_api("baseptr[1]", unsafe{cc_struct.channels.as_ptr().read()}.dst_end_ptr); - report_api("baseptr[2]", unsafe{cc_struct.channels.as_ptr().read()}.control); - report_api("baseptr[3]", unsafe{cc_struct.channels.as_ptr().read()}.reserved); - report_api("baseptr reg", pl230.csr.r(utra::pl230::CTRLBASEPTR)); + report_api("src start", region_a.as_ptr() as u32); + // report_api("baseptr[0]", unsafe{cc_struct.channels.as_ptr().read()}.src_end_ptr); + report_api("dst start", region_b.as_ptr() as u32); + // report_api("baseptr[1]", unsafe{cc_struct.channels.as_ptr().read()}.dst_end_ptr); + // report_api("baseptr[2]", unsafe{cc_struct.channels.as_ptr().read()}.control); + // report_api("baseptr[3]", unsafe{cc_struct.channels.as_ptr().read()}.reserved); + // report_api("baseptr reg", pl230.csr.r(utra::pl230::CTRLBASEPTR)); // this should kick off the DMA pl230.csr.wo(utra::pl230::CHNLSWREQUEST, 1); let mut timeout = 0; while (DmaChanControl(cc_struct.channels[0].control).cycle_ctrl() != 0) && timeout < 16 { - report_api("dma progress ", cc_struct.channels[0].control); + // report_api("dma progress ", cc_struct.channels[0].control); + report_api("progress as baseptr[2]", unsafe{cc_struct.channels.as_ptr().read()}.control); timeout += 1; } - for d in region_b { - report_api("b: ", d); + + unsafe {core::arch::asm!( + ".word 0x500F", + "nop", + "nop", + "nop", + "nop", + "nop", + ); } + + let mut passing = true; + for (i, (src, dst)) in region_a.iter().zip(region_b.iter()).enumerate() { + if *src != *dst { + report_api("error in iter ", i as u32); + report_api("src: ", *src); + report_api("dst: ", *dst); + passing = false; + } } + report_api("basic dma result (1=pass)", if passing { 1 } else { 0 }); + passing } \ No newline at end of file diff --git a/precursors/soc_csr_pvt.bin b/precursors/soc_csr_pvt.bin index 89c13d951..0c816fbbe 100644 Binary files a/precursors/soc_csr_pvt.bin and b/precursors/soc_csr_pvt.bin differ diff --git a/services/spinor/Cargo.toml b/services/spinor/Cargo.toml index 4d14e8819..be0d460ce 100644 --- a/services/spinor/Cargo.toml +++ b/services/spinor/Cargo.toml @@ -33,7 +33,7 @@ precursor = ["utralib/precursor"] hosted = ["utralib/hosted"] renode = ["utralib/renode"] extra_flush = [] -default = ["extra_flush"] +default = [] [lib] test = true diff --git a/utralib/cramium/core.svd b/utralib/cramium/core.svd index e0c333125..1bb615db7 100644 --- a/utralib/cramium/core.svd +++ b/utralib/cramium/core.svd @@ -3,7 +3,7 @@ litex SOC - + 8 32 diff --git a/utralib/cramium/daric.svd b/utralib/cramium/daric.svd index 4b18fc041..951a169fd 100644 --- a/utralib/cramium/daric.svd +++ b/utralib/cramium/daric.svd @@ -445,6 +445,5044 @@ + + UDMA_CTRL + 0x50100000 + UDMA_CTRL + + + REG_CG + 0x0000 + 0x00 + 32 + + + r_cg + 5 + [5:0] + 0 + + + + + + REG_CFG_EVT + 0x0004 + 0x00 + 32 + + + r_cmp_evt_0 + 7 + [7:0] + 0 + + + + r_cmp_evt_1 + 15 + [15:8] + 8 + + + + r_cmp_evt_2 + 23 + [23:16] + 16 + + + + r_cmp_evt_3 + 31 + [31:24] + 24 + + + + + + REG_RST + 0x0008 + 0x00 + 32 + + + r_rst + 5 + [5:0] + 0 + + + + + + + 0 + 0xc + registers + + + + UDMA_UART_0 + 0x50101000 + UDMA_UART_0 + + + REG_RX_SADDR + 0x0000 + 0x00 + 32 + + + r_rx_startaddr + 11 + [11:0] + 0 + + + + + + REG_RX_SIZE + 0x0004 + 0x00 + 32 + + + r_rx_size + 15 + [15:0] + 0 + + + + + + REG_RX_CFG + 0x0008 + 0x00 + 32 + + + r_rx_continuous + 0 + [0:0] + 0 + + + + r_rx_en + 4 + [4:4] + 4 + + + + r_rx_clr + 6 + [6:6] + 6 + + + + + + REG_TX_SADDR + 0x0010 + 0x00 + 32 + + + r_tx_startaddr + 11 + [11:0] + 0 + + + + + + REG_TX_SIZE + 0x0014 + 0x00 + 32 + + + r_tx_size + 15 + [15:0] + 0 + + + + + + REG_TX_CFG + 0x0018 + 0x00 + 32 + + + r_tx_continuous + 0 + [0:0] + 0 + + + + r_tx_en + 4 + [4:4] + 4 + + + + r_tx_clr + 6 + [6:6] + 6 + + + + + + REG_STATUS + 0x0020 + 0x00 + 32 + + + status_i + 0 + [0:0] + 0 + + + + + + REG_UART_SETUP + 0x0024 + 0x00 + 32 + + + r_uart_parity_en + 0 + [0:0] + 0 + + + + r_uart_bits + 2 + [2:1] + 1 + + + + r_uart_stop_bits + 3 + [3:3] + 3 + + + + r_uart_rx_polling_en + 4 + [4:4] + 4 + + + + r_uart_rx_clean_fifo + 5 + [5:5] + 5 + + + + r_uart_en_tx + 8 + [8:8] + 8 + + + + r_uart_en_rx + 9 + [9:9] + 9 + + + + r_uart_div + 31 + [31:16] + 16 + + + + + + REG_ERROR + 0x0028 + 0x00 + 32 + + + r_err_overflow + 0 + [0:0] + 0 + + + + r_err_parity + 1 + [1:1] + 1 + + + + + + REG_IRQ_EN + 0x002c + 0x00 + 32 + + + r_uart_rx_irq_en + 0 + [0:0] + 0 + + + + r_uart_err_irq_en + 1 + [1:1] + 1 + + + + + + REG_VALID + 0x0030 + 0x00 + 32 + + + r_uart_rx_data_valid + 0 + [0:0] + 0 + + + + + + REG_DATA + 0x0034 + 0x00 + 32 + + + r_uart_rx_data + 7 + [7:0] + 0 + + + + + + + 0 + 0x38 + registers + + + + UDMA_UART_1 + 0x50102000 + UDMA_UART_1 + + + REG_RX_SADDR + 0x0000 + 0x00 + 32 + + + r_rx_startaddr + 11 + [11:0] + 0 + + + + + + REG_RX_SIZE + 0x0004 + 0x00 + 32 + + + r_rx_size + 15 + [15:0] + 0 + + + + + + REG_RX_CFG + 0x0008 + 0x00 + 32 + + + r_rx_continuous + 0 + [0:0] + 0 + + + + r_rx_en + 4 + [4:4] + 4 + + + + r_rx_clr + 6 + [6:6] + 6 + + + + + + REG_TX_SADDR + 0x0010 + 0x00 + 32 + + + r_tx_startaddr + 11 + [11:0] + 0 + + + + + + REG_TX_SIZE + 0x0014 + 0x00 + 32 + + + r_tx_size + 15 + [15:0] + 0 + + + + + + REG_TX_CFG + 0x0018 + 0x00 + 32 + + + r_tx_continuous + 0 + [0:0] + 0 + + + + r_tx_en + 4 + [4:4] + 4 + + + + r_tx_clr + 6 + [6:6] + 6 + + + + + + REG_STATUS + 0x0020 + 0x00 + 32 + + + status_i + 0 + [0:0] + 0 + + + + + + REG_UART_SETUP + 0x0024 + 0x00 + 32 + + + r_uart_parity_en + 0 + [0:0] + 0 + + + + r_uart_bits + 2 + [2:1] + 1 + + + + r_uart_stop_bits + 3 + [3:3] + 3 + + + + r_uart_rx_polling_en + 4 + [4:4] + 4 + + + + r_uart_rx_clean_fifo + 5 + [5:5] + 5 + + + + r_uart_en_tx + 8 + [8:8] + 8 + + + + r_uart_en_rx + 9 + [9:9] + 9 + + + + r_uart_div + 31 + [31:16] + 16 + + + + + + REG_ERROR + 0x0028 + 0x00 + 32 + + + r_err_overflow + 0 + [0:0] + 0 + + + + r_err_parity + 1 + [1:1] + 1 + + + + + + REG_IRQ_EN + 0x002c + 0x00 + 32 + + + r_uart_rx_irq_en + 0 + [0:0] + 0 + + + + r_uart_err_irq_en + 1 + [1:1] + 1 + + + + + + REG_VALID + 0x0030 + 0x00 + 32 + + + r_uart_rx_data_valid + 0 + [0:0] + 0 + + + + + + REG_DATA + 0x0034 + 0x00 + 32 + + + r_uart_rx_data + 7 + [7:0] + 0 + + + + + + + 0 + 0x38 + registers + + + + UDMA_UART_2 + 0x50103000 + UDMA_UART_2 + + + REG_RX_SADDR + 0x0000 + 0x00 + 32 + + + r_rx_startaddr + 11 + [11:0] + 0 + + + + + + REG_RX_SIZE + 0x0004 + 0x00 + 32 + + + r_rx_size + 15 + [15:0] + 0 + + + + + + REG_RX_CFG + 0x0008 + 0x00 + 32 + + + r_rx_continuous + 0 + [0:0] + 0 + + + + r_rx_en + 4 + [4:4] + 4 + + + + r_rx_clr + 6 + [6:6] + 6 + + + + + + REG_TX_SADDR + 0x0010 + 0x00 + 32 + + + r_tx_startaddr + 11 + [11:0] + 0 + + + + + + REG_TX_SIZE + 0x0014 + 0x00 + 32 + + + r_tx_size + 15 + [15:0] + 0 + + + + + + REG_TX_CFG + 0x0018 + 0x00 + 32 + + + r_tx_continuous + 0 + [0:0] + 0 + + + + r_tx_en + 4 + [4:4] + 4 + + + + r_tx_clr + 6 + [6:6] + 6 + + + + + + REG_STATUS + 0x0020 + 0x00 + 32 + + + status_i + 0 + [0:0] + 0 + + + + + + REG_UART_SETUP + 0x0024 + 0x00 + 32 + + + r_uart_parity_en + 0 + [0:0] + 0 + + + + r_uart_bits + 2 + [2:1] + 1 + + + + r_uart_stop_bits + 3 + [3:3] + 3 + + + + r_uart_rx_polling_en + 4 + [4:4] + 4 + + + + r_uart_rx_clean_fifo + 5 + [5:5] + 5 + + + + r_uart_en_tx + 8 + [8:8] + 8 + + + + r_uart_en_rx + 9 + [9:9] + 9 + + + + r_uart_div + 31 + [31:16] + 16 + + + + + + REG_ERROR + 0x0028 + 0x00 + 32 + + + r_err_overflow + 0 + [0:0] + 0 + + + + r_err_parity + 1 + [1:1] + 1 + + + + + + REG_IRQ_EN + 0x002c + 0x00 + 32 + + + r_uart_rx_irq_en + 0 + [0:0] + 0 + + + + r_uart_err_irq_en + 1 + [1:1] + 1 + + + + + + REG_VALID + 0x0030 + 0x00 + 32 + + + r_uart_rx_data_valid + 0 + [0:0] + 0 + + + + + + REG_DATA + 0x0034 + 0x00 + 32 + + + r_uart_rx_data + 7 + [7:0] + 0 + + + + + + + 0 + 0x38 + registers + + + + UDMA_UART_3 + 0x50104000 + UDMA_UART_3 + + + REG_RX_SADDR + 0x0000 + 0x00 + 32 + + + r_rx_startaddr + 11 + [11:0] + 0 + + + + + + REG_RX_SIZE + 0x0004 + 0x00 + 32 + + + r_rx_size + 15 + [15:0] + 0 + + + + + + REG_RX_CFG + 0x0008 + 0x00 + 32 + + + r_rx_continuous + 0 + [0:0] + 0 + + + + r_rx_en + 4 + [4:4] + 4 + + + + r_rx_clr + 6 + [6:6] + 6 + + + + + + REG_TX_SADDR + 0x0010 + 0x00 + 32 + + + r_tx_startaddr + 11 + [11:0] + 0 + + + + + + REG_TX_SIZE + 0x0014 + 0x00 + 32 + + + r_tx_size + 15 + [15:0] + 0 + + + + + + REG_TX_CFG + 0x0018 + 0x00 + 32 + + + r_tx_continuous + 0 + [0:0] + 0 + + + + r_tx_en + 4 + [4:4] + 4 + + + + r_tx_clr + 6 + [6:6] + 6 + + + + + + REG_STATUS + 0x0020 + 0x00 + 32 + + + status_i + 0 + [0:0] + 0 + + + + + + REG_UART_SETUP + 0x0024 + 0x00 + 32 + + + r_uart_parity_en + 0 + [0:0] + 0 + + + + r_uart_bits + 2 + [2:1] + 1 + + + + r_uart_stop_bits + 3 + [3:3] + 3 + + + + r_uart_rx_polling_en + 4 + [4:4] + 4 + + + + r_uart_rx_clean_fifo + 5 + [5:5] + 5 + + + + r_uart_en_tx + 8 + [8:8] + 8 + + + + r_uart_en_rx + 9 + [9:9] + 9 + + + + r_uart_div + 31 + [31:16] + 16 + + + + + + REG_ERROR + 0x0028 + 0x00 + 32 + + + r_err_overflow + 0 + [0:0] + 0 + + + + r_err_parity + 1 + [1:1] + 1 + + + + + + REG_IRQ_EN + 0x002c + 0x00 + 32 + + + r_uart_rx_irq_en + 0 + [0:0] + 0 + + + + r_uart_err_irq_en + 1 + [1:1] + 1 + + + + + + REG_VALID + 0x0030 + 0x00 + 32 + + + r_uart_rx_data_valid + 0 + [0:0] + 0 + + + + + + REG_DATA + 0x0034 + 0x00 + 32 + + + r_uart_rx_data + 7 + [7:0] + 0 + + + + + + + 0 + 0x38 + registers + + + + UDMA_SPIM_0 + 0x50105000 + UDMA_SPIM_0 + + + REG_RX_SADDR + 0x0000 + 0x00 + 32 + + + r_rx_startaddr + 11 + [11:0] + 0 + + + + + + REG_RX_SIZE + 0x0004 + 0x00 + 32 + + + r_rx_size + 15 + [15:0] + 0 + + + + + + REG_RX_CFG + 0x0008 + 0x00 + 32 + + + r_rx_continuous + 0 + [0:0] + 0 + + + + r_rx_datasize + 2 + [2:1] + 1 + + + + r_rx_en + 4 + [4:4] + 4 + + + + r_rx_clr + 6 + [6:6] + 6 + + + + + + REG_TX_SADDR + 0x0010 + 0x00 + 32 + + + r_tx_startaddr + 11 + [11:0] + 0 + + + + + + REG_TX_SIZE + 0x0014 + 0x00 + 32 + + + r_tx_size + 15 + [15:0] + 0 + + + + + + REG_TX_CFG + 0x0018 + 0x00 + 32 + + + r_tx_continuous + 0 + [0:0] + 0 + + + + r_tx_datasize + 2 + [2:1] + 1 + + + + r_tx_en + 4 + [4:4] + 4 + + + + r_tx_clr + 6 + [6:6] + 6 + + + + + + REG_CMD_SADDR + 0x0020 + 0x00 + 32 + + + r_cmd_startaddr + 11 + [11:0] + 0 + + + + + + REG_CMD_SIZE + 0x0024 + 0x00 + 32 + + + r_cmd_size + 15 + [15:0] + 0 + + + + + + REG_CMD_CFG + 0x0028 + 0x00 + 32 + + + r_cmd_continuous + 0 + [0:0] + 0 + + + + r_cmd_en + 4 + [4:4] + 4 + + + + r_cmd_clr + 6 + [6:6] + 6 + + + + + + REG_STATUS + 0x0030 + 0x00 + 32 + + + status_i + 0 + [0:0] + 0 + + + + + + + 0 + 0x34 + registers + + + + UDMA_SPIM_1 + 0x50106000 + UDMA_SPIM_1 + + + REG_RX_SADDR + 0x0000 + 0x00 + 32 + + + r_rx_startaddr + 11 + [11:0] + 0 + + + + + + REG_RX_SIZE + 0x0004 + 0x00 + 32 + + + r_rx_size + 15 + [15:0] + 0 + + + + + + REG_RX_CFG + 0x0008 + 0x00 + 32 + + + r_rx_continuous + 0 + [0:0] + 0 + + + + r_rx_datasize + 2 + [2:1] + 1 + + + + r_rx_en + 4 + [4:4] + 4 + + + + r_rx_clr + 6 + [6:6] + 6 + + + + + + REG_TX_SADDR + 0x0010 + 0x00 + 32 + + + r_tx_startaddr + 11 + [11:0] + 0 + + + + + + REG_TX_SIZE + 0x0014 + 0x00 + 32 + + + r_tx_size + 15 + [15:0] + 0 + + + + + + REG_TX_CFG + 0x0018 + 0x00 + 32 + + + r_tx_continuous + 0 + [0:0] + 0 + + + + r_tx_datasize + 2 + [2:1] + 1 + + + + r_tx_en + 4 + [4:4] + 4 + + + + r_tx_clr + 6 + [6:6] + 6 + + + + + + REG_CMD_SADDR + 0x0020 + 0x00 + 32 + + + r_cmd_startaddr + 11 + [11:0] + 0 + + + + + + REG_CMD_SIZE + 0x0024 + 0x00 + 32 + + + r_cmd_size + 15 + [15:0] + 0 + + + + + + REG_CMD_CFG + 0x0028 + 0x00 + 32 + + + r_cmd_continuous + 0 + [0:0] + 0 + + + + r_cmd_en + 4 + [4:4] + 4 + + + + r_cmd_clr + 6 + [6:6] + 6 + + + + + + REG_STATUS + 0x0030 + 0x00 + 32 + + + status_i + 0 + [0:0] + 0 + + + + + + + 0 + 0x34 + registers + + + + UDMA_SPIM_2 + 0x50107000 + UDMA_SPIM_2 + + + REG_RX_SADDR + 0x0000 + 0x00 + 32 + + + r_rx_startaddr + 11 + [11:0] + 0 + + + + + + REG_RX_SIZE + 0x0004 + 0x00 + 32 + + + r_rx_size + 15 + [15:0] + 0 + + + + + + REG_RX_CFG + 0x0008 + 0x00 + 32 + + + r_rx_continuous + 0 + [0:0] + 0 + + + + r_rx_datasize + 2 + [2:1] + 1 + + + + r_rx_en + 4 + [4:4] + 4 + + + + r_rx_clr + 6 + [6:6] + 6 + + + + + + REG_TX_SADDR + 0x0010 + 0x00 + 32 + + + r_tx_startaddr + 11 + [11:0] + 0 + + + + + + REG_TX_SIZE + 0x0014 + 0x00 + 32 + + + r_tx_size + 15 + [15:0] + 0 + + + + + + REG_TX_CFG + 0x0018 + 0x00 + 32 + + + r_tx_continuous + 0 + [0:0] + 0 + + + + r_tx_datasize + 2 + [2:1] + 1 + + + + r_tx_en + 4 + [4:4] + 4 + + + + r_tx_clr + 6 + [6:6] + 6 + + + + + + REG_CMD_SADDR + 0x0020 + 0x00 + 32 + + + r_cmd_startaddr + 11 + [11:0] + 0 + + + + + + REG_CMD_SIZE + 0x0024 + 0x00 + 32 + + + r_cmd_size + 15 + [15:0] + 0 + + + + + + REG_CMD_CFG + 0x0028 + 0x00 + 32 + + + r_cmd_continuous + 0 + [0:0] + 0 + + + + r_cmd_en + 4 + [4:4] + 4 + + + + r_cmd_clr + 6 + [6:6] + 6 + + + + + + REG_STATUS + 0x0030 + 0x00 + 32 + + + status_i + 0 + [0:0] + 0 + + + + + + + 0 + 0x34 + registers + + + + UDMA_SPIM_3 + 0x50108000 + UDMA_SPIM_3 + + + REG_RX_SADDR + 0x0000 + 0x00 + 32 + + + r_rx_startaddr + 11 + [11:0] + 0 + + + + + + REG_RX_SIZE + 0x0004 + 0x00 + 32 + + + r_rx_size + 15 + [15:0] + 0 + + + + + + REG_RX_CFG + 0x0008 + 0x00 + 32 + + + r_rx_continuous + 0 + [0:0] + 0 + + + + r_rx_datasize + 2 + [2:1] + 1 + + + + r_rx_en + 4 + [4:4] + 4 + + + + r_rx_clr + 6 + [6:6] + 6 + + + + + + REG_TX_SADDR + 0x0010 + 0x00 + 32 + + + r_tx_startaddr + 11 + [11:0] + 0 + + + + + + REG_TX_SIZE + 0x0014 + 0x00 + 32 + + + r_tx_size + 15 + [15:0] + 0 + + + + + + REG_TX_CFG + 0x0018 + 0x00 + 32 + + + r_tx_continuous + 0 + [0:0] + 0 + + + + r_tx_datasize + 2 + [2:1] + 1 + + + + r_tx_en + 4 + [4:4] + 4 + + + + r_tx_clr + 6 + [6:6] + 6 + + + + + + REG_CMD_SADDR + 0x0020 + 0x00 + 32 + + + r_cmd_startaddr + 11 + [11:0] + 0 + + + + + + REG_CMD_SIZE + 0x0024 + 0x00 + 32 + + + r_cmd_size + 15 + [15:0] + 0 + + + + + + REG_CMD_CFG + 0x0028 + 0x00 + 32 + + + r_cmd_continuous + 0 + [0:0] + 0 + + + + r_cmd_en + 4 + [4:4] + 4 + + + + r_cmd_clr + 6 + [6:6] + 6 + + + + + + REG_STATUS + 0x0030 + 0x00 + 32 + + + status_i + 0 + [0:0] + 0 + + + + + + + 0 + 0x34 + registers + + + + UDMA_I2C_0 + 0x50109000 + UDMA_I2C_0 + + + REG_RX_SADDR + 0x0000 + 0x00 + 32 + + + r_rx_startaddr + 11 + [11:0] + 0 + + + + + + REG_RX_SIZE + 0x0004 + 0x00 + 32 + + + r_rx_size + 15 + [15:0] + 0 + + + + + + REG_RX_CFG + 0x0008 + 0x00 + 32 + + + r_rx_continuous + 0 + [0:0] + 0 + + + + r_rx_en + 4 + [4:4] + 4 + + + + r_rx_clr + 6 + [6:6] + 6 + + + + + + REG_TX_SADDR + 0x0010 + 0x00 + 32 + + + r_tx_startaddr + 11 + [11:0] + 0 + + + + + + REG_TX_SIZE + 0x0014 + 0x00 + 32 + + + r_tx_size + 15 + [15:0] + 0 + + + + + + REG_TX_CFG + 0x0018 + 0x00 + 32 + + + r_tx_continuous + 0 + [0:0] + 0 + + + + r_tx_en + 4 + [4:4] + 4 + + + + r_tx_clr + 6 + [6:6] + 6 + + + + + + REG_CMD_SADDR + 0x0020 + 0x00 + 32 + + + r_cmd_startaddr + 11 + [11:0] + 0 + + + + + + REG_CMD_SIZE + 0x0024 + 0x00 + 32 + + + r_cmd_size + 15 + [15:0] + 0 + + + + + + REG_CMD_CFG + 0x0028 + 0x00 + 32 + + + r_cmd_continuous + 0 + [0:0] + 0 + + + + r_cmd_en + 4 + [4:4] + 4 + + + + r_cmd_clr + 6 + [6:6] + 6 + + + + + + REG_STATUS + 0x0030 + 0x00 + 32 + + + r_busy + 0 + [0:0] + 0 + + + + r_al + 1 + [1:1] + 1 + + + + + + REG_SETUP + 0x0034 + 0x00 + 32 + + + r_do_rst + 0 + [0:0] + 0 + + + + + + REG_ACK + 0x0038 + 0x00 + 32 + + + r_nack + 0 + [0:0] + 0 + + + + + + + 0 + 0x3c + registers + + + + UDMA_I2C_1 + 0x5010A000 + UDMA_I2C_1 + + + REG_RX_SADDR + 0x0000 + 0x00 + 32 + + + r_rx_startaddr + 11 + [11:0] + 0 + + + + + + REG_RX_SIZE + 0x0004 + 0x00 + 32 + + + r_rx_size + 15 + [15:0] + 0 + + + + + + REG_RX_CFG + 0x0008 + 0x00 + 32 + + + r_rx_continuous + 0 + [0:0] + 0 + + + + r_rx_en + 4 + [4:4] + 4 + + + + r_rx_clr + 6 + [6:6] + 6 + + + + + + REG_TX_SADDR + 0x0010 + 0x00 + 32 + + + r_tx_startaddr + 11 + [11:0] + 0 + + + + + + REG_TX_SIZE + 0x0014 + 0x00 + 32 + + + r_tx_size + 15 + [15:0] + 0 + + + + + + REG_TX_CFG + 0x0018 + 0x00 + 32 + + + r_tx_continuous + 0 + [0:0] + 0 + + + + r_tx_en + 4 + [4:4] + 4 + + + + r_tx_clr + 6 + [6:6] + 6 + + + + + + REG_CMD_SADDR + 0x0020 + 0x00 + 32 + + + r_cmd_startaddr + 11 + [11:0] + 0 + + + + + + REG_CMD_SIZE + 0x0024 + 0x00 + 32 + + + r_cmd_size + 15 + [15:0] + 0 + + + + + + REG_CMD_CFG + 0x0028 + 0x00 + 32 + + + r_cmd_continuous + 0 + [0:0] + 0 + + + + r_cmd_en + 4 + [4:4] + 4 + + + + r_cmd_clr + 6 + [6:6] + 6 + + + + + + REG_STATUS + 0x0030 + 0x00 + 32 + + + r_busy + 0 + [0:0] + 0 + + + + r_al + 1 + [1:1] + 1 + + + + + + REG_SETUP + 0x0034 + 0x00 + 32 + + + r_do_rst + 0 + [0:0] + 0 + + + + + + REG_ACK + 0x0038 + 0x00 + 32 + + + r_nack + 0 + [0:0] + 0 + + + + + + + 0 + 0x3c + registers + + + + UDMA_I2C_2 + 0x5010B000 + UDMA_I2C_2 + + + REG_RX_SADDR + 0x0000 + 0x00 + 32 + + + r_rx_startaddr + 11 + [11:0] + 0 + + + + + + REG_RX_SIZE + 0x0004 + 0x00 + 32 + + + r_rx_size + 15 + [15:0] + 0 + + + + + + REG_RX_CFG + 0x0008 + 0x00 + 32 + + + r_rx_continuous + 0 + [0:0] + 0 + + + + r_rx_en + 4 + [4:4] + 4 + + + + r_rx_clr + 6 + [6:6] + 6 + + + + + + REG_TX_SADDR + 0x0010 + 0x00 + 32 + + + r_tx_startaddr + 11 + [11:0] + 0 + + + + + + REG_TX_SIZE + 0x0014 + 0x00 + 32 + + + r_tx_size + 15 + [15:0] + 0 + + + + + + REG_TX_CFG + 0x0018 + 0x00 + 32 + + + r_tx_continuous + 0 + [0:0] + 0 + + + + r_tx_en + 4 + [4:4] + 4 + + + + r_tx_clr + 6 + [6:6] + 6 + + + + + + REG_CMD_SADDR + 0x0020 + 0x00 + 32 + + + r_cmd_startaddr + 11 + [11:0] + 0 + + + + + + REG_CMD_SIZE + 0x0024 + 0x00 + 32 + + + r_cmd_size + 15 + [15:0] + 0 + + + + + + REG_CMD_CFG + 0x0028 + 0x00 + 32 + + + r_cmd_continuous + 0 + [0:0] + 0 + + + + r_cmd_en + 4 + [4:4] + 4 + + + + r_cmd_clr + 6 + [6:6] + 6 + + + + + + REG_STATUS + 0x0030 + 0x00 + 32 + + + r_busy + 0 + [0:0] + 0 + + + + r_al + 1 + [1:1] + 1 + + + + + + REG_SETUP + 0x0034 + 0x00 + 32 + + + r_do_rst + 0 + [0:0] + 0 + + + + + + REG_ACK + 0x0038 + 0x00 + 32 + + + r_nack + 0 + [0:0] + 0 + + + + + + + 0 + 0x3c + registers + + + + UDMA_I2C_3 + 0x5010C000 + UDMA_I2C_3 + + + REG_RX_SADDR + 0x0000 + 0x00 + 32 + + + r_rx_startaddr + 11 + [11:0] + 0 + + + + + + REG_RX_SIZE + 0x0004 + 0x00 + 32 + + + r_rx_size + 15 + [15:0] + 0 + + + + + + REG_RX_CFG + 0x0008 + 0x00 + 32 + + + r_rx_continuous + 0 + [0:0] + 0 + + + + r_rx_en + 4 + [4:4] + 4 + + + + r_rx_clr + 6 + [6:6] + 6 + + + + + + REG_TX_SADDR + 0x0010 + 0x00 + 32 + + + r_tx_startaddr + 11 + [11:0] + 0 + + + + + + REG_TX_SIZE + 0x0014 + 0x00 + 32 + + + r_tx_size + 15 + [15:0] + 0 + + + + + + REG_TX_CFG + 0x0018 + 0x00 + 32 + + + r_tx_continuous + 0 + [0:0] + 0 + + + + r_tx_en + 4 + [4:4] + 4 + + + + r_tx_clr + 6 + [6:6] + 6 + + + + + + REG_CMD_SADDR + 0x0020 + 0x00 + 32 + + + r_cmd_startaddr + 11 + [11:0] + 0 + + + + + + REG_CMD_SIZE + 0x0024 + 0x00 + 32 + + + r_cmd_size + 15 + [15:0] + 0 + + + + + + REG_CMD_CFG + 0x0028 + 0x00 + 32 + + + r_cmd_continuous + 0 + [0:0] + 0 + + + + r_cmd_en + 4 + [4:4] + 4 + + + + r_cmd_clr + 6 + [6:6] + 6 + + + + + + REG_STATUS + 0x0030 + 0x00 + 32 + + + r_busy + 0 + [0:0] + 0 + + + + r_al + 1 + [1:1] + 1 + + + + + + REG_SETUP + 0x0034 + 0x00 + 32 + + + r_do_rst + 0 + [0:0] + 0 + + + + + + REG_ACK + 0x0038 + 0x00 + 32 + + + r_nack + 0 + [0:0] + 0 + + + + + + + 0 + 0x3c + registers + + + + UDMA_SDIO + 0x5010D000 + UDMA_SDIO + + + REG_RX_SADDR + 0x0000 + 0x00 + 32 + + + r_rx_startaddr + 11 + [11:0] + 0 + + + + + + REG_RX_SIZE + 0x0004 + 0x00 + 32 + + + r_rx_size + 15 + [15:0] + 0 + + + + + + REG_RX_CFG + 0x0008 + 0x00 + 32 + + + r_rx_continuous + 0 + [0:0] + 0 + + + + r_rx_en + 4 + [4:4] + 4 + + + + r_rx_clr + 5 + [5:5] + 5 + + + + + + REG_TX_SADDR + 0x0010 + 0x00 + 32 + + + r_tx_startaddr + 11 + [11:0] + 0 + + + + + + REG_TX_SIZE + 0x0014 + 0x00 + 32 + + + r_tx_size + 15 + [15:0] + 0 + + + + + + REG_TX_CFG + 0x0018 + 0x00 + 32 + + + r_tx_continuous + 0 + [0:0] + 0 + + + + r_tx_en + 4 + [4:4] + 4 + + + + r_tx_clr + 5 + [5:5] + 5 + + + + + + REG_CMD_OP + 0x0020 + 0x00 + 32 + + + r_cmd_rsp_type + 2 + [2:0] + 0 + + + + r_cmd_op + 13 + [13:8] + 8 + + + + + + REG_DATA_SETUP + 0x0028 + 0x00 + 32 + + + r_data_en + 0 + [0:0] + 0 + + + + r_data_rwn + 1 + [1:1] + 1 + + + + r_data_quad + 2 + [2:2] + 2 + + + + r_data_block_num + 15 + [15:8] + 8 + + + + r_data_block_size + 25 + [25:16] + 16 + + + + + + REG_START + 0x002c + 0x00 + 32 + + + r_sdio_start + 0 + [0:0] + 0 + + + + + + REG_RSP0 + 0x0030 + 0x00 + 32 + + + cfg_rsp_data_i_31_0 + 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 + + + + + + + 0 + 0x48 + registers + + + + UDMA_I2S + 0x5010E000 + UDMA_I2S + + + REG_RX_SADDR + 0x0000 + 0x00 + 32 + + + r_rx_startaddr + 11 + [11:0] + 0 + + + + + + REG_RX_SIZE + 0x0004 + 0x00 + 32 + + + r_rx_size + 15 + [15:0] + 0 + + + + + + REG_RX_CFG + 0x0008 + 0x00 + 32 + + + r_rx_continuous + 0 + [0:0] + 0 + + + + r_rx_datasize + 2 + [2:1] + 1 + + + + r_rx_en + 4 + [4:4] + 4 + + + + r_rx_clr + 5 + [5:5] + 5 + + + + + + REG_TX_SADDR + 0x0010 + 0x00 + 32 + + + r_tx_startaddr + 11 + [11:0] + 0 + + + + + + REG_TX_SIZE + 0x0014 + 0x00 + 32 + + + r_tx_size + 15 + [15:0] + 0 + + + + + + REG_TX_CFG + 0x0018 + 0x00 + 32 + + + r_tx_continuous + 0 + [0:0] + 0 + + + + r_tx_datasize + 2 + [2:1] + 1 + + + + r_tx_en + 4 + [4:4] + 4 + + + + r_tx_clr + 5 + [5:5] + 5 + + + + + + REG_I2S_CLKCFG_SETUP + 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 + 2 + [2:0] + 0 + + + + r_slave_i2s_bits_word + 12 + [12:8] + 8 + + + + r_slave_i2s_lsb_first + 16 + [16:16] + 16 + + + + r_slave_i2s_2ch + 17 + [17:17] + 17 + + + + r_slave_i2s_en + 31 + [31:31] + 31 + + + + + + REG_I2S_MST_SETUP + 0x0028 + 0x00 + 32 + + + r_master_i2s_words + 2 + [2:0] + 0 + + + + r_master_i2s_bits_word + 12 + [12:8] + 8 + + + + r_master_i2s_lsb_first + 16 + [16:16] + 16 + + + + r_master_i2s_2ch + 17 + [17:17] + 17 + + + + r_master_i2s_en + 31 + [31:31] + 31 + + + + + + REG_I2S_PDM_SETUP + 0x002c + 0x00 + 32 + + + r_slave_pdm_shift + 2 + [2:0] + 0 + + + + r_slave_pdm_decimation + 12 + [12:3] + 3 + + + + r_slave_pdm_mode + 14 + [14:13] + 13 + + + + r_slave_pdm_en + 31 + [31:31] + 31 + + + + + + + 0 + 0x30 + registers + + + + UDMA_CAMERA + 0x5010F000 + UDMA_CAMERA + + + REG_RX_SADDR + 0x0000 + 0x00 + 32 + + + r_rx_startaddr + 11 + [11:0] + 0 + + + + + + REG_RX_SIZE + 0x0004 + 0x00 + 32 + + + r_rx_size + 15 + [15:0] + 0 + + + + + + REG_RX_CFG + 0x0008 + 0x00 + 32 + + + r_rx_continuous + 0 + [0:0] + 0 + + + + r_rx_datasize + 2 + [2:1] + 1 + + + + r_rx_en + 4 + [4:4] + 4 + + + + r_rx_clr + 6 + [6:6] + 6 + + + + + + REG_CAM_CFG_GLOB + 0x0020 + 0x00 + 32 + + + r_cam_cfg + 29 + [29:0] + 0 + + + + cfg_cam_ip_en_i + 30 + [30:30] + 30 + + + + + + REG_CAM_CFG_LL + 0x0024 + 0x00 + 32 + + + r_cam_cfg_ll + 31 + [31:0] + 0 + + + + + + REG_CAM_CFG_UR + 0x0028 + 0x00 + 32 + + + r_cam_cfg_ur + 31 + [31:0] + 0 + + + + + + REG_CAM_CFG_SIZE + 0x002c + 0x00 + 32 + + + r_cam_cfg_size + 31 + [31:0] + 0 + + + + + + REG_CAM_CFG_FILTER + 0x0030 + 0x00 + 32 + + + r_cam_cfg_filter + 31 + [31:0] + 0 + + + + + + REG_CAM_VSYNC_POLARITY + 0x0034 + 0x00 + 32 + + + r_cam_vsync_polarity + 0 + [0:0] + 0 + + + + r_cam_hsync_polarity + 1 + [1:1] + 1 + + + + + + + 0 + 0x38 + registers + + + + UDMA_FILTER + 0x50110000 + UDMA_FILTER + + + REG_TX_CH0_ADD + 0x0000 + 0x00 + 32 + + + r_filter_tx_start_addr_0 + 14 + [14:0] + 0 + + + + + + REG_TX_CH0_CFG + 0x0004 + 0x00 + 32 + + + r_filter_tx_datasize_0 + 1 + [1:0] + 0 + + + + r_filter_tx_mode_0 + 9 + [9:8] + 8 + + + + + + REG_TX_CH0_LEN0 + 0x0008 + 0x00 + 32 + + + r_filter_tx_len0_0 + 14 + [14:0] + 0 + + + + + + REG_TX_CH0_LEN1 + 0x000c + 0x00 + 32 + + + r_filter_tx_len1_0 + 14 + [14:0] + 0 + + + + + + REG_TX_CH0_LEN2 + 0x0010 + 0x00 + 32 + + + r_filter_tx_len2_0 + 14 + [14:0] + 0 + + + + + + REG_TX_CH1_ADD + 0x0014 + 0x00 + 32 + + + r_filter_tx_start_addr_1 + 14 + [14:0] + 0 + + + + + + REG_TX_CH1_CFG + 0x0018 + 0x00 + 32 + + + r_filter_tx_datasize_1 + 1 + [1:0] + 0 + + + + r_filter_tx_mode_1 + 9 + [9:8] + 8 + + + + + + REG_TX_CH1_LEN0 + 0x001c + 0x00 + 32 + + + r_filter_tx_len0_1 + 14 + [14:0] + 0 + + + + + + REG_TX_CH1_LEN1 + 0x0020 + 0x00 + 32 + + + r_filter_tx_len1_1 + 14 + [14:0] + 0 + + + + + + REG_TX_CH1_LEN2 + 0x0024 + 0x00 + 32 + + + r_filter_tx_len2_1 + 14 + [14:0] + 0 + + + + + + REG_RX_CH_ADD + 0x0028 + 0x00 + 32 + + + r_filter_rx_start_addr + 14 + [14:0] + 0 + + + + + + REG_RX_CH_CFG + 0x002c + 0x00 + 32 + + + r_filter_rx_datasize + 1 + [1:0] + 0 + + + + r_filter_rx_mode + 9 + [9:8] + 8 + + + + + + REG_RX_CH_LEN0 + 0x0030 + 0x00 + 32 + + + r_filter_rx_len0 + 15 + [15:0] + 0 + + + + + + REG_RX_CH_LEN1 + 0x0034 + 0x00 + 32 + + + r_filter_rx_len1 + 15 + [15:0] + 0 + + + + + + REG_RX_CH_LEN2 + 0x0038 + 0x00 + 32 + + + r_filter_rx_len2 + 15 + [15:0] + 0 + + + + + + REG_AU_CFG + 0x003c + 0x00 + 32 + + + r_au_use_signed + 0 + [0:0] + 0 + + + + r_au_bypass + 1 + [1:1] + 1 + + + + r_au_mode + 11 + [11:8] + 8 + + + + r_au_shift + 20 + [20:16] + 16 + + + + + + REG_AU_REG0 + 0x0040 + 0x00 + 32 + + + r_commit_au_reg0 + 31 + [31:0] + 0 + + + + + + REG_AU_REG1 + 0x0044 + 0x00 + 32 + + + r_commit_au_reg1 + 31 + [31:0] + 0 + + + + + + REG_BINCU_TH + 0x0048 + 0x00 + 32 + + + r_commit_bincu_threshold + 31 + [31:0] + 0 + + + + + + REG_BINCU_CNT + 0x004c + 0x00 + 32 + + + r_bincu_counter + 14 + [14:0] + 0 + + + + r_bincu_en_counter + 31 + [31:31] + 31 + + + + + + REG_BINCU_SETUP + 0x0050 + 0x00 + 32 + + + r_bincu_datasize + 1 + [1:0] + 0 + + + + + + REG_BINCU_VAL + 0x0054 + 0x00 + 32 + + + bincu_counter_i + 14 + [14:0] + 0 + + + + + + REG_FILT + 0x0058 + 0x00 + 32 + + + r_filter_mode + 3 + [3:0] + 0 + + + + + + REG_STATUS + 0x0060 + 0x00 + 32 + + + r_filter_done + 0 + [0:0] + 0 + + + + + + + 0 + 0x64 + registers + + + + UDMA_SCIF + 0x50111000 + UDMA_SCIF + + + REG_RX_SADDR + 0x0000 + 0x00 + 32 + + + r_rx_startaddr + 11 + [11:0] + 0 + + + + + + REG_RX_SIZE + 0x0004 + 0x00 + 32 + + + r_rx_size + 15 + [15:0] + 0 + + + + + + REG_RX_CFG + 0x0008 + 0x00 + 32 + + + r_rx_continuous + 0 + [0:0] + 0 + + + + + + REG_TX_SADDR + 0x0010 + 0x00 + 32 + + + r_tx_startaddr + 11 + [11:0] + 0 + + + + + + REG_TX_SIZE + 0x0014 + 0x00 + 32 + + + r_tx_size + 15 + [15:0] + 0 + + + + + + REG_TX_CFG + 0x0018 + 0x00 + 32 + + + r_tx_continuous + 0 + [0:0] + 0 + + + + + + REG_STATUS + 0x0020 + 0x00 + 32 + + + status_i + 0 + [0:0] + 0 + + + + + + REG_SCIF_SETUP + 0x0024 + 0x00 + 32 + + + r_scif_parity_en + 0 + [0:0] + 0 + + + + r_scif_bits + 2 + [2:1] + 1 + + + + r_scif_stop_bits + 3 + [3:3] + 3 + + + + r_scif_rx_polling_en + 4 + [4:4] + 4 + + + + r_scif_rx_clean_fifo + 5 + [5:5] + 5 + + + + r_scif_en_tx + 8 + [8:8] + 8 + + + + r_scif_en_rx + 9 + [9:9] + 9 + + + + r_scif_clksel + 15 + [15:14] + 14 + + + + r_scif_div + 31 + [31:16] + 16 + + + + + + REG_ERROR + 0x0028 + 0x00 + 32 + + + r_err_overflow + 0 + [0:0] + 0 + + + + r_err_parity + 1 + [1:1] + 1 + + + + + + REG_IRQ_EN + 0x002c + 0x00 + 32 + + + r_scif_rx_irq_en + 0 + [0:0] + 0 + + + + r_scif_err_irq_en + 1 + [1:1] + 1 + + + + + + REG_VALID + 0x0030 + 0x00 + 32 + + + r_scif_rx_data_valid + 0 + [0:0] + 0 + + + + + + REG_DATA + 0x0034 + 0x00 + 32 + + + r_scif_rx_data + 7 + [7:0] + 0 + + + + + + REG_SCIF_ETU + 0x0038 + 0x00 + 32 + + + r_scif_etu + 15 + [15:0] + 0 + + + + + + + 0 + 0x3c + registers + + + + UDMA_SPIS_0 + 0x50112000 + UDMA_SPIS_0 + + + REG_RX_SADDR + 0x0000 + 0x00 + 32 + + + r_rx_startaddr + 11 + [11:0] + 0 + + + + + + REG_RX_SIZE + 0x0004 + 0x00 + 32 + + + r_rx_size + 15 + [15:0] + 0 + + + + + + REG_RX_CFG + 0x0008 + 0x00 + 32 + + + r_rx_continuous + 0 + [0:0] + 0 + + + + r_rx_en + 4 + [4:4] + 4 + + + + r_rx_clr + 6 + [6:6] + 6 + + + + + + REG_TX_SADDR + 0x0010 + 0x00 + 32 + + + r_tx_startaddr + 11 + [11:0] + 0 + + + + + + REG_TX_SIZE + 0x0014 + 0x00 + 32 + + + r_tx_size + 15 + [15:0] + 0 + + + + + + REG_TX_CFG + 0x0018 + 0x00 + 32 + + + r_tx_continuous + 0 + [0:0] + 0 + + + + r_tx_en + 4 + [4:4] + 4 + + + + r_tx_clr + 6 + [6:6] + 6 + + + + + + REG_SPIS_SETUP + 0x0020 + 0x00 + 32 + + + cfgcpol + 0 + [0:0] + 0 + + + + cfgcpha + 1 + [1:1] + 1 + + + + + + REG_SEOT_CNT + 0x0024 + 0x00 + 32 + + + sr_seot_cnt + 15 + [15:0] + 0 + + + + + + REG_SPIS_IRQ_EN + 0x0028 + 0x00 + 32 + + + seot_irq_en + 0 + [0:0] + 0 + + + + + + REG_SPIS_RXCNT + 0x002c + 0x00 + 32 + + + cfgrxcnt + 15 + [15:0] + 0 + + + + + + REG_SPIS_TXCNT + 0x0030 + 0x00 + 32 + + + cfgtxcnt + 15 + [15:0] + 0 + + + + + + REG_SPIS_DMCNT + 0x0034 + 0x00 + 32 + + + cfgdmcnt + 15 + [15:0] + 0 + + + + + + + 0 + 0x38 + registers + + + + UDMA_SPIS_1 + 0x50113000 + UDMA_SPIS_1 + + + REG_RX_SADDR + 0x0000 + 0x00 + 32 + + + r_rx_startaddr + 11 + [11:0] + 0 + + + + + + REG_RX_SIZE + 0x0004 + 0x00 + 32 + + + r_rx_size + 15 + [15:0] + 0 + + + + + + REG_RX_CFG + 0x0008 + 0x00 + 32 + + + r_rx_continuous + 0 + [0:0] + 0 + + + + r_rx_en + 4 + [4:4] + 4 + + + + r_rx_clr + 6 + [6:6] + 6 + + + + + + REG_TX_SADDR + 0x0010 + 0x00 + 32 + + + r_tx_startaddr + 11 + [11:0] + 0 + + + + + + REG_TX_SIZE + 0x0014 + 0x00 + 32 + + + r_tx_size + 15 + [15:0] + 0 + + + + + + REG_TX_CFG + 0x0018 + 0x00 + 32 + + + r_tx_continuous + 0 + [0:0] + 0 + + + + r_tx_en + 4 + [4:4] + 4 + + + + r_tx_clr + 6 + [6:6] + 6 + + + + + + REG_SPIS_SETUP + 0x0020 + 0x00 + 32 + + + cfgcpol + 0 + [0:0] + 0 + + + + cfgcpha + 1 + [1:1] + 1 + + + + + + REG_SEOT_CNT + 0x0024 + 0x00 + 32 + + + sr_seot_cnt + 15 + [15:0] + 0 + + + + + + REG_SPIS_IRQ_EN + 0x0028 + 0x00 + 32 + + + seot_irq_en + 0 + [0:0] + 0 + + + + + + REG_SPIS_RXCNT + 0x002c + 0x00 + 32 + + + cfgrxcnt + 15 + [15:0] + 0 + + + + + + REG_SPIS_TXCNT + 0x0030 + 0x00 + 32 + + + cfgtxcnt + 15 + [15:0] + 0 + + + + + + REG_SPIS_DMCNT + 0x0034 + 0x00 + 32 + + + cfgdmcnt + 15 + [15:0] + 0 + + + + + + + 0 + 0x38 + registers + + AES 0x4002D000 diff --git a/utralib/cramium/soc.svd b/utralib/cramium/soc.svd index 948585398..5d87191ae 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_fpga.rs b/utralib/src/generated/cramium_fpga.rs index 8e2298e6a..826a790f6 100644 --- a/utralib/src/generated/cramium_fpga.rs +++ b/utralib/src/generated/cramium_fpga.rs @@ -356,6 +356,26 @@ pub const HW_MB_CLIENT_BASE : usize = 0xe0019000; pub const HW_RESETVALUE_BASE : usize = 0xe001a000; pub const HW_TICKTIMER_BASE : usize = 0xe001b000; pub const HW_PL230_BASE : usize = 0x40011000; +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; +pub const HW_UDMA_UART_2_BASE : usize = 0x50103000; +pub const HW_UDMA_UART_3_BASE : usize = 0x50104000; +pub const HW_UDMA_SPIM_0_BASE : usize = 0x50105000; +pub const HW_UDMA_SPIM_1_BASE : usize = 0x50106000; +pub const HW_UDMA_SPIM_2_BASE : usize = 0x50107000; +pub const HW_UDMA_SPIM_3_BASE : usize = 0x50108000; +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_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_AES_BASE : usize = 0x4002d000; pub const HW_COMBOHASH_BASE : usize = 0x4002b000; pub const HW_PKE_BASE : usize = 0x4002c000; @@ -2366,6 +2386,1012 @@ pub mod utra { pub const HW_PL230_BASE: usize = 0x40011000; } + pub mod udma_ctrl { + pub const UDMA_CTRL_NUMREGS: usize = 3; + + pub const REG_CG: crate::Register = crate::Register::new(0, 0x3f); + pub const REG_CG_R_CG: crate::Field = crate::Field::new(6, 0, REG_CG); + + pub const REG_CFG_EVT: crate::Register = crate::Register::new(1, 0xffffffff); + pub const REG_CFG_EVT_R_CMP_EVT_0: crate::Field = crate::Field::new(8, 0, REG_CFG_EVT); + pub const REG_CFG_EVT_R_CMP_EVT_1: crate::Field = crate::Field::new(8, 8, REG_CFG_EVT); + pub const REG_CFG_EVT_R_CMP_EVT_2: crate::Field = crate::Field::new(8, 16, REG_CFG_EVT); + pub const REG_CFG_EVT_R_CMP_EVT_3: crate::Field = crate::Field::new(8, 24, REG_CFG_EVT); + + pub const REG_RST: crate::Register = crate::Register::new(2, 0x3f); + pub const REG_RST_R_RST: crate::Field = crate::Field::new(6, 0, REG_RST); + + pub const HW_UDMA_CTRL_BASE: usize = 0x50100000; + } + + pub mod udma_uart_0 { + pub const UDMA_UART_0_NUMREGS: usize = 12; + + 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, 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); + + 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, 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); + + pub const REG_UART_SETUP: crate::Register = crate::Register::new(9, 0xffff033f); + pub const REG_UART_SETUP_R_UART_PARITY_EN: crate::Field = crate::Field::new(1, 0, REG_UART_SETUP); + pub const REG_UART_SETUP_R_UART_BITS: crate::Field = crate::Field::new(2, 1, REG_UART_SETUP); + pub const REG_UART_SETUP_R_UART_STOP_BITS: crate::Field = crate::Field::new(1, 3, REG_UART_SETUP); + pub const REG_UART_SETUP_R_UART_RX_POLLING_EN: crate::Field = crate::Field::new(1, 4, REG_UART_SETUP); + pub const REG_UART_SETUP_R_UART_RX_CLEAN_FIFO: crate::Field = crate::Field::new(1, 5, REG_UART_SETUP); + pub const REG_UART_SETUP_R_UART_EN_TX: crate::Field = crate::Field::new(1, 8, REG_UART_SETUP); + pub const REG_UART_SETUP_R_UART_EN_RX: crate::Field = crate::Field::new(1, 9, REG_UART_SETUP); + pub const REG_UART_SETUP_R_UART_DIV: crate::Field = crate::Field::new(16, 16, REG_UART_SETUP); + + pub const REG_ERROR: crate::Register = crate::Register::new(10, 0x3); + pub const REG_ERROR_R_ERR_OVERFLOW: crate::Field = crate::Field::new(1, 0, REG_ERROR); + pub const REG_ERROR_R_ERR_PARITY: crate::Field = crate::Field::new(1, 1, REG_ERROR); + + pub const REG_IRQ_EN: crate::Register = crate::Register::new(11, 0x3); + pub const REG_IRQ_EN_R_UART_RX_IRQ_EN: crate::Field = crate::Field::new(1, 0, REG_IRQ_EN); + pub const REG_IRQ_EN_R_UART_ERR_IRQ_EN: crate::Field = crate::Field::new(1, 1, REG_IRQ_EN); + + pub const REG_VALID: crate::Register = crate::Register::new(12, 0x1); + pub const REG_VALID_R_UART_RX_DATA_VALID: crate::Field = crate::Field::new(1, 0, REG_VALID); + + pub const REG_DATA: crate::Register = crate::Register::new(13, 0xff); + pub const REG_DATA_R_UART_RX_DATA: crate::Field = crate::Field::new(8, 0, REG_DATA); + + pub const HW_UDMA_UART_0_BASE: usize = 0x50101000; + } + + pub mod udma_uart_1 { + pub const UDMA_UART_1_NUMREGS: usize = 12; + + 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, 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); + + 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, 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); + + pub const REG_UART_SETUP: crate::Register = crate::Register::new(9, 0xffff033f); + pub const REG_UART_SETUP_R_UART_PARITY_EN: crate::Field = crate::Field::new(1, 0, REG_UART_SETUP); + pub const REG_UART_SETUP_R_UART_BITS: crate::Field = crate::Field::new(2, 1, REG_UART_SETUP); + pub const REG_UART_SETUP_R_UART_STOP_BITS: crate::Field = crate::Field::new(1, 3, REG_UART_SETUP); + pub const REG_UART_SETUP_R_UART_RX_POLLING_EN: crate::Field = crate::Field::new(1, 4, REG_UART_SETUP); + pub const REG_UART_SETUP_R_UART_RX_CLEAN_FIFO: crate::Field = crate::Field::new(1, 5, REG_UART_SETUP); + pub const REG_UART_SETUP_R_UART_EN_TX: crate::Field = crate::Field::new(1, 8, REG_UART_SETUP); + pub const REG_UART_SETUP_R_UART_EN_RX: crate::Field = crate::Field::new(1, 9, REG_UART_SETUP); + pub const REG_UART_SETUP_R_UART_DIV: crate::Field = crate::Field::new(16, 16, REG_UART_SETUP); + + pub const REG_ERROR: crate::Register = crate::Register::new(10, 0x3); + pub const REG_ERROR_R_ERR_OVERFLOW: crate::Field = crate::Field::new(1, 0, REG_ERROR); + pub const REG_ERROR_R_ERR_PARITY: crate::Field = crate::Field::new(1, 1, REG_ERROR); + + pub const REG_IRQ_EN: crate::Register = crate::Register::new(11, 0x3); + pub const REG_IRQ_EN_R_UART_RX_IRQ_EN: crate::Field = crate::Field::new(1, 0, REG_IRQ_EN); + pub const REG_IRQ_EN_R_UART_ERR_IRQ_EN: crate::Field = crate::Field::new(1, 1, REG_IRQ_EN); + + pub const REG_VALID: crate::Register = crate::Register::new(12, 0x1); + pub const REG_VALID_R_UART_RX_DATA_VALID: crate::Field = crate::Field::new(1, 0, REG_VALID); + + pub const REG_DATA: crate::Register = crate::Register::new(13, 0xff); + pub const REG_DATA_R_UART_RX_DATA: crate::Field = crate::Field::new(8, 0, REG_DATA); + + pub const HW_UDMA_UART_1_BASE: usize = 0x50102000; + } + + pub mod udma_uart_2 { + pub const UDMA_UART_2_NUMREGS: usize = 12; + + 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, 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); + + 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, 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); + + pub const REG_UART_SETUP: crate::Register = crate::Register::new(9, 0xffff033f); + pub const REG_UART_SETUP_R_UART_PARITY_EN: crate::Field = crate::Field::new(1, 0, REG_UART_SETUP); + pub const REG_UART_SETUP_R_UART_BITS: crate::Field = crate::Field::new(2, 1, REG_UART_SETUP); + pub const REG_UART_SETUP_R_UART_STOP_BITS: crate::Field = crate::Field::new(1, 3, REG_UART_SETUP); + pub const REG_UART_SETUP_R_UART_RX_POLLING_EN: crate::Field = crate::Field::new(1, 4, REG_UART_SETUP); + pub const REG_UART_SETUP_R_UART_RX_CLEAN_FIFO: crate::Field = crate::Field::new(1, 5, REG_UART_SETUP); + pub const REG_UART_SETUP_R_UART_EN_TX: crate::Field = crate::Field::new(1, 8, REG_UART_SETUP); + pub const REG_UART_SETUP_R_UART_EN_RX: crate::Field = crate::Field::new(1, 9, REG_UART_SETUP); + pub const REG_UART_SETUP_R_UART_DIV: crate::Field = crate::Field::new(16, 16, REG_UART_SETUP); + + pub const REG_ERROR: crate::Register = crate::Register::new(10, 0x3); + pub const REG_ERROR_R_ERR_OVERFLOW: crate::Field = crate::Field::new(1, 0, REG_ERROR); + pub const REG_ERROR_R_ERR_PARITY: crate::Field = crate::Field::new(1, 1, REG_ERROR); + + pub const REG_IRQ_EN: crate::Register = crate::Register::new(11, 0x3); + pub const REG_IRQ_EN_R_UART_RX_IRQ_EN: crate::Field = crate::Field::new(1, 0, REG_IRQ_EN); + pub const REG_IRQ_EN_R_UART_ERR_IRQ_EN: crate::Field = crate::Field::new(1, 1, REG_IRQ_EN); + + pub const REG_VALID: crate::Register = crate::Register::new(12, 0x1); + pub const REG_VALID_R_UART_RX_DATA_VALID: crate::Field = crate::Field::new(1, 0, REG_VALID); + + pub const REG_DATA: crate::Register = crate::Register::new(13, 0xff); + pub const REG_DATA_R_UART_RX_DATA: crate::Field = crate::Field::new(8, 0, REG_DATA); + + pub const HW_UDMA_UART_2_BASE: usize = 0x50103000; + } + + pub mod udma_uart_3 { + pub const UDMA_UART_3_NUMREGS: usize = 12; + + 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, 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); + + 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, 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); + + pub const REG_UART_SETUP: crate::Register = crate::Register::new(9, 0xffff033f); + pub const REG_UART_SETUP_R_UART_PARITY_EN: crate::Field = crate::Field::new(1, 0, REG_UART_SETUP); + pub const REG_UART_SETUP_R_UART_BITS: crate::Field = crate::Field::new(2, 1, REG_UART_SETUP); + pub const REG_UART_SETUP_R_UART_STOP_BITS: crate::Field = crate::Field::new(1, 3, REG_UART_SETUP); + pub const REG_UART_SETUP_R_UART_RX_POLLING_EN: crate::Field = crate::Field::new(1, 4, REG_UART_SETUP); + pub const REG_UART_SETUP_R_UART_RX_CLEAN_FIFO: crate::Field = crate::Field::new(1, 5, REG_UART_SETUP); + pub const REG_UART_SETUP_R_UART_EN_TX: crate::Field = crate::Field::new(1, 8, REG_UART_SETUP); + pub const REG_UART_SETUP_R_UART_EN_RX: crate::Field = crate::Field::new(1, 9, REG_UART_SETUP); + pub const REG_UART_SETUP_R_UART_DIV: crate::Field = crate::Field::new(16, 16, REG_UART_SETUP); + + pub const REG_ERROR: crate::Register = crate::Register::new(10, 0x3); + pub const REG_ERROR_R_ERR_OVERFLOW: crate::Field = crate::Field::new(1, 0, REG_ERROR); + pub const REG_ERROR_R_ERR_PARITY: crate::Field = crate::Field::new(1, 1, REG_ERROR); + + pub const REG_IRQ_EN: crate::Register = crate::Register::new(11, 0x3); + pub const REG_IRQ_EN_R_UART_RX_IRQ_EN: crate::Field = crate::Field::new(1, 0, REG_IRQ_EN); + pub const REG_IRQ_EN_R_UART_ERR_IRQ_EN: crate::Field = crate::Field::new(1, 1, REG_IRQ_EN); + + pub const REG_VALID: crate::Register = crate::Register::new(12, 0x1); + pub const REG_VALID_R_UART_RX_DATA_VALID: crate::Field = crate::Field::new(1, 0, REG_VALID); + + pub const REG_DATA: crate::Register = crate::Register::new(13, 0xff); + pub const REG_DATA_R_UART_RX_DATA: crate::Field = crate::Field::new(8, 0, REG_DATA); + + pub const HW_UDMA_UART_3_BASE: usize = 0x50104000; + } + + pub mod udma_spim_0 { + pub const UDMA_SPIM_0_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); + + 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_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_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); + + 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, 0x57); + 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, 6, REG_TX_CFG); + + pub const REG_CMD_SADDR: crate::Register = crate::Register::new(8, 0xfff); + pub const REG_CMD_SADDR_R_CMD_STARTADDR: crate::Field = crate::Field::new(12, 0, REG_CMD_SADDR); + + pub const REG_CMD_SIZE: crate::Register = crate::Register::new(9, 0xffff); + pub const REG_CMD_SIZE_R_CMD_SIZE: crate::Field = crate::Field::new(16, 0, REG_CMD_SIZE); + + pub const REG_CMD_CFG: crate::Register = crate::Register::new(10, 0x51); + pub const REG_CMD_CFG_R_CMD_CONTINUOUS: crate::Field = crate::Field::new(1, 0, REG_CMD_CFG); + pub const REG_CMD_CFG_R_CMD_EN: crate::Field = crate::Field::new(1, 4, REG_CMD_CFG); + pub const REG_CMD_CFG_R_CMD_CLR: crate::Field = crate::Field::new(1, 6, REG_CMD_CFG); + + pub const REG_STATUS: crate::Register = crate::Register::new(12, 0x1); + pub const REG_STATUS_STATUS_I: crate::Field = crate::Field::new(1, 0, REG_STATUS); + + pub const HW_UDMA_SPIM_0_BASE: usize = 0x50105000; + } + + pub mod udma_spim_1 { + pub const UDMA_SPIM_1_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); + + 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_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_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); + + 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, 0x57); + 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, 6, REG_TX_CFG); + + pub const REG_CMD_SADDR: crate::Register = crate::Register::new(8, 0xfff); + pub const REG_CMD_SADDR_R_CMD_STARTADDR: crate::Field = crate::Field::new(12, 0, REG_CMD_SADDR); + + pub const REG_CMD_SIZE: crate::Register = crate::Register::new(9, 0xffff); + pub const REG_CMD_SIZE_R_CMD_SIZE: crate::Field = crate::Field::new(16, 0, REG_CMD_SIZE); + + pub const REG_CMD_CFG: crate::Register = crate::Register::new(10, 0x51); + pub const REG_CMD_CFG_R_CMD_CONTINUOUS: crate::Field = crate::Field::new(1, 0, REG_CMD_CFG); + pub const REG_CMD_CFG_R_CMD_EN: crate::Field = crate::Field::new(1, 4, REG_CMD_CFG); + pub const REG_CMD_CFG_R_CMD_CLR: crate::Field = crate::Field::new(1, 6, REG_CMD_CFG); + + pub const REG_STATUS: crate::Register = crate::Register::new(12, 0x1); + pub const REG_STATUS_STATUS_I: crate::Field = crate::Field::new(1, 0, REG_STATUS); + + pub const HW_UDMA_SPIM_1_BASE: usize = 0x50106000; + } + + pub mod udma_spim_2 { + pub const UDMA_SPIM_2_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); + + 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_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_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); + + 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, 0x57); + 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, 6, REG_TX_CFG); + + pub const REG_CMD_SADDR: crate::Register = crate::Register::new(8, 0xfff); + pub const REG_CMD_SADDR_R_CMD_STARTADDR: crate::Field = crate::Field::new(12, 0, REG_CMD_SADDR); + + pub const REG_CMD_SIZE: crate::Register = crate::Register::new(9, 0xffff); + pub const REG_CMD_SIZE_R_CMD_SIZE: crate::Field = crate::Field::new(16, 0, REG_CMD_SIZE); + + pub const REG_CMD_CFG: crate::Register = crate::Register::new(10, 0x51); + pub const REG_CMD_CFG_R_CMD_CONTINUOUS: crate::Field = crate::Field::new(1, 0, REG_CMD_CFG); + pub const REG_CMD_CFG_R_CMD_EN: crate::Field = crate::Field::new(1, 4, REG_CMD_CFG); + pub const REG_CMD_CFG_R_CMD_CLR: crate::Field = crate::Field::new(1, 6, REG_CMD_CFG); + + pub const REG_STATUS: crate::Register = crate::Register::new(12, 0x1); + pub const REG_STATUS_STATUS_I: crate::Field = crate::Field::new(1, 0, REG_STATUS); + + pub const HW_UDMA_SPIM_2_BASE: usize = 0x50107000; + } + + pub mod udma_spim_3 { + pub const UDMA_SPIM_3_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); + + 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_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_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); + + 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, 0x57); + 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, 6, REG_TX_CFG); + + pub const REG_CMD_SADDR: crate::Register = crate::Register::new(8, 0xfff); + pub const REG_CMD_SADDR_R_CMD_STARTADDR: crate::Field = crate::Field::new(12, 0, REG_CMD_SADDR); + + pub const REG_CMD_SIZE: crate::Register = crate::Register::new(9, 0xffff); + pub const REG_CMD_SIZE_R_CMD_SIZE: crate::Field = crate::Field::new(16, 0, REG_CMD_SIZE); + + pub const REG_CMD_CFG: crate::Register = crate::Register::new(10, 0x51); + pub const REG_CMD_CFG_R_CMD_CONTINUOUS: crate::Field = crate::Field::new(1, 0, REG_CMD_CFG); + pub const REG_CMD_CFG_R_CMD_EN: crate::Field = crate::Field::new(1, 4, REG_CMD_CFG); + pub const REG_CMD_CFG_R_CMD_CLR: crate::Field = crate::Field::new(1, 6, REG_CMD_CFG); + + pub const REG_STATUS: crate::Register = crate::Register::new(12, 0x1); + pub const REG_STATUS_STATUS_I: crate::Field = crate::Field::new(1, 0, REG_STATUS); + + pub const HW_UDMA_SPIM_3_BASE: usize = 0x50108000; + } + + pub mod udma_i2c_0 { + pub const UDMA_I2C_0_NUMREGS: usize = 12; + + 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, 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); + + 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, 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_CMD_SADDR: crate::Register = crate::Register::new(8, 0xfff); + pub const REG_CMD_SADDR_R_CMD_STARTADDR: crate::Field = crate::Field::new(12, 0, REG_CMD_SADDR); + + pub const REG_CMD_SIZE: crate::Register = crate::Register::new(9, 0xffff); + pub const REG_CMD_SIZE_R_CMD_SIZE: crate::Field = crate::Field::new(16, 0, REG_CMD_SIZE); + + pub const REG_CMD_CFG: crate::Register = crate::Register::new(10, 0x51); + pub const REG_CMD_CFG_R_CMD_CONTINUOUS: crate::Field = crate::Field::new(1, 0, REG_CMD_CFG); + pub const REG_CMD_CFG_R_CMD_EN: crate::Field = crate::Field::new(1, 4, REG_CMD_CFG); + pub const REG_CMD_CFG_R_CMD_CLR: crate::Field = crate::Field::new(1, 6, REG_CMD_CFG); + + pub const REG_STATUS: crate::Register = crate::Register::new(12, 0x3); + pub const REG_STATUS_R_BUSY: crate::Field = crate::Field::new(1, 0, REG_STATUS); + pub const REG_STATUS_R_AL: crate::Field = crate::Field::new(1, 1, REG_STATUS); + + pub const REG_SETUP: crate::Register = crate::Register::new(13, 0x1); + pub const REG_SETUP_R_DO_RST: crate::Field = crate::Field::new(1, 0, REG_SETUP); + + pub const REG_ACK: crate::Register = crate::Register::new(14, 0x1); + pub const REG_ACK_R_NACK: crate::Field = crate::Field::new(1, 0, REG_ACK); + + pub const HW_UDMA_I2C_0_BASE: usize = 0x50109000; + } + + pub mod udma_i2c_1 { + pub const UDMA_I2C_1_NUMREGS: usize = 12; + + 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, 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); + + 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, 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_CMD_SADDR: crate::Register = crate::Register::new(8, 0xfff); + pub const REG_CMD_SADDR_R_CMD_STARTADDR: crate::Field = crate::Field::new(12, 0, REG_CMD_SADDR); + + pub const REG_CMD_SIZE: crate::Register = crate::Register::new(9, 0xffff); + pub const REG_CMD_SIZE_R_CMD_SIZE: crate::Field = crate::Field::new(16, 0, REG_CMD_SIZE); + + pub const REG_CMD_CFG: crate::Register = crate::Register::new(10, 0x51); + pub const REG_CMD_CFG_R_CMD_CONTINUOUS: crate::Field = crate::Field::new(1, 0, REG_CMD_CFG); + pub const REG_CMD_CFG_R_CMD_EN: crate::Field = crate::Field::new(1, 4, REG_CMD_CFG); + pub const REG_CMD_CFG_R_CMD_CLR: crate::Field = crate::Field::new(1, 6, REG_CMD_CFG); + + pub const REG_STATUS: crate::Register = crate::Register::new(12, 0x3); + pub const REG_STATUS_R_BUSY: crate::Field = crate::Field::new(1, 0, REG_STATUS); + pub const REG_STATUS_R_AL: crate::Field = crate::Field::new(1, 1, REG_STATUS); + + pub const REG_SETUP: crate::Register = crate::Register::new(13, 0x1); + pub const REG_SETUP_R_DO_RST: crate::Field = crate::Field::new(1, 0, REG_SETUP); + + pub const REG_ACK: crate::Register = crate::Register::new(14, 0x1); + pub const REG_ACK_R_NACK: crate::Field = crate::Field::new(1, 0, REG_ACK); + + pub const HW_UDMA_I2C_1_BASE: usize = 0x5010a000; + } + + pub mod udma_i2c_2 { + pub const UDMA_I2C_2_NUMREGS: usize = 12; + + 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, 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); + + 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, 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_CMD_SADDR: crate::Register = crate::Register::new(8, 0xfff); + pub const REG_CMD_SADDR_R_CMD_STARTADDR: crate::Field = crate::Field::new(12, 0, REG_CMD_SADDR); + + pub const REG_CMD_SIZE: crate::Register = crate::Register::new(9, 0xffff); + pub const REG_CMD_SIZE_R_CMD_SIZE: crate::Field = crate::Field::new(16, 0, REG_CMD_SIZE); + + pub const REG_CMD_CFG: crate::Register = crate::Register::new(10, 0x51); + pub const REG_CMD_CFG_R_CMD_CONTINUOUS: crate::Field = crate::Field::new(1, 0, REG_CMD_CFG); + pub const REG_CMD_CFG_R_CMD_EN: crate::Field = crate::Field::new(1, 4, REG_CMD_CFG); + pub const REG_CMD_CFG_R_CMD_CLR: crate::Field = crate::Field::new(1, 6, REG_CMD_CFG); + + pub const REG_STATUS: crate::Register = crate::Register::new(12, 0x3); + pub const REG_STATUS_R_BUSY: crate::Field = crate::Field::new(1, 0, REG_STATUS); + pub const REG_STATUS_R_AL: crate::Field = crate::Field::new(1, 1, REG_STATUS); + + pub const REG_SETUP: crate::Register = crate::Register::new(13, 0x1); + pub const REG_SETUP_R_DO_RST: crate::Field = crate::Field::new(1, 0, REG_SETUP); + + pub const REG_ACK: crate::Register = crate::Register::new(14, 0x1); + pub const REG_ACK_R_NACK: crate::Field = crate::Field::new(1, 0, REG_ACK); + + pub const HW_UDMA_I2C_2_BASE: usize = 0x5010b000; + } + + pub mod udma_i2c_3 { + pub const UDMA_I2C_3_NUMREGS: usize = 12; + + 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, 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); + + 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, 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_CMD_SADDR: crate::Register = crate::Register::new(8, 0xfff); + pub const REG_CMD_SADDR_R_CMD_STARTADDR: crate::Field = crate::Field::new(12, 0, REG_CMD_SADDR); + + pub const REG_CMD_SIZE: crate::Register = crate::Register::new(9, 0xffff); + pub const REG_CMD_SIZE_R_CMD_SIZE: crate::Field = crate::Field::new(16, 0, REG_CMD_SIZE); + + pub const REG_CMD_CFG: crate::Register = crate::Register::new(10, 0x51); + pub const REG_CMD_CFG_R_CMD_CONTINUOUS: crate::Field = crate::Field::new(1, 0, REG_CMD_CFG); + pub const REG_CMD_CFG_R_CMD_EN: crate::Field = crate::Field::new(1, 4, REG_CMD_CFG); + pub const REG_CMD_CFG_R_CMD_CLR: crate::Field = crate::Field::new(1, 6, REG_CMD_CFG); + + pub const REG_STATUS: crate::Register = crate::Register::new(12, 0x3); + pub const REG_STATUS_R_BUSY: crate::Field = crate::Field::new(1, 0, REG_STATUS); + pub const REG_STATUS_R_AL: crate::Field = crate::Field::new(1, 1, REG_STATUS); + + pub const REG_SETUP: crate::Register = crate::Register::new(13, 0x1); + pub const REG_SETUP_R_DO_RST: crate::Field = crate::Field::new(1, 0, REG_SETUP); + + pub const REG_ACK: crate::Register = crate::Register::new(14, 0x1); + pub const REG_ACK_R_NACK: crate::Field = crate::Field::new(1, 0, REG_ACK); + + pub const HW_UDMA_I2C_3_BASE: usize = 0x5010c000; + } + + pub mod udma_sdio { + pub const UDMA_SDIO_NUMREGS: usize = 15; + + 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_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); + + 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, 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_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_CMD_OP: crate::Register = crate::Register::new(8, 0x3f07); + 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_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_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_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 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 HW_UDMA_SDIO_BASE: usize = 0x5010d000; + } + + 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); + + 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_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); + + 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); + + 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_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_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_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_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 HW_UDMA_I2S_BASE: usize = 0x5010e000; + } + + pub mod udma_camera { + pub const UDMA_CAMERA_NUMREGS: usize = 9; + + 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, 0x57); + 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_CAM_CFG_GLOB: crate::Register = crate::Register::new(8, 0x7fffffff); + pub const REG_CAM_CFG_GLOB_R_CAM_CFG: crate::Field = crate::Field::new(30, 0, REG_CAM_CFG_GLOB); + pub const REG_CAM_CFG_GLOB_CFG_CAM_IP_EN_I: crate::Field = crate::Field::new(1, 30, REG_CAM_CFG_GLOB); + + pub const REG_CAM_CFG_LL: crate::Register = crate::Register::new(9, 0xffffffff); + pub const REG_CAM_CFG_LL_R_CAM_CFG_LL: crate::Field = crate::Field::new(32, 0, REG_CAM_CFG_LL); + + pub const REG_CAM_CFG_UR: crate::Register = crate::Register::new(10, 0xffffffff); + pub const REG_CAM_CFG_UR_R_CAM_CFG_UR: crate::Field = crate::Field::new(32, 0, REG_CAM_CFG_UR); + + pub const REG_CAM_CFG_SIZE: crate::Register = crate::Register::new(11, 0xffffffff); + pub const REG_CAM_CFG_SIZE_R_CAM_CFG_SIZE: crate::Field = crate::Field::new(32, 0, REG_CAM_CFG_SIZE); + + pub const REG_CAM_CFG_FILTER: crate::Register = crate::Register::new(12, 0xffffffff); + pub const REG_CAM_CFG_FILTER_R_CAM_CFG_FILTER: crate::Field = crate::Field::new(32, 0, REG_CAM_CFG_FILTER); + + pub const REG_CAM_VSYNC_POLARITY: crate::Register = crate::Register::new(13, 0x3); + pub const REG_CAM_VSYNC_POLARITY_R_CAM_VSYNC_POLARITY: crate::Field = crate::Field::new(1, 0, REG_CAM_VSYNC_POLARITY); + pub const REG_CAM_VSYNC_POLARITY_R_CAM_HSYNC_POLARITY: crate::Field = crate::Field::new(1, 1, REG_CAM_VSYNC_POLARITY); + + pub const HW_UDMA_CAMERA_BASE: usize = 0x5010f000; + } + + pub mod udma_filter { + pub const UDMA_FILTER_NUMREGS: usize = 24; + + pub const REG_TX_CH0_ADD: crate::Register = crate::Register::new(0, 0x7fff); + pub const REG_TX_CH0_ADD_R_FILTER_TX_START_ADDR_0: crate::Field = crate::Field::new(15, 0, REG_TX_CH0_ADD); + + pub const REG_TX_CH0_CFG: crate::Register = crate::Register::new(1, 0x303); + pub const REG_TX_CH0_CFG_R_FILTER_TX_DATASIZE_0: crate::Field = crate::Field::new(2, 0, REG_TX_CH0_CFG); + pub const REG_TX_CH0_CFG_R_FILTER_TX_MODE_0: crate::Field = crate::Field::new(2, 8, REG_TX_CH0_CFG); + + pub const REG_TX_CH0_LEN0: crate::Register = crate::Register::new(2, 0x7fff); + pub const REG_TX_CH0_LEN0_R_FILTER_TX_LEN0_0: crate::Field = crate::Field::new(15, 0, REG_TX_CH0_LEN0); + + pub const REG_TX_CH0_LEN1: crate::Register = crate::Register::new(3, 0x7fff); + pub const REG_TX_CH0_LEN1_R_FILTER_TX_LEN1_0: crate::Field = crate::Field::new(15, 0, REG_TX_CH0_LEN1); + + pub const REG_TX_CH0_LEN2: crate::Register = crate::Register::new(4, 0x7fff); + pub const REG_TX_CH0_LEN2_R_FILTER_TX_LEN2_0: crate::Field = crate::Field::new(15, 0, REG_TX_CH0_LEN2); + + pub const REG_TX_CH1_ADD: crate::Register = crate::Register::new(5, 0x7fff); + pub const REG_TX_CH1_ADD_R_FILTER_TX_START_ADDR_1: crate::Field = crate::Field::new(15, 0, REG_TX_CH1_ADD); + + pub const REG_TX_CH1_CFG: crate::Register = crate::Register::new(6, 0x303); + pub const REG_TX_CH1_CFG_R_FILTER_TX_DATASIZE_1: crate::Field = crate::Field::new(2, 0, REG_TX_CH1_CFG); + pub const REG_TX_CH1_CFG_R_FILTER_TX_MODE_1: crate::Field = crate::Field::new(2, 8, REG_TX_CH1_CFG); + + pub const REG_TX_CH1_LEN0: crate::Register = crate::Register::new(7, 0x7fff); + pub const REG_TX_CH1_LEN0_R_FILTER_TX_LEN0_1: crate::Field = crate::Field::new(15, 0, REG_TX_CH1_LEN0); + + pub const REG_TX_CH1_LEN1: crate::Register = crate::Register::new(8, 0x7fff); + pub const REG_TX_CH1_LEN1_R_FILTER_TX_LEN1_1: crate::Field = crate::Field::new(15, 0, REG_TX_CH1_LEN1); + + pub const REG_TX_CH1_LEN2: crate::Register = crate::Register::new(9, 0x7fff); + pub const REG_TX_CH1_LEN2_R_FILTER_TX_LEN2_1: crate::Field = crate::Field::new(15, 0, REG_TX_CH1_LEN2); + + pub const REG_RX_CH_ADD: crate::Register = crate::Register::new(10, 0x7fff); + pub const REG_RX_CH_ADD_R_FILTER_RX_START_ADDR: crate::Field = crate::Field::new(15, 0, REG_RX_CH_ADD); + + pub const REG_RX_CH_CFG: crate::Register = crate::Register::new(11, 0x303); + pub const REG_RX_CH_CFG_R_FILTER_RX_DATASIZE: crate::Field = crate::Field::new(2, 0, REG_RX_CH_CFG); + pub const REG_RX_CH_CFG_R_FILTER_RX_MODE: crate::Field = crate::Field::new(2, 8, REG_RX_CH_CFG); + + pub const REG_RX_CH_LEN0: crate::Register = crate::Register::new(12, 0xffff); + pub const REG_RX_CH_LEN0_R_FILTER_RX_LEN0: crate::Field = crate::Field::new(16, 0, REG_RX_CH_LEN0); + + pub const REG_RX_CH_LEN1: crate::Register = crate::Register::new(13, 0xffff); + pub const REG_RX_CH_LEN1_R_FILTER_RX_LEN1: crate::Field = crate::Field::new(16, 0, REG_RX_CH_LEN1); + + pub const REG_RX_CH_LEN2: crate::Register = crate::Register::new(14, 0xffff); + pub const REG_RX_CH_LEN2_R_FILTER_RX_LEN2: crate::Field = crate::Field::new(16, 0, REG_RX_CH_LEN2); + + pub const REG_AU_CFG: crate::Register = crate::Register::new(15, 0x1f0f03); + pub const REG_AU_CFG_R_AU_USE_SIGNED: crate::Field = crate::Field::new(1, 0, REG_AU_CFG); + pub const REG_AU_CFG_R_AU_BYPASS: crate::Field = crate::Field::new(1, 1, REG_AU_CFG); + pub const REG_AU_CFG_R_AU_MODE: crate::Field = crate::Field::new(4, 8, REG_AU_CFG); + pub const REG_AU_CFG_R_AU_SHIFT: crate::Field = crate::Field::new(5, 16, REG_AU_CFG); + + pub const REG_AU_REG0: crate::Register = crate::Register::new(16, 0xffffffff); + pub const REG_AU_REG0_R_COMMIT_AU_REG0: crate::Field = crate::Field::new(32, 0, REG_AU_REG0); + + pub const REG_AU_REG1: crate::Register = crate::Register::new(17, 0xffffffff); + pub const REG_AU_REG1_R_COMMIT_AU_REG1: crate::Field = crate::Field::new(32, 0, REG_AU_REG1); + + pub const REG_BINCU_TH: crate::Register = crate::Register::new(18, 0xffffffff); + pub const REG_BINCU_TH_R_COMMIT_BINCU_THRESHOLD: crate::Field = crate::Field::new(32, 0, REG_BINCU_TH); + + pub const REG_BINCU_CNT: crate::Register = crate::Register::new(19, 0x80007fff); + pub const REG_BINCU_CNT_R_BINCU_COUNTER: crate::Field = crate::Field::new(15, 0, REG_BINCU_CNT); + pub const REG_BINCU_CNT_R_BINCU_EN_COUNTER: crate::Field = crate::Field::new(1, 31, REG_BINCU_CNT); + + pub const REG_BINCU_SETUP: crate::Register = crate::Register::new(20, 0x3); + pub const REG_BINCU_SETUP_R_BINCU_DATASIZE: crate::Field = crate::Field::new(2, 0, REG_BINCU_SETUP); + + pub const REG_BINCU_VAL: crate::Register = crate::Register::new(21, 0x7fff); + pub const REG_BINCU_VAL_BINCU_COUNTER_I: crate::Field = crate::Field::new(15, 0, REG_BINCU_VAL); + + pub const REG_FILT: crate::Register = crate::Register::new(22, 0xf); + pub const REG_FILT_R_FILTER_MODE: crate::Field = crate::Field::new(4, 0, REG_FILT); + + pub const REG_STATUS: crate::Register = crate::Register::new(24, 0x1); + pub const REG_STATUS_R_FILTER_DONE: crate::Field = crate::Field::new(1, 0, REG_STATUS); + + pub const HW_UDMA_FILTER_BASE: usize = 0x50110000; + } + + pub mod udma_scif { + pub const UDMA_SCIF_NUMREGS: usize = 13; + + 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, 0x1); + pub const REG_RX_CFG_R_RX_CONTINUOUS: crate::Field = crate::Field::new(1, 0, 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); + + 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_R_TX_CONTINUOUS: crate::Field = crate::Field::new(1, 0, 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); + + pub const REG_SCIF_SETUP: crate::Register = crate::Register::new(9, 0xffffc33f); + pub const REG_SCIF_SETUP_R_SCIF_PARITY_EN: crate::Field = crate::Field::new(1, 0, REG_SCIF_SETUP); + pub const REG_SCIF_SETUP_R_SCIF_BITS: crate::Field = crate::Field::new(2, 1, REG_SCIF_SETUP); + pub const REG_SCIF_SETUP_R_SCIF_STOP_BITS: crate::Field = crate::Field::new(1, 3, REG_SCIF_SETUP); + pub const REG_SCIF_SETUP_R_SCIF_RX_POLLING_EN: crate::Field = crate::Field::new(1, 4, REG_SCIF_SETUP); + pub const REG_SCIF_SETUP_R_SCIF_RX_CLEAN_FIFO: crate::Field = crate::Field::new(1, 5, REG_SCIF_SETUP); + pub const REG_SCIF_SETUP_R_SCIF_EN_TX: crate::Field = crate::Field::new(1, 8, REG_SCIF_SETUP); + pub const REG_SCIF_SETUP_R_SCIF_EN_RX: crate::Field = crate::Field::new(1, 9, REG_SCIF_SETUP); + pub const REG_SCIF_SETUP_R_SCIF_CLKSEL: crate::Field = crate::Field::new(2, 14, REG_SCIF_SETUP); + pub const REG_SCIF_SETUP_R_SCIF_DIV: crate::Field = crate::Field::new(16, 16, REG_SCIF_SETUP); + + pub const REG_ERROR: crate::Register = crate::Register::new(10, 0x3); + pub const REG_ERROR_R_ERR_OVERFLOW: crate::Field = crate::Field::new(1, 0, REG_ERROR); + pub const REG_ERROR_R_ERR_PARITY: crate::Field = crate::Field::new(1, 1, REG_ERROR); + + pub const REG_IRQ_EN: crate::Register = crate::Register::new(11, 0x3); + pub const REG_IRQ_EN_R_SCIF_RX_IRQ_EN: crate::Field = crate::Field::new(1, 0, REG_IRQ_EN); + pub const REG_IRQ_EN_R_SCIF_ERR_IRQ_EN: crate::Field = crate::Field::new(1, 1, REG_IRQ_EN); + + pub const REG_VALID: crate::Register = crate::Register::new(12, 0x1); + pub const REG_VALID_R_SCIF_RX_DATA_VALID: crate::Field = crate::Field::new(1, 0, REG_VALID); + + pub const REG_DATA: crate::Register = crate::Register::new(13, 0xff); + pub const REG_DATA_R_SCIF_RX_DATA: crate::Field = crate::Field::new(8, 0, REG_DATA); + + pub const REG_SCIF_ETU: crate::Register = crate::Register::new(14, 0xffff); + pub const REG_SCIF_ETU_R_SCIF_ETU: crate::Field = crate::Field::new(16, 0, REG_SCIF_ETU); + + pub const HW_UDMA_SCIF_BASE: usize = 0x50111000; + } + + pub mod udma_spis_0 { + pub const UDMA_SPIS_0_NUMREGS: usize = 12; + + 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, 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); + + 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, 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_SPIS_SETUP: crate::Register = crate::Register::new(8, 0x3); + pub const REG_SPIS_SETUP_CFGCPOL: crate::Field = crate::Field::new(1, 0, REG_SPIS_SETUP); + pub const REG_SPIS_SETUP_CFGCPHA: crate::Field = crate::Field::new(1, 1, REG_SPIS_SETUP); + + pub const REG_SEOT_CNT: crate::Register = crate::Register::new(9, 0xffff); + pub const REG_SEOT_CNT_SR_SEOT_CNT: crate::Field = crate::Field::new(16, 0, REG_SEOT_CNT); + + pub const REG_SPIS_IRQ_EN: crate::Register = crate::Register::new(10, 0x1); + pub const REG_SPIS_IRQ_EN_SEOT_IRQ_EN: crate::Field = crate::Field::new(1, 0, REG_SPIS_IRQ_EN); + + pub const REG_SPIS_RXCNT: crate::Register = crate::Register::new(11, 0xffff); + pub const REG_SPIS_RXCNT_CFGRXCNT: crate::Field = crate::Field::new(16, 0, REG_SPIS_RXCNT); + + pub const REG_SPIS_TXCNT: crate::Register = crate::Register::new(12, 0xffff); + pub const REG_SPIS_TXCNT_CFGTXCNT: crate::Field = crate::Field::new(16, 0, REG_SPIS_TXCNT); + + pub const REG_SPIS_DMCNT: crate::Register = crate::Register::new(13, 0xffff); + pub const REG_SPIS_DMCNT_CFGDMCNT: crate::Field = crate::Field::new(16, 0, REG_SPIS_DMCNT); + + pub const HW_UDMA_SPIS_0_BASE: usize = 0x50112000; + } + + pub mod udma_spis_1 { + pub const UDMA_SPIS_1_NUMREGS: usize = 12; + + 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, 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); + + 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, 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_SPIS_SETUP: crate::Register = crate::Register::new(8, 0x3); + pub const REG_SPIS_SETUP_CFGCPOL: crate::Field = crate::Field::new(1, 0, REG_SPIS_SETUP); + pub const REG_SPIS_SETUP_CFGCPHA: crate::Field = crate::Field::new(1, 1, REG_SPIS_SETUP); + + pub const REG_SEOT_CNT: crate::Register = crate::Register::new(9, 0xffff); + pub const REG_SEOT_CNT_SR_SEOT_CNT: crate::Field = crate::Field::new(16, 0, REG_SEOT_CNT); + + pub const REG_SPIS_IRQ_EN: crate::Register = crate::Register::new(10, 0x1); + pub const REG_SPIS_IRQ_EN_SEOT_IRQ_EN: crate::Field = crate::Field::new(1, 0, REG_SPIS_IRQ_EN); + + pub const REG_SPIS_RXCNT: crate::Register = crate::Register::new(11, 0xffff); + pub const REG_SPIS_RXCNT_CFGRXCNT: crate::Field = crate::Field::new(16, 0, REG_SPIS_RXCNT); + + pub const REG_SPIS_TXCNT: crate::Register = crate::Register::new(12, 0xffff); + pub const REG_SPIS_TXCNT_CFGTXCNT: crate::Field = crate::Field::new(16, 0, REG_SPIS_TXCNT); + + pub const REG_SPIS_DMCNT: crate::Register = crate::Register::new(13, 0xffff); + pub const REG_SPIS_DMCNT_CFGDMCNT: crate::Field = crate::Field::new(16, 0, REG_SPIS_DMCNT); + + pub const HW_UDMA_SPIS_1_BASE: usize = 0x50113000; + } + pub mod aes { pub const AES_NUMREGS: usize = 10; @@ -11782,6 +12808,2938 @@ mod tests { pl230_csr.wfo(utra::pl230::PERIPH_ID_2_REVISION, baz); } + #[test] + #[ignore] + fn compile_check_udma_ctrl_csr() { + use super::*; + let mut udma_ctrl_csr = CSR::new(HW_UDMA_CTRL_BASE as *mut u32); + + let foo = udma_ctrl_csr.r(utra::udma_ctrl::REG_CG); + udma_ctrl_csr.wo(utra::udma_ctrl::REG_CG, foo); + let bar = udma_ctrl_csr.rf(utra::udma_ctrl::REG_CG_R_CG); + udma_ctrl_csr.rmwf(utra::udma_ctrl::REG_CG_R_CG, bar); + let mut baz = udma_ctrl_csr.zf(utra::udma_ctrl::REG_CG_R_CG, bar); + baz |= udma_ctrl_csr.ms(utra::udma_ctrl::REG_CG_R_CG, 1); + udma_ctrl_csr.wfo(utra::udma_ctrl::REG_CG_R_CG, baz); + + let foo = udma_ctrl_csr.r(utra::udma_ctrl::REG_CFG_EVT); + udma_ctrl_csr.wo(utra::udma_ctrl::REG_CFG_EVT, foo); + let bar = udma_ctrl_csr.rf(utra::udma_ctrl::REG_CFG_EVT_R_CMP_EVT_0); + udma_ctrl_csr.rmwf(utra::udma_ctrl::REG_CFG_EVT_R_CMP_EVT_0, bar); + let mut baz = udma_ctrl_csr.zf(utra::udma_ctrl::REG_CFG_EVT_R_CMP_EVT_0, bar); + baz |= udma_ctrl_csr.ms(utra::udma_ctrl::REG_CFG_EVT_R_CMP_EVT_0, 1); + udma_ctrl_csr.wfo(utra::udma_ctrl::REG_CFG_EVT_R_CMP_EVT_0, baz); + let bar = udma_ctrl_csr.rf(utra::udma_ctrl::REG_CFG_EVT_R_CMP_EVT_1); + udma_ctrl_csr.rmwf(utra::udma_ctrl::REG_CFG_EVT_R_CMP_EVT_1, bar); + let mut baz = udma_ctrl_csr.zf(utra::udma_ctrl::REG_CFG_EVT_R_CMP_EVT_1, bar); + baz |= udma_ctrl_csr.ms(utra::udma_ctrl::REG_CFG_EVT_R_CMP_EVT_1, 1); + udma_ctrl_csr.wfo(utra::udma_ctrl::REG_CFG_EVT_R_CMP_EVT_1, baz); + let bar = udma_ctrl_csr.rf(utra::udma_ctrl::REG_CFG_EVT_R_CMP_EVT_2); + udma_ctrl_csr.rmwf(utra::udma_ctrl::REG_CFG_EVT_R_CMP_EVT_2, bar); + let mut baz = udma_ctrl_csr.zf(utra::udma_ctrl::REG_CFG_EVT_R_CMP_EVT_2, bar); + baz |= udma_ctrl_csr.ms(utra::udma_ctrl::REG_CFG_EVT_R_CMP_EVT_2, 1); + udma_ctrl_csr.wfo(utra::udma_ctrl::REG_CFG_EVT_R_CMP_EVT_2, baz); + let bar = udma_ctrl_csr.rf(utra::udma_ctrl::REG_CFG_EVT_R_CMP_EVT_3); + udma_ctrl_csr.rmwf(utra::udma_ctrl::REG_CFG_EVT_R_CMP_EVT_3, bar); + let mut baz = udma_ctrl_csr.zf(utra::udma_ctrl::REG_CFG_EVT_R_CMP_EVT_3, bar); + baz |= udma_ctrl_csr.ms(utra::udma_ctrl::REG_CFG_EVT_R_CMP_EVT_3, 1); + udma_ctrl_csr.wfo(utra::udma_ctrl::REG_CFG_EVT_R_CMP_EVT_3, baz); + + let foo = udma_ctrl_csr.r(utra::udma_ctrl::REG_RST); + udma_ctrl_csr.wo(utra::udma_ctrl::REG_RST, foo); + let bar = udma_ctrl_csr.rf(utra::udma_ctrl::REG_RST_R_RST); + udma_ctrl_csr.rmwf(utra::udma_ctrl::REG_RST_R_RST, bar); + let mut baz = udma_ctrl_csr.zf(utra::udma_ctrl::REG_RST_R_RST, bar); + baz |= udma_ctrl_csr.ms(utra::udma_ctrl::REG_RST_R_RST, 1); + udma_ctrl_csr.wfo(utra::udma_ctrl::REG_RST_R_RST, baz); + } + + #[test] + #[ignore] + fn compile_check_udma_uart_0_csr() { + use super::*; + let mut udma_uart_0_csr = CSR::new(HW_UDMA_UART_0_BASE as *mut u32); + + let foo = udma_uart_0_csr.r(utra::udma_uart_0::REG_RX_SADDR); + udma_uart_0_csr.wo(utra::udma_uart_0::REG_RX_SADDR, foo); + let bar = udma_uart_0_csr.rf(utra::udma_uart_0::REG_RX_SADDR_R_RX_STARTADDR); + udma_uart_0_csr.rmwf(utra::udma_uart_0::REG_RX_SADDR_R_RX_STARTADDR, bar); + let mut baz = udma_uart_0_csr.zf(utra::udma_uart_0::REG_RX_SADDR_R_RX_STARTADDR, bar); + baz |= udma_uart_0_csr.ms(utra::udma_uart_0::REG_RX_SADDR_R_RX_STARTADDR, 1); + udma_uart_0_csr.wfo(utra::udma_uart_0::REG_RX_SADDR_R_RX_STARTADDR, baz); + + let foo = udma_uart_0_csr.r(utra::udma_uart_0::REG_RX_SIZE); + udma_uart_0_csr.wo(utra::udma_uart_0::REG_RX_SIZE, foo); + let bar = udma_uart_0_csr.rf(utra::udma_uart_0::REG_RX_SIZE_R_RX_SIZE); + udma_uart_0_csr.rmwf(utra::udma_uart_0::REG_RX_SIZE_R_RX_SIZE, bar); + let mut baz = udma_uart_0_csr.zf(utra::udma_uart_0::REG_RX_SIZE_R_RX_SIZE, bar); + baz |= udma_uart_0_csr.ms(utra::udma_uart_0::REG_RX_SIZE_R_RX_SIZE, 1); + udma_uart_0_csr.wfo(utra::udma_uart_0::REG_RX_SIZE_R_RX_SIZE, baz); + + let foo = udma_uart_0_csr.r(utra::udma_uart_0::REG_RX_CFG); + udma_uart_0_csr.wo(utra::udma_uart_0::REG_RX_CFG, foo); + let bar = udma_uart_0_csr.rf(utra::udma_uart_0::REG_RX_CFG_R_RX_CONTINUOUS); + udma_uart_0_csr.rmwf(utra::udma_uart_0::REG_RX_CFG_R_RX_CONTINUOUS, bar); + let mut baz = udma_uart_0_csr.zf(utra::udma_uart_0::REG_RX_CFG_R_RX_CONTINUOUS, bar); + baz |= udma_uart_0_csr.ms(utra::udma_uart_0::REG_RX_CFG_R_RX_CONTINUOUS, 1); + udma_uart_0_csr.wfo(utra::udma_uart_0::REG_RX_CFG_R_RX_CONTINUOUS, baz); + let bar = udma_uart_0_csr.rf(utra::udma_uart_0::REG_RX_CFG_R_RX_EN); + udma_uart_0_csr.rmwf(utra::udma_uart_0::REG_RX_CFG_R_RX_EN, bar); + let mut baz = udma_uart_0_csr.zf(utra::udma_uart_0::REG_RX_CFG_R_RX_EN, bar); + baz |= udma_uart_0_csr.ms(utra::udma_uart_0::REG_RX_CFG_R_RX_EN, 1); + udma_uart_0_csr.wfo(utra::udma_uart_0::REG_RX_CFG_R_RX_EN, baz); + let bar = udma_uart_0_csr.rf(utra::udma_uart_0::REG_RX_CFG_R_RX_CLR); + udma_uart_0_csr.rmwf(utra::udma_uart_0::REG_RX_CFG_R_RX_CLR, bar); + let mut baz = udma_uart_0_csr.zf(utra::udma_uart_0::REG_RX_CFG_R_RX_CLR, bar); + baz |= udma_uart_0_csr.ms(utra::udma_uart_0::REG_RX_CFG_R_RX_CLR, 1); + udma_uart_0_csr.wfo(utra::udma_uart_0::REG_RX_CFG_R_RX_CLR, baz); + + let foo = udma_uart_0_csr.r(utra::udma_uart_0::REG_TX_SADDR); + udma_uart_0_csr.wo(utra::udma_uart_0::REG_TX_SADDR, foo); + let bar = udma_uart_0_csr.rf(utra::udma_uart_0::REG_TX_SADDR_R_TX_STARTADDR); + udma_uart_0_csr.rmwf(utra::udma_uart_0::REG_TX_SADDR_R_TX_STARTADDR, bar); + let mut baz = udma_uart_0_csr.zf(utra::udma_uart_0::REG_TX_SADDR_R_TX_STARTADDR, bar); + baz |= udma_uart_0_csr.ms(utra::udma_uart_0::REG_TX_SADDR_R_TX_STARTADDR, 1); + udma_uart_0_csr.wfo(utra::udma_uart_0::REG_TX_SADDR_R_TX_STARTADDR, baz); + + let foo = udma_uart_0_csr.r(utra::udma_uart_0::REG_TX_SIZE); + udma_uart_0_csr.wo(utra::udma_uart_0::REG_TX_SIZE, foo); + let bar = udma_uart_0_csr.rf(utra::udma_uart_0::REG_TX_SIZE_R_TX_SIZE); + udma_uart_0_csr.rmwf(utra::udma_uart_0::REG_TX_SIZE_R_TX_SIZE, bar); + let mut baz = udma_uart_0_csr.zf(utra::udma_uart_0::REG_TX_SIZE_R_TX_SIZE, bar); + baz |= udma_uart_0_csr.ms(utra::udma_uart_0::REG_TX_SIZE_R_TX_SIZE, 1); + udma_uart_0_csr.wfo(utra::udma_uart_0::REG_TX_SIZE_R_TX_SIZE, baz); + + let foo = udma_uart_0_csr.r(utra::udma_uart_0::REG_TX_CFG); + udma_uart_0_csr.wo(utra::udma_uart_0::REG_TX_CFG, foo); + let bar = udma_uart_0_csr.rf(utra::udma_uart_0::REG_TX_CFG_R_TX_CONTINUOUS); + udma_uart_0_csr.rmwf(utra::udma_uart_0::REG_TX_CFG_R_TX_CONTINUOUS, bar); + let mut baz = udma_uart_0_csr.zf(utra::udma_uart_0::REG_TX_CFG_R_TX_CONTINUOUS, bar); + baz |= udma_uart_0_csr.ms(utra::udma_uart_0::REG_TX_CFG_R_TX_CONTINUOUS, 1); + udma_uart_0_csr.wfo(utra::udma_uart_0::REG_TX_CFG_R_TX_CONTINUOUS, baz); + let bar = udma_uart_0_csr.rf(utra::udma_uart_0::REG_TX_CFG_R_TX_EN); + udma_uart_0_csr.rmwf(utra::udma_uart_0::REG_TX_CFG_R_TX_EN, bar); + let mut baz = udma_uart_0_csr.zf(utra::udma_uart_0::REG_TX_CFG_R_TX_EN, bar); + baz |= udma_uart_0_csr.ms(utra::udma_uart_0::REG_TX_CFG_R_TX_EN, 1); + udma_uart_0_csr.wfo(utra::udma_uart_0::REG_TX_CFG_R_TX_EN, baz); + let bar = udma_uart_0_csr.rf(utra::udma_uart_0::REG_TX_CFG_R_TX_CLR); + udma_uart_0_csr.rmwf(utra::udma_uart_0::REG_TX_CFG_R_TX_CLR, bar); + let mut baz = udma_uart_0_csr.zf(utra::udma_uart_0::REG_TX_CFG_R_TX_CLR, bar); + baz |= udma_uart_0_csr.ms(utra::udma_uart_0::REG_TX_CFG_R_TX_CLR, 1); + udma_uart_0_csr.wfo(utra::udma_uart_0::REG_TX_CFG_R_TX_CLR, baz); + + let foo = udma_uart_0_csr.r(utra::udma_uart_0::REG_STATUS); + udma_uart_0_csr.wo(utra::udma_uart_0::REG_STATUS, foo); + let bar = udma_uart_0_csr.rf(utra::udma_uart_0::REG_STATUS_STATUS_I); + udma_uart_0_csr.rmwf(utra::udma_uart_0::REG_STATUS_STATUS_I, bar); + let mut baz = udma_uart_0_csr.zf(utra::udma_uart_0::REG_STATUS_STATUS_I, bar); + baz |= udma_uart_0_csr.ms(utra::udma_uart_0::REG_STATUS_STATUS_I, 1); + udma_uart_0_csr.wfo(utra::udma_uart_0::REG_STATUS_STATUS_I, baz); + + let foo = udma_uart_0_csr.r(utra::udma_uart_0::REG_UART_SETUP); + udma_uart_0_csr.wo(utra::udma_uart_0::REG_UART_SETUP, foo); + let bar = udma_uart_0_csr.rf(utra::udma_uart_0::REG_UART_SETUP_R_UART_PARITY_EN); + udma_uart_0_csr.rmwf(utra::udma_uart_0::REG_UART_SETUP_R_UART_PARITY_EN, bar); + let mut baz = udma_uart_0_csr.zf(utra::udma_uart_0::REG_UART_SETUP_R_UART_PARITY_EN, bar); + baz |= udma_uart_0_csr.ms(utra::udma_uart_0::REG_UART_SETUP_R_UART_PARITY_EN, 1); + udma_uart_0_csr.wfo(utra::udma_uart_0::REG_UART_SETUP_R_UART_PARITY_EN, baz); + let bar = udma_uart_0_csr.rf(utra::udma_uart_0::REG_UART_SETUP_R_UART_BITS); + udma_uart_0_csr.rmwf(utra::udma_uart_0::REG_UART_SETUP_R_UART_BITS, bar); + let mut baz = udma_uart_0_csr.zf(utra::udma_uart_0::REG_UART_SETUP_R_UART_BITS, bar); + baz |= udma_uart_0_csr.ms(utra::udma_uart_0::REG_UART_SETUP_R_UART_BITS, 1); + udma_uart_0_csr.wfo(utra::udma_uart_0::REG_UART_SETUP_R_UART_BITS, baz); + let bar = udma_uart_0_csr.rf(utra::udma_uart_0::REG_UART_SETUP_R_UART_STOP_BITS); + udma_uart_0_csr.rmwf(utra::udma_uart_0::REG_UART_SETUP_R_UART_STOP_BITS, bar); + let mut baz = udma_uart_0_csr.zf(utra::udma_uart_0::REG_UART_SETUP_R_UART_STOP_BITS, bar); + baz |= udma_uart_0_csr.ms(utra::udma_uart_0::REG_UART_SETUP_R_UART_STOP_BITS, 1); + udma_uart_0_csr.wfo(utra::udma_uart_0::REG_UART_SETUP_R_UART_STOP_BITS, baz); + let bar = udma_uart_0_csr.rf(utra::udma_uart_0::REG_UART_SETUP_R_UART_RX_POLLING_EN); + udma_uart_0_csr.rmwf(utra::udma_uart_0::REG_UART_SETUP_R_UART_RX_POLLING_EN, bar); + let mut baz = udma_uart_0_csr.zf(utra::udma_uart_0::REG_UART_SETUP_R_UART_RX_POLLING_EN, bar); + baz |= udma_uart_0_csr.ms(utra::udma_uart_0::REG_UART_SETUP_R_UART_RX_POLLING_EN, 1); + udma_uart_0_csr.wfo(utra::udma_uart_0::REG_UART_SETUP_R_UART_RX_POLLING_EN, baz); + let bar = udma_uart_0_csr.rf(utra::udma_uart_0::REG_UART_SETUP_R_UART_RX_CLEAN_FIFO); + udma_uart_0_csr.rmwf(utra::udma_uart_0::REG_UART_SETUP_R_UART_RX_CLEAN_FIFO, bar); + let mut baz = udma_uart_0_csr.zf(utra::udma_uart_0::REG_UART_SETUP_R_UART_RX_CLEAN_FIFO, bar); + baz |= udma_uart_0_csr.ms(utra::udma_uart_0::REG_UART_SETUP_R_UART_RX_CLEAN_FIFO, 1); + udma_uart_0_csr.wfo(utra::udma_uart_0::REG_UART_SETUP_R_UART_RX_CLEAN_FIFO, baz); + let bar = udma_uart_0_csr.rf(utra::udma_uart_0::REG_UART_SETUP_R_UART_EN_TX); + udma_uart_0_csr.rmwf(utra::udma_uart_0::REG_UART_SETUP_R_UART_EN_TX, bar); + let mut baz = udma_uart_0_csr.zf(utra::udma_uart_0::REG_UART_SETUP_R_UART_EN_TX, bar); + baz |= udma_uart_0_csr.ms(utra::udma_uart_0::REG_UART_SETUP_R_UART_EN_TX, 1); + udma_uart_0_csr.wfo(utra::udma_uart_0::REG_UART_SETUP_R_UART_EN_TX, baz); + let bar = udma_uart_0_csr.rf(utra::udma_uart_0::REG_UART_SETUP_R_UART_EN_RX); + udma_uart_0_csr.rmwf(utra::udma_uart_0::REG_UART_SETUP_R_UART_EN_RX, bar); + let mut baz = udma_uart_0_csr.zf(utra::udma_uart_0::REG_UART_SETUP_R_UART_EN_RX, bar); + baz |= udma_uart_0_csr.ms(utra::udma_uart_0::REG_UART_SETUP_R_UART_EN_RX, 1); + udma_uart_0_csr.wfo(utra::udma_uart_0::REG_UART_SETUP_R_UART_EN_RX, baz); + let bar = udma_uart_0_csr.rf(utra::udma_uart_0::REG_UART_SETUP_R_UART_DIV); + udma_uart_0_csr.rmwf(utra::udma_uart_0::REG_UART_SETUP_R_UART_DIV, bar); + let mut baz = udma_uart_0_csr.zf(utra::udma_uart_0::REG_UART_SETUP_R_UART_DIV, bar); + baz |= udma_uart_0_csr.ms(utra::udma_uart_0::REG_UART_SETUP_R_UART_DIV, 1); + udma_uart_0_csr.wfo(utra::udma_uart_0::REG_UART_SETUP_R_UART_DIV, baz); + + let foo = udma_uart_0_csr.r(utra::udma_uart_0::REG_ERROR); + udma_uart_0_csr.wo(utra::udma_uart_0::REG_ERROR, foo); + let bar = udma_uart_0_csr.rf(utra::udma_uart_0::REG_ERROR_R_ERR_OVERFLOW); + udma_uart_0_csr.rmwf(utra::udma_uart_0::REG_ERROR_R_ERR_OVERFLOW, bar); + let mut baz = udma_uart_0_csr.zf(utra::udma_uart_0::REG_ERROR_R_ERR_OVERFLOW, bar); + baz |= udma_uart_0_csr.ms(utra::udma_uart_0::REG_ERROR_R_ERR_OVERFLOW, 1); + udma_uart_0_csr.wfo(utra::udma_uart_0::REG_ERROR_R_ERR_OVERFLOW, baz); + let bar = udma_uart_0_csr.rf(utra::udma_uart_0::REG_ERROR_R_ERR_PARITY); + udma_uart_0_csr.rmwf(utra::udma_uart_0::REG_ERROR_R_ERR_PARITY, bar); + let mut baz = udma_uart_0_csr.zf(utra::udma_uart_0::REG_ERROR_R_ERR_PARITY, bar); + baz |= udma_uart_0_csr.ms(utra::udma_uart_0::REG_ERROR_R_ERR_PARITY, 1); + udma_uart_0_csr.wfo(utra::udma_uart_0::REG_ERROR_R_ERR_PARITY, baz); + + let foo = udma_uart_0_csr.r(utra::udma_uart_0::REG_IRQ_EN); + udma_uart_0_csr.wo(utra::udma_uart_0::REG_IRQ_EN, foo); + let bar = udma_uart_0_csr.rf(utra::udma_uart_0::REG_IRQ_EN_R_UART_RX_IRQ_EN); + udma_uart_0_csr.rmwf(utra::udma_uart_0::REG_IRQ_EN_R_UART_RX_IRQ_EN, bar); + let mut baz = udma_uart_0_csr.zf(utra::udma_uart_0::REG_IRQ_EN_R_UART_RX_IRQ_EN, bar); + baz |= udma_uart_0_csr.ms(utra::udma_uart_0::REG_IRQ_EN_R_UART_RX_IRQ_EN, 1); + udma_uart_0_csr.wfo(utra::udma_uart_0::REG_IRQ_EN_R_UART_RX_IRQ_EN, baz); + let bar = udma_uart_0_csr.rf(utra::udma_uart_0::REG_IRQ_EN_R_UART_ERR_IRQ_EN); + udma_uart_0_csr.rmwf(utra::udma_uart_0::REG_IRQ_EN_R_UART_ERR_IRQ_EN, bar); + let mut baz = udma_uart_0_csr.zf(utra::udma_uart_0::REG_IRQ_EN_R_UART_ERR_IRQ_EN, bar); + baz |= udma_uart_0_csr.ms(utra::udma_uart_0::REG_IRQ_EN_R_UART_ERR_IRQ_EN, 1); + udma_uart_0_csr.wfo(utra::udma_uart_0::REG_IRQ_EN_R_UART_ERR_IRQ_EN, baz); + + let foo = udma_uart_0_csr.r(utra::udma_uart_0::REG_VALID); + udma_uart_0_csr.wo(utra::udma_uart_0::REG_VALID, foo); + let bar = udma_uart_0_csr.rf(utra::udma_uart_0::REG_VALID_R_UART_RX_DATA_VALID); + udma_uart_0_csr.rmwf(utra::udma_uart_0::REG_VALID_R_UART_RX_DATA_VALID, bar); + let mut baz = udma_uart_0_csr.zf(utra::udma_uart_0::REG_VALID_R_UART_RX_DATA_VALID, bar); + baz |= udma_uart_0_csr.ms(utra::udma_uart_0::REG_VALID_R_UART_RX_DATA_VALID, 1); + udma_uart_0_csr.wfo(utra::udma_uart_0::REG_VALID_R_UART_RX_DATA_VALID, baz); + + let foo = udma_uart_0_csr.r(utra::udma_uart_0::REG_DATA); + udma_uart_0_csr.wo(utra::udma_uart_0::REG_DATA, foo); + let bar = udma_uart_0_csr.rf(utra::udma_uart_0::REG_DATA_R_UART_RX_DATA); + udma_uart_0_csr.rmwf(utra::udma_uart_0::REG_DATA_R_UART_RX_DATA, bar); + let mut baz = udma_uart_0_csr.zf(utra::udma_uart_0::REG_DATA_R_UART_RX_DATA, bar); + baz |= udma_uart_0_csr.ms(utra::udma_uart_0::REG_DATA_R_UART_RX_DATA, 1); + udma_uart_0_csr.wfo(utra::udma_uart_0::REG_DATA_R_UART_RX_DATA, baz); + } + + #[test] + #[ignore] + fn compile_check_udma_uart_1_csr() { + use super::*; + let mut udma_uart_1_csr = CSR::new(HW_UDMA_UART_1_BASE as *mut u32); + + let foo = udma_uart_1_csr.r(utra::udma_uart_1::REG_RX_SADDR); + udma_uart_1_csr.wo(utra::udma_uart_1::REG_RX_SADDR, foo); + let bar = udma_uart_1_csr.rf(utra::udma_uart_1::REG_RX_SADDR_R_RX_STARTADDR); + udma_uart_1_csr.rmwf(utra::udma_uart_1::REG_RX_SADDR_R_RX_STARTADDR, bar); + let mut baz = udma_uart_1_csr.zf(utra::udma_uart_1::REG_RX_SADDR_R_RX_STARTADDR, bar); + baz |= udma_uart_1_csr.ms(utra::udma_uart_1::REG_RX_SADDR_R_RX_STARTADDR, 1); + udma_uart_1_csr.wfo(utra::udma_uart_1::REG_RX_SADDR_R_RX_STARTADDR, baz); + + let foo = udma_uart_1_csr.r(utra::udma_uart_1::REG_RX_SIZE); + udma_uart_1_csr.wo(utra::udma_uart_1::REG_RX_SIZE, foo); + let bar = udma_uart_1_csr.rf(utra::udma_uart_1::REG_RX_SIZE_R_RX_SIZE); + udma_uart_1_csr.rmwf(utra::udma_uart_1::REG_RX_SIZE_R_RX_SIZE, bar); + let mut baz = udma_uart_1_csr.zf(utra::udma_uart_1::REG_RX_SIZE_R_RX_SIZE, bar); + baz |= udma_uart_1_csr.ms(utra::udma_uart_1::REG_RX_SIZE_R_RX_SIZE, 1); + udma_uart_1_csr.wfo(utra::udma_uart_1::REG_RX_SIZE_R_RX_SIZE, baz); + + let foo = udma_uart_1_csr.r(utra::udma_uart_1::REG_RX_CFG); + udma_uart_1_csr.wo(utra::udma_uart_1::REG_RX_CFG, foo); + let bar = udma_uart_1_csr.rf(utra::udma_uart_1::REG_RX_CFG_R_RX_CONTINUOUS); + udma_uart_1_csr.rmwf(utra::udma_uart_1::REG_RX_CFG_R_RX_CONTINUOUS, bar); + let mut baz = udma_uart_1_csr.zf(utra::udma_uart_1::REG_RX_CFG_R_RX_CONTINUOUS, bar); + baz |= udma_uart_1_csr.ms(utra::udma_uart_1::REG_RX_CFG_R_RX_CONTINUOUS, 1); + udma_uart_1_csr.wfo(utra::udma_uart_1::REG_RX_CFG_R_RX_CONTINUOUS, baz); + let bar = udma_uart_1_csr.rf(utra::udma_uart_1::REG_RX_CFG_R_RX_EN); + udma_uart_1_csr.rmwf(utra::udma_uart_1::REG_RX_CFG_R_RX_EN, bar); + let mut baz = udma_uart_1_csr.zf(utra::udma_uart_1::REG_RX_CFG_R_RX_EN, bar); + baz |= udma_uart_1_csr.ms(utra::udma_uart_1::REG_RX_CFG_R_RX_EN, 1); + udma_uart_1_csr.wfo(utra::udma_uart_1::REG_RX_CFG_R_RX_EN, baz); + let bar = udma_uart_1_csr.rf(utra::udma_uart_1::REG_RX_CFG_R_RX_CLR); + udma_uart_1_csr.rmwf(utra::udma_uart_1::REG_RX_CFG_R_RX_CLR, bar); + let mut baz = udma_uart_1_csr.zf(utra::udma_uart_1::REG_RX_CFG_R_RX_CLR, bar); + baz |= udma_uart_1_csr.ms(utra::udma_uart_1::REG_RX_CFG_R_RX_CLR, 1); + udma_uart_1_csr.wfo(utra::udma_uart_1::REG_RX_CFG_R_RX_CLR, baz); + + let foo = udma_uart_1_csr.r(utra::udma_uart_1::REG_TX_SADDR); + udma_uart_1_csr.wo(utra::udma_uart_1::REG_TX_SADDR, foo); + let bar = udma_uart_1_csr.rf(utra::udma_uart_1::REG_TX_SADDR_R_TX_STARTADDR); + udma_uart_1_csr.rmwf(utra::udma_uart_1::REG_TX_SADDR_R_TX_STARTADDR, bar); + let mut baz = udma_uart_1_csr.zf(utra::udma_uart_1::REG_TX_SADDR_R_TX_STARTADDR, bar); + baz |= udma_uart_1_csr.ms(utra::udma_uart_1::REG_TX_SADDR_R_TX_STARTADDR, 1); + udma_uart_1_csr.wfo(utra::udma_uart_1::REG_TX_SADDR_R_TX_STARTADDR, baz); + + let foo = udma_uart_1_csr.r(utra::udma_uart_1::REG_TX_SIZE); + udma_uart_1_csr.wo(utra::udma_uart_1::REG_TX_SIZE, foo); + let bar = udma_uart_1_csr.rf(utra::udma_uart_1::REG_TX_SIZE_R_TX_SIZE); + udma_uart_1_csr.rmwf(utra::udma_uart_1::REG_TX_SIZE_R_TX_SIZE, bar); + let mut baz = udma_uart_1_csr.zf(utra::udma_uart_1::REG_TX_SIZE_R_TX_SIZE, bar); + baz |= udma_uart_1_csr.ms(utra::udma_uart_1::REG_TX_SIZE_R_TX_SIZE, 1); + udma_uart_1_csr.wfo(utra::udma_uart_1::REG_TX_SIZE_R_TX_SIZE, baz); + + let foo = udma_uart_1_csr.r(utra::udma_uart_1::REG_TX_CFG); + udma_uart_1_csr.wo(utra::udma_uart_1::REG_TX_CFG, foo); + let bar = udma_uart_1_csr.rf(utra::udma_uart_1::REG_TX_CFG_R_TX_CONTINUOUS); + udma_uart_1_csr.rmwf(utra::udma_uart_1::REG_TX_CFG_R_TX_CONTINUOUS, bar); + let mut baz = udma_uart_1_csr.zf(utra::udma_uart_1::REG_TX_CFG_R_TX_CONTINUOUS, bar); + baz |= udma_uart_1_csr.ms(utra::udma_uart_1::REG_TX_CFG_R_TX_CONTINUOUS, 1); + udma_uart_1_csr.wfo(utra::udma_uart_1::REG_TX_CFG_R_TX_CONTINUOUS, baz); + let bar = udma_uart_1_csr.rf(utra::udma_uart_1::REG_TX_CFG_R_TX_EN); + udma_uart_1_csr.rmwf(utra::udma_uart_1::REG_TX_CFG_R_TX_EN, bar); + let mut baz = udma_uart_1_csr.zf(utra::udma_uart_1::REG_TX_CFG_R_TX_EN, bar); + baz |= udma_uart_1_csr.ms(utra::udma_uart_1::REG_TX_CFG_R_TX_EN, 1); + udma_uart_1_csr.wfo(utra::udma_uart_1::REG_TX_CFG_R_TX_EN, baz); + let bar = udma_uart_1_csr.rf(utra::udma_uart_1::REG_TX_CFG_R_TX_CLR); + udma_uart_1_csr.rmwf(utra::udma_uart_1::REG_TX_CFG_R_TX_CLR, bar); + let mut baz = udma_uart_1_csr.zf(utra::udma_uart_1::REG_TX_CFG_R_TX_CLR, bar); + baz |= udma_uart_1_csr.ms(utra::udma_uart_1::REG_TX_CFG_R_TX_CLR, 1); + udma_uart_1_csr.wfo(utra::udma_uart_1::REG_TX_CFG_R_TX_CLR, baz); + + let foo = udma_uart_1_csr.r(utra::udma_uart_1::REG_STATUS); + udma_uart_1_csr.wo(utra::udma_uart_1::REG_STATUS, foo); + let bar = udma_uart_1_csr.rf(utra::udma_uart_1::REG_STATUS_STATUS_I); + udma_uart_1_csr.rmwf(utra::udma_uart_1::REG_STATUS_STATUS_I, bar); + let mut baz = udma_uart_1_csr.zf(utra::udma_uart_1::REG_STATUS_STATUS_I, bar); + baz |= udma_uart_1_csr.ms(utra::udma_uart_1::REG_STATUS_STATUS_I, 1); + udma_uart_1_csr.wfo(utra::udma_uart_1::REG_STATUS_STATUS_I, baz); + + let foo = udma_uart_1_csr.r(utra::udma_uart_1::REG_UART_SETUP); + udma_uart_1_csr.wo(utra::udma_uart_1::REG_UART_SETUP, foo); + let bar = udma_uart_1_csr.rf(utra::udma_uart_1::REG_UART_SETUP_R_UART_PARITY_EN); + udma_uart_1_csr.rmwf(utra::udma_uart_1::REG_UART_SETUP_R_UART_PARITY_EN, bar); + let mut baz = udma_uart_1_csr.zf(utra::udma_uart_1::REG_UART_SETUP_R_UART_PARITY_EN, bar); + baz |= udma_uart_1_csr.ms(utra::udma_uart_1::REG_UART_SETUP_R_UART_PARITY_EN, 1); + udma_uart_1_csr.wfo(utra::udma_uart_1::REG_UART_SETUP_R_UART_PARITY_EN, baz); + let bar = udma_uart_1_csr.rf(utra::udma_uart_1::REG_UART_SETUP_R_UART_BITS); + udma_uart_1_csr.rmwf(utra::udma_uart_1::REG_UART_SETUP_R_UART_BITS, bar); + let mut baz = udma_uart_1_csr.zf(utra::udma_uart_1::REG_UART_SETUP_R_UART_BITS, bar); + baz |= udma_uart_1_csr.ms(utra::udma_uart_1::REG_UART_SETUP_R_UART_BITS, 1); + udma_uart_1_csr.wfo(utra::udma_uart_1::REG_UART_SETUP_R_UART_BITS, baz); + let bar = udma_uart_1_csr.rf(utra::udma_uart_1::REG_UART_SETUP_R_UART_STOP_BITS); + udma_uart_1_csr.rmwf(utra::udma_uart_1::REG_UART_SETUP_R_UART_STOP_BITS, bar); + let mut baz = udma_uart_1_csr.zf(utra::udma_uart_1::REG_UART_SETUP_R_UART_STOP_BITS, bar); + baz |= udma_uart_1_csr.ms(utra::udma_uart_1::REG_UART_SETUP_R_UART_STOP_BITS, 1); + udma_uart_1_csr.wfo(utra::udma_uart_1::REG_UART_SETUP_R_UART_STOP_BITS, baz); + let bar = udma_uart_1_csr.rf(utra::udma_uart_1::REG_UART_SETUP_R_UART_RX_POLLING_EN); + udma_uart_1_csr.rmwf(utra::udma_uart_1::REG_UART_SETUP_R_UART_RX_POLLING_EN, bar); + let mut baz = udma_uart_1_csr.zf(utra::udma_uart_1::REG_UART_SETUP_R_UART_RX_POLLING_EN, bar); + baz |= udma_uart_1_csr.ms(utra::udma_uart_1::REG_UART_SETUP_R_UART_RX_POLLING_EN, 1); + udma_uart_1_csr.wfo(utra::udma_uart_1::REG_UART_SETUP_R_UART_RX_POLLING_EN, baz); + let bar = udma_uart_1_csr.rf(utra::udma_uart_1::REG_UART_SETUP_R_UART_RX_CLEAN_FIFO); + udma_uart_1_csr.rmwf(utra::udma_uart_1::REG_UART_SETUP_R_UART_RX_CLEAN_FIFO, bar); + let mut baz = udma_uart_1_csr.zf(utra::udma_uart_1::REG_UART_SETUP_R_UART_RX_CLEAN_FIFO, bar); + baz |= udma_uart_1_csr.ms(utra::udma_uart_1::REG_UART_SETUP_R_UART_RX_CLEAN_FIFO, 1); + udma_uart_1_csr.wfo(utra::udma_uart_1::REG_UART_SETUP_R_UART_RX_CLEAN_FIFO, baz); + let bar = udma_uart_1_csr.rf(utra::udma_uart_1::REG_UART_SETUP_R_UART_EN_TX); + udma_uart_1_csr.rmwf(utra::udma_uart_1::REG_UART_SETUP_R_UART_EN_TX, bar); + let mut baz = udma_uart_1_csr.zf(utra::udma_uart_1::REG_UART_SETUP_R_UART_EN_TX, bar); + baz |= udma_uart_1_csr.ms(utra::udma_uart_1::REG_UART_SETUP_R_UART_EN_TX, 1); + udma_uart_1_csr.wfo(utra::udma_uart_1::REG_UART_SETUP_R_UART_EN_TX, baz); + let bar = udma_uart_1_csr.rf(utra::udma_uart_1::REG_UART_SETUP_R_UART_EN_RX); + udma_uart_1_csr.rmwf(utra::udma_uart_1::REG_UART_SETUP_R_UART_EN_RX, bar); + let mut baz = udma_uart_1_csr.zf(utra::udma_uart_1::REG_UART_SETUP_R_UART_EN_RX, bar); + baz |= udma_uart_1_csr.ms(utra::udma_uart_1::REG_UART_SETUP_R_UART_EN_RX, 1); + udma_uart_1_csr.wfo(utra::udma_uart_1::REG_UART_SETUP_R_UART_EN_RX, baz); + let bar = udma_uart_1_csr.rf(utra::udma_uart_1::REG_UART_SETUP_R_UART_DIV); + udma_uart_1_csr.rmwf(utra::udma_uart_1::REG_UART_SETUP_R_UART_DIV, bar); + let mut baz = udma_uart_1_csr.zf(utra::udma_uart_1::REG_UART_SETUP_R_UART_DIV, bar); + baz |= udma_uart_1_csr.ms(utra::udma_uart_1::REG_UART_SETUP_R_UART_DIV, 1); + udma_uart_1_csr.wfo(utra::udma_uart_1::REG_UART_SETUP_R_UART_DIV, baz); + + let foo = udma_uart_1_csr.r(utra::udma_uart_1::REG_ERROR); + udma_uart_1_csr.wo(utra::udma_uart_1::REG_ERROR, foo); + let bar = udma_uart_1_csr.rf(utra::udma_uart_1::REG_ERROR_R_ERR_OVERFLOW); + udma_uart_1_csr.rmwf(utra::udma_uart_1::REG_ERROR_R_ERR_OVERFLOW, bar); + let mut baz = udma_uart_1_csr.zf(utra::udma_uart_1::REG_ERROR_R_ERR_OVERFLOW, bar); + baz |= udma_uart_1_csr.ms(utra::udma_uart_1::REG_ERROR_R_ERR_OVERFLOW, 1); + udma_uart_1_csr.wfo(utra::udma_uart_1::REG_ERROR_R_ERR_OVERFLOW, baz); + let bar = udma_uart_1_csr.rf(utra::udma_uart_1::REG_ERROR_R_ERR_PARITY); + udma_uart_1_csr.rmwf(utra::udma_uart_1::REG_ERROR_R_ERR_PARITY, bar); + let mut baz = udma_uart_1_csr.zf(utra::udma_uart_1::REG_ERROR_R_ERR_PARITY, bar); + baz |= udma_uart_1_csr.ms(utra::udma_uart_1::REG_ERROR_R_ERR_PARITY, 1); + udma_uart_1_csr.wfo(utra::udma_uart_1::REG_ERROR_R_ERR_PARITY, baz); + + let foo = udma_uart_1_csr.r(utra::udma_uart_1::REG_IRQ_EN); + udma_uart_1_csr.wo(utra::udma_uart_1::REG_IRQ_EN, foo); + let bar = udma_uart_1_csr.rf(utra::udma_uart_1::REG_IRQ_EN_R_UART_RX_IRQ_EN); + udma_uart_1_csr.rmwf(utra::udma_uart_1::REG_IRQ_EN_R_UART_RX_IRQ_EN, bar); + let mut baz = udma_uart_1_csr.zf(utra::udma_uart_1::REG_IRQ_EN_R_UART_RX_IRQ_EN, bar); + baz |= udma_uart_1_csr.ms(utra::udma_uart_1::REG_IRQ_EN_R_UART_RX_IRQ_EN, 1); + udma_uart_1_csr.wfo(utra::udma_uart_1::REG_IRQ_EN_R_UART_RX_IRQ_EN, baz); + let bar = udma_uart_1_csr.rf(utra::udma_uart_1::REG_IRQ_EN_R_UART_ERR_IRQ_EN); + udma_uart_1_csr.rmwf(utra::udma_uart_1::REG_IRQ_EN_R_UART_ERR_IRQ_EN, bar); + let mut baz = udma_uart_1_csr.zf(utra::udma_uart_1::REG_IRQ_EN_R_UART_ERR_IRQ_EN, bar); + baz |= udma_uart_1_csr.ms(utra::udma_uart_1::REG_IRQ_EN_R_UART_ERR_IRQ_EN, 1); + udma_uart_1_csr.wfo(utra::udma_uart_1::REG_IRQ_EN_R_UART_ERR_IRQ_EN, baz); + + let foo = udma_uart_1_csr.r(utra::udma_uart_1::REG_VALID); + udma_uart_1_csr.wo(utra::udma_uart_1::REG_VALID, foo); + let bar = udma_uart_1_csr.rf(utra::udma_uart_1::REG_VALID_R_UART_RX_DATA_VALID); + udma_uart_1_csr.rmwf(utra::udma_uart_1::REG_VALID_R_UART_RX_DATA_VALID, bar); + let mut baz = udma_uart_1_csr.zf(utra::udma_uart_1::REG_VALID_R_UART_RX_DATA_VALID, bar); + baz |= udma_uart_1_csr.ms(utra::udma_uart_1::REG_VALID_R_UART_RX_DATA_VALID, 1); + udma_uart_1_csr.wfo(utra::udma_uart_1::REG_VALID_R_UART_RX_DATA_VALID, baz); + + let foo = udma_uart_1_csr.r(utra::udma_uart_1::REG_DATA); + udma_uart_1_csr.wo(utra::udma_uart_1::REG_DATA, foo); + let bar = udma_uart_1_csr.rf(utra::udma_uart_1::REG_DATA_R_UART_RX_DATA); + udma_uart_1_csr.rmwf(utra::udma_uart_1::REG_DATA_R_UART_RX_DATA, bar); + let mut baz = udma_uart_1_csr.zf(utra::udma_uart_1::REG_DATA_R_UART_RX_DATA, bar); + baz |= udma_uart_1_csr.ms(utra::udma_uart_1::REG_DATA_R_UART_RX_DATA, 1); + udma_uart_1_csr.wfo(utra::udma_uart_1::REG_DATA_R_UART_RX_DATA, baz); + } + + #[test] + #[ignore] + fn compile_check_udma_uart_2_csr() { + use super::*; + let mut udma_uart_2_csr = CSR::new(HW_UDMA_UART_2_BASE as *mut u32); + + let foo = udma_uart_2_csr.r(utra::udma_uart_2::REG_RX_SADDR); + udma_uart_2_csr.wo(utra::udma_uart_2::REG_RX_SADDR, foo); + let bar = udma_uart_2_csr.rf(utra::udma_uart_2::REG_RX_SADDR_R_RX_STARTADDR); + udma_uart_2_csr.rmwf(utra::udma_uart_2::REG_RX_SADDR_R_RX_STARTADDR, bar); + let mut baz = udma_uart_2_csr.zf(utra::udma_uart_2::REG_RX_SADDR_R_RX_STARTADDR, bar); + baz |= udma_uart_2_csr.ms(utra::udma_uart_2::REG_RX_SADDR_R_RX_STARTADDR, 1); + udma_uart_2_csr.wfo(utra::udma_uart_2::REG_RX_SADDR_R_RX_STARTADDR, baz); + + let foo = udma_uart_2_csr.r(utra::udma_uart_2::REG_RX_SIZE); + udma_uart_2_csr.wo(utra::udma_uart_2::REG_RX_SIZE, foo); + let bar = udma_uart_2_csr.rf(utra::udma_uart_2::REG_RX_SIZE_R_RX_SIZE); + udma_uart_2_csr.rmwf(utra::udma_uart_2::REG_RX_SIZE_R_RX_SIZE, bar); + let mut baz = udma_uart_2_csr.zf(utra::udma_uart_2::REG_RX_SIZE_R_RX_SIZE, bar); + baz |= udma_uart_2_csr.ms(utra::udma_uart_2::REG_RX_SIZE_R_RX_SIZE, 1); + udma_uart_2_csr.wfo(utra::udma_uart_2::REG_RX_SIZE_R_RX_SIZE, baz); + + let foo = udma_uart_2_csr.r(utra::udma_uart_2::REG_RX_CFG); + udma_uart_2_csr.wo(utra::udma_uart_2::REG_RX_CFG, foo); + let bar = udma_uart_2_csr.rf(utra::udma_uart_2::REG_RX_CFG_R_RX_CONTINUOUS); + udma_uart_2_csr.rmwf(utra::udma_uart_2::REG_RX_CFG_R_RX_CONTINUOUS, bar); + let mut baz = udma_uart_2_csr.zf(utra::udma_uart_2::REG_RX_CFG_R_RX_CONTINUOUS, bar); + baz |= udma_uart_2_csr.ms(utra::udma_uart_2::REG_RX_CFG_R_RX_CONTINUOUS, 1); + udma_uart_2_csr.wfo(utra::udma_uart_2::REG_RX_CFG_R_RX_CONTINUOUS, baz); + let bar = udma_uart_2_csr.rf(utra::udma_uart_2::REG_RX_CFG_R_RX_EN); + udma_uart_2_csr.rmwf(utra::udma_uart_2::REG_RX_CFG_R_RX_EN, bar); + let mut baz = udma_uart_2_csr.zf(utra::udma_uart_2::REG_RX_CFG_R_RX_EN, bar); + baz |= udma_uart_2_csr.ms(utra::udma_uart_2::REG_RX_CFG_R_RX_EN, 1); + udma_uart_2_csr.wfo(utra::udma_uart_2::REG_RX_CFG_R_RX_EN, baz); + let bar = udma_uart_2_csr.rf(utra::udma_uart_2::REG_RX_CFG_R_RX_CLR); + udma_uart_2_csr.rmwf(utra::udma_uart_2::REG_RX_CFG_R_RX_CLR, bar); + let mut baz = udma_uart_2_csr.zf(utra::udma_uart_2::REG_RX_CFG_R_RX_CLR, bar); + baz |= udma_uart_2_csr.ms(utra::udma_uart_2::REG_RX_CFG_R_RX_CLR, 1); + udma_uart_2_csr.wfo(utra::udma_uart_2::REG_RX_CFG_R_RX_CLR, baz); + + let foo = udma_uart_2_csr.r(utra::udma_uart_2::REG_TX_SADDR); + udma_uart_2_csr.wo(utra::udma_uart_2::REG_TX_SADDR, foo); + let bar = udma_uart_2_csr.rf(utra::udma_uart_2::REG_TX_SADDR_R_TX_STARTADDR); + udma_uart_2_csr.rmwf(utra::udma_uart_2::REG_TX_SADDR_R_TX_STARTADDR, bar); + let mut baz = udma_uart_2_csr.zf(utra::udma_uart_2::REG_TX_SADDR_R_TX_STARTADDR, bar); + baz |= udma_uart_2_csr.ms(utra::udma_uart_2::REG_TX_SADDR_R_TX_STARTADDR, 1); + udma_uart_2_csr.wfo(utra::udma_uart_2::REG_TX_SADDR_R_TX_STARTADDR, baz); + + let foo = udma_uart_2_csr.r(utra::udma_uart_2::REG_TX_SIZE); + udma_uart_2_csr.wo(utra::udma_uart_2::REG_TX_SIZE, foo); + let bar = udma_uart_2_csr.rf(utra::udma_uart_2::REG_TX_SIZE_R_TX_SIZE); + udma_uart_2_csr.rmwf(utra::udma_uart_2::REG_TX_SIZE_R_TX_SIZE, bar); + let mut baz = udma_uart_2_csr.zf(utra::udma_uart_2::REG_TX_SIZE_R_TX_SIZE, bar); + baz |= udma_uart_2_csr.ms(utra::udma_uart_2::REG_TX_SIZE_R_TX_SIZE, 1); + udma_uart_2_csr.wfo(utra::udma_uart_2::REG_TX_SIZE_R_TX_SIZE, baz); + + let foo = udma_uart_2_csr.r(utra::udma_uart_2::REG_TX_CFG); + udma_uart_2_csr.wo(utra::udma_uart_2::REG_TX_CFG, foo); + let bar = udma_uart_2_csr.rf(utra::udma_uart_2::REG_TX_CFG_R_TX_CONTINUOUS); + udma_uart_2_csr.rmwf(utra::udma_uart_2::REG_TX_CFG_R_TX_CONTINUOUS, bar); + let mut baz = udma_uart_2_csr.zf(utra::udma_uart_2::REG_TX_CFG_R_TX_CONTINUOUS, bar); + baz |= udma_uart_2_csr.ms(utra::udma_uart_2::REG_TX_CFG_R_TX_CONTINUOUS, 1); + udma_uart_2_csr.wfo(utra::udma_uart_2::REG_TX_CFG_R_TX_CONTINUOUS, baz); + let bar = udma_uart_2_csr.rf(utra::udma_uart_2::REG_TX_CFG_R_TX_EN); + udma_uart_2_csr.rmwf(utra::udma_uart_2::REG_TX_CFG_R_TX_EN, bar); + let mut baz = udma_uart_2_csr.zf(utra::udma_uart_2::REG_TX_CFG_R_TX_EN, bar); + baz |= udma_uart_2_csr.ms(utra::udma_uart_2::REG_TX_CFG_R_TX_EN, 1); + udma_uart_2_csr.wfo(utra::udma_uart_2::REG_TX_CFG_R_TX_EN, baz); + let bar = udma_uart_2_csr.rf(utra::udma_uart_2::REG_TX_CFG_R_TX_CLR); + udma_uart_2_csr.rmwf(utra::udma_uart_2::REG_TX_CFG_R_TX_CLR, bar); + let mut baz = udma_uart_2_csr.zf(utra::udma_uart_2::REG_TX_CFG_R_TX_CLR, bar); + baz |= udma_uart_2_csr.ms(utra::udma_uart_2::REG_TX_CFG_R_TX_CLR, 1); + udma_uart_2_csr.wfo(utra::udma_uart_2::REG_TX_CFG_R_TX_CLR, baz); + + let foo = udma_uart_2_csr.r(utra::udma_uart_2::REG_STATUS); + udma_uart_2_csr.wo(utra::udma_uart_2::REG_STATUS, foo); + let bar = udma_uart_2_csr.rf(utra::udma_uart_2::REG_STATUS_STATUS_I); + udma_uart_2_csr.rmwf(utra::udma_uart_2::REG_STATUS_STATUS_I, bar); + let mut baz = udma_uart_2_csr.zf(utra::udma_uart_2::REG_STATUS_STATUS_I, bar); + baz |= udma_uart_2_csr.ms(utra::udma_uart_2::REG_STATUS_STATUS_I, 1); + udma_uart_2_csr.wfo(utra::udma_uart_2::REG_STATUS_STATUS_I, baz); + + let foo = udma_uart_2_csr.r(utra::udma_uart_2::REG_UART_SETUP); + udma_uart_2_csr.wo(utra::udma_uart_2::REG_UART_SETUP, foo); + let bar = udma_uart_2_csr.rf(utra::udma_uart_2::REG_UART_SETUP_R_UART_PARITY_EN); + udma_uart_2_csr.rmwf(utra::udma_uart_2::REG_UART_SETUP_R_UART_PARITY_EN, bar); + let mut baz = udma_uart_2_csr.zf(utra::udma_uart_2::REG_UART_SETUP_R_UART_PARITY_EN, bar); + baz |= udma_uart_2_csr.ms(utra::udma_uart_2::REG_UART_SETUP_R_UART_PARITY_EN, 1); + udma_uart_2_csr.wfo(utra::udma_uart_2::REG_UART_SETUP_R_UART_PARITY_EN, baz); + let bar = udma_uart_2_csr.rf(utra::udma_uart_2::REG_UART_SETUP_R_UART_BITS); + udma_uart_2_csr.rmwf(utra::udma_uart_2::REG_UART_SETUP_R_UART_BITS, bar); + let mut baz = udma_uart_2_csr.zf(utra::udma_uart_2::REG_UART_SETUP_R_UART_BITS, bar); + baz |= udma_uart_2_csr.ms(utra::udma_uart_2::REG_UART_SETUP_R_UART_BITS, 1); + udma_uart_2_csr.wfo(utra::udma_uart_2::REG_UART_SETUP_R_UART_BITS, baz); + let bar = udma_uart_2_csr.rf(utra::udma_uart_2::REG_UART_SETUP_R_UART_STOP_BITS); + udma_uart_2_csr.rmwf(utra::udma_uart_2::REG_UART_SETUP_R_UART_STOP_BITS, bar); + let mut baz = udma_uart_2_csr.zf(utra::udma_uart_2::REG_UART_SETUP_R_UART_STOP_BITS, bar); + baz |= udma_uart_2_csr.ms(utra::udma_uart_2::REG_UART_SETUP_R_UART_STOP_BITS, 1); + udma_uart_2_csr.wfo(utra::udma_uart_2::REG_UART_SETUP_R_UART_STOP_BITS, baz); + let bar = udma_uart_2_csr.rf(utra::udma_uart_2::REG_UART_SETUP_R_UART_RX_POLLING_EN); + udma_uart_2_csr.rmwf(utra::udma_uart_2::REG_UART_SETUP_R_UART_RX_POLLING_EN, bar); + let mut baz = udma_uart_2_csr.zf(utra::udma_uart_2::REG_UART_SETUP_R_UART_RX_POLLING_EN, bar); + baz |= udma_uart_2_csr.ms(utra::udma_uart_2::REG_UART_SETUP_R_UART_RX_POLLING_EN, 1); + udma_uart_2_csr.wfo(utra::udma_uart_2::REG_UART_SETUP_R_UART_RX_POLLING_EN, baz); + let bar = udma_uart_2_csr.rf(utra::udma_uart_2::REG_UART_SETUP_R_UART_RX_CLEAN_FIFO); + udma_uart_2_csr.rmwf(utra::udma_uart_2::REG_UART_SETUP_R_UART_RX_CLEAN_FIFO, bar); + let mut baz = udma_uart_2_csr.zf(utra::udma_uart_2::REG_UART_SETUP_R_UART_RX_CLEAN_FIFO, bar); + baz |= udma_uart_2_csr.ms(utra::udma_uart_2::REG_UART_SETUP_R_UART_RX_CLEAN_FIFO, 1); + udma_uart_2_csr.wfo(utra::udma_uart_2::REG_UART_SETUP_R_UART_RX_CLEAN_FIFO, baz); + let bar = udma_uart_2_csr.rf(utra::udma_uart_2::REG_UART_SETUP_R_UART_EN_TX); + udma_uart_2_csr.rmwf(utra::udma_uart_2::REG_UART_SETUP_R_UART_EN_TX, bar); + let mut baz = udma_uart_2_csr.zf(utra::udma_uart_2::REG_UART_SETUP_R_UART_EN_TX, bar); + baz |= udma_uart_2_csr.ms(utra::udma_uart_2::REG_UART_SETUP_R_UART_EN_TX, 1); + udma_uart_2_csr.wfo(utra::udma_uart_2::REG_UART_SETUP_R_UART_EN_TX, baz); + let bar = udma_uart_2_csr.rf(utra::udma_uart_2::REG_UART_SETUP_R_UART_EN_RX); + udma_uart_2_csr.rmwf(utra::udma_uart_2::REG_UART_SETUP_R_UART_EN_RX, bar); + let mut baz = udma_uart_2_csr.zf(utra::udma_uart_2::REG_UART_SETUP_R_UART_EN_RX, bar); + baz |= udma_uart_2_csr.ms(utra::udma_uart_2::REG_UART_SETUP_R_UART_EN_RX, 1); + udma_uart_2_csr.wfo(utra::udma_uart_2::REG_UART_SETUP_R_UART_EN_RX, baz); + let bar = udma_uart_2_csr.rf(utra::udma_uart_2::REG_UART_SETUP_R_UART_DIV); + udma_uart_2_csr.rmwf(utra::udma_uart_2::REG_UART_SETUP_R_UART_DIV, bar); + let mut baz = udma_uart_2_csr.zf(utra::udma_uart_2::REG_UART_SETUP_R_UART_DIV, bar); + baz |= udma_uart_2_csr.ms(utra::udma_uart_2::REG_UART_SETUP_R_UART_DIV, 1); + udma_uart_2_csr.wfo(utra::udma_uart_2::REG_UART_SETUP_R_UART_DIV, baz); + + let foo = udma_uart_2_csr.r(utra::udma_uart_2::REG_ERROR); + udma_uart_2_csr.wo(utra::udma_uart_2::REG_ERROR, foo); + let bar = udma_uart_2_csr.rf(utra::udma_uart_2::REG_ERROR_R_ERR_OVERFLOW); + udma_uart_2_csr.rmwf(utra::udma_uart_2::REG_ERROR_R_ERR_OVERFLOW, bar); + let mut baz = udma_uart_2_csr.zf(utra::udma_uart_2::REG_ERROR_R_ERR_OVERFLOW, bar); + baz |= udma_uart_2_csr.ms(utra::udma_uart_2::REG_ERROR_R_ERR_OVERFLOW, 1); + udma_uart_2_csr.wfo(utra::udma_uart_2::REG_ERROR_R_ERR_OVERFLOW, baz); + let bar = udma_uart_2_csr.rf(utra::udma_uart_2::REG_ERROR_R_ERR_PARITY); + udma_uart_2_csr.rmwf(utra::udma_uart_2::REG_ERROR_R_ERR_PARITY, bar); + let mut baz = udma_uart_2_csr.zf(utra::udma_uart_2::REG_ERROR_R_ERR_PARITY, bar); + baz |= udma_uart_2_csr.ms(utra::udma_uart_2::REG_ERROR_R_ERR_PARITY, 1); + udma_uart_2_csr.wfo(utra::udma_uart_2::REG_ERROR_R_ERR_PARITY, baz); + + let foo = udma_uart_2_csr.r(utra::udma_uart_2::REG_IRQ_EN); + udma_uart_2_csr.wo(utra::udma_uart_2::REG_IRQ_EN, foo); + let bar = udma_uart_2_csr.rf(utra::udma_uart_2::REG_IRQ_EN_R_UART_RX_IRQ_EN); + udma_uart_2_csr.rmwf(utra::udma_uart_2::REG_IRQ_EN_R_UART_RX_IRQ_EN, bar); + let mut baz = udma_uart_2_csr.zf(utra::udma_uart_2::REG_IRQ_EN_R_UART_RX_IRQ_EN, bar); + baz |= udma_uart_2_csr.ms(utra::udma_uart_2::REG_IRQ_EN_R_UART_RX_IRQ_EN, 1); + udma_uart_2_csr.wfo(utra::udma_uart_2::REG_IRQ_EN_R_UART_RX_IRQ_EN, baz); + let bar = udma_uart_2_csr.rf(utra::udma_uart_2::REG_IRQ_EN_R_UART_ERR_IRQ_EN); + udma_uart_2_csr.rmwf(utra::udma_uart_2::REG_IRQ_EN_R_UART_ERR_IRQ_EN, bar); + let mut baz = udma_uart_2_csr.zf(utra::udma_uart_2::REG_IRQ_EN_R_UART_ERR_IRQ_EN, bar); + baz |= udma_uart_2_csr.ms(utra::udma_uart_2::REG_IRQ_EN_R_UART_ERR_IRQ_EN, 1); + udma_uart_2_csr.wfo(utra::udma_uart_2::REG_IRQ_EN_R_UART_ERR_IRQ_EN, baz); + + let foo = udma_uart_2_csr.r(utra::udma_uart_2::REG_VALID); + udma_uart_2_csr.wo(utra::udma_uart_2::REG_VALID, foo); + let bar = udma_uart_2_csr.rf(utra::udma_uart_2::REG_VALID_R_UART_RX_DATA_VALID); + udma_uart_2_csr.rmwf(utra::udma_uart_2::REG_VALID_R_UART_RX_DATA_VALID, bar); + let mut baz = udma_uart_2_csr.zf(utra::udma_uart_2::REG_VALID_R_UART_RX_DATA_VALID, bar); + baz |= udma_uart_2_csr.ms(utra::udma_uart_2::REG_VALID_R_UART_RX_DATA_VALID, 1); + udma_uart_2_csr.wfo(utra::udma_uart_2::REG_VALID_R_UART_RX_DATA_VALID, baz); + + let foo = udma_uart_2_csr.r(utra::udma_uart_2::REG_DATA); + udma_uart_2_csr.wo(utra::udma_uart_2::REG_DATA, foo); + let bar = udma_uart_2_csr.rf(utra::udma_uart_2::REG_DATA_R_UART_RX_DATA); + udma_uart_2_csr.rmwf(utra::udma_uart_2::REG_DATA_R_UART_RX_DATA, bar); + let mut baz = udma_uart_2_csr.zf(utra::udma_uart_2::REG_DATA_R_UART_RX_DATA, bar); + baz |= udma_uart_2_csr.ms(utra::udma_uart_2::REG_DATA_R_UART_RX_DATA, 1); + udma_uart_2_csr.wfo(utra::udma_uart_2::REG_DATA_R_UART_RX_DATA, baz); + } + + #[test] + #[ignore] + fn compile_check_udma_uart_3_csr() { + use super::*; + let mut udma_uart_3_csr = CSR::new(HW_UDMA_UART_3_BASE as *mut u32); + + let foo = udma_uart_3_csr.r(utra::udma_uart_3::REG_RX_SADDR); + udma_uart_3_csr.wo(utra::udma_uart_3::REG_RX_SADDR, foo); + let bar = udma_uart_3_csr.rf(utra::udma_uart_3::REG_RX_SADDR_R_RX_STARTADDR); + udma_uart_3_csr.rmwf(utra::udma_uart_3::REG_RX_SADDR_R_RX_STARTADDR, bar); + let mut baz = udma_uart_3_csr.zf(utra::udma_uart_3::REG_RX_SADDR_R_RX_STARTADDR, bar); + baz |= udma_uart_3_csr.ms(utra::udma_uart_3::REG_RX_SADDR_R_RX_STARTADDR, 1); + udma_uart_3_csr.wfo(utra::udma_uart_3::REG_RX_SADDR_R_RX_STARTADDR, baz); + + let foo = udma_uart_3_csr.r(utra::udma_uart_3::REG_RX_SIZE); + udma_uart_3_csr.wo(utra::udma_uart_3::REG_RX_SIZE, foo); + let bar = udma_uart_3_csr.rf(utra::udma_uart_3::REG_RX_SIZE_R_RX_SIZE); + udma_uart_3_csr.rmwf(utra::udma_uart_3::REG_RX_SIZE_R_RX_SIZE, bar); + let mut baz = udma_uart_3_csr.zf(utra::udma_uart_3::REG_RX_SIZE_R_RX_SIZE, bar); + baz |= udma_uart_3_csr.ms(utra::udma_uart_3::REG_RX_SIZE_R_RX_SIZE, 1); + udma_uart_3_csr.wfo(utra::udma_uart_3::REG_RX_SIZE_R_RX_SIZE, baz); + + let foo = udma_uart_3_csr.r(utra::udma_uart_3::REG_RX_CFG); + udma_uart_3_csr.wo(utra::udma_uart_3::REG_RX_CFG, foo); + let bar = udma_uart_3_csr.rf(utra::udma_uart_3::REG_RX_CFG_R_RX_CONTINUOUS); + udma_uart_3_csr.rmwf(utra::udma_uart_3::REG_RX_CFG_R_RX_CONTINUOUS, bar); + let mut baz = udma_uart_3_csr.zf(utra::udma_uart_3::REG_RX_CFG_R_RX_CONTINUOUS, bar); + baz |= udma_uart_3_csr.ms(utra::udma_uart_3::REG_RX_CFG_R_RX_CONTINUOUS, 1); + udma_uart_3_csr.wfo(utra::udma_uart_3::REG_RX_CFG_R_RX_CONTINUOUS, baz); + let bar = udma_uart_3_csr.rf(utra::udma_uart_3::REG_RX_CFG_R_RX_EN); + udma_uart_3_csr.rmwf(utra::udma_uart_3::REG_RX_CFG_R_RX_EN, bar); + let mut baz = udma_uart_3_csr.zf(utra::udma_uart_3::REG_RX_CFG_R_RX_EN, bar); + baz |= udma_uart_3_csr.ms(utra::udma_uart_3::REG_RX_CFG_R_RX_EN, 1); + udma_uart_3_csr.wfo(utra::udma_uart_3::REG_RX_CFG_R_RX_EN, baz); + let bar = udma_uart_3_csr.rf(utra::udma_uart_3::REG_RX_CFG_R_RX_CLR); + udma_uart_3_csr.rmwf(utra::udma_uart_3::REG_RX_CFG_R_RX_CLR, bar); + let mut baz = udma_uart_3_csr.zf(utra::udma_uart_3::REG_RX_CFG_R_RX_CLR, bar); + baz |= udma_uart_3_csr.ms(utra::udma_uart_3::REG_RX_CFG_R_RX_CLR, 1); + udma_uart_3_csr.wfo(utra::udma_uart_3::REG_RX_CFG_R_RX_CLR, baz); + + let foo = udma_uart_3_csr.r(utra::udma_uart_3::REG_TX_SADDR); + udma_uart_3_csr.wo(utra::udma_uart_3::REG_TX_SADDR, foo); + let bar = udma_uart_3_csr.rf(utra::udma_uart_3::REG_TX_SADDR_R_TX_STARTADDR); + udma_uart_3_csr.rmwf(utra::udma_uart_3::REG_TX_SADDR_R_TX_STARTADDR, bar); + let mut baz = udma_uart_3_csr.zf(utra::udma_uart_3::REG_TX_SADDR_R_TX_STARTADDR, bar); + baz |= udma_uart_3_csr.ms(utra::udma_uart_3::REG_TX_SADDR_R_TX_STARTADDR, 1); + udma_uart_3_csr.wfo(utra::udma_uart_3::REG_TX_SADDR_R_TX_STARTADDR, baz); + + let foo = udma_uart_3_csr.r(utra::udma_uart_3::REG_TX_SIZE); + udma_uart_3_csr.wo(utra::udma_uart_3::REG_TX_SIZE, foo); + let bar = udma_uart_3_csr.rf(utra::udma_uart_3::REG_TX_SIZE_R_TX_SIZE); + udma_uart_3_csr.rmwf(utra::udma_uart_3::REG_TX_SIZE_R_TX_SIZE, bar); + let mut baz = udma_uart_3_csr.zf(utra::udma_uart_3::REG_TX_SIZE_R_TX_SIZE, bar); + baz |= udma_uart_3_csr.ms(utra::udma_uart_3::REG_TX_SIZE_R_TX_SIZE, 1); + udma_uart_3_csr.wfo(utra::udma_uart_3::REG_TX_SIZE_R_TX_SIZE, baz); + + let foo = udma_uart_3_csr.r(utra::udma_uart_3::REG_TX_CFG); + udma_uart_3_csr.wo(utra::udma_uart_3::REG_TX_CFG, foo); + let bar = udma_uart_3_csr.rf(utra::udma_uart_3::REG_TX_CFG_R_TX_CONTINUOUS); + udma_uart_3_csr.rmwf(utra::udma_uart_3::REG_TX_CFG_R_TX_CONTINUOUS, bar); + let mut baz = udma_uart_3_csr.zf(utra::udma_uart_3::REG_TX_CFG_R_TX_CONTINUOUS, bar); + baz |= udma_uart_3_csr.ms(utra::udma_uart_3::REG_TX_CFG_R_TX_CONTINUOUS, 1); + udma_uart_3_csr.wfo(utra::udma_uart_3::REG_TX_CFG_R_TX_CONTINUOUS, baz); + let bar = udma_uart_3_csr.rf(utra::udma_uart_3::REG_TX_CFG_R_TX_EN); + udma_uart_3_csr.rmwf(utra::udma_uart_3::REG_TX_CFG_R_TX_EN, bar); + let mut baz = udma_uart_3_csr.zf(utra::udma_uart_3::REG_TX_CFG_R_TX_EN, bar); + baz |= udma_uart_3_csr.ms(utra::udma_uart_3::REG_TX_CFG_R_TX_EN, 1); + udma_uart_3_csr.wfo(utra::udma_uart_3::REG_TX_CFG_R_TX_EN, baz); + let bar = udma_uart_3_csr.rf(utra::udma_uart_3::REG_TX_CFG_R_TX_CLR); + udma_uart_3_csr.rmwf(utra::udma_uart_3::REG_TX_CFG_R_TX_CLR, bar); + let mut baz = udma_uart_3_csr.zf(utra::udma_uart_3::REG_TX_CFG_R_TX_CLR, bar); + baz |= udma_uart_3_csr.ms(utra::udma_uart_3::REG_TX_CFG_R_TX_CLR, 1); + udma_uart_3_csr.wfo(utra::udma_uart_3::REG_TX_CFG_R_TX_CLR, baz); + + let foo = udma_uart_3_csr.r(utra::udma_uart_3::REG_STATUS); + udma_uart_3_csr.wo(utra::udma_uart_3::REG_STATUS, foo); + let bar = udma_uart_3_csr.rf(utra::udma_uart_3::REG_STATUS_STATUS_I); + udma_uart_3_csr.rmwf(utra::udma_uart_3::REG_STATUS_STATUS_I, bar); + let mut baz = udma_uart_3_csr.zf(utra::udma_uart_3::REG_STATUS_STATUS_I, bar); + baz |= udma_uart_3_csr.ms(utra::udma_uart_3::REG_STATUS_STATUS_I, 1); + udma_uart_3_csr.wfo(utra::udma_uart_3::REG_STATUS_STATUS_I, baz); + + let foo = udma_uart_3_csr.r(utra::udma_uart_3::REG_UART_SETUP); + udma_uart_3_csr.wo(utra::udma_uart_3::REG_UART_SETUP, foo); + let bar = udma_uart_3_csr.rf(utra::udma_uart_3::REG_UART_SETUP_R_UART_PARITY_EN); + udma_uart_3_csr.rmwf(utra::udma_uart_3::REG_UART_SETUP_R_UART_PARITY_EN, bar); + let mut baz = udma_uart_3_csr.zf(utra::udma_uart_3::REG_UART_SETUP_R_UART_PARITY_EN, bar); + baz |= udma_uart_3_csr.ms(utra::udma_uart_3::REG_UART_SETUP_R_UART_PARITY_EN, 1); + udma_uart_3_csr.wfo(utra::udma_uart_3::REG_UART_SETUP_R_UART_PARITY_EN, baz); + let bar = udma_uart_3_csr.rf(utra::udma_uart_3::REG_UART_SETUP_R_UART_BITS); + udma_uart_3_csr.rmwf(utra::udma_uart_3::REG_UART_SETUP_R_UART_BITS, bar); + let mut baz = udma_uart_3_csr.zf(utra::udma_uart_3::REG_UART_SETUP_R_UART_BITS, bar); + baz |= udma_uart_3_csr.ms(utra::udma_uart_3::REG_UART_SETUP_R_UART_BITS, 1); + udma_uart_3_csr.wfo(utra::udma_uart_3::REG_UART_SETUP_R_UART_BITS, baz); + let bar = udma_uart_3_csr.rf(utra::udma_uart_3::REG_UART_SETUP_R_UART_STOP_BITS); + udma_uart_3_csr.rmwf(utra::udma_uart_3::REG_UART_SETUP_R_UART_STOP_BITS, bar); + let mut baz = udma_uart_3_csr.zf(utra::udma_uart_3::REG_UART_SETUP_R_UART_STOP_BITS, bar); + baz |= udma_uart_3_csr.ms(utra::udma_uart_3::REG_UART_SETUP_R_UART_STOP_BITS, 1); + udma_uart_3_csr.wfo(utra::udma_uart_3::REG_UART_SETUP_R_UART_STOP_BITS, baz); + let bar = udma_uart_3_csr.rf(utra::udma_uart_3::REG_UART_SETUP_R_UART_RX_POLLING_EN); + udma_uart_3_csr.rmwf(utra::udma_uart_3::REG_UART_SETUP_R_UART_RX_POLLING_EN, bar); + let mut baz = udma_uart_3_csr.zf(utra::udma_uart_3::REG_UART_SETUP_R_UART_RX_POLLING_EN, bar); + baz |= udma_uart_3_csr.ms(utra::udma_uart_3::REG_UART_SETUP_R_UART_RX_POLLING_EN, 1); + udma_uart_3_csr.wfo(utra::udma_uart_3::REG_UART_SETUP_R_UART_RX_POLLING_EN, baz); + let bar = udma_uart_3_csr.rf(utra::udma_uart_3::REG_UART_SETUP_R_UART_RX_CLEAN_FIFO); + udma_uart_3_csr.rmwf(utra::udma_uart_3::REG_UART_SETUP_R_UART_RX_CLEAN_FIFO, bar); + let mut baz = udma_uart_3_csr.zf(utra::udma_uart_3::REG_UART_SETUP_R_UART_RX_CLEAN_FIFO, bar); + baz |= udma_uart_3_csr.ms(utra::udma_uart_3::REG_UART_SETUP_R_UART_RX_CLEAN_FIFO, 1); + udma_uart_3_csr.wfo(utra::udma_uart_3::REG_UART_SETUP_R_UART_RX_CLEAN_FIFO, baz); + let bar = udma_uart_3_csr.rf(utra::udma_uart_3::REG_UART_SETUP_R_UART_EN_TX); + udma_uart_3_csr.rmwf(utra::udma_uart_3::REG_UART_SETUP_R_UART_EN_TX, bar); + let mut baz = udma_uart_3_csr.zf(utra::udma_uart_3::REG_UART_SETUP_R_UART_EN_TX, bar); + baz |= udma_uart_3_csr.ms(utra::udma_uart_3::REG_UART_SETUP_R_UART_EN_TX, 1); + udma_uart_3_csr.wfo(utra::udma_uart_3::REG_UART_SETUP_R_UART_EN_TX, baz); + let bar = udma_uart_3_csr.rf(utra::udma_uart_3::REG_UART_SETUP_R_UART_EN_RX); + udma_uart_3_csr.rmwf(utra::udma_uart_3::REG_UART_SETUP_R_UART_EN_RX, bar); + let mut baz = udma_uart_3_csr.zf(utra::udma_uart_3::REG_UART_SETUP_R_UART_EN_RX, bar); + baz |= udma_uart_3_csr.ms(utra::udma_uart_3::REG_UART_SETUP_R_UART_EN_RX, 1); + udma_uart_3_csr.wfo(utra::udma_uart_3::REG_UART_SETUP_R_UART_EN_RX, baz); + let bar = udma_uart_3_csr.rf(utra::udma_uart_3::REG_UART_SETUP_R_UART_DIV); + udma_uart_3_csr.rmwf(utra::udma_uart_3::REG_UART_SETUP_R_UART_DIV, bar); + let mut baz = udma_uart_3_csr.zf(utra::udma_uart_3::REG_UART_SETUP_R_UART_DIV, bar); + baz |= udma_uart_3_csr.ms(utra::udma_uart_3::REG_UART_SETUP_R_UART_DIV, 1); + udma_uart_3_csr.wfo(utra::udma_uart_3::REG_UART_SETUP_R_UART_DIV, baz); + + let foo = udma_uart_3_csr.r(utra::udma_uart_3::REG_ERROR); + udma_uart_3_csr.wo(utra::udma_uart_3::REG_ERROR, foo); + let bar = udma_uart_3_csr.rf(utra::udma_uart_3::REG_ERROR_R_ERR_OVERFLOW); + udma_uart_3_csr.rmwf(utra::udma_uart_3::REG_ERROR_R_ERR_OVERFLOW, bar); + let mut baz = udma_uart_3_csr.zf(utra::udma_uart_3::REG_ERROR_R_ERR_OVERFLOW, bar); + baz |= udma_uart_3_csr.ms(utra::udma_uart_3::REG_ERROR_R_ERR_OVERFLOW, 1); + udma_uart_3_csr.wfo(utra::udma_uart_3::REG_ERROR_R_ERR_OVERFLOW, baz); + let bar = udma_uart_3_csr.rf(utra::udma_uart_3::REG_ERROR_R_ERR_PARITY); + udma_uart_3_csr.rmwf(utra::udma_uart_3::REG_ERROR_R_ERR_PARITY, bar); + let mut baz = udma_uart_3_csr.zf(utra::udma_uart_3::REG_ERROR_R_ERR_PARITY, bar); + baz |= udma_uart_3_csr.ms(utra::udma_uart_3::REG_ERROR_R_ERR_PARITY, 1); + udma_uart_3_csr.wfo(utra::udma_uart_3::REG_ERROR_R_ERR_PARITY, baz); + + let foo = udma_uart_3_csr.r(utra::udma_uart_3::REG_IRQ_EN); + udma_uart_3_csr.wo(utra::udma_uart_3::REG_IRQ_EN, foo); + let bar = udma_uart_3_csr.rf(utra::udma_uart_3::REG_IRQ_EN_R_UART_RX_IRQ_EN); + udma_uart_3_csr.rmwf(utra::udma_uart_3::REG_IRQ_EN_R_UART_RX_IRQ_EN, bar); + let mut baz = udma_uart_3_csr.zf(utra::udma_uart_3::REG_IRQ_EN_R_UART_RX_IRQ_EN, bar); + baz |= udma_uart_3_csr.ms(utra::udma_uart_3::REG_IRQ_EN_R_UART_RX_IRQ_EN, 1); + udma_uart_3_csr.wfo(utra::udma_uart_3::REG_IRQ_EN_R_UART_RX_IRQ_EN, baz); + let bar = udma_uart_3_csr.rf(utra::udma_uart_3::REG_IRQ_EN_R_UART_ERR_IRQ_EN); + udma_uart_3_csr.rmwf(utra::udma_uart_3::REG_IRQ_EN_R_UART_ERR_IRQ_EN, bar); + let mut baz = udma_uart_3_csr.zf(utra::udma_uart_3::REG_IRQ_EN_R_UART_ERR_IRQ_EN, bar); + baz |= udma_uart_3_csr.ms(utra::udma_uart_3::REG_IRQ_EN_R_UART_ERR_IRQ_EN, 1); + udma_uart_3_csr.wfo(utra::udma_uart_3::REG_IRQ_EN_R_UART_ERR_IRQ_EN, baz); + + let foo = udma_uart_3_csr.r(utra::udma_uart_3::REG_VALID); + udma_uart_3_csr.wo(utra::udma_uart_3::REG_VALID, foo); + let bar = udma_uart_3_csr.rf(utra::udma_uart_3::REG_VALID_R_UART_RX_DATA_VALID); + udma_uart_3_csr.rmwf(utra::udma_uart_3::REG_VALID_R_UART_RX_DATA_VALID, bar); + let mut baz = udma_uart_3_csr.zf(utra::udma_uart_3::REG_VALID_R_UART_RX_DATA_VALID, bar); + baz |= udma_uart_3_csr.ms(utra::udma_uart_3::REG_VALID_R_UART_RX_DATA_VALID, 1); + udma_uart_3_csr.wfo(utra::udma_uart_3::REG_VALID_R_UART_RX_DATA_VALID, baz); + + let foo = udma_uart_3_csr.r(utra::udma_uart_3::REG_DATA); + udma_uart_3_csr.wo(utra::udma_uart_3::REG_DATA, foo); + let bar = udma_uart_3_csr.rf(utra::udma_uart_3::REG_DATA_R_UART_RX_DATA); + udma_uart_3_csr.rmwf(utra::udma_uart_3::REG_DATA_R_UART_RX_DATA, bar); + let mut baz = udma_uart_3_csr.zf(utra::udma_uart_3::REG_DATA_R_UART_RX_DATA, bar); + baz |= udma_uart_3_csr.ms(utra::udma_uart_3::REG_DATA_R_UART_RX_DATA, 1); + udma_uart_3_csr.wfo(utra::udma_uart_3::REG_DATA_R_UART_RX_DATA, baz); + } + + #[test] + #[ignore] + fn compile_check_udma_spim_0_csr() { + use super::*; + let mut udma_spim_0_csr = CSR::new(HW_UDMA_SPIM_0_BASE as *mut u32); + + let foo = udma_spim_0_csr.r(utra::udma_spim_0::REG_RX_SADDR); + udma_spim_0_csr.wo(utra::udma_spim_0::REG_RX_SADDR, foo); + let bar = udma_spim_0_csr.rf(utra::udma_spim_0::REG_RX_SADDR_R_RX_STARTADDR); + udma_spim_0_csr.rmwf(utra::udma_spim_0::REG_RX_SADDR_R_RX_STARTADDR, bar); + let mut baz = udma_spim_0_csr.zf(utra::udma_spim_0::REG_RX_SADDR_R_RX_STARTADDR, bar); + baz |= udma_spim_0_csr.ms(utra::udma_spim_0::REG_RX_SADDR_R_RX_STARTADDR, 1); + udma_spim_0_csr.wfo(utra::udma_spim_0::REG_RX_SADDR_R_RX_STARTADDR, baz); + + let foo = udma_spim_0_csr.r(utra::udma_spim_0::REG_RX_SIZE); + udma_spim_0_csr.wo(utra::udma_spim_0::REG_RX_SIZE, foo); + let bar = udma_spim_0_csr.rf(utra::udma_spim_0::REG_RX_SIZE_R_RX_SIZE); + udma_spim_0_csr.rmwf(utra::udma_spim_0::REG_RX_SIZE_R_RX_SIZE, bar); + let mut baz = udma_spim_0_csr.zf(utra::udma_spim_0::REG_RX_SIZE_R_RX_SIZE, bar); + baz |= udma_spim_0_csr.ms(utra::udma_spim_0::REG_RX_SIZE_R_RX_SIZE, 1); + udma_spim_0_csr.wfo(utra::udma_spim_0::REG_RX_SIZE_R_RX_SIZE, baz); + + let foo = udma_spim_0_csr.r(utra::udma_spim_0::REG_RX_CFG); + udma_spim_0_csr.wo(utra::udma_spim_0::REG_RX_CFG, foo); + let bar = udma_spim_0_csr.rf(utra::udma_spim_0::REG_RX_CFG_R_RX_CONTINUOUS); + udma_spim_0_csr.rmwf(utra::udma_spim_0::REG_RX_CFG_R_RX_CONTINUOUS, bar); + let mut baz = udma_spim_0_csr.zf(utra::udma_spim_0::REG_RX_CFG_R_RX_CONTINUOUS, bar); + baz |= udma_spim_0_csr.ms(utra::udma_spim_0::REG_RX_CFG_R_RX_CONTINUOUS, 1); + udma_spim_0_csr.wfo(utra::udma_spim_0::REG_RX_CFG_R_RX_CONTINUOUS, baz); + let bar = udma_spim_0_csr.rf(utra::udma_spim_0::REG_RX_CFG_R_RX_DATASIZE); + udma_spim_0_csr.rmwf(utra::udma_spim_0::REG_RX_CFG_R_RX_DATASIZE, bar); + let mut baz = udma_spim_0_csr.zf(utra::udma_spim_0::REG_RX_CFG_R_RX_DATASIZE, bar); + baz |= udma_spim_0_csr.ms(utra::udma_spim_0::REG_RX_CFG_R_RX_DATASIZE, 1); + udma_spim_0_csr.wfo(utra::udma_spim_0::REG_RX_CFG_R_RX_DATASIZE, baz); + let bar = udma_spim_0_csr.rf(utra::udma_spim_0::REG_RX_CFG_R_RX_EN); + udma_spim_0_csr.rmwf(utra::udma_spim_0::REG_RX_CFG_R_RX_EN, bar); + let mut baz = udma_spim_0_csr.zf(utra::udma_spim_0::REG_RX_CFG_R_RX_EN, bar); + baz |= udma_spim_0_csr.ms(utra::udma_spim_0::REG_RX_CFG_R_RX_EN, 1); + udma_spim_0_csr.wfo(utra::udma_spim_0::REG_RX_CFG_R_RX_EN, baz); + let bar = udma_spim_0_csr.rf(utra::udma_spim_0::REG_RX_CFG_R_RX_CLR); + udma_spim_0_csr.rmwf(utra::udma_spim_0::REG_RX_CFG_R_RX_CLR, bar); + 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 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); + let bar = udma_spim_0_csr.rf(utra::udma_spim_0::REG_TX_SADDR_R_TX_STARTADDR); + udma_spim_0_csr.rmwf(utra::udma_spim_0::REG_TX_SADDR_R_TX_STARTADDR, bar); + let mut baz = udma_spim_0_csr.zf(utra::udma_spim_0::REG_TX_SADDR_R_TX_STARTADDR, bar); + baz |= udma_spim_0_csr.ms(utra::udma_spim_0::REG_TX_SADDR_R_TX_STARTADDR, 1); + udma_spim_0_csr.wfo(utra::udma_spim_0::REG_TX_SADDR_R_TX_STARTADDR, baz); + + let foo = udma_spim_0_csr.r(utra::udma_spim_0::REG_TX_SIZE); + udma_spim_0_csr.wo(utra::udma_spim_0::REG_TX_SIZE, foo); + let bar = udma_spim_0_csr.rf(utra::udma_spim_0::REG_TX_SIZE_R_TX_SIZE); + udma_spim_0_csr.rmwf(utra::udma_spim_0::REG_TX_SIZE_R_TX_SIZE, bar); + let mut baz = udma_spim_0_csr.zf(utra::udma_spim_0::REG_TX_SIZE_R_TX_SIZE, bar); + baz |= udma_spim_0_csr.ms(utra::udma_spim_0::REG_TX_SIZE_R_TX_SIZE, 1); + udma_spim_0_csr.wfo(utra::udma_spim_0::REG_TX_SIZE_R_TX_SIZE, baz); + + let foo = udma_spim_0_csr.r(utra::udma_spim_0::REG_TX_CFG); + udma_spim_0_csr.wo(utra::udma_spim_0::REG_TX_CFG, foo); + let bar = udma_spim_0_csr.rf(utra::udma_spim_0::REG_TX_CFG_R_TX_CONTINUOUS); + udma_spim_0_csr.rmwf(utra::udma_spim_0::REG_TX_CFG_R_TX_CONTINUOUS, bar); + let mut baz = udma_spim_0_csr.zf(utra::udma_spim_0::REG_TX_CFG_R_TX_CONTINUOUS, bar); + baz |= udma_spim_0_csr.ms(utra::udma_spim_0::REG_TX_CFG_R_TX_CONTINUOUS, 1); + udma_spim_0_csr.wfo(utra::udma_spim_0::REG_TX_CFG_R_TX_CONTINUOUS, baz); + let bar = udma_spim_0_csr.rf(utra::udma_spim_0::REG_TX_CFG_R_TX_DATASIZE); + udma_spim_0_csr.rmwf(utra::udma_spim_0::REG_TX_CFG_R_TX_DATASIZE, bar); + let mut baz = udma_spim_0_csr.zf(utra::udma_spim_0::REG_TX_CFG_R_TX_DATASIZE, bar); + baz |= udma_spim_0_csr.ms(utra::udma_spim_0::REG_TX_CFG_R_TX_DATASIZE, 1); + udma_spim_0_csr.wfo(utra::udma_spim_0::REG_TX_CFG_R_TX_DATASIZE, baz); + let bar = udma_spim_0_csr.rf(utra::udma_spim_0::REG_TX_CFG_R_TX_EN); + udma_spim_0_csr.rmwf(utra::udma_spim_0::REG_TX_CFG_R_TX_EN, bar); + let mut baz = udma_spim_0_csr.zf(utra::udma_spim_0::REG_TX_CFG_R_TX_EN, bar); + baz |= udma_spim_0_csr.ms(utra::udma_spim_0::REG_TX_CFG_R_TX_EN, 1); + udma_spim_0_csr.wfo(utra::udma_spim_0::REG_TX_CFG_R_TX_EN, baz); + let bar = udma_spim_0_csr.rf(utra::udma_spim_0::REG_TX_CFG_R_TX_CLR); + udma_spim_0_csr.rmwf(utra::udma_spim_0::REG_TX_CFG_R_TX_CLR, bar); + let mut baz = udma_spim_0_csr.zf(utra::udma_spim_0::REG_TX_CFG_R_TX_CLR, bar); + baz |= udma_spim_0_csr.ms(utra::udma_spim_0::REG_TX_CFG_R_TX_CLR, 1); + udma_spim_0_csr.wfo(utra::udma_spim_0::REG_TX_CFG_R_TX_CLR, baz); + + let foo = udma_spim_0_csr.r(utra::udma_spim_0::REG_CMD_SADDR); + udma_spim_0_csr.wo(utra::udma_spim_0::REG_CMD_SADDR, foo); + let bar = udma_spim_0_csr.rf(utra::udma_spim_0::REG_CMD_SADDR_R_CMD_STARTADDR); + udma_spim_0_csr.rmwf(utra::udma_spim_0::REG_CMD_SADDR_R_CMD_STARTADDR, bar); + let mut baz = udma_spim_0_csr.zf(utra::udma_spim_0::REG_CMD_SADDR_R_CMD_STARTADDR, bar); + baz |= udma_spim_0_csr.ms(utra::udma_spim_0::REG_CMD_SADDR_R_CMD_STARTADDR, 1); + udma_spim_0_csr.wfo(utra::udma_spim_0::REG_CMD_SADDR_R_CMD_STARTADDR, baz); + + let foo = udma_spim_0_csr.r(utra::udma_spim_0::REG_CMD_SIZE); + udma_spim_0_csr.wo(utra::udma_spim_0::REG_CMD_SIZE, foo); + let bar = udma_spim_0_csr.rf(utra::udma_spim_0::REG_CMD_SIZE_R_CMD_SIZE); + udma_spim_0_csr.rmwf(utra::udma_spim_0::REG_CMD_SIZE_R_CMD_SIZE, bar); + let mut baz = udma_spim_0_csr.zf(utra::udma_spim_0::REG_CMD_SIZE_R_CMD_SIZE, bar); + baz |= udma_spim_0_csr.ms(utra::udma_spim_0::REG_CMD_SIZE_R_CMD_SIZE, 1); + udma_spim_0_csr.wfo(utra::udma_spim_0::REG_CMD_SIZE_R_CMD_SIZE, baz); + + let foo = udma_spim_0_csr.r(utra::udma_spim_0::REG_CMD_CFG); + udma_spim_0_csr.wo(utra::udma_spim_0::REG_CMD_CFG, foo); + let bar = udma_spim_0_csr.rf(utra::udma_spim_0::REG_CMD_CFG_R_CMD_CONTINUOUS); + udma_spim_0_csr.rmwf(utra::udma_spim_0::REG_CMD_CFG_R_CMD_CONTINUOUS, bar); + let mut baz = udma_spim_0_csr.zf(utra::udma_spim_0::REG_CMD_CFG_R_CMD_CONTINUOUS, bar); + baz |= udma_spim_0_csr.ms(utra::udma_spim_0::REG_CMD_CFG_R_CMD_CONTINUOUS, 1); + udma_spim_0_csr.wfo(utra::udma_spim_0::REG_CMD_CFG_R_CMD_CONTINUOUS, baz); + let bar = udma_spim_0_csr.rf(utra::udma_spim_0::REG_CMD_CFG_R_CMD_EN); + udma_spim_0_csr.rmwf(utra::udma_spim_0::REG_CMD_CFG_R_CMD_EN, bar); + let mut baz = udma_spim_0_csr.zf(utra::udma_spim_0::REG_CMD_CFG_R_CMD_EN, bar); + baz |= udma_spim_0_csr.ms(utra::udma_spim_0::REG_CMD_CFG_R_CMD_EN, 1); + udma_spim_0_csr.wfo(utra::udma_spim_0::REG_CMD_CFG_R_CMD_EN, baz); + let bar = udma_spim_0_csr.rf(utra::udma_spim_0::REG_CMD_CFG_R_CMD_CLR); + udma_spim_0_csr.rmwf(utra::udma_spim_0::REG_CMD_CFG_R_CMD_CLR, bar); + let mut baz = udma_spim_0_csr.zf(utra::udma_spim_0::REG_CMD_CFG_R_CMD_CLR, bar); + baz |= udma_spim_0_csr.ms(utra::udma_spim_0::REG_CMD_CFG_R_CMD_CLR, 1); + udma_spim_0_csr.wfo(utra::udma_spim_0::REG_CMD_CFG_R_CMD_CLR, baz); + + let foo = udma_spim_0_csr.r(utra::udma_spim_0::REG_STATUS); + udma_spim_0_csr.wo(utra::udma_spim_0::REG_STATUS, foo); + let bar = udma_spim_0_csr.rf(utra::udma_spim_0::REG_STATUS_STATUS_I); + udma_spim_0_csr.rmwf(utra::udma_spim_0::REG_STATUS_STATUS_I, bar); + let mut baz = udma_spim_0_csr.zf(utra::udma_spim_0::REG_STATUS_STATUS_I, bar); + baz |= udma_spim_0_csr.ms(utra::udma_spim_0::REG_STATUS_STATUS_I, 1); + udma_spim_0_csr.wfo(utra::udma_spim_0::REG_STATUS_STATUS_I, baz); + } + + #[test] + #[ignore] + fn compile_check_udma_spim_1_csr() { + use super::*; + let mut udma_spim_1_csr = CSR::new(HW_UDMA_SPIM_1_BASE as *mut u32); + + let foo = udma_spim_1_csr.r(utra::udma_spim_1::REG_RX_SADDR); + udma_spim_1_csr.wo(utra::udma_spim_1::REG_RX_SADDR, foo); + let bar = udma_spim_1_csr.rf(utra::udma_spim_1::REG_RX_SADDR_R_RX_STARTADDR); + udma_spim_1_csr.rmwf(utra::udma_spim_1::REG_RX_SADDR_R_RX_STARTADDR, bar); + let mut baz = udma_spim_1_csr.zf(utra::udma_spim_1::REG_RX_SADDR_R_RX_STARTADDR, bar); + baz |= udma_spim_1_csr.ms(utra::udma_spim_1::REG_RX_SADDR_R_RX_STARTADDR, 1); + udma_spim_1_csr.wfo(utra::udma_spim_1::REG_RX_SADDR_R_RX_STARTADDR, baz); + + let foo = udma_spim_1_csr.r(utra::udma_spim_1::REG_RX_SIZE); + udma_spim_1_csr.wo(utra::udma_spim_1::REG_RX_SIZE, foo); + let bar = udma_spim_1_csr.rf(utra::udma_spim_1::REG_RX_SIZE_R_RX_SIZE); + udma_spim_1_csr.rmwf(utra::udma_spim_1::REG_RX_SIZE_R_RX_SIZE, bar); + let mut baz = udma_spim_1_csr.zf(utra::udma_spim_1::REG_RX_SIZE_R_RX_SIZE, bar); + baz |= udma_spim_1_csr.ms(utra::udma_spim_1::REG_RX_SIZE_R_RX_SIZE, 1); + udma_spim_1_csr.wfo(utra::udma_spim_1::REG_RX_SIZE_R_RX_SIZE, baz); + + let foo = udma_spim_1_csr.r(utra::udma_spim_1::REG_RX_CFG); + udma_spim_1_csr.wo(utra::udma_spim_1::REG_RX_CFG, foo); + let bar = udma_spim_1_csr.rf(utra::udma_spim_1::REG_RX_CFG_R_RX_CONTINUOUS); + udma_spim_1_csr.rmwf(utra::udma_spim_1::REG_RX_CFG_R_RX_CONTINUOUS, bar); + let mut baz = udma_spim_1_csr.zf(utra::udma_spim_1::REG_RX_CFG_R_RX_CONTINUOUS, bar); + baz |= udma_spim_1_csr.ms(utra::udma_spim_1::REG_RX_CFG_R_RX_CONTINUOUS, 1); + udma_spim_1_csr.wfo(utra::udma_spim_1::REG_RX_CFG_R_RX_CONTINUOUS, baz); + let bar = udma_spim_1_csr.rf(utra::udma_spim_1::REG_RX_CFG_R_RX_DATASIZE); + udma_spim_1_csr.rmwf(utra::udma_spim_1::REG_RX_CFG_R_RX_DATASIZE, bar); + let mut baz = udma_spim_1_csr.zf(utra::udma_spim_1::REG_RX_CFG_R_RX_DATASIZE, bar); + baz |= udma_spim_1_csr.ms(utra::udma_spim_1::REG_RX_CFG_R_RX_DATASIZE, 1); + udma_spim_1_csr.wfo(utra::udma_spim_1::REG_RX_CFG_R_RX_DATASIZE, baz); + let bar = udma_spim_1_csr.rf(utra::udma_spim_1::REG_RX_CFG_R_RX_EN); + udma_spim_1_csr.rmwf(utra::udma_spim_1::REG_RX_CFG_R_RX_EN, bar); + let mut baz = udma_spim_1_csr.zf(utra::udma_spim_1::REG_RX_CFG_R_RX_EN, bar); + baz |= udma_spim_1_csr.ms(utra::udma_spim_1::REG_RX_CFG_R_RX_EN, 1); + udma_spim_1_csr.wfo(utra::udma_spim_1::REG_RX_CFG_R_RX_EN, baz); + let bar = udma_spim_1_csr.rf(utra::udma_spim_1::REG_RX_CFG_R_RX_CLR); + udma_spim_1_csr.rmwf(utra::udma_spim_1::REG_RX_CFG_R_RX_CLR, bar); + 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 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); + let bar = udma_spim_1_csr.rf(utra::udma_spim_1::REG_TX_SADDR_R_TX_STARTADDR); + udma_spim_1_csr.rmwf(utra::udma_spim_1::REG_TX_SADDR_R_TX_STARTADDR, bar); + let mut baz = udma_spim_1_csr.zf(utra::udma_spim_1::REG_TX_SADDR_R_TX_STARTADDR, bar); + baz |= udma_spim_1_csr.ms(utra::udma_spim_1::REG_TX_SADDR_R_TX_STARTADDR, 1); + udma_spim_1_csr.wfo(utra::udma_spim_1::REG_TX_SADDR_R_TX_STARTADDR, baz); + + let foo = udma_spim_1_csr.r(utra::udma_spim_1::REG_TX_SIZE); + udma_spim_1_csr.wo(utra::udma_spim_1::REG_TX_SIZE, foo); + let bar = udma_spim_1_csr.rf(utra::udma_spim_1::REG_TX_SIZE_R_TX_SIZE); + udma_spim_1_csr.rmwf(utra::udma_spim_1::REG_TX_SIZE_R_TX_SIZE, bar); + let mut baz = udma_spim_1_csr.zf(utra::udma_spim_1::REG_TX_SIZE_R_TX_SIZE, bar); + baz |= udma_spim_1_csr.ms(utra::udma_spim_1::REG_TX_SIZE_R_TX_SIZE, 1); + udma_spim_1_csr.wfo(utra::udma_spim_1::REG_TX_SIZE_R_TX_SIZE, baz); + + let foo = udma_spim_1_csr.r(utra::udma_spim_1::REG_TX_CFG); + udma_spim_1_csr.wo(utra::udma_spim_1::REG_TX_CFG, foo); + let bar = udma_spim_1_csr.rf(utra::udma_spim_1::REG_TX_CFG_R_TX_CONTINUOUS); + udma_spim_1_csr.rmwf(utra::udma_spim_1::REG_TX_CFG_R_TX_CONTINUOUS, bar); + let mut baz = udma_spim_1_csr.zf(utra::udma_spim_1::REG_TX_CFG_R_TX_CONTINUOUS, bar); + baz |= udma_spim_1_csr.ms(utra::udma_spim_1::REG_TX_CFG_R_TX_CONTINUOUS, 1); + udma_spim_1_csr.wfo(utra::udma_spim_1::REG_TX_CFG_R_TX_CONTINUOUS, baz); + let bar = udma_spim_1_csr.rf(utra::udma_spim_1::REG_TX_CFG_R_TX_DATASIZE); + udma_spim_1_csr.rmwf(utra::udma_spim_1::REG_TX_CFG_R_TX_DATASIZE, bar); + let mut baz = udma_spim_1_csr.zf(utra::udma_spim_1::REG_TX_CFG_R_TX_DATASIZE, bar); + baz |= udma_spim_1_csr.ms(utra::udma_spim_1::REG_TX_CFG_R_TX_DATASIZE, 1); + udma_spim_1_csr.wfo(utra::udma_spim_1::REG_TX_CFG_R_TX_DATASIZE, baz); + let bar = udma_spim_1_csr.rf(utra::udma_spim_1::REG_TX_CFG_R_TX_EN); + udma_spim_1_csr.rmwf(utra::udma_spim_1::REG_TX_CFG_R_TX_EN, bar); + let mut baz = udma_spim_1_csr.zf(utra::udma_spim_1::REG_TX_CFG_R_TX_EN, bar); + baz |= udma_spim_1_csr.ms(utra::udma_spim_1::REG_TX_CFG_R_TX_EN, 1); + udma_spim_1_csr.wfo(utra::udma_spim_1::REG_TX_CFG_R_TX_EN, baz); + let bar = udma_spim_1_csr.rf(utra::udma_spim_1::REG_TX_CFG_R_TX_CLR); + udma_spim_1_csr.rmwf(utra::udma_spim_1::REG_TX_CFG_R_TX_CLR, bar); + let mut baz = udma_spim_1_csr.zf(utra::udma_spim_1::REG_TX_CFG_R_TX_CLR, bar); + baz |= udma_spim_1_csr.ms(utra::udma_spim_1::REG_TX_CFG_R_TX_CLR, 1); + udma_spim_1_csr.wfo(utra::udma_spim_1::REG_TX_CFG_R_TX_CLR, baz); + + let foo = udma_spim_1_csr.r(utra::udma_spim_1::REG_CMD_SADDR); + udma_spim_1_csr.wo(utra::udma_spim_1::REG_CMD_SADDR, foo); + let bar = udma_spim_1_csr.rf(utra::udma_spim_1::REG_CMD_SADDR_R_CMD_STARTADDR); + udma_spim_1_csr.rmwf(utra::udma_spim_1::REG_CMD_SADDR_R_CMD_STARTADDR, bar); + let mut baz = udma_spim_1_csr.zf(utra::udma_spim_1::REG_CMD_SADDR_R_CMD_STARTADDR, bar); + baz |= udma_spim_1_csr.ms(utra::udma_spim_1::REG_CMD_SADDR_R_CMD_STARTADDR, 1); + udma_spim_1_csr.wfo(utra::udma_spim_1::REG_CMD_SADDR_R_CMD_STARTADDR, baz); + + let foo = udma_spim_1_csr.r(utra::udma_spim_1::REG_CMD_SIZE); + udma_spim_1_csr.wo(utra::udma_spim_1::REG_CMD_SIZE, foo); + let bar = udma_spim_1_csr.rf(utra::udma_spim_1::REG_CMD_SIZE_R_CMD_SIZE); + udma_spim_1_csr.rmwf(utra::udma_spim_1::REG_CMD_SIZE_R_CMD_SIZE, bar); + let mut baz = udma_spim_1_csr.zf(utra::udma_spim_1::REG_CMD_SIZE_R_CMD_SIZE, bar); + baz |= udma_spim_1_csr.ms(utra::udma_spim_1::REG_CMD_SIZE_R_CMD_SIZE, 1); + udma_spim_1_csr.wfo(utra::udma_spim_1::REG_CMD_SIZE_R_CMD_SIZE, baz); + + let foo = udma_spim_1_csr.r(utra::udma_spim_1::REG_CMD_CFG); + udma_spim_1_csr.wo(utra::udma_spim_1::REG_CMD_CFG, foo); + let bar = udma_spim_1_csr.rf(utra::udma_spim_1::REG_CMD_CFG_R_CMD_CONTINUOUS); + udma_spim_1_csr.rmwf(utra::udma_spim_1::REG_CMD_CFG_R_CMD_CONTINUOUS, bar); + let mut baz = udma_spim_1_csr.zf(utra::udma_spim_1::REG_CMD_CFG_R_CMD_CONTINUOUS, bar); + baz |= udma_spim_1_csr.ms(utra::udma_spim_1::REG_CMD_CFG_R_CMD_CONTINUOUS, 1); + udma_spim_1_csr.wfo(utra::udma_spim_1::REG_CMD_CFG_R_CMD_CONTINUOUS, baz); + let bar = udma_spim_1_csr.rf(utra::udma_spim_1::REG_CMD_CFG_R_CMD_EN); + udma_spim_1_csr.rmwf(utra::udma_spim_1::REG_CMD_CFG_R_CMD_EN, bar); + let mut baz = udma_spim_1_csr.zf(utra::udma_spim_1::REG_CMD_CFG_R_CMD_EN, bar); + baz |= udma_spim_1_csr.ms(utra::udma_spim_1::REG_CMD_CFG_R_CMD_EN, 1); + udma_spim_1_csr.wfo(utra::udma_spim_1::REG_CMD_CFG_R_CMD_EN, baz); + let bar = udma_spim_1_csr.rf(utra::udma_spim_1::REG_CMD_CFG_R_CMD_CLR); + udma_spim_1_csr.rmwf(utra::udma_spim_1::REG_CMD_CFG_R_CMD_CLR, bar); + let mut baz = udma_spim_1_csr.zf(utra::udma_spim_1::REG_CMD_CFG_R_CMD_CLR, bar); + baz |= udma_spim_1_csr.ms(utra::udma_spim_1::REG_CMD_CFG_R_CMD_CLR, 1); + udma_spim_1_csr.wfo(utra::udma_spim_1::REG_CMD_CFG_R_CMD_CLR, baz); + + let foo = udma_spim_1_csr.r(utra::udma_spim_1::REG_STATUS); + udma_spim_1_csr.wo(utra::udma_spim_1::REG_STATUS, foo); + let bar = udma_spim_1_csr.rf(utra::udma_spim_1::REG_STATUS_STATUS_I); + udma_spim_1_csr.rmwf(utra::udma_spim_1::REG_STATUS_STATUS_I, bar); + let mut baz = udma_spim_1_csr.zf(utra::udma_spim_1::REG_STATUS_STATUS_I, bar); + baz |= udma_spim_1_csr.ms(utra::udma_spim_1::REG_STATUS_STATUS_I, 1); + udma_spim_1_csr.wfo(utra::udma_spim_1::REG_STATUS_STATUS_I, baz); + } + + #[test] + #[ignore] + fn compile_check_udma_spim_2_csr() { + use super::*; + let mut udma_spim_2_csr = CSR::new(HW_UDMA_SPIM_2_BASE as *mut u32); + + let foo = udma_spim_2_csr.r(utra::udma_spim_2::REG_RX_SADDR); + udma_spim_2_csr.wo(utra::udma_spim_2::REG_RX_SADDR, foo); + let bar = udma_spim_2_csr.rf(utra::udma_spim_2::REG_RX_SADDR_R_RX_STARTADDR); + udma_spim_2_csr.rmwf(utra::udma_spim_2::REG_RX_SADDR_R_RX_STARTADDR, bar); + let mut baz = udma_spim_2_csr.zf(utra::udma_spim_2::REG_RX_SADDR_R_RX_STARTADDR, bar); + baz |= udma_spim_2_csr.ms(utra::udma_spim_2::REG_RX_SADDR_R_RX_STARTADDR, 1); + udma_spim_2_csr.wfo(utra::udma_spim_2::REG_RX_SADDR_R_RX_STARTADDR, baz); + + let foo = udma_spim_2_csr.r(utra::udma_spim_2::REG_RX_SIZE); + udma_spim_2_csr.wo(utra::udma_spim_2::REG_RX_SIZE, foo); + let bar = udma_spim_2_csr.rf(utra::udma_spim_2::REG_RX_SIZE_R_RX_SIZE); + udma_spim_2_csr.rmwf(utra::udma_spim_2::REG_RX_SIZE_R_RX_SIZE, bar); + let mut baz = udma_spim_2_csr.zf(utra::udma_spim_2::REG_RX_SIZE_R_RX_SIZE, bar); + baz |= udma_spim_2_csr.ms(utra::udma_spim_2::REG_RX_SIZE_R_RX_SIZE, 1); + udma_spim_2_csr.wfo(utra::udma_spim_2::REG_RX_SIZE_R_RX_SIZE, baz); + + let foo = udma_spim_2_csr.r(utra::udma_spim_2::REG_RX_CFG); + udma_spim_2_csr.wo(utra::udma_spim_2::REG_RX_CFG, foo); + let bar = udma_spim_2_csr.rf(utra::udma_spim_2::REG_RX_CFG_R_RX_CONTINUOUS); + udma_spim_2_csr.rmwf(utra::udma_spim_2::REG_RX_CFG_R_RX_CONTINUOUS, bar); + let mut baz = udma_spim_2_csr.zf(utra::udma_spim_2::REG_RX_CFG_R_RX_CONTINUOUS, bar); + baz |= udma_spim_2_csr.ms(utra::udma_spim_2::REG_RX_CFG_R_RX_CONTINUOUS, 1); + udma_spim_2_csr.wfo(utra::udma_spim_2::REG_RX_CFG_R_RX_CONTINUOUS, baz); + let bar = udma_spim_2_csr.rf(utra::udma_spim_2::REG_RX_CFG_R_RX_DATASIZE); + udma_spim_2_csr.rmwf(utra::udma_spim_2::REG_RX_CFG_R_RX_DATASIZE, bar); + let mut baz = udma_spim_2_csr.zf(utra::udma_spim_2::REG_RX_CFG_R_RX_DATASIZE, bar); + baz |= udma_spim_2_csr.ms(utra::udma_spim_2::REG_RX_CFG_R_RX_DATASIZE, 1); + udma_spim_2_csr.wfo(utra::udma_spim_2::REG_RX_CFG_R_RX_DATASIZE, baz); + let bar = udma_spim_2_csr.rf(utra::udma_spim_2::REG_RX_CFG_R_RX_EN); + udma_spim_2_csr.rmwf(utra::udma_spim_2::REG_RX_CFG_R_RX_EN, bar); + let mut baz = udma_spim_2_csr.zf(utra::udma_spim_2::REG_RX_CFG_R_RX_EN, bar); + baz |= udma_spim_2_csr.ms(utra::udma_spim_2::REG_RX_CFG_R_RX_EN, 1); + udma_spim_2_csr.wfo(utra::udma_spim_2::REG_RX_CFG_R_RX_EN, baz); + let bar = udma_spim_2_csr.rf(utra::udma_spim_2::REG_RX_CFG_R_RX_CLR); + udma_spim_2_csr.rmwf(utra::udma_spim_2::REG_RX_CFG_R_RX_CLR, bar); + 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 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); + let bar = udma_spim_2_csr.rf(utra::udma_spim_2::REG_TX_SADDR_R_TX_STARTADDR); + udma_spim_2_csr.rmwf(utra::udma_spim_2::REG_TX_SADDR_R_TX_STARTADDR, bar); + let mut baz = udma_spim_2_csr.zf(utra::udma_spim_2::REG_TX_SADDR_R_TX_STARTADDR, bar); + baz |= udma_spim_2_csr.ms(utra::udma_spim_2::REG_TX_SADDR_R_TX_STARTADDR, 1); + udma_spim_2_csr.wfo(utra::udma_spim_2::REG_TX_SADDR_R_TX_STARTADDR, baz); + + let foo = udma_spim_2_csr.r(utra::udma_spim_2::REG_TX_SIZE); + udma_spim_2_csr.wo(utra::udma_spim_2::REG_TX_SIZE, foo); + let bar = udma_spim_2_csr.rf(utra::udma_spim_2::REG_TX_SIZE_R_TX_SIZE); + udma_spim_2_csr.rmwf(utra::udma_spim_2::REG_TX_SIZE_R_TX_SIZE, bar); + let mut baz = udma_spim_2_csr.zf(utra::udma_spim_2::REG_TX_SIZE_R_TX_SIZE, bar); + baz |= udma_spim_2_csr.ms(utra::udma_spim_2::REG_TX_SIZE_R_TX_SIZE, 1); + udma_spim_2_csr.wfo(utra::udma_spim_2::REG_TX_SIZE_R_TX_SIZE, baz); + + let foo = udma_spim_2_csr.r(utra::udma_spim_2::REG_TX_CFG); + udma_spim_2_csr.wo(utra::udma_spim_2::REG_TX_CFG, foo); + let bar = udma_spim_2_csr.rf(utra::udma_spim_2::REG_TX_CFG_R_TX_CONTINUOUS); + udma_spim_2_csr.rmwf(utra::udma_spim_2::REG_TX_CFG_R_TX_CONTINUOUS, bar); + let mut baz = udma_spim_2_csr.zf(utra::udma_spim_2::REG_TX_CFG_R_TX_CONTINUOUS, bar); + baz |= udma_spim_2_csr.ms(utra::udma_spim_2::REG_TX_CFG_R_TX_CONTINUOUS, 1); + udma_spim_2_csr.wfo(utra::udma_spim_2::REG_TX_CFG_R_TX_CONTINUOUS, baz); + let bar = udma_spim_2_csr.rf(utra::udma_spim_2::REG_TX_CFG_R_TX_DATASIZE); + udma_spim_2_csr.rmwf(utra::udma_spim_2::REG_TX_CFG_R_TX_DATASIZE, bar); + let mut baz = udma_spim_2_csr.zf(utra::udma_spim_2::REG_TX_CFG_R_TX_DATASIZE, bar); + baz |= udma_spim_2_csr.ms(utra::udma_spim_2::REG_TX_CFG_R_TX_DATASIZE, 1); + udma_spim_2_csr.wfo(utra::udma_spim_2::REG_TX_CFG_R_TX_DATASIZE, baz); + let bar = udma_spim_2_csr.rf(utra::udma_spim_2::REG_TX_CFG_R_TX_EN); + udma_spim_2_csr.rmwf(utra::udma_spim_2::REG_TX_CFG_R_TX_EN, bar); + let mut baz = udma_spim_2_csr.zf(utra::udma_spim_2::REG_TX_CFG_R_TX_EN, bar); + baz |= udma_spim_2_csr.ms(utra::udma_spim_2::REG_TX_CFG_R_TX_EN, 1); + udma_spim_2_csr.wfo(utra::udma_spim_2::REG_TX_CFG_R_TX_EN, baz); + let bar = udma_spim_2_csr.rf(utra::udma_spim_2::REG_TX_CFG_R_TX_CLR); + udma_spim_2_csr.rmwf(utra::udma_spim_2::REG_TX_CFG_R_TX_CLR, bar); + let mut baz = udma_spim_2_csr.zf(utra::udma_spim_2::REG_TX_CFG_R_TX_CLR, bar); + baz |= udma_spim_2_csr.ms(utra::udma_spim_2::REG_TX_CFG_R_TX_CLR, 1); + udma_spim_2_csr.wfo(utra::udma_spim_2::REG_TX_CFG_R_TX_CLR, baz); + + let foo = udma_spim_2_csr.r(utra::udma_spim_2::REG_CMD_SADDR); + udma_spim_2_csr.wo(utra::udma_spim_2::REG_CMD_SADDR, foo); + let bar = udma_spim_2_csr.rf(utra::udma_spim_2::REG_CMD_SADDR_R_CMD_STARTADDR); + udma_spim_2_csr.rmwf(utra::udma_spim_2::REG_CMD_SADDR_R_CMD_STARTADDR, bar); + let mut baz = udma_spim_2_csr.zf(utra::udma_spim_2::REG_CMD_SADDR_R_CMD_STARTADDR, bar); + baz |= udma_spim_2_csr.ms(utra::udma_spim_2::REG_CMD_SADDR_R_CMD_STARTADDR, 1); + udma_spim_2_csr.wfo(utra::udma_spim_2::REG_CMD_SADDR_R_CMD_STARTADDR, baz); + + let foo = udma_spim_2_csr.r(utra::udma_spim_2::REG_CMD_SIZE); + udma_spim_2_csr.wo(utra::udma_spim_2::REG_CMD_SIZE, foo); + let bar = udma_spim_2_csr.rf(utra::udma_spim_2::REG_CMD_SIZE_R_CMD_SIZE); + udma_spim_2_csr.rmwf(utra::udma_spim_2::REG_CMD_SIZE_R_CMD_SIZE, bar); + let mut baz = udma_spim_2_csr.zf(utra::udma_spim_2::REG_CMD_SIZE_R_CMD_SIZE, bar); + baz |= udma_spim_2_csr.ms(utra::udma_spim_2::REG_CMD_SIZE_R_CMD_SIZE, 1); + udma_spim_2_csr.wfo(utra::udma_spim_2::REG_CMD_SIZE_R_CMD_SIZE, baz); + + let foo = udma_spim_2_csr.r(utra::udma_spim_2::REG_CMD_CFG); + udma_spim_2_csr.wo(utra::udma_spim_2::REG_CMD_CFG, foo); + let bar = udma_spim_2_csr.rf(utra::udma_spim_2::REG_CMD_CFG_R_CMD_CONTINUOUS); + udma_spim_2_csr.rmwf(utra::udma_spim_2::REG_CMD_CFG_R_CMD_CONTINUOUS, bar); + let mut baz = udma_spim_2_csr.zf(utra::udma_spim_2::REG_CMD_CFG_R_CMD_CONTINUOUS, bar); + baz |= udma_spim_2_csr.ms(utra::udma_spim_2::REG_CMD_CFG_R_CMD_CONTINUOUS, 1); + udma_spim_2_csr.wfo(utra::udma_spim_2::REG_CMD_CFG_R_CMD_CONTINUOUS, baz); + let bar = udma_spim_2_csr.rf(utra::udma_spim_2::REG_CMD_CFG_R_CMD_EN); + udma_spim_2_csr.rmwf(utra::udma_spim_2::REG_CMD_CFG_R_CMD_EN, bar); + let mut baz = udma_spim_2_csr.zf(utra::udma_spim_2::REG_CMD_CFG_R_CMD_EN, bar); + baz |= udma_spim_2_csr.ms(utra::udma_spim_2::REG_CMD_CFG_R_CMD_EN, 1); + udma_spim_2_csr.wfo(utra::udma_spim_2::REG_CMD_CFG_R_CMD_EN, baz); + let bar = udma_spim_2_csr.rf(utra::udma_spim_2::REG_CMD_CFG_R_CMD_CLR); + udma_spim_2_csr.rmwf(utra::udma_spim_2::REG_CMD_CFG_R_CMD_CLR, bar); + let mut baz = udma_spim_2_csr.zf(utra::udma_spim_2::REG_CMD_CFG_R_CMD_CLR, bar); + baz |= udma_spim_2_csr.ms(utra::udma_spim_2::REG_CMD_CFG_R_CMD_CLR, 1); + udma_spim_2_csr.wfo(utra::udma_spim_2::REG_CMD_CFG_R_CMD_CLR, baz); + + let foo = udma_spim_2_csr.r(utra::udma_spim_2::REG_STATUS); + udma_spim_2_csr.wo(utra::udma_spim_2::REG_STATUS, foo); + let bar = udma_spim_2_csr.rf(utra::udma_spim_2::REG_STATUS_STATUS_I); + udma_spim_2_csr.rmwf(utra::udma_spim_2::REG_STATUS_STATUS_I, bar); + let mut baz = udma_spim_2_csr.zf(utra::udma_spim_2::REG_STATUS_STATUS_I, bar); + baz |= udma_spim_2_csr.ms(utra::udma_spim_2::REG_STATUS_STATUS_I, 1); + udma_spim_2_csr.wfo(utra::udma_spim_2::REG_STATUS_STATUS_I, baz); + } + + #[test] + #[ignore] + fn compile_check_udma_spim_3_csr() { + use super::*; + let mut udma_spim_3_csr = CSR::new(HW_UDMA_SPIM_3_BASE as *mut u32); + + let foo = udma_spim_3_csr.r(utra::udma_spim_3::REG_RX_SADDR); + udma_spim_3_csr.wo(utra::udma_spim_3::REG_RX_SADDR, foo); + let bar = udma_spim_3_csr.rf(utra::udma_spim_3::REG_RX_SADDR_R_RX_STARTADDR); + udma_spim_3_csr.rmwf(utra::udma_spim_3::REG_RX_SADDR_R_RX_STARTADDR, bar); + let mut baz = udma_spim_3_csr.zf(utra::udma_spim_3::REG_RX_SADDR_R_RX_STARTADDR, bar); + baz |= udma_spim_3_csr.ms(utra::udma_spim_3::REG_RX_SADDR_R_RX_STARTADDR, 1); + udma_spim_3_csr.wfo(utra::udma_spim_3::REG_RX_SADDR_R_RX_STARTADDR, baz); + + let foo = udma_spim_3_csr.r(utra::udma_spim_3::REG_RX_SIZE); + udma_spim_3_csr.wo(utra::udma_spim_3::REG_RX_SIZE, foo); + let bar = udma_spim_3_csr.rf(utra::udma_spim_3::REG_RX_SIZE_R_RX_SIZE); + udma_spim_3_csr.rmwf(utra::udma_spim_3::REG_RX_SIZE_R_RX_SIZE, bar); + let mut baz = udma_spim_3_csr.zf(utra::udma_spim_3::REG_RX_SIZE_R_RX_SIZE, bar); + baz |= udma_spim_3_csr.ms(utra::udma_spim_3::REG_RX_SIZE_R_RX_SIZE, 1); + udma_spim_3_csr.wfo(utra::udma_spim_3::REG_RX_SIZE_R_RX_SIZE, baz); + + let foo = udma_spim_3_csr.r(utra::udma_spim_3::REG_RX_CFG); + udma_spim_3_csr.wo(utra::udma_spim_3::REG_RX_CFG, foo); + let bar = udma_spim_3_csr.rf(utra::udma_spim_3::REG_RX_CFG_R_RX_CONTINUOUS); + udma_spim_3_csr.rmwf(utra::udma_spim_3::REG_RX_CFG_R_RX_CONTINUOUS, bar); + let mut baz = udma_spim_3_csr.zf(utra::udma_spim_3::REG_RX_CFG_R_RX_CONTINUOUS, bar); + baz |= udma_spim_3_csr.ms(utra::udma_spim_3::REG_RX_CFG_R_RX_CONTINUOUS, 1); + udma_spim_3_csr.wfo(utra::udma_spim_3::REG_RX_CFG_R_RX_CONTINUOUS, baz); + let bar = udma_spim_3_csr.rf(utra::udma_spim_3::REG_RX_CFG_R_RX_DATASIZE); + udma_spim_3_csr.rmwf(utra::udma_spim_3::REG_RX_CFG_R_RX_DATASIZE, bar); + let mut baz = udma_spim_3_csr.zf(utra::udma_spim_3::REG_RX_CFG_R_RX_DATASIZE, bar); + baz |= udma_spim_3_csr.ms(utra::udma_spim_3::REG_RX_CFG_R_RX_DATASIZE, 1); + udma_spim_3_csr.wfo(utra::udma_spim_3::REG_RX_CFG_R_RX_DATASIZE, baz); + let bar = udma_spim_3_csr.rf(utra::udma_spim_3::REG_RX_CFG_R_RX_EN); + udma_spim_3_csr.rmwf(utra::udma_spim_3::REG_RX_CFG_R_RX_EN, bar); + let mut baz = udma_spim_3_csr.zf(utra::udma_spim_3::REG_RX_CFG_R_RX_EN, bar); + baz |= udma_spim_3_csr.ms(utra::udma_spim_3::REG_RX_CFG_R_RX_EN, 1); + udma_spim_3_csr.wfo(utra::udma_spim_3::REG_RX_CFG_R_RX_EN, baz); + let bar = udma_spim_3_csr.rf(utra::udma_spim_3::REG_RX_CFG_R_RX_CLR); + udma_spim_3_csr.rmwf(utra::udma_spim_3::REG_RX_CFG_R_RX_CLR, bar); + 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 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); + let bar = udma_spim_3_csr.rf(utra::udma_spim_3::REG_TX_SADDR_R_TX_STARTADDR); + udma_spim_3_csr.rmwf(utra::udma_spim_3::REG_TX_SADDR_R_TX_STARTADDR, bar); + let mut baz = udma_spim_3_csr.zf(utra::udma_spim_3::REG_TX_SADDR_R_TX_STARTADDR, bar); + baz |= udma_spim_3_csr.ms(utra::udma_spim_3::REG_TX_SADDR_R_TX_STARTADDR, 1); + udma_spim_3_csr.wfo(utra::udma_spim_3::REG_TX_SADDR_R_TX_STARTADDR, baz); + + let foo = udma_spim_3_csr.r(utra::udma_spim_3::REG_TX_SIZE); + udma_spim_3_csr.wo(utra::udma_spim_3::REG_TX_SIZE, foo); + let bar = udma_spim_3_csr.rf(utra::udma_spim_3::REG_TX_SIZE_R_TX_SIZE); + udma_spim_3_csr.rmwf(utra::udma_spim_3::REG_TX_SIZE_R_TX_SIZE, bar); + let mut baz = udma_spim_3_csr.zf(utra::udma_spim_3::REG_TX_SIZE_R_TX_SIZE, bar); + baz |= udma_spim_3_csr.ms(utra::udma_spim_3::REG_TX_SIZE_R_TX_SIZE, 1); + udma_spim_3_csr.wfo(utra::udma_spim_3::REG_TX_SIZE_R_TX_SIZE, baz); + + let foo = udma_spim_3_csr.r(utra::udma_spim_3::REG_TX_CFG); + udma_spim_3_csr.wo(utra::udma_spim_3::REG_TX_CFG, foo); + let bar = udma_spim_3_csr.rf(utra::udma_spim_3::REG_TX_CFG_R_TX_CONTINUOUS); + udma_spim_3_csr.rmwf(utra::udma_spim_3::REG_TX_CFG_R_TX_CONTINUOUS, bar); + let mut baz = udma_spim_3_csr.zf(utra::udma_spim_3::REG_TX_CFG_R_TX_CONTINUOUS, bar); + baz |= udma_spim_3_csr.ms(utra::udma_spim_3::REG_TX_CFG_R_TX_CONTINUOUS, 1); + udma_spim_3_csr.wfo(utra::udma_spim_3::REG_TX_CFG_R_TX_CONTINUOUS, baz); + let bar = udma_spim_3_csr.rf(utra::udma_spim_3::REG_TX_CFG_R_TX_DATASIZE); + udma_spim_3_csr.rmwf(utra::udma_spim_3::REG_TX_CFG_R_TX_DATASIZE, bar); + let mut baz = udma_spim_3_csr.zf(utra::udma_spim_3::REG_TX_CFG_R_TX_DATASIZE, bar); + baz |= udma_spim_3_csr.ms(utra::udma_spim_3::REG_TX_CFG_R_TX_DATASIZE, 1); + udma_spim_3_csr.wfo(utra::udma_spim_3::REG_TX_CFG_R_TX_DATASIZE, baz); + let bar = udma_spim_3_csr.rf(utra::udma_spim_3::REG_TX_CFG_R_TX_EN); + udma_spim_3_csr.rmwf(utra::udma_spim_3::REG_TX_CFG_R_TX_EN, bar); + let mut baz = udma_spim_3_csr.zf(utra::udma_spim_3::REG_TX_CFG_R_TX_EN, bar); + baz |= udma_spim_3_csr.ms(utra::udma_spim_3::REG_TX_CFG_R_TX_EN, 1); + udma_spim_3_csr.wfo(utra::udma_spim_3::REG_TX_CFG_R_TX_EN, baz); + let bar = udma_spim_3_csr.rf(utra::udma_spim_3::REG_TX_CFG_R_TX_CLR); + udma_spim_3_csr.rmwf(utra::udma_spim_3::REG_TX_CFG_R_TX_CLR, bar); + let mut baz = udma_spim_3_csr.zf(utra::udma_spim_3::REG_TX_CFG_R_TX_CLR, bar); + baz |= udma_spim_3_csr.ms(utra::udma_spim_3::REG_TX_CFG_R_TX_CLR, 1); + udma_spim_3_csr.wfo(utra::udma_spim_3::REG_TX_CFG_R_TX_CLR, baz); + + let foo = udma_spim_3_csr.r(utra::udma_spim_3::REG_CMD_SADDR); + udma_spim_3_csr.wo(utra::udma_spim_3::REG_CMD_SADDR, foo); + let bar = udma_spim_3_csr.rf(utra::udma_spim_3::REG_CMD_SADDR_R_CMD_STARTADDR); + udma_spim_3_csr.rmwf(utra::udma_spim_3::REG_CMD_SADDR_R_CMD_STARTADDR, bar); + let mut baz = udma_spim_3_csr.zf(utra::udma_spim_3::REG_CMD_SADDR_R_CMD_STARTADDR, bar); + baz |= udma_spim_3_csr.ms(utra::udma_spim_3::REG_CMD_SADDR_R_CMD_STARTADDR, 1); + udma_spim_3_csr.wfo(utra::udma_spim_3::REG_CMD_SADDR_R_CMD_STARTADDR, baz); + + let foo = udma_spim_3_csr.r(utra::udma_spim_3::REG_CMD_SIZE); + udma_spim_3_csr.wo(utra::udma_spim_3::REG_CMD_SIZE, foo); + let bar = udma_spim_3_csr.rf(utra::udma_spim_3::REG_CMD_SIZE_R_CMD_SIZE); + udma_spim_3_csr.rmwf(utra::udma_spim_3::REG_CMD_SIZE_R_CMD_SIZE, bar); + let mut baz = udma_spim_3_csr.zf(utra::udma_spim_3::REG_CMD_SIZE_R_CMD_SIZE, bar); + baz |= udma_spim_3_csr.ms(utra::udma_spim_3::REG_CMD_SIZE_R_CMD_SIZE, 1); + udma_spim_3_csr.wfo(utra::udma_spim_3::REG_CMD_SIZE_R_CMD_SIZE, baz); + + let foo = udma_spim_3_csr.r(utra::udma_spim_3::REG_CMD_CFG); + udma_spim_3_csr.wo(utra::udma_spim_3::REG_CMD_CFG, foo); + let bar = udma_spim_3_csr.rf(utra::udma_spim_3::REG_CMD_CFG_R_CMD_CONTINUOUS); + udma_spim_3_csr.rmwf(utra::udma_spim_3::REG_CMD_CFG_R_CMD_CONTINUOUS, bar); + let mut baz = udma_spim_3_csr.zf(utra::udma_spim_3::REG_CMD_CFG_R_CMD_CONTINUOUS, bar); + baz |= udma_spim_3_csr.ms(utra::udma_spim_3::REG_CMD_CFG_R_CMD_CONTINUOUS, 1); + udma_spim_3_csr.wfo(utra::udma_spim_3::REG_CMD_CFG_R_CMD_CONTINUOUS, baz); + let bar = udma_spim_3_csr.rf(utra::udma_spim_3::REG_CMD_CFG_R_CMD_EN); + udma_spim_3_csr.rmwf(utra::udma_spim_3::REG_CMD_CFG_R_CMD_EN, bar); + let mut baz = udma_spim_3_csr.zf(utra::udma_spim_3::REG_CMD_CFG_R_CMD_EN, bar); + baz |= udma_spim_3_csr.ms(utra::udma_spim_3::REG_CMD_CFG_R_CMD_EN, 1); + udma_spim_3_csr.wfo(utra::udma_spim_3::REG_CMD_CFG_R_CMD_EN, baz); + let bar = udma_spim_3_csr.rf(utra::udma_spim_3::REG_CMD_CFG_R_CMD_CLR); + udma_spim_3_csr.rmwf(utra::udma_spim_3::REG_CMD_CFG_R_CMD_CLR, bar); + let mut baz = udma_spim_3_csr.zf(utra::udma_spim_3::REG_CMD_CFG_R_CMD_CLR, bar); + baz |= udma_spim_3_csr.ms(utra::udma_spim_3::REG_CMD_CFG_R_CMD_CLR, 1); + udma_spim_3_csr.wfo(utra::udma_spim_3::REG_CMD_CFG_R_CMD_CLR, baz); + + let foo = udma_spim_3_csr.r(utra::udma_spim_3::REG_STATUS); + udma_spim_3_csr.wo(utra::udma_spim_3::REG_STATUS, foo); + let bar = udma_spim_3_csr.rf(utra::udma_spim_3::REG_STATUS_STATUS_I); + udma_spim_3_csr.rmwf(utra::udma_spim_3::REG_STATUS_STATUS_I, bar); + let mut baz = udma_spim_3_csr.zf(utra::udma_spim_3::REG_STATUS_STATUS_I, bar); + baz |= udma_spim_3_csr.ms(utra::udma_spim_3::REG_STATUS_STATUS_I, 1); + udma_spim_3_csr.wfo(utra::udma_spim_3::REG_STATUS_STATUS_I, baz); + } + + #[test] + #[ignore] + fn compile_check_udma_i2c_0_csr() { + use super::*; + let mut udma_i2c_0_csr = CSR::new(HW_UDMA_I2C_0_BASE as *mut u32); + + let foo = udma_i2c_0_csr.r(utra::udma_i2c_0::REG_RX_SADDR); + udma_i2c_0_csr.wo(utra::udma_i2c_0::REG_RX_SADDR, foo); + let bar = udma_i2c_0_csr.rf(utra::udma_i2c_0::REG_RX_SADDR_R_RX_STARTADDR); + udma_i2c_0_csr.rmwf(utra::udma_i2c_0::REG_RX_SADDR_R_RX_STARTADDR, bar); + let mut baz = udma_i2c_0_csr.zf(utra::udma_i2c_0::REG_RX_SADDR_R_RX_STARTADDR, bar); + baz |= udma_i2c_0_csr.ms(utra::udma_i2c_0::REG_RX_SADDR_R_RX_STARTADDR, 1); + udma_i2c_0_csr.wfo(utra::udma_i2c_0::REG_RX_SADDR_R_RX_STARTADDR, baz); + + let foo = udma_i2c_0_csr.r(utra::udma_i2c_0::REG_RX_SIZE); + udma_i2c_0_csr.wo(utra::udma_i2c_0::REG_RX_SIZE, foo); + let bar = udma_i2c_0_csr.rf(utra::udma_i2c_0::REG_RX_SIZE_R_RX_SIZE); + udma_i2c_0_csr.rmwf(utra::udma_i2c_0::REG_RX_SIZE_R_RX_SIZE, bar); + let mut baz = udma_i2c_0_csr.zf(utra::udma_i2c_0::REG_RX_SIZE_R_RX_SIZE, bar); + baz |= udma_i2c_0_csr.ms(utra::udma_i2c_0::REG_RX_SIZE_R_RX_SIZE, 1); + udma_i2c_0_csr.wfo(utra::udma_i2c_0::REG_RX_SIZE_R_RX_SIZE, baz); + + let foo = udma_i2c_0_csr.r(utra::udma_i2c_0::REG_RX_CFG); + udma_i2c_0_csr.wo(utra::udma_i2c_0::REG_RX_CFG, foo); + let bar = udma_i2c_0_csr.rf(utra::udma_i2c_0::REG_RX_CFG_R_RX_CONTINUOUS); + udma_i2c_0_csr.rmwf(utra::udma_i2c_0::REG_RX_CFG_R_RX_CONTINUOUS, bar); + let mut baz = udma_i2c_0_csr.zf(utra::udma_i2c_0::REG_RX_CFG_R_RX_CONTINUOUS, bar); + baz |= udma_i2c_0_csr.ms(utra::udma_i2c_0::REG_RX_CFG_R_RX_CONTINUOUS, 1); + udma_i2c_0_csr.wfo(utra::udma_i2c_0::REG_RX_CFG_R_RX_CONTINUOUS, baz); + let bar = udma_i2c_0_csr.rf(utra::udma_i2c_0::REG_RX_CFG_R_RX_EN); + udma_i2c_0_csr.rmwf(utra::udma_i2c_0::REG_RX_CFG_R_RX_EN, bar); + let mut baz = udma_i2c_0_csr.zf(utra::udma_i2c_0::REG_RX_CFG_R_RX_EN, bar); + baz |= udma_i2c_0_csr.ms(utra::udma_i2c_0::REG_RX_CFG_R_RX_EN, 1); + udma_i2c_0_csr.wfo(utra::udma_i2c_0::REG_RX_CFG_R_RX_EN, baz); + let bar = udma_i2c_0_csr.rf(utra::udma_i2c_0::REG_RX_CFG_R_RX_CLR); + udma_i2c_0_csr.rmwf(utra::udma_i2c_0::REG_RX_CFG_R_RX_CLR, bar); + let mut baz = udma_i2c_0_csr.zf(utra::udma_i2c_0::REG_RX_CFG_R_RX_CLR, bar); + baz |= udma_i2c_0_csr.ms(utra::udma_i2c_0::REG_RX_CFG_R_RX_CLR, 1); + udma_i2c_0_csr.wfo(utra::udma_i2c_0::REG_RX_CFG_R_RX_CLR, baz); + + let foo = udma_i2c_0_csr.r(utra::udma_i2c_0::REG_TX_SADDR); + udma_i2c_0_csr.wo(utra::udma_i2c_0::REG_TX_SADDR, foo); + let bar = udma_i2c_0_csr.rf(utra::udma_i2c_0::REG_TX_SADDR_R_TX_STARTADDR); + udma_i2c_0_csr.rmwf(utra::udma_i2c_0::REG_TX_SADDR_R_TX_STARTADDR, bar); + let mut baz = udma_i2c_0_csr.zf(utra::udma_i2c_0::REG_TX_SADDR_R_TX_STARTADDR, bar); + baz |= udma_i2c_0_csr.ms(utra::udma_i2c_0::REG_TX_SADDR_R_TX_STARTADDR, 1); + udma_i2c_0_csr.wfo(utra::udma_i2c_0::REG_TX_SADDR_R_TX_STARTADDR, baz); + + let foo = udma_i2c_0_csr.r(utra::udma_i2c_0::REG_TX_SIZE); + udma_i2c_0_csr.wo(utra::udma_i2c_0::REG_TX_SIZE, foo); + let bar = udma_i2c_0_csr.rf(utra::udma_i2c_0::REG_TX_SIZE_R_TX_SIZE); + udma_i2c_0_csr.rmwf(utra::udma_i2c_0::REG_TX_SIZE_R_TX_SIZE, bar); + let mut baz = udma_i2c_0_csr.zf(utra::udma_i2c_0::REG_TX_SIZE_R_TX_SIZE, bar); + baz |= udma_i2c_0_csr.ms(utra::udma_i2c_0::REG_TX_SIZE_R_TX_SIZE, 1); + udma_i2c_0_csr.wfo(utra::udma_i2c_0::REG_TX_SIZE_R_TX_SIZE, baz); + + let foo = udma_i2c_0_csr.r(utra::udma_i2c_0::REG_TX_CFG); + udma_i2c_0_csr.wo(utra::udma_i2c_0::REG_TX_CFG, foo); + let bar = udma_i2c_0_csr.rf(utra::udma_i2c_0::REG_TX_CFG_R_TX_CONTINUOUS); + udma_i2c_0_csr.rmwf(utra::udma_i2c_0::REG_TX_CFG_R_TX_CONTINUOUS, bar); + let mut baz = udma_i2c_0_csr.zf(utra::udma_i2c_0::REG_TX_CFG_R_TX_CONTINUOUS, bar); + baz |= udma_i2c_0_csr.ms(utra::udma_i2c_0::REG_TX_CFG_R_TX_CONTINUOUS, 1); + udma_i2c_0_csr.wfo(utra::udma_i2c_0::REG_TX_CFG_R_TX_CONTINUOUS, baz); + let bar = udma_i2c_0_csr.rf(utra::udma_i2c_0::REG_TX_CFG_R_TX_EN); + udma_i2c_0_csr.rmwf(utra::udma_i2c_0::REG_TX_CFG_R_TX_EN, bar); + let mut baz = udma_i2c_0_csr.zf(utra::udma_i2c_0::REG_TX_CFG_R_TX_EN, bar); + baz |= udma_i2c_0_csr.ms(utra::udma_i2c_0::REG_TX_CFG_R_TX_EN, 1); + udma_i2c_0_csr.wfo(utra::udma_i2c_0::REG_TX_CFG_R_TX_EN, baz); + let bar = udma_i2c_0_csr.rf(utra::udma_i2c_0::REG_TX_CFG_R_TX_CLR); + udma_i2c_0_csr.rmwf(utra::udma_i2c_0::REG_TX_CFG_R_TX_CLR, bar); + let mut baz = udma_i2c_0_csr.zf(utra::udma_i2c_0::REG_TX_CFG_R_TX_CLR, bar); + baz |= udma_i2c_0_csr.ms(utra::udma_i2c_0::REG_TX_CFG_R_TX_CLR, 1); + udma_i2c_0_csr.wfo(utra::udma_i2c_0::REG_TX_CFG_R_TX_CLR, baz); + + let foo = udma_i2c_0_csr.r(utra::udma_i2c_0::REG_CMD_SADDR); + udma_i2c_0_csr.wo(utra::udma_i2c_0::REG_CMD_SADDR, foo); + let bar = udma_i2c_0_csr.rf(utra::udma_i2c_0::REG_CMD_SADDR_R_CMD_STARTADDR); + udma_i2c_0_csr.rmwf(utra::udma_i2c_0::REG_CMD_SADDR_R_CMD_STARTADDR, bar); + let mut baz = udma_i2c_0_csr.zf(utra::udma_i2c_0::REG_CMD_SADDR_R_CMD_STARTADDR, bar); + baz |= udma_i2c_0_csr.ms(utra::udma_i2c_0::REG_CMD_SADDR_R_CMD_STARTADDR, 1); + udma_i2c_0_csr.wfo(utra::udma_i2c_0::REG_CMD_SADDR_R_CMD_STARTADDR, baz); + + let foo = udma_i2c_0_csr.r(utra::udma_i2c_0::REG_CMD_SIZE); + udma_i2c_0_csr.wo(utra::udma_i2c_0::REG_CMD_SIZE, foo); + let bar = udma_i2c_0_csr.rf(utra::udma_i2c_0::REG_CMD_SIZE_R_CMD_SIZE); + udma_i2c_0_csr.rmwf(utra::udma_i2c_0::REG_CMD_SIZE_R_CMD_SIZE, bar); + let mut baz = udma_i2c_0_csr.zf(utra::udma_i2c_0::REG_CMD_SIZE_R_CMD_SIZE, bar); + baz |= udma_i2c_0_csr.ms(utra::udma_i2c_0::REG_CMD_SIZE_R_CMD_SIZE, 1); + udma_i2c_0_csr.wfo(utra::udma_i2c_0::REG_CMD_SIZE_R_CMD_SIZE, baz); + + let foo = udma_i2c_0_csr.r(utra::udma_i2c_0::REG_CMD_CFG); + udma_i2c_0_csr.wo(utra::udma_i2c_0::REG_CMD_CFG, foo); + let bar = udma_i2c_0_csr.rf(utra::udma_i2c_0::REG_CMD_CFG_R_CMD_CONTINUOUS); + udma_i2c_0_csr.rmwf(utra::udma_i2c_0::REG_CMD_CFG_R_CMD_CONTINUOUS, bar); + let mut baz = udma_i2c_0_csr.zf(utra::udma_i2c_0::REG_CMD_CFG_R_CMD_CONTINUOUS, bar); + baz |= udma_i2c_0_csr.ms(utra::udma_i2c_0::REG_CMD_CFG_R_CMD_CONTINUOUS, 1); + udma_i2c_0_csr.wfo(utra::udma_i2c_0::REG_CMD_CFG_R_CMD_CONTINUOUS, baz); + let bar = udma_i2c_0_csr.rf(utra::udma_i2c_0::REG_CMD_CFG_R_CMD_EN); + udma_i2c_0_csr.rmwf(utra::udma_i2c_0::REG_CMD_CFG_R_CMD_EN, bar); + let mut baz = udma_i2c_0_csr.zf(utra::udma_i2c_0::REG_CMD_CFG_R_CMD_EN, bar); + baz |= udma_i2c_0_csr.ms(utra::udma_i2c_0::REG_CMD_CFG_R_CMD_EN, 1); + udma_i2c_0_csr.wfo(utra::udma_i2c_0::REG_CMD_CFG_R_CMD_EN, baz); + let bar = udma_i2c_0_csr.rf(utra::udma_i2c_0::REG_CMD_CFG_R_CMD_CLR); + udma_i2c_0_csr.rmwf(utra::udma_i2c_0::REG_CMD_CFG_R_CMD_CLR, bar); + let mut baz = udma_i2c_0_csr.zf(utra::udma_i2c_0::REG_CMD_CFG_R_CMD_CLR, bar); + baz |= udma_i2c_0_csr.ms(utra::udma_i2c_0::REG_CMD_CFG_R_CMD_CLR, 1); + udma_i2c_0_csr.wfo(utra::udma_i2c_0::REG_CMD_CFG_R_CMD_CLR, baz); + + let foo = udma_i2c_0_csr.r(utra::udma_i2c_0::REG_STATUS); + udma_i2c_0_csr.wo(utra::udma_i2c_0::REG_STATUS, foo); + let bar = udma_i2c_0_csr.rf(utra::udma_i2c_0::REG_STATUS_R_BUSY); + udma_i2c_0_csr.rmwf(utra::udma_i2c_0::REG_STATUS_R_BUSY, bar); + let mut baz = udma_i2c_0_csr.zf(utra::udma_i2c_0::REG_STATUS_R_BUSY, bar); + baz |= udma_i2c_0_csr.ms(utra::udma_i2c_0::REG_STATUS_R_BUSY, 1); + udma_i2c_0_csr.wfo(utra::udma_i2c_0::REG_STATUS_R_BUSY, baz); + let bar = udma_i2c_0_csr.rf(utra::udma_i2c_0::REG_STATUS_R_AL); + udma_i2c_0_csr.rmwf(utra::udma_i2c_0::REG_STATUS_R_AL, bar); + let mut baz = udma_i2c_0_csr.zf(utra::udma_i2c_0::REG_STATUS_R_AL, bar); + baz |= udma_i2c_0_csr.ms(utra::udma_i2c_0::REG_STATUS_R_AL, 1); + udma_i2c_0_csr.wfo(utra::udma_i2c_0::REG_STATUS_R_AL, baz); + + let foo = udma_i2c_0_csr.r(utra::udma_i2c_0::REG_SETUP); + udma_i2c_0_csr.wo(utra::udma_i2c_0::REG_SETUP, foo); + let bar = udma_i2c_0_csr.rf(utra::udma_i2c_0::REG_SETUP_R_DO_RST); + udma_i2c_0_csr.rmwf(utra::udma_i2c_0::REG_SETUP_R_DO_RST, bar); + let mut baz = udma_i2c_0_csr.zf(utra::udma_i2c_0::REG_SETUP_R_DO_RST, bar); + baz |= udma_i2c_0_csr.ms(utra::udma_i2c_0::REG_SETUP_R_DO_RST, 1); + udma_i2c_0_csr.wfo(utra::udma_i2c_0::REG_SETUP_R_DO_RST, baz); + + let foo = udma_i2c_0_csr.r(utra::udma_i2c_0::REG_ACK); + udma_i2c_0_csr.wo(utra::udma_i2c_0::REG_ACK, foo); + let bar = udma_i2c_0_csr.rf(utra::udma_i2c_0::REG_ACK_R_NACK); + udma_i2c_0_csr.rmwf(utra::udma_i2c_0::REG_ACK_R_NACK, bar); + let mut baz = udma_i2c_0_csr.zf(utra::udma_i2c_0::REG_ACK_R_NACK, bar); + baz |= udma_i2c_0_csr.ms(utra::udma_i2c_0::REG_ACK_R_NACK, 1); + udma_i2c_0_csr.wfo(utra::udma_i2c_0::REG_ACK_R_NACK, baz); + } + + #[test] + #[ignore] + fn compile_check_udma_i2c_1_csr() { + use super::*; + let mut udma_i2c_1_csr = CSR::new(HW_UDMA_I2C_1_BASE as *mut u32); + + let foo = udma_i2c_1_csr.r(utra::udma_i2c_1::REG_RX_SADDR); + udma_i2c_1_csr.wo(utra::udma_i2c_1::REG_RX_SADDR, foo); + let bar = udma_i2c_1_csr.rf(utra::udma_i2c_1::REG_RX_SADDR_R_RX_STARTADDR); + udma_i2c_1_csr.rmwf(utra::udma_i2c_1::REG_RX_SADDR_R_RX_STARTADDR, bar); + let mut baz = udma_i2c_1_csr.zf(utra::udma_i2c_1::REG_RX_SADDR_R_RX_STARTADDR, bar); + baz |= udma_i2c_1_csr.ms(utra::udma_i2c_1::REG_RX_SADDR_R_RX_STARTADDR, 1); + udma_i2c_1_csr.wfo(utra::udma_i2c_1::REG_RX_SADDR_R_RX_STARTADDR, baz); + + let foo = udma_i2c_1_csr.r(utra::udma_i2c_1::REG_RX_SIZE); + udma_i2c_1_csr.wo(utra::udma_i2c_1::REG_RX_SIZE, foo); + let bar = udma_i2c_1_csr.rf(utra::udma_i2c_1::REG_RX_SIZE_R_RX_SIZE); + udma_i2c_1_csr.rmwf(utra::udma_i2c_1::REG_RX_SIZE_R_RX_SIZE, bar); + let mut baz = udma_i2c_1_csr.zf(utra::udma_i2c_1::REG_RX_SIZE_R_RX_SIZE, bar); + baz |= udma_i2c_1_csr.ms(utra::udma_i2c_1::REG_RX_SIZE_R_RX_SIZE, 1); + udma_i2c_1_csr.wfo(utra::udma_i2c_1::REG_RX_SIZE_R_RX_SIZE, baz); + + let foo = udma_i2c_1_csr.r(utra::udma_i2c_1::REG_RX_CFG); + udma_i2c_1_csr.wo(utra::udma_i2c_1::REG_RX_CFG, foo); + let bar = udma_i2c_1_csr.rf(utra::udma_i2c_1::REG_RX_CFG_R_RX_CONTINUOUS); + udma_i2c_1_csr.rmwf(utra::udma_i2c_1::REG_RX_CFG_R_RX_CONTINUOUS, bar); + let mut baz = udma_i2c_1_csr.zf(utra::udma_i2c_1::REG_RX_CFG_R_RX_CONTINUOUS, bar); + baz |= udma_i2c_1_csr.ms(utra::udma_i2c_1::REG_RX_CFG_R_RX_CONTINUOUS, 1); + udma_i2c_1_csr.wfo(utra::udma_i2c_1::REG_RX_CFG_R_RX_CONTINUOUS, baz); + let bar = udma_i2c_1_csr.rf(utra::udma_i2c_1::REG_RX_CFG_R_RX_EN); + udma_i2c_1_csr.rmwf(utra::udma_i2c_1::REG_RX_CFG_R_RX_EN, bar); + let mut baz = udma_i2c_1_csr.zf(utra::udma_i2c_1::REG_RX_CFG_R_RX_EN, bar); + baz |= udma_i2c_1_csr.ms(utra::udma_i2c_1::REG_RX_CFG_R_RX_EN, 1); + udma_i2c_1_csr.wfo(utra::udma_i2c_1::REG_RX_CFG_R_RX_EN, baz); + let bar = udma_i2c_1_csr.rf(utra::udma_i2c_1::REG_RX_CFG_R_RX_CLR); + udma_i2c_1_csr.rmwf(utra::udma_i2c_1::REG_RX_CFG_R_RX_CLR, bar); + let mut baz = udma_i2c_1_csr.zf(utra::udma_i2c_1::REG_RX_CFG_R_RX_CLR, bar); + baz |= udma_i2c_1_csr.ms(utra::udma_i2c_1::REG_RX_CFG_R_RX_CLR, 1); + udma_i2c_1_csr.wfo(utra::udma_i2c_1::REG_RX_CFG_R_RX_CLR, baz); + + let foo = udma_i2c_1_csr.r(utra::udma_i2c_1::REG_TX_SADDR); + udma_i2c_1_csr.wo(utra::udma_i2c_1::REG_TX_SADDR, foo); + let bar = udma_i2c_1_csr.rf(utra::udma_i2c_1::REG_TX_SADDR_R_TX_STARTADDR); + udma_i2c_1_csr.rmwf(utra::udma_i2c_1::REG_TX_SADDR_R_TX_STARTADDR, bar); + let mut baz = udma_i2c_1_csr.zf(utra::udma_i2c_1::REG_TX_SADDR_R_TX_STARTADDR, bar); + baz |= udma_i2c_1_csr.ms(utra::udma_i2c_1::REG_TX_SADDR_R_TX_STARTADDR, 1); + udma_i2c_1_csr.wfo(utra::udma_i2c_1::REG_TX_SADDR_R_TX_STARTADDR, baz); + + let foo = udma_i2c_1_csr.r(utra::udma_i2c_1::REG_TX_SIZE); + udma_i2c_1_csr.wo(utra::udma_i2c_1::REG_TX_SIZE, foo); + let bar = udma_i2c_1_csr.rf(utra::udma_i2c_1::REG_TX_SIZE_R_TX_SIZE); + udma_i2c_1_csr.rmwf(utra::udma_i2c_1::REG_TX_SIZE_R_TX_SIZE, bar); + let mut baz = udma_i2c_1_csr.zf(utra::udma_i2c_1::REG_TX_SIZE_R_TX_SIZE, bar); + baz |= udma_i2c_1_csr.ms(utra::udma_i2c_1::REG_TX_SIZE_R_TX_SIZE, 1); + udma_i2c_1_csr.wfo(utra::udma_i2c_1::REG_TX_SIZE_R_TX_SIZE, baz); + + let foo = udma_i2c_1_csr.r(utra::udma_i2c_1::REG_TX_CFG); + udma_i2c_1_csr.wo(utra::udma_i2c_1::REG_TX_CFG, foo); + let bar = udma_i2c_1_csr.rf(utra::udma_i2c_1::REG_TX_CFG_R_TX_CONTINUOUS); + udma_i2c_1_csr.rmwf(utra::udma_i2c_1::REG_TX_CFG_R_TX_CONTINUOUS, bar); + let mut baz = udma_i2c_1_csr.zf(utra::udma_i2c_1::REG_TX_CFG_R_TX_CONTINUOUS, bar); + baz |= udma_i2c_1_csr.ms(utra::udma_i2c_1::REG_TX_CFG_R_TX_CONTINUOUS, 1); + udma_i2c_1_csr.wfo(utra::udma_i2c_1::REG_TX_CFG_R_TX_CONTINUOUS, baz); + let bar = udma_i2c_1_csr.rf(utra::udma_i2c_1::REG_TX_CFG_R_TX_EN); + udma_i2c_1_csr.rmwf(utra::udma_i2c_1::REG_TX_CFG_R_TX_EN, bar); + let mut baz = udma_i2c_1_csr.zf(utra::udma_i2c_1::REG_TX_CFG_R_TX_EN, bar); + baz |= udma_i2c_1_csr.ms(utra::udma_i2c_1::REG_TX_CFG_R_TX_EN, 1); + udma_i2c_1_csr.wfo(utra::udma_i2c_1::REG_TX_CFG_R_TX_EN, baz); + let bar = udma_i2c_1_csr.rf(utra::udma_i2c_1::REG_TX_CFG_R_TX_CLR); + udma_i2c_1_csr.rmwf(utra::udma_i2c_1::REG_TX_CFG_R_TX_CLR, bar); + let mut baz = udma_i2c_1_csr.zf(utra::udma_i2c_1::REG_TX_CFG_R_TX_CLR, bar); + baz |= udma_i2c_1_csr.ms(utra::udma_i2c_1::REG_TX_CFG_R_TX_CLR, 1); + udma_i2c_1_csr.wfo(utra::udma_i2c_1::REG_TX_CFG_R_TX_CLR, baz); + + let foo = udma_i2c_1_csr.r(utra::udma_i2c_1::REG_CMD_SADDR); + udma_i2c_1_csr.wo(utra::udma_i2c_1::REG_CMD_SADDR, foo); + let bar = udma_i2c_1_csr.rf(utra::udma_i2c_1::REG_CMD_SADDR_R_CMD_STARTADDR); + udma_i2c_1_csr.rmwf(utra::udma_i2c_1::REG_CMD_SADDR_R_CMD_STARTADDR, bar); + let mut baz = udma_i2c_1_csr.zf(utra::udma_i2c_1::REG_CMD_SADDR_R_CMD_STARTADDR, bar); + baz |= udma_i2c_1_csr.ms(utra::udma_i2c_1::REG_CMD_SADDR_R_CMD_STARTADDR, 1); + udma_i2c_1_csr.wfo(utra::udma_i2c_1::REG_CMD_SADDR_R_CMD_STARTADDR, baz); + + let foo = udma_i2c_1_csr.r(utra::udma_i2c_1::REG_CMD_SIZE); + udma_i2c_1_csr.wo(utra::udma_i2c_1::REG_CMD_SIZE, foo); + let bar = udma_i2c_1_csr.rf(utra::udma_i2c_1::REG_CMD_SIZE_R_CMD_SIZE); + udma_i2c_1_csr.rmwf(utra::udma_i2c_1::REG_CMD_SIZE_R_CMD_SIZE, bar); + let mut baz = udma_i2c_1_csr.zf(utra::udma_i2c_1::REG_CMD_SIZE_R_CMD_SIZE, bar); + baz |= udma_i2c_1_csr.ms(utra::udma_i2c_1::REG_CMD_SIZE_R_CMD_SIZE, 1); + udma_i2c_1_csr.wfo(utra::udma_i2c_1::REG_CMD_SIZE_R_CMD_SIZE, baz); + + let foo = udma_i2c_1_csr.r(utra::udma_i2c_1::REG_CMD_CFG); + udma_i2c_1_csr.wo(utra::udma_i2c_1::REG_CMD_CFG, foo); + let bar = udma_i2c_1_csr.rf(utra::udma_i2c_1::REG_CMD_CFG_R_CMD_CONTINUOUS); + udma_i2c_1_csr.rmwf(utra::udma_i2c_1::REG_CMD_CFG_R_CMD_CONTINUOUS, bar); + let mut baz = udma_i2c_1_csr.zf(utra::udma_i2c_1::REG_CMD_CFG_R_CMD_CONTINUOUS, bar); + baz |= udma_i2c_1_csr.ms(utra::udma_i2c_1::REG_CMD_CFG_R_CMD_CONTINUOUS, 1); + udma_i2c_1_csr.wfo(utra::udma_i2c_1::REG_CMD_CFG_R_CMD_CONTINUOUS, baz); + let bar = udma_i2c_1_csr.rf(utra::udma_i2c_1::REG_CMD_CFG_R_CMD_EN); + udma_i2c_1_csr.rmwf(utra::udma_i2c_1::REG_CMD_CFG_R_CMD_EN, bar); + let mut baz = udma_i2c_1_csr.zf(utra::udma_i2c_1::REG_CMD_CFG_R_CMD_EN, bar); + baz |= udma_i2c_1_csr.ms(utra::udma_i2c_1::REG_CMD_CFG_R_CMD_EN, 1); + udma_i2c_1_csr.wfo(utra::udma_i2c_1::REG_CMD_CFG_R_CMD_EN, baz); + let bar = udma_i2c_1_csr.rf(utra::udma_i2c_1::REG_CMD_CFG_R_CMD_CLR); + udma_i2c_1_csr.rmwf(utra::udma_i2c_1::REG_CMD_CFG_R_CMD_CLR, bar); + let mut baz = udma_i2c_1_csr.zf(utra::udma_i2c_1::REG_CMD_CFG_R_CMD_CLR, bar); + baz |= udma_i2c_1_csr.ms(utra::udma_i2c_1::REG_CMD_CFG_R_CMD_CLR, 1); + udma_i2c_1_csr.wfo(utra::udma_i2c_1::REG_CMD_CFG_R_CMD_CLR, baz); + + let foo = udma_i2c_1_csr.r(utra::udma_i2c_1::REG_STATUS); + udma_i2c_1_csr.wo(utra::udma_i2c_1::REG_STATUS, foo); + let bar = udma_i2c_1_csr.rf(utra::udma_i2c_1::REG_STATUS_R_BUSY); + udma_i2c_1_csr.rmwf(utra::udma_i2c_1::REG_STATUS_R_BUSY, bar); + let mut baz = udma_i2c_1_csr.zf(utra::udma_i2c_1::REG_STATUS_R_BUSY, bar); + baz |= udma_i2c_1_csr.ms(utra::udma_i2c_1::REG_STATUS_R_BUSY, 1); + udma_i2c_1_csr.wfo(utra::udma_i2c_1::REG_STATUS_R_BUSY, baz); + let bar = udma_i2c_1_csr.rf(utra::udma_i2c_1::REG_STATUS_R_AL); + udma_i2c_1_csr.rmwf(utra::udma_i2c_1::REG_STATUS_R_AL, bar); + let mut baz = udma_i2c_1_csr.zf(utra::udma_i2c_1::REG_STATUS_R_AL, bar); + baz |= udma_i2c_1_csr.ms(utra::udma_i2c_1::REG_STATUS_R_AL, 1); + udma_i2c_1_csr.wfo(utra::udma_i2c_1::REG_STATUS_R_AL, baz); + + let foo = udma_i2c_1_csr.r(utra::udma_i2c_1::REG_SETUP); + udma_i2c_1_csr.wo(utra::udma_i2c_1::REG_SETUP, foo); + let bar = udma_i2c_1_csr.rf(utra::udma_i2c_1::REG_SETUP_R_DO_RST); + udma_i2c_1_csr.rmwf(utra::udma_i2c_1::REG_SETUP_R_DO_RST, bar); + let mut baz = udma_i2c_1_csr.zf(utra::udma_i2c_1::REG_SETUP_R_DO_RST, bar); + baz |= udma_i2c_1_csr.ms(utra::udma_i2c_1::REG_SETUP_R_DO_RST, 1); + udma_i2c_1_csr.wfo(utra::udma_i2c_1::REG_SETUP_R_DO_RST, baz); + + let foo = udma_i2c_1_csr.r(utra::udma_i2c_1::REG_ACK); + udma_i2c_1_csr.wo(utra::udma_i2c_1::REG_ACK, foo); + let bar = udma_i2c_1_csr.rf(utra::udma_i2c_1::REG_ACK_R_NACK); + udma_i2c_1_csr.rmwf(utra::udma_i2c_1::REG_ACK_R_NACK, bar); + let mut baz = udma_i2c_1_csr.zf(utra::udma_i2c_1::REG_ACK_R_NACK, bar); + baz |= udma_i2c_1_csr.ms(utra::udma_i2c_1::REG_ACK_R_NACK, 1); + udma_i2c_1_csr.wfo(utra::udma_i2c_1::REG_ACK_R_NACK, baz); + } + + #[test] + #[ignore] + fn compile_check_udma_i2c_2_csr() { + use super::*; + let mut udma_i2c_2_csr = CSR::new(HW_UDMA_I2C_2_BASE as *mut u32); + + let foo = udma_i2c_2_csr.r(utra::udma_i2c_2::REG_RX_SADDR); + udma_i2c_2_csr.wo(utra::udma_i2c_2::REG_RX_SADDR, foo); + let bar = udma_i2c_2_csr.rf(utra::udma_i2c_2::REG_RX_SADDR_R_RX_STARTADDR); + udma_i2c_2_csr.rmwf(utra::udma_i2c_2::REG_RX_SADDR_R_RX_STARTADDR, bar); + let mut baz = udma_i2c_2_csr.zf(utra::udma_i2c_2::REG_RX_SADDR_R_RX_STARTADDR, bar); + baz |= udma_i2c_2_csr.ms(utra::udma_i2c_2::REG_RX_SADDR_R_RX_STARTADDR, 1); + udma_i2c_2_csr.wfo(utra::udma_i2c_2::REG_RX_SADDR_R_RX_STARTADDR, baz); + + let foo = udma_i2c_2_csr.r(utra::udma_i2c_2::REG_RX_SIZE); + udma_i2c_2_csr.wo(utra::udma_i2c_2::REG_RX_SIZE, foo); + let bar = udma_i2c_2_csr.rf(utra::udma_i2c_2::REG_RX_SIZE_R_RX_SIZE); + udma_i2c_2_csr.rmwf(utra::udma_i2c_2::REG_RX_SIZE_R_RX_SIZE, bar); + let mut baz = udma_i2c_2_csr.zf(utra::udma_i2c_2::REG_RX_SIZE_R_RX_SIZE, bar); + baz |= udma_i2c_2_csr.ms(utra::udma_i2c_2::REG_RX_SIZE_R_RX_SIZE, 1); + udma_i2c_2_csr.wfo(utra::udma_i2c_2::REG_RX_SIZE_R_RX_SIZE, baz); + + let foo = udma_i2c_2_csr.r(utra::udma_i2c_2::REG_RX_CFG); + udma_i2c_2_csr.wo(utra::udma_i2c_2::REG_RX_CFG, foo); + let bar = udma_i2c_2_csr.rf(utra::udma_i2c_2::REG_RX_CFG_R_RX_CONTINUOUS); + udma_i2c_2_csr.rmwf(utra::udma_i2c_2::REG_RX_CFG_R_RX_CONTINUOUS, bar); + let mut baz = udma_i2c_2_csr.zf(utra::udma_i2c_2::REG_RX_CFG_R_RX_CONTINUOUS, bar); + baz |= udma_i2c_2_csr.ms(utra::udma_i2c_2::REG_RX_CFG_R_RX_CONTINUOUS, 1); + udma_i2c_2_csr.wfo(utra::udma_i2c_2::REG_RX_CFG_R_RX_CONTINUOUS, baz); + let bar = udma_i2c_2_csr.rf(utra::udma_i2c_2::REG_RX_CFG_R_RX_EN); + udma_i2c_2_csr.rmwf(utra::udma_i2c_2::REG_RX_CFG_R_RX_EN, bar); + let mut baz = udma_i2c_2_csr.zf(utra::udma_i2c_2::REG_RX_CFG_R_RX_EN, bar); + baz |= udma_i2c_2_csr.ms(utra::udma_i2c_2::REG_RX_CFG_R_RX_EN, 1); + udma_i2c_2_csr.wfo(utra::udma_i2c_2::REG_RX_CFG_R_RX_EN, baz); + let bar = udma_i2c_2_csr.rf(utra::udma_i2c_2::REG_RX_CFG_R_RX_CLR); + udma_i2c_2_csr.rmwf(utra::udma_i2c_2::REG_RX_CFG_R_RX_CLR, bar); + let mut baz = udma_i2c_2_csr.zf(utra::udma_i2c_2::REG_RX_CFG_R_RX_CLR, bar); + baz |= udma_i2c_2_csr.ms(utra::udma_i2c_2::REG_RX_CFG_R_RX_CLR, 1); + udma_i2c_2_csr.wfo(utra::udma_i2c_2::REG_RX_CFG_R_RX_CLR, baz); + + let foo = udma_i2c_2_csr.r(utra::udma_i2c_2::REG_TX_SADDR); + udma_i2c_2_csr.wo(utra::udma_i2c_2::REG_TX_SADDR, foo); + let bar = udma_i2c_2_csr.rf(utra::udma_i2c_2::REG_TX_SADDR_R_TX_STARTADDR); + udma_i2c_2_csr.rmwf(utra::udma_i2c_2::REG_TX_SADDR_R_TX_STARTADDR, bar); + let mut baz = udma_i2c_2_csr.zf(utra::udma_i2c_2::REG_TX_SADDR_R_TX_STARTADDR, bar); + baz |= udma_i2c_2_csr.ms(utra::udma_i2c_2::REG_TX_SADDR_R_TX_STARTADDR, 1); + udma_i2c_2_csr.wfo(utra::udma_i2c_2::REG_TX_SADDR_R_TX_STARTADDR, baz); + + let foo = udma_i2c_2_csr.r(utra::udma_i2c_2::REG_TX_SIZE); + udma_i2c_2_csr.wo(utra::udma_i2c_2::REG_TX_SIZE, foo); + let bar = udma_i2c_2_csr.rf(utra::udma_i2c_2::REG_TX_SIZE_R_TX_SIZE); + udma_i2c_2_csr.rmwf(utra::udma_i2c_2::REG_TX_SIZE_R_TX_SIZE, bar); + let mut baz = udma_i2c_2_csr.zf(utra::udma_i2c_2::REG_TX_SIZE_R_TX_SIZE, bar); + baz |= udma_i2c_2_csr.ms(utra::udma_i2c_2::REG_TX_SIZE_R_TX_SIZE, 1); + udma_i2c_2_csr.wfo(utra::udma_i2c_2::REG_TX_SIZE_R_TX_SIZE, baz); + + let foo = udma_i2c_2_csr.r(utra::udma_i2c_2::REG_TX_CFG); + udma_i2c_2_csr.wo(utra::udma_i2c_2::REG_TX_CFG, foo); + let bar = udma_i2c_2_csr.rf(utra::udma_i2c_2::REG_TX_CFG_R_TX_CONTINUOUS); + udma_i2c_2_csr.rmwf(utra::udma_i2c_2::REG_TX_CFG_R_TX_CONTINUOUS, bar); + let mut baz = udma_i2c_2_csr.zf(utra::udma_i2c_2::REG_TX_CFG_R_TX_CONTINUOUS, bar); + baz |= udma_i2c_2_csr.ms(utra::udma_i2c_2::REG_TX_CFG_R_TX_CONTINUOUS, 1); + udma_i2c_2_csr.wfo(utra::udma_i2c_2::REG_TX_CFG_R_TX_CONTINUOUS, baz); + let bar = udma_i2c_2_csr.rf(utra::udma_i2c_2::REG_TX_CFG_R_TX_EN); + udma_i2c_2_csr.rmwf(utra::udma_i2c_2::REG_TX_CFG_R_TX_EN, bar); + let mut baz = udma_i2c_2_csr.zf(utra::udma_i2c_2::REG_TX_CFG_R_TX_EN, bar); + baz |= udma_i2c_2_csr.ms(utra::udma_i2c_2::REG_TX_CFG_R_TX_EN, 1); + udma_i2c_2_csr.wfo(utra::udma_i2c_2::REG_TX_CFG_R_TX_EN, baz); + let bar = udma_i2c_2_csr.rf(utra::udma_i2c_2::REG_TX_CFG_R_TX_CLR); + udma_i2c_2_csr.rmwf(utra::udma_i2c_2::REG_TX_CFG_R_TX_CLR, bar); + let mut baz = udma_i2c_2_csr.zf(utra::udma_i2c_2::REG_TX_CFG_R_TX_CLR, bar); + baz |= udma_i2c_2_csr.ms(utra::udma_i2c_2::REG_TX_CFG_R_TX_CLR, 1); + udma_i2c_2_csr.wfo(utra::udma_i2c_2::REG_TX_CFG_R_TX_CLR, baz); + + let foo = udma_i2c_2_csr.r(utra::udma_i2c_2::REG_CMD_SADDR); + udma_i2c_2_csr.wo(utra::udma_i2c_2::REG_CMD_SADDR, foo); + let bar = udma_i2c_2_csr.rf(utra::udma_i2c_2::REG_CMD_SADDR_R_CMD_STARTADDR); + udma_i2c_2_csr.rmwf(utra::udma_i2c_2::REG_CMD_SADDR_R_CMD_STARTADDR, bar); + let mut baz = udma_i2c_2_csr.zf(utra::udma_i2c_2::REG_CMD_SADDR_R_CMD_STARTADDR, bar); + baz |= udma_i2c_2_csr.ms(utra::udma_i2c_2::REG_CMD_SADDR_R_CMD_STARTADDR, 1); + udma_i2c_2_csr.wfo(utra::udma_i2c_2::REG_CMD_SADDR_R_CMD_STARTADDR, baz); + + let foo = udma_i2c_2_csr.r(utra::udma_i2c_2::REG_CMD_SIZE); + udma_i2c_2_csr.wo(utra::udma_i2c_2::REG_CMD_SIZE, foo); + let bar = udma_i2c_2_csr.rf(utra::udma_i2c_2::REG_CMD_SIZE_R_CMD_SIZE); + udma_i2c_2_csr.rmwf(utra::udma_i2c_2::REG_CMD_SIZE_R_CMD_SIZE, bar); + let mut baz = udma_i2c_2_csr.zf(utra::udma_i2c_2::REG_CMD_SIZE_R_CMD_SIZE, bar); + baz |= udma_i2c_2_csr.ms(utra::udma_i2c_2::REG_CMD_SIZE_R_CMD_SIZE, 1); + udma_i2c_2_csr.wfo(utra::udma_i2c_2::REG_CMD_SIZE_R_CMD_SIZE, baz); + + let foo = udma_i2c_2_csr.r(utra::udma_i2c_2::REG_CMD_CFG); + udma_i2c_2_csr.wo(utra::udma_i2c_2::REG_CMD_CFG, foo); + let bar = udma_i2c_2_csr.rf(utra::udma_i2c_2::REG_CMD_CFG_R_CMD_CONTINUOUS); + udma_i2c_2_csr.rmwf(utra::udma_i2c_2::REG_CMD_CFG_R_CMD_CONTINUOUS, bar); + let mut baz = udma_i2c_2_csr.zf(utra::udma_i2c_2::REG_CMD_CFG_R_CMD_CONTINUOUS, bar); + baz |= udma_i2c_2_csr.ms(utra::udma_i2c_2::REG_CMD_CFG_R_CMD_CONTINUOUS, 1); + udma_i2c_2_csr.wfo(utra::udma_i2c_2::REG_CMD_CFG_R_CMD_CONTINUOUS, baz); + let bar = udma_i2c_2_csr.rf(utra::udma_i2c_2::REG_CMD_CFG_R_CMD_EN); + udma_i2c_2_csr.rmwf(utra::udma_i2c_2::REG_CMD_CFG_R_CMD_EN, bar); + let mut baz = udma_i2c_2_csr.zf(utra::udma_i2c_2::REG_CMD_CFG_R_CMD_EN, bar); + baz |= udma_i2c_2_csr.ms(utra::udma_i2c_2::REG_CMD_CFG_R_CMD_EN, 1); + udma_i2c_2_csr.wfo(utra::udma_i2c_2::REG_CMD_CFG_R_CMD_EN, baz); + let bar = udma_i2c_2_csr.rf(utra::udma_i2c_2::REG_CMD_CFG_R_CMD_CLR); + udma_i2c_2_csr.rmwf(utra::udma_i2c_2::REG_CMD_CFG_R_CMD_CLR, bar); + let mut baz = udma_i2c_2_csr.zf(utra::udma_i2c_2::REG_CMD_CFG_R_CMD_CLR, bar); + baz |= udma_i2c_2_csr.ms(utra::udma_i2c_2::REG_CMD_CFG_R_CMD_CLR, 1); + udma_i2c_2_csr.wfo(utra::udma_i2c_2::REG_CMD_CFG_R_CMD_CLR, baz); + + let foo = udma_i2c_2_csr.r(utra::udma_i2c_2::REG_STATUS); + udma_i2c_2_csr.wo(utra::udma_i2c_2::REG_STATUS, foo); + let bar = udma_i2c_2_csr.rf(utra::udma_i2c_2::REG_STATUS_R_BUSY); + udma_i2c_2_csr.rmwf(utra::udma_i2c_2::REG_STATUS_R_BUSY, bar); + let mut baz = udma_i2c_2_csr.zf(utra::udma_i2c_2::REG_STATUS_R_BUSY, bar); + baz |= udma_i2c_2_csr.ms(utra::udma_i2c_2::REG_STATUS_R_BUSY, 1); + udma_i2c_2_csr.wfo(utra::udma_i2c_2::REG_STATUS_R_BUSY, baz); + let bar = udma_i2c_2_csr.rf(utra::udma_i2c_2::REG_STATUS_R_AL); + udma_i2c_2_csr.rmwf(utra::udma_i2c_2::REG_STATUS_R_AL, bar); + let mut baz = udma_i2c_2_csr.zf(utra::udma_i2c_2::REG_STATUS_R_AL, bar); + baz |= udma_i2c_2_csr.ms(utra::udma_i2c_2::REG_STATUS_R_AL, 1); + udma_i2c_2_csr.wfo(utra::udma_i2c_2::REG_STATUS_R_AL, baz); + + let foo = udma_i2c_2_csr.r(utra::udma_i2c_2::REG_SETUP); + udma_i2c_2_csr.wo(utra::udma_i2c_2::REG_SETUP, foo); + let bar = udma_i2c_2_csr.rf(utra::udma_i2c_2::REG_SETUP_R_DO_RST); + udma_i2c_2_csr.rmwf(utra::udma_i2c_2::REG_SETUP_R_DO_RST, bar); + let mut baz = udma_i2c_2_csr.zf(utra::udma_i2c_2::REG_SETUP_R_DO_RST, bar); + baz |= udma_i2c_2_csr.ms(utra::udma_i2c_2::REG_SETUP_R_DO_RST, 1); + udma_i2c_2_csr.wfo(utra::udma_i2c_2::REG_SETUP_R_DO_RST, baz); + + let foo = udma_i2c_2_csr.r(utra::udma_i2c_2::REG_ACK); + udma_i2c_2_csr.wo(utra::udma_i2c_2::REG_ACK, foo); + let bar = udma_i2c_2_csr.rf(utra::udma_i2c_2::REG_ACK_R_NACK); + udma_i2c_2_csr.rmwf(utra::udma_i2c_2::REG_ACK_R_NACK, bar); + let mut baz = udma_i2c_2_csr.zf(utra::udma_i2c_2::REG_ACK_R_NACK, bar); + baz |= udma_i2c_2_csr.ms(utra::udma_i2c_2::REG_ACK_R_NACK, 1); + udma_i2c_2_csr.wfo(utra::udma_i2c_2::REG_ACK_R_NACK, baz); + } + + #[test] + #[ignore] + fn compile_check_udma_i2c_3_csr() { + use super::*; + let mut udma_i2c_3_csr = CSR::new(HW_UDMA_I2C_3_BASE as *mut u32); + + let foo = udma_i2c_3_csr.r(utra::udma_i2c_3::REG_RX_SADDR); + udma_i2c_3_csr.wo(utra::udma_i2c_3::REG_RX_SADDR, foo); + let bar = udma_i2c_3_csr.rf(utra::udma_i2c_3::REG_RX_SADDR_R_RX_STARTADDR); + udma_i2c_3_csr.rmwf(utra::udma_i2c_3::REG_RX_SADDR_R_RX_STARTADDR, bar); + let mut baz = udma_i2c_3_csr.zf(utra::udma_i2c_3::REG_RX_SADDR_R_RX_STARTADDR, bar); + baz |= udma_i2c_3_csr.ms(utra::udma_i2c_3::REG_RX_SADDR_R_RX_STARTADDR, 1); + udma_i2c_3_csr.wfo(utra::udma_i2c_3::REG_RX_SADDR_R_RX_STARTADDR, baz); + + let foo = udma_i2c_3_csr.r(utra::udma_i2c_3::REG_RX_SIZE); + udma_i2c_3_csr.wo(utra::udma_i2c_3::REG_RX_SIZE, foo); + let bar = udma_i2c_3_csr.rf(utra::udma_i2c_3::REG_RX_SIZE_R_RX_SIZE); + udma_i2c_3_csr.rmwf(utra::udma_i2c_3::REG_RX_SIZE_R_RX_SIZE, bar); + let mut baz = udma_i2c_3_csr.zf(utra::udma_i2c_3::REG_RX_SIZE_R_RX_SIZE, bar); + baz |= udma_i2c_3_csr.ms(utra::udma_i2c_3::REG_RX_SIZE_R_RX_SIZE, 1); + udma_i2c_3_csr.wfo(utra::udma_i2c_3::REG_RX_SIZE_R_RX_SIZE, baz); + + let foo = udma_i2c_3_csr.r(utra::udma_i2c_3::REG_RX_CFG); + udma_i2c_3_csr.wo(utra::udma_i2c_3::REG_RX_CFG, foo); + let bar = udma_i2c_3_csr.rf(utra::udma_i2c_3::REG_RX_CFG_R_RX_CONTINUOUS); + udma_i2c_3_csr.rmwf(utra::udma_i2c_3::REG_RX_CFG_R_RX_CONTINUOUS, bar); + let mut baz = udma_i2c_3_csr.zf(utra::udma_i2c_3::REG_RX_CFG_R_RX_CONTINUOUS, bar); + baz |= udma_i2c_3_csr.ms(utra::udma_i2c_3::REG_RX_CFG_R_RX_CONTINUOUS, 1); + udma_i2c_3_csr.wfo(utra::udma_i2c_3::REG_RX_CFG_R_RX_CONTINUOUS, baz); + let bar = udma_i2c_3_csr.rf(utra::udma_i2c_3::REG_RX_CFG_R_RX_EN); + udma_i2c_3_csr.rmwf(utra::udma_i2c_3::REG_RX_CFG_R_RX_EN, bar); + let mut baz = udma_i2c_3_csr.zf(utra::udma_i2c_3::REG_RX_CFG_R_RX_EN, bar); + baz |= udma_i2c_3_csr.ms(utra::udma_i2c_3::REG_RX_CFG_R_RX_EN, 1); + udma_i2c_3_csr.wfo(utra::udma_i2c_3::REG_RX_CFG_R_RX_EN, baz); + let bar = udma_i2c_3_csr.rf(utra::udma_i2c_3::REG_RX_CFG_R_RX_CLR); + udma_i2c_3_csr.rmwf(utra::udma_i2c_3::REG_RX_CFG_R_RX_CLR, bar); + let mut baz = udma_i2c_3_csr.zf(utra::udma_i2c_3::REG_RX_CFG_R_RX_CLR, bar); + baz |= udma_i2c_3_csr.ms(utra::udma_i2c_3::REG_RX_CFG_R_RX_CLR, 1); + udma_i2c_3_csr.wfo(utra::udma_i2c_3::REG_RX_CFG_R_RX_CLR, baz); + + let foo = udma_i2c_3_csr.r(utra::udma_i2c_3::REG_TX_SADDR); + udma_i2c_3_csr.wo(utra::udma_i2c_3::REG_TX_SADDR, foo); + let bar = udma_i2c_3_csr.rf(utra::udma_i2c_3::REG_TX_SADDR_R_TX_STARTADDR); + udma_i2c_3_csr.rmwf(utra::udma_i2c_3::REG_TX_SADDR_R_TX_STARTADDR, bar); + let mut baz = udma_i2c_3_csr.zf(utra::udma_i2c_3::REG_TX_SADDR_R_TX_STARTADDR, bar); + baz |= udma_i2c_3_csr.ms(utra::udma_i2c_3::REG_TX_SADDR_R_TX_STARTADDR, 1); + udma_i2c_3_csr.wfo(utra::udma_i2c_3::REG_TX_SADDR_R_TX_STARTADDR, baz); + + let foo = udma_i2c_3_csr.r(utra::udma_i2c_3::REG_TX_SIZE); + udma_i2c_3_csr.wo(utra::udma_i2c_3::REG_TX_SIZE, foo); + let bar = udma_i2c_3_csr.rf(utra::udma_i2c_3::REG_TX_SIZE_R_TX_SIZE); + udma_i2c_3_csr.rmwf(utra::udma_i2c_3::REG_TX_SIZE_R_TX_SIZE, bar); + let mut baz = udma_i2c_3_csr.zf(utra::udma_i2c_3::REG_TX_SIZE_R_TX_SIZE, bar); + baz |= udma_i2c_3_csr.ms(utra::udma_i2c_3::REG_TX_SIZE_R_TX_SIZE, 1); + udma_i2c_3_csr.wfo(utra::udma_i2c_3::REG_TX_SIZE_R_TX_SIZE, baz); + + let foo = udma_i2c_3_csr.r(utra::udma_i2c_3::REG_TX_CFG); + udma_i2c_3_csr.wo(utra::udma_i2c_3::REG_TX_CFG, foo); + let bar = udma_i2c_3_csr.rf(utra::udma_i2c_3::REG_TX_CFG_R_TX_CONTINUOUS); + udma_i2c_3_csr.rmwf(utra::udma_i2c_3::REG_TX_CFG_R_TX_CONTINUOUS, bar); + let mut baz = udma_i2c_3_csr.zf(utra::udma_i2c_3::REG_TX_CFG_R_TX_CONTINUOUS, bar); + baz |= udma_i2c_3_csr.ms(utra::udma_i2c_3::REG_TX_CFG_R_TX_CONTINUOUS, 1); + udma_i2c_3_csr.wfo(utra::udma_i2c_3::REG_TX_CFG_R_TX_CONTINUOUS, baz); + let bar = udma_i2c_3_csr.rf(utra::udma_i2c_3::REG_TX_CFG_R_TX_EN); + udma_i2c_3_csr.rmwf(utra::udma_i2c_3::REG_TX_CFG_R_TX_EN, bar); + let mut baz = udma_i2c_3_csr.zf(utra::udma_i2c_3::REG_TX_CFG_R_TX_EN, bar); + baz |= udma_i2c_3_csr.ms(utra::udma_i2c_3::REG_TX_CFG_R_TX_EN, 1); + udma_i2c_3_csr.wfo(utra::udma_i2c_3::REG_TX_CFG_R_TX_EN, baz); + let bar = udma_i2c_3_csr.rf(utra::udma_i2c_3::REG_TX_CFG_R_TX_CLR); + udma_i2c_3_csr.rmwf(utra::udma_i2c_3::REG_TX_CFG_R_TX_CLR, bar); + let mut baz = udma_i2c_3_csr.zf(utra::udma_i2c_3::REG_TX_CFG_R_TX_CLR, bar); + baz |= udma_i2c_3_csr.ms(utra::udma_i2c_3::REG_TX_CFG_R_TX_CLR, 1); + udma_i2c_3_csr.wfo(utra::udma_i2c_3::REG_TX_CFG_R_TX_CLR, baz); + + let foo = udma_i2c_3_csr.r(utra::udma_i2c_3::REG_CMD_SADDR); + udma_i2c_3_csr.wo(utra::udma_i2c_3::REG_CMD_SADDR, foo); + let bar = udma_i2c_3_csr.rf(utra::udma_i2c_3::REG_CMD_SADDR_R_CMD_STARTADDR); + udma_i2c_3_csr.rmwf(utra::udma_i2c_3::REG_CMD_SADDR_R_CMD_STARTADDR, bar); + let mut baz = udma_i2c_3_csr.zf(utra::udma_i2c_3::REG_CMD_SADDR_R_CMD_STARTADDR, bar); + baz |= udma_i2c_3_csr.ms(utra::udma_i2c_3::REG_CMD_SADDR_R_CMD_STARTADDR, 1); + udma_i2c_3_csr.wfo(utra::udma_i2c_3::REG_CMD_SADDR_R_CMD_STARTADDR, baz); + + let foo = udma_i2c_3_csr.r(utra::udma_i2c_3::REG_CMD_SIZE); + udma_i2c_3_csr.wo(utra::udma_i2c_3::REG_CMD_SIZE, foo); + let bar = udma_i2c_3_csr.rf(utra::udma_i2c_3::REG_CMD_SIZE_R_CMD_SIZE); + udma_i2c_3_csr.rmwf(utra::udma_i2c_3::REG_CMD_SIZE_R_CMD_SIZE, bar); + let mut baz = udma_i2c_3_csr.zf(utra::udma_i2c_3::REG_CMD_SIZE_R_CMD_SIZE, bar); + baz |= udma_i2c_3_csr.ms(utra::udma_i2c_3::REG_CMD_SIZE_R_CMD_SIZE, 1); + udma_i2c_3_csr.wfo(utra::udma_i2c_3::REG_CMD_SIZE_R_CMD_SIZE, baz); + + let foo = udma_i2c_3_csr.r(utra::udma_i2c_3::REG_CMD_CFG); + udma_i2c_3_csr.wo(utra::udma_i2c_3::REG_CMD_CFG, foo); + let bar = udma_i2c_3_csr.rf(utra::udma_i2c_3::REG_CMD_CFG_R_CMD_CONTINUOUS); + udma_i2c_3_csr.rmwf(utra::udma_i2c_3::REG_CMD_CFG_R_CMD_CONTINUOUS, bar); + let mut baz = udma_i2c_3_csr.zf(utra::udma_i2c_3::REG_CMD_CFG_R_CMD_CONTINUOUS, bar); + baz |= udma_i2c_3_csr.ms(utra::udma_i2c_3::REG_CMD_CFG_R_CMD_CONTINUOUS, 1); + udma_i2c_3_csr.wfo(utra::udma_i2c_3::REG_CMD_CFG_R_CMD_CONTINUOUS, baz); + let bar = udma_i2c_3_csr.rf(utra::udma_i2c_3::REG_CMD_CFG_R_CMD_EN); + udma_i2c_3_csr.rmwf(utra::udma_i2c_3::REG_CMD_CFG_R_CMD_EN, bar); + let mut baz = udma_i2c_3_csr.zf(utra::udma_i2c_3::REG_CMD_CFG_R_CMD_EN, bar); + baz |= udma_i2c_3_csr.ms(utra::udma_i2c_3::REG_CMD_CFG_R_CMD_EN, 1); + udma_i2c_3_csr.wfo(utra::udma_i2c_3::REG_CMD_CFG_R_CMD_EN, baz); + let bar = udma_i2c_3_csr.rf(utra::udma_i2c_3::REG_CMD_CFG_R_CMD_CLR); + udma_i2c_3_csr.rmwf(utra::udma_i2c_3::REG_CMD_CFG_R_CMD_CLR, bar); + let mut baz = udma_i2c_3_csr.zf(utra::udma_i2c_3::REG_CMD_CFG_R_CMD_CLR, bar); + baz |= udma_i2c_3_csr.ms(utra::udma_i2c_3::REG_CMD_CFG_R_CMD_CLR, 1); + udma_i2c_3_csr.wfo(utra::udma_i2c_3::REG_CMD_CFG_R_CMD_CLR, baz); + + let foo = udma_i2c_3_csr.r(utra::udma_i2c_3::REG_STATUS); + udma_i2c_3_csr.wo(utra::udma_i2c_3::REG_STATUS, foo); + let bar = udma_i2c_3_csr.rf(utra::udma_i2c_3::REG_STATUS_R_BUSY); + udma_i2c_3_csr.rmwf(utra::udma_i2c_3::REG_STATUS_R_BUSY, bar); + let mut baz = udma_i2c_3_csr.zf(utra::udma_i2c_3::REG_STATUS_R_BUSY, bar); + baz |= udma_i2c_3_csr.ms(utra::udma_i2c_3::REG_STATUS_R_BUSY, 1); + udma_i2c_3_csr.wfo(utra::udma_i2c_3::REG_STATUS_R_BUSY, baz); + let bar = udma_i2c_3_csr.rf(utra::udma_i2c_3::REG_STATUS_R_AL); + udma_i2c_3_csr.rmwf(utra::udma_i2c_3::REG_STATUS_R_AL, bar); + let mut baz = udma_i2c_3_csr.zf(utra::udma_i2c_3::REG_STATUS_R_AL, bar); + baz |= udma_i2c_3_csr.ms(utra::udma_i2c_3::REG_STATUS_R_AL, 1); + udma_i2c_3_csr.wfo(utra::udma_i2c_3::REG_STATUS_R_AL, baz); + + let foo = udma_i2c_3_csr.r(utra::udma_i2c_3::REG_SETUP); + udma_i2c_3_csr.wo(utra::udma_i2c_3::REG_SETUP, foo); + let bar = udma_i2c_3_csr.rf(utra::udma_i2c_3::REG_SETUP_R_DO_RST); + udma_i2c_3_csr.rmwf(utra::udma_i2c_3::REG_SETUP_R_DO_RST, bar); + let mut baz = udma_i2c_3_csr.zf(utra::udma_i2c_3::REG_SETUP_R_DO_RST, bar); + baz |= udma_i2c_3_csr.ms(utra::udma_i2c_3::REG_SETUP_R_DO_RST, 1); + udma_i2c_3_csr.wfo(utra::udma_i2c_3::REG_SETUP_R_DO_RST, baz); + + let foo = udma_i2c_3_csr.r(utra::udma_i2c_3::REG_ACK); + udma_i2c_3_csr.wo(utra::udma_i2c_3::REG_ACK, foo); + let bar = udma_i2c_3_csr.rf(utra::udma_i2c_3::REG_ACK_R_NACK); + udma_i2c_3_csr.rmwf(utra::udma_i2c_3::REG_ACK_R_NACK, bar); + let mut baz = udma_i2c_3_csr.zf(utra::udma_i2c_3::REG_ACK_R_NACK, bar); + baz |= udma_i2c_3_csr.ms(utra::udma_i2c_3::REG_ACK_R_NACK, 1); + udma_i2c_3_csr.wfo(utra::udma_i2c_3::REG_ACK_R_NACK, baz); + } + + #[test] + #[ignore] + fn compile_check_udma_sdio_csr() { + use super::*; + let mut udma_sdio_csr = CSR::new(HW_UDMA_SDIO_BASE as *mut u32); + + 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_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_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_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_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_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_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 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_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_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); + } + + #[test] + #[ignore] + fn compile_check_udma_i2s_csr() { + use super::*; + let mut udma_i2s_csr = CSR::new(HW_UDMA_I2S_BASE as *mut u32); + + 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_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_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_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_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_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_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_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_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_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] + #[ignore] + fn compile_check_udma_camera_csr() { + use super::*; + let mut udma_camera_csr = CSR::new(HW_UDMA_CAMERA_BASE as *mut u32); + + let foo = udma_camera_csr.r(utra::udma_camera::REG_RX_SADDR); + udma_camera_csr.wo(utra::udma_camera::REG_RX_SADDR, foo); + let bar = udma_camera_csr.rf(utra::udma_camera::REG_RX_SADDR_R_RX_STARTADDR); + udma_camera_csr.rmwf(utra::udma_camera::REG_RX_SADDR_R_RX_STARTADDR, bar); + let mut baz = udma_camera_csr.zf(utra::udma_camera::REG_RX_SADDR_R_RX_STARTADDR, bar); + baz |= udma_camera_csr.ms(utra::udma_camera::REG_RX_SADDR_R_RX_STARTADDR, 1); + udma_camera_csr.wfo(utra::udma_camera::REG_RX_SADDR_R_RX_STARTADDR, baz); + + let foo = udma_camera_csr.r(utra::udma_camera::REG_RX_SIZE); + udma_camera_csr.wo(utra::udma_camera::REG_RX_SIZE, foo); + let bar = udma_camera_csr.rf(utra::udma_camera::REG_RX_SIZE_R_RX_SIZE); + udma_camera_csr.rmwf(utra::udma_camera::REG_RX_SIZE_R_RX_SIZE, bar); + let mut baz = udma_camera_csr.zf(utra::udma_camera::REG_RX_SIZE_R_RX_SIZE, bar); + baz |= udma_camera_csr.ms(utra::udma_camera::REG_RX_SIZE_R_RX_SIZE, 1); + udma_camera_csr.wfo(utra::udma_camera::REG_RX_SIZE_R_RX_SIZE, baz); + + let foo = udma_camera_csr.r(utra::udma_camera::REG_RX_CFG); + udma_camera_csr.wo(utra::udma_camera::REG_RX_CFG, foo); + let bar = udma_camera_csr.rf(utra::udma_camera::REG_RX_CFG_R_RX_CONTINUOUS); + udma_camera_csr.rmwf(utra::udma_camera::REG_RX_CFG_R_RX_CONTINUOUS, bar); + let mut baz = udma_camera_csr.zf(utra::udma_camera::REG_RX_CFG_R_RX_CONTINUOUS, bar); + baz |= udma_camera_csr.ms(utra::udma_camera::REG_RX_CFG_R_RX_CONTINUOUS, 1); + udma_camera_csr.wfo(utra::udma_camera::REG_RX_CFG_R_RX_CONTINUOUS, baz); + let bar = udma_camera_csr.rf(utra::udma_camera::REG_RX_CFG_R_RX_DATASIZE); + udma_camera_csr.rmwf(utra::udma_camera::REG_RX_CFG_R_RX_DATASIZE, bar); + let mut baz = udma_camera_csr.zf(utra::udma_camera::REG_RX_CFG_R_RX_DATASIZE, bar); + baz |= udma_camera_csr.ms(utra::udma_camera::REG_RX_CFG_R_RX_DATASIZE, 1); + udma_camera_csr.wfo(utra::udma_camera::REG_RX_CFG_R_RX_DATASIZE, baz); + let bar = udma_camera_csr.rf(utra::udma_camera::REG_RX_CFG_R_RX_EN); + udma_camera_csr.rmwf(utra::udma_camera::REG_RX_CFG_R_RX_EN, bar); + let mut baz = udma_camera_csr.zf(utra::udma_camera::REG_RX_CFG_R_RX_EN, bar); + baz |= udma_camera_csr.ms(utra::udma_camera::REG_RX_CFG_R_RX_EN, 1); + udma_camera_csr.wfo(utra::udma_camera::REG_RX_CFG_R_RX_EN, baz); + let bar = udma_camera_csr.rf(utra::udma_camera::REG_RX_CFG_R_RX_CLR); + udma_camera_csr.rmwf(utra::udma_camera::REG_RX_CFG_R_RX_CLR, bar); + let mut baz = udma_camera_csr.zf(utra::udma_camera::REG_RX_CFG_R_RX_CLR, bar); + baz |= udma_camera_csr.ms(utra::udma_camera::REG_RX_CFG_R_RX_CLR, 1); + udma_camera_csr.wfo(utra::udma_camera::REG_RX_CFG_R_RX_CLR, baz); + + let foo = udma_camera_csr.r(utra::udma_camera::REG_CAM_CFG_GLOB); + udma_camera_csr.wo(utra::udma_camera::REG_CAM_CFG_GLOB, foo); + let bar = udma_camera_csr.rf(utra::udma_camera::REG_CAM_CFG_GLOB_R_CAM_CFG); + udma_camera_csr.rmwf(utra::udma_camera::REG_CAM_CFG_GLOB_R_CAM_CFG, bar); + let mut baz = udma_camera_csr.zf(utra::udma_camera::REG_CAM_CFG_GLOB_R_CAM_CFG, bar); + baz |= udma_camera_csr.ms(utra::udma_camera::REG_CAM_CFG_GLOB_R_CAM_CFG, 1); + udma_camera_csr.wfo(utra::udma_camera::REG_CAM_CFG_GLOB_R_CAM_CFG, baz); + let bar = udma_camera_csr.rf(utra::udma_camera::REG_CAM_CFG_GLOB_CFG_CAM_IP_EN_I); + udma_camera_csr.rmwf(utra::udma_camera::REG_CAM_CFG_GLOB_CFG_CAM_IP_EN_I, bar); + let mut baz = udma_camera_csr.zf(utra::udma_camera::REG_CAM_CFG_GLOB_CFG_CAM_IP_EN_I, bar); + baz |= udma_camera_csr.ms(utra::udma_camera::REG_CAM_CFG_GLOB_CFG_CAM_IP_EN_I, 1); + udma_camera_csr.wfo(utra::udma_camera::REG_CAM_CFG_GLOB_CFG_CAM_IP_EN_I, baz); + + let foo = udma_camera_csr.r(utra::udma_camera::REG_CAM_CFG_LL); + udma_camera_csr.wo(utra::udma_camera::REG_CAM_CFG_LL, foo); + let bar = udma_camera_csr.rf(utra::udma_camera::REG_CAM_CFG_LL_R_CAM_CFG_LL); + udma_camera_csr.rmwf(utra::udma_camera::REG_CAM_CFG_LL_R_CAM_CFG_LL, bar); + let mut baz = udma_camera_csr.zf(utra::udma_camera::REG_CAM_CFG_LL_R_CAM_CFG_LL, bar); + baz |= udma_camera_csr.ms(utra::udma_camera::REG_CAM_CFG_LL_R_CAM_CFG_LL, 1); + udma_camera_csr.wfo(utra::udma_camera::REG_CAM_CFG_LL_R_CAM_CFG_LL, baz); + + let foo = udma_camera_csr.r(utra::udma_camera::REG_CAM_CFG_UR); + udma_camera_csr.wo(utra::udma_camera::REG_CAM_CFG_UR, foo); + let bar = udma_camera_csr.rf(utra::udma_camera::REG_CAM_CFG_UR_R_CAM_CFG_UR); + udma_camera_csr.rmwf(utra::udma_camera::REG_CAM_CFG_UR_R_CAM_CFG_UR, bar); + let mut baz = udma_camera_csr.zf(utra::udma_camera::REG_CAM_CFG_UR_R_CAM_CFG_UR, bar); + baz |= udma_camera_csr.ms(utra::udma_camera::REG_CAM_CFG_UR_R_CAM_CFG_UR, 1); + udma_camera_csr.wfo(utra::udma_camera::REG_CAM_CFG_UR_R_CAM_CFG_UR, baz); + + let foo = udma_camera_csr.r(utra::udma_camera::REG_CAM_CFG_SIZE); + udma_camera_csr.wo(utra::udma_camera::REG_CAM_CFG_SIZE, foo); + let bar = udma_camera_csr.rf(utra::udma_camera::REG_CAM_CFG_SIZE_R_CAM_CFG_SIZE); + udma_camera_csr.rmwf(utra::udma_camera::REG_CAM_CFG_SIZE_R_CAM_CFG_SIZE, bar); + let mut baz = udma_camera_csr.zf(utra::udma_camera::REG_CAM_CFG_SIZE_R_CAM_CFG_SIZE, bar); + baz |= udma_camera_csr.ms(utra::udma_camera::REG_CAM_CFG_SIZE_R_CAM_CFG_SIZE, 1); + udma_camera_csr.wfo(utra::udma_camera::REG_CAM_CFG_SIZE_R_CAM_CFG_SIZE, baz); + + let foo = udma_camera_csr.r(utra::udma_camera::REG_CAM_CFG_FILTER); + udma_camera_csr.wo(utra::udma_camera::REG_CAM_CFG_FILTER, foo); + let bar = udma_camera_csr.rf(utra::udma_camera::REG_CAM_CFG_FILTER_R_CAM_CFG_FILTER); + udma_camera_csr.rmwf(utra::udma_camera::REG_CAM_CFG_FILTER_R_CAM_CFG_FILTER, bar); + let mut baz = udma_camera_csr.zf(utra::udma_camera::REG_CAM_CFG_FILTER_R_CAM_CFG_FILTER, bar); + baz |= udma_camera_csr.ms(utra::udma_camera::REG_CAM_CFG_FILTER_R_CAM_CFG_FILTER, 1); + udma_camera_csr.wfo(utra::udma_camera::REG_CAM_CFG_FILTER_R_CAM_CFG_FILTER, baz); + + let foo = udma_camera_csr.r(utra::udma_camera::REG_CAM_VSYNC_POLARITY); + udma_camera_csr.wo(utra::udma_camera::REG_CAM_VSYNC_POLARITY, foo); + let bar = udma_camera_csr.rf(utra::udma_camera::REG_CAM_VSYNC_POLARITY_R_CAM_VSYNC_POLARITY); + udma_camera_csr.rmwf(utra::udma_camera::REG_CAM_VSYNC_POLARITY_R_CAM_VSYNC_POLARITY, bar); + let mut baz = udma_camera_csr.zf(utra::udma_camera::REG_CAM_VSYNC_POLARITY_R_CAM_VSYNC_POLARITY, bar); + baz |= udma_camera_csr.ms(utra::udma_camera::REG_CAM_VSYNC_POLARITY_R_CAM_VSYNC_POLARITY, 1); + udma_camera_csr.wfo(utra::udma_camera::REG_CAM_VSYNC_POLARITY_R_CAM_VSYNC_POLARITY, baz); + let bar = udma_camera_csr.rf(utra::udma_camera::REG_CAM_VSYNC_POLARITY_R_CAM_HSYNC_POLARITY); + udma_camera_csr.rmwf(utra::udma_camera::REG_CAM_VSYNC_POLARITY_R_CAM_HSYNC_POLARITY, bar); + let mut baz = udma_camera_csr.zf(utra::udma_camera::REG_CAM_VSYNC_POLARITY_R_CAM_HSYNC_POLARITY, bar); + baz |= udma_camera_csr.ms(utra::udma_camera::REG_CAM_VSYNC_POLARITY_R_CAM_HSYNC_POLARITY, 1); + udma_camera_csr.wfo(utra::udma_camera::REG_CAM_VSYNC_POLARITY_R_CAM_HSYNC_POLARITY, baz); + } + + #[test] + #[ignore] + fn compile_check_udma_filter_csr() { + use super::*; + let mut udma_filter_csr = CSR::new(HW_UDMA_FILTER_BASE as *mut u32); + + let foo = udma_filter_csr.r(utra::udma_filter::REG_TX_CH0_ADD); + udma_filter_csr.wo(utra::udma_filter::REG_TX_CH0_ADD, foo); + let bar = udma_filter_csr.rf(utra::udma_filter::REG_TX_CH0_ADD_R_FILTER_TX_START_ADDR_0); + udma_filter_csr.rmwf(utra::udma_filter::REG_TX_CH0_ADD_R_FILTER_TX_START_ADDR_0, bar); + let mut baz = udma_filter_csr.zf(utra::udma_filter::REG_TX_CH0_ADD_R_FILTER_TX_START_ADDR_0, bar); + baz |= udma_filter_csr.ms(utra::udma_filter::REG_TX_CH0_ADD_R_FILTER_TX_START_ADDR_0, 1); + udma_filter_csr.wfo(utra::udma_filter::REG_TX_CH0_ADD_R_FILTER_TX_START_ADDR_0, baz); + + let foo = udma_filter_csr.r(utra::udma_filter::REG_TX_CH0_CFG); + udma_filter_csr.wo(utra::udma_filter::REG_TX_CH0_CFG, foo); + let bar = udma_filter_csr.rf(utra::udma_filter::REG_TX_CH0_CFG_R_FILTER_TX_DATASIZE_0); + udma_filter_csr.rmwf(utra::udma_filter::REG_TX_CH0_CFG_R_FILTER_TX_DATASIZE_0, bar); + let mut baz = udma_filter_csr.zf(utra::udma_filter::REG_TX_CH0_CFG_R_FILTER_TX_DATASIZE_0, bar); + baz |= udma_filter_csr.ms(utra::udma_filter::REG_TX_CH0_CFG_R_FILTER_TX_DATASIZE_0, 1); + udma_filter_csr.wfo(utra::udma_filter::REG_TX_CH0_CFG_R_FILTER_TX_DATASIZE_0, baz); + let bar = udma_filter_csr.rf(utra::udma_filter::REG_TX_CH0_CFG_R_FILTER_TX_MODE_0); + udma_filter_csr.rmwf(utra::udma_filter::REG_TX_CH0_CFG_R_FILTER_TX_MODE_0, bar); + let mut baz = udma_filter_csr.zf(utra::udma_filter::REG_TX_CH0_CFG_R_FILTER_TX_MODE_0, bar); + baz |= udma_filter_csr.ms(utra::udma_filter::REG_TX_CH0_CFG_R_FILTER_TX_MODE_0, 1); + udma_filter_csr.wfo(utra::udma_filter::REG_TX_CH0_CFG_R_FILTER_TX_MODE_0, baz); + + let foo = udma_filter_csr.r(utra::udma_filter::REG_TX_CH0_LEN0); + udma_filter_csr.wo(utra::udma_filter::REG_TX_CH0_LEN0, foo); + let bar = udma_filter_csr.rf(utra::udma_filter::REG_TX_CH0_LEN0_R_FILTER_TX_LEN0_0); + udma_filter_csr.rmwf(utra::udma_filter::REG_TX_CH0_LEN0_R_FILTER_TX_LEN0_0, bar); + let mut baz = udma_filter_csr.zf(utra::udma_filter::REG_TX_CH0_LEN0_R_FILTER_TX_LEN0_0, bar); + baz |= udma_filter_csr.ms(utra::udma_filter::REG_TX_CH0_LEN0_R_FILTER_TX_LEN0_0, 1); + udma_filter_csr.wfo(utra::udma_filter::REG_TX_CH0_LEN0_R_FILTER_TX_LEN0_0, baz); + + let foo = udma_filter_csr.r(utra::udma_filter::REG_TX_CH0_LEN1); + udma_filter_csr.wo(utra::udma_filter::REG_TX_CH0_LEN1, foo); + let bar = udma_filter_csr.rf(utra::udma_filter::REG_TX_CH0_LEN1_R_FILTER_TX_LEN1_0); + udma_filter_csr.rmwf(utra::udma_filter::REG_TX_CH0_LEN1_R_FILTER_TX_LEN1_0, bar); + let mut baz = udma_filter_csr.zf(utra::udma_filter::REG_TX_CH0_LEN1_R_FILTER_TX_LEN1_0, bar); + baz |= udma_filter_csr.ms(utra::udma_filter::REG_TX_CH0_LEN1_R_FILTER_TX_LEN1_0, 1); + udma_filter_csr.wfo(utra::udma_filter::REG_TX_CH0_LEN1_R_FILTER_TX_LEN1_0, baz); + + let foo = udma_filter_csr.r(utra::udma_filter::REG_TX_CH0_LEN2); + udma_filter_csr.wo(utra::udma_filter::REG_TX_CH0_LEN2, foo); + let bar = udma_filter_csr.rf(utra::udma_filter::REG_TX_CH0_LEN2_R_FILTER_TX_LEN2_0); + udma_filter_csr.rmwf(utra::udma_filter::REG_TX_CH0_LEN2_R_FILTER_TX_LEN2_0, bar); + let mut baz = udma_filter_csr.zf(utra::udma_filter::REG_TX_CH0_LEN2_R_FILTER_TX_LEN2_0, bar); + baz |= udma_filter_csr.ms(utra::udma_filter::REG_TX_CH0_LEN2_R_FILTER_TX_LEN2_0, 1); + udma_filter_csr.wfo(utra::udma_filter::REG_TX_CH0_LEN2_R_FILTER_TX_LEN2_0, baz); + + let foo = udma_filter_csr.r(utra::udma_filter::REG_TX_CH1_ADD); + udma_filter_csr.wo(utra::udma_filter::REG_TX_CH1_ADD, foo); + let bar = udma_filter_csr.rf(utra::udma_filter::REG_TX_CH1_ADD_R_FILTER_TX_START_ADDR_1); + udma_filter_csr.rmwf(utra::udma_filter::REG_TX_CH1_ADD_R_FILTER_TX_START_ADDR_1, bar); + let mut baz = udma_filter_csr.zf(utra::udma_filter::REG_TX_CH1_ADD_R_FILTER_TX_START_ADDR_1, bar); + baz |= udma_filter_csr.ms(utra::udma_filter::REG_TX_CH1_ADD_R_FILTER_TX_START_ADDR_1, 1); + udma_filter_csr.wfo(utra::udma_filter::REG_TX_CH1_ADD_R_FILTER_TX_START_ADDR_1, baz); + + let foo = udma_filter_csr.r(utra::udma_filter::REG_TX_CH1_CFG); + udma_filter_csr.wo(utra::udma_filter::REG_TX_CH1_CFG, foo); + let bar = udma_filter_csr.rf(utra::udma_filter::REG_TX_CH1_CFG_R_FILTER_TX_DATASIZE_1); + udma_filter_csr.rmwf(utra::udma_filter::REG_TX_CH1_CFG_R_FILTER_TX_DATASIZE_1, bar); + let mut baz = udma_filter_csr.zf(utra::udma_filter::REG_TX_CH1_CFG_R_FILTER_TX_DATASIZE_1, bar); + baz |= udma_filter_csr.ms(utra::udma_filter::REG_TX_CH1_CFG_R_FILTER_TX_DATASIZE_1, 1); + udma_filter_csr.wfo(utra::udma_filter::REG_TX_CH1_CFG_R_FILTER_TX_DATASIZE_1, baz); + let bar = udma_filter_csr.rf(utra::udma_filter::REG_TX_CH1_CFG_R_FILTER_TX_MODE_1); + udma_filter_csr.rmwf(utra::udma_filter::REG_TX_CH1_CFG_R_FILTER_TX_MODE_1, bar); + let mut baz = udma_filter_csr.zf(utra::udma_filter::REG_TX_CH1_CFG_R_FILTER_TX_MODE_1, bar); + baz |= udma_filter_csr.ms(utra::udma_filter::REG_TX_CH1_CFG_R_FILTER_TX_MODE_1, 1); + udma_filter_csr.wfo(utra::udma_filter::REG_TX_CH1_CFG_R_FILTER_TX_MODE_1, baz); + + let foo = udma_filter_csr.r(utra::udma_filter::REG_TX_CH1_LEN0); + udma_filter_csr.wo(utra::udma_filter::REG_TX_CH1_LEN0, foo); + let bar = udma_filter_csr.rf(utra::udma_filter::REG_TX_CH1_LEN0_R_FILTER_TX_LEN0_1); + udma_filter_csr.rmwf(utra::udma_filter::REG_TX_CH1_LEN0_R_FILTER_TX_LEN0_1, bar); + let mut baz = udma_filter_csr.zf(utra::udma_filter::REG_TX_CH1_LEN0_R_FILTER_TX_LEN0_1, bar); + baz |= udma_filter_csr.ms(utra::udma_filter::REG_TX_CH1_LEN0_R_FILTER_TX_LEN0_1, 1); + udma_filter_csr.wfo(utra::udma_filter::REG_TX_CH1_LEN0_R_FILTER_TX_LEN0_1, baz); + + let foo = udma_filter_csr.r(utra::udma_filter::REG_TX_CH1_LEN1); + udma_filter_csr.wo(utra::udma_filter::REG_TX_CH1_LEN1, foo); + let bar = udma_filter_csr.rf(utra::udma_filter::REG_TX_CH1_LEN1_R_FILTER_TX_LEN1_1); + udma_filter_csr.rmwf(utra::udma_filter::REG_TX_CH1_LEN1_R_FILTER_TX_LEN1_1, bar); + let mut baz = udma_filter_csr.zf(utra::udma_filter::REG_TX_CH1_LEN1_R_FILTER_TX_LEN1_1, bar); + baz |= udma_filter_csr.ms(utra::udma_filter::REG_TX_CH1_LEN1_R_FILTER_TX_LEN1_1, 1); + udma_filter_csr.wfo(utra::udma_filter::REG_TX_CH1_LEN1_R_FILTER_TX_LEN1_1, baz); + + let foo = udma_filter_csr.r(utra::udma_filter::REG_TX_CH1_LEN2); + udma_filter_csr.wo(utra::udma_filter::REG_TX_CH1_LEN2, foo); + let bar = udma_filter_csr.rf(utra::udma_filter::REG_TX_CH1_LEN2_R_FILTER_TX_LEN2_1); + udma_filter_csr.rmwf(utra::udma_filter::REG_TX_CH1_LEN2_R_FILTER_TX_LEN2_1, bar); + let mut baz = udma_filter_csr.zf(utra::udma_filter::REG_TX_CH1_LEN2_R_FILTER_TX_LEN2_1, bar); + baz |= udma_filter_csr.ms(utra::udma_filter::REG_TX_CH1_LEN2_R_FILTER_TX_LEN2_1, 1); + udma_filter_csr.wfo(utra::udma_filter::REG_TX_CH1_LEN2_R_FILTER_TX_LEN2_1, baz); + + let foo = udma_filter_csr.r(utra::udma_filter::REG_RX_CH_ADD); + udma_filter_csr.wo(utra::udma_filter::REG_RX_CH_ADD, foo); + let bar = udma_filter_csr.rf(utra::udma_filter::REG_RX_CH_ADD_R_FILTER_RX_START_ADDR); + udma_filter_csr.rmwf(utra::udma_filter::REG_RX_CH_ADD_R_FILTER_RX_START_ADDR, bar); + let mut baz = udma_filter_csr.zf(utra::udma_filter::REG_RX_CH_ADD_R_FILTER_RX_START_ADDR, bar); + baz |= udma_filter_csr.ms(utra::udma_filter::REG_RX_CH_ADD_R_FILTER_RX_START_ADDR, 1); + udma_filter_csr.wfo(utra::udma_filter::REG_RX_CH_ADD_R_FILTER_RX_START_ADDR, baz); + + let foo = udma_filter_csr.r(utra::udma_filter::REG_RX_CH_CFG); + udma_filter_csr.wo(utra::udma_filter::REG_RX_CH_CFG, foo); + let bar = udma_filter_csr.rf(utra::udma_filter::REG_RX_CH_CFG_R_FILTER_RX_DATASIZE); + udma_filter_csr.rmwf(utra::udma_filter::REG_RX_CH_CFG_R_FILTER_RX_DATASIZE, bar); + let mut baz = udma_filter_csr.zf(utra::udma_filter::REG_RX_CH_CFG_R_FILTER_RX_DATASIZE, bar); + baz |= udma_filter_csr.ms(utra::udma_filter::REG_RX_CH_CFG_R_FILTER_RX_DATASIZE, 1); + udma_filter_csr.wfo(utra::udma_filter::REG_RX_CH_CFG_R_FILTER_RX_DATASIZE, baz); + let bar = udma_filter_csr.rf(utra::udma_filter::REG_RX_CH_CFG_R_FILTER_RX_MODE); + udma_filter_csr.rmwf(utra::udma_filter::REG_RX_CH_CFG_R_FILTER_RX_MODE, bar); + let mut baz = udma_filter_csr.zf(utra::udma_filter::REG_RX_CH_CFG_R_FILTER_RX_MODE, bar); + baz |= udma_filter_csr.ms(utra::udma_filter::REG_RX_CH_CFG_R_FILTER_RX_MODE, 1); + udma_filter_csr.wfo(utra::udma_filter::REG_RX_CH_CFG_R_FILTER_RX_MODE, baz); + + let foo = udma_filter_csr.r(utra::udma_filter::REG_RX_CH_LEN0); + udma_filter_csr.wo(utra::udma_filter::REG_RX_CH_LEN0, foo); + let bar = udma_filter_csr.rf(utra::udma_filter::REG_RX_CH_LEN0_R_FILTER_RX_LEN0); + udma_filter_csr.rmwf(utra::udma_filter::REG_RX_CH_LEN0_R_FILTER_RX_LEN0, bar); + let mut baz = udma_filter_csr.zf(utra::udma_filter::REG_RX_CH_LEN0_R_FILTER_RX_LEN0, bar); + baz |= udma_filter_csr.ms(utra::udma_filter::REG_RX_CH_LEN0_R_FILTER_RX_LEN0, 1); + udma_filter_csr.wfo(utra::udma_filter::REG_RX_CH_LEN0_R_FILTER_RX_LEN0, baz); + + let foo = udma_filter_csr.r(utra::udma_filter::REG_RX_CH_LEN1); + udma_filter_csr.wo(utra::udma_filter::REG_RX_CH_LEN1, foo); + let bar = udma_filter_csr.rf(utra::udma_filter::REG_RX_CH_LEN1_R_FILTER_RX_LEN1); + udma_filter_csr.rmwf(utra::udma_filter::REG_RX_CH_LEN1_R_FILTER_RX_LEN1, bar); + let mut baz = udma_filter_csr.zf(utra::udma_filter::REG_RX_CH_LEN1_R_FILTER_RX_LEN1, bar); + baz |= udma_filter_csr.ms(utra::udma_filter::REG_RX_CH_LEN1_R_FILTER_RX_LEN1, 1); + udma_filter_csr.wfo(utra::udma_filter::REG_RX_CH_LEN1_R_FILTER_RX_LEN1, baz); + + let foo = udma_filter_csr.r(utra::udma_filter::REG_RX_CH_LEN2); + udma_filter_csr.wo(utra::udma_filter::REG_RX_CH_LEN2, foo); + let bar = udma_filter_csr.rf(utra::udma_filter::REG_RX_CH_LEN2_R_FILTER_RX_LEN2); + udma_filter_csr.rmwf(utra::udma_filter::REG_RX_CH_LEN2_R_FILTER_RX_LEN2, bar); + let mut baz = udma_filter_csr.zf(utra::udma_filter::REG_RX_CH_LEN2_R_FILTER_RX_LEN2, bar); + baz |= udma_filter_csr.ms(utra::udma_filter::REG_RX_CH_LEN2_R_FILTER_RX_LEN2, 1); + udma_filter_csr.wfo(utra::udma_filter::REG_RX_CH_LEN2_R_FILTER_RX_LEN2, baz); + + let foo = udma_filter_csr.r(utra::udma_filter::REG_AU_CFG); + udma_filter_csr.wo(utra::udma_filter::REG_AU_CFG, foo); + let bar = udma_filter_csr.rf(utra::udma_filter::REG_AU_CFG_R_AU_USE_SIGNED); + udma_filter_csr.rmwf(utra::udma_filter::REG_AU_CFG_R_AU_USE_SIGNED, bar); + let mut baz = udma_filter_csr.zf(utra::udma_filter::REG_AU_CFG_R_AU_USE_SIGNED, bar); + baz |= udma_filter_csr.ms(utra::udma_filter::REG_AU_CFG_R_AU_USE_SIGNED, 1); + udma_filter_csr.wfo(utra::udma_filter::REG_AU_CFG_R_AU_USE_SIGNED, baz); + let bar = udma_filter_csr.rf(utra::udma_filter::REG_AU_CFG_R_AU_BYPASS); + udma_filter_csr.rmwf(utra::udma_filter::REG_AU_CFG_R_AU_BYPASS, bar); + let mut baz = udma_filter_csr.zf(utra::udma_filter::REG_AU_CFG_R_AU_BYPASS, bar); + baz |= udma_filter_csr.ms(utra::udma_filter::REG_AU_CFG_R_AU_BYPASS, 1); + udma_filter_csr.wfo(utra::udma_filter::REG_AU_CFG_R_AU_BYPASS, baz); + let bar = udma_filter_csr.rf(utra::udma_filter::REG_AU_CFG_R_AU_MODE); + udma_filter_csr.rmwf(utra::udma_filter::REG_AU_CFG_R_AU_MODE, bar); + let mut baz = udma_filter_csr.zf(utra::udma_filter::REG_AU_CFG_R_AU_MODE, bar); + baz |= udma_filter_csr.ms(utra::udma_filter::REG_AU_CFG_R_AU_MODE, 1); + udma_filter_csr.wfo(utra::udma_filter::REG_AU_CFG_R_AU_MODE, baz); + let bar = udma_filter_csr.rf(utra::udma_filter::REG_AU_CFG_R_AU_SHIFT); + udma_filter_csr.rmwf(utra::udma_filter::REG_AU_CFG_R_AU_SHIFT, bar); + let mut baz = udma_filter_csr.zf(utra::udma_filter::REG_AU_CFG_R_AU_SHIFT, bar); + baz |= udma_filter_csr.ms(utra::udma_filter::REG_AU_CFG_R_AU_SHIFT, 1); + udma_filter_csr.wfo(utra::udma_filter::REG_AU_CFG_R_AU_SHIFT, baz); + + let foo = udma_filter_csr.r(utra::udma_filter::REG_AU_REG0); + udma_filter_csr.wo(utra::udma_filter::REG_AU_REG0, foo); + let bar = udma_filter_csr.rf(utra::udma_filter::REG_AU_REG0_R_COMMIT_AU_REG0); + udma_filter_csr.rmwf(utra::udma_filter::REG_AU_REG0_R_COMMIT_AU_REG0, bar); + let mut baz = udma_filter_csr.zf(utra::udma_filter::REG_AU_REG0_R_COMMIT_AU_REG0, bar); + baz |= udma_filter_csr.ms(utra::udma_filter::REG_AU_REG0_R_COMMIT_AU_REG0, 1); + udma_filter_csr.wfo(utra::udma_filter::REG_AU_REG0_R_COMMIT_AU_REG0, baz); + + let foo = udma_filter_csr.r(utra::udma_filter::REG_AU_REG1); + udma_filter_csr.wo(utra::udma_filter::REG_AU_REG1, foo); + let bar = udma_filter_csr.rf(utra::udma_filter::REG_AU_REG1_R_COMMIT_AU_REG1); + udma_filter_csr.rmwf(utra::udma_filter::REG_AU_REG1_R_COMMIT_AU_REG1, bar); + let mut baz = udma_filter_csr.zf(utra::udma_filter::REG_AU_REG1_R_COMMIT_AU_REG1, bar); + baz |= udma_filter_csr.ms(utra::udma_filter::REG_AU_REG1_R_COMMIT_AU_REG1, 1); + udma_filter_csr.wfo(utra::udma_filter::REG_AU_REG1_R_COMMIT_AU_REG1, baz); + + let foo = udma_filter_csr.r(utra::udma_filter::REG_BINCU_TH); + udma_filter_csr.wo(utra::udma_filter::REG_BINCU_TH, foo); + let bar = udma_filter_csr.rf(utra::udma_filter::REG_BINCU_TH_R_COMMIT_BINCU_THRESHOLD); + udma_filter_csr.rmwf(utra::udma_filter::REG_BINCU_TH_R_COMMIT_BINCU_THRESHOLD, bar); + let mut baz = udma_filter_csr.zf(utra::udma_filter::REG_BINCU_TH_R_COMMIT_BINCU_THRESHOLD, bar); + baz |= udma_filter_csr.ms(utra::udma_filter::REG_BINCU_TH_R_COMMIT_BINCU_THRESHOLD, 1); + udma_filter_csr.wfo(utra::udma_filter::REG_BINCU_TH_R_COMMIT_BINCU_THRESHOLD, baz); + + let foo = udma_filter_csr.r(utra::udma_filter::REG_BINCU_CNT); + udma_filter_csr.wo(utra::udma_filter::REG_BINCU_CNT, foo); + let bar = udma_filter_csr.rf(utra::udma_filter::REG_BINCU_CNT_R_BINCU_COUNTER); + udma_filter_csr.rmwf(utra::udma_filter::REG_BINCU_CNT_R_BINCU_COUNTER, bar); + let mut baz = udma_filter_csr.zf(utra::udma_filter::REG_BINCU_CNT_R_BINCU_COUNTER, bar); + baz |= udma_filter_csr.ms(utra::udma_filter::REG_BINCU_CNT_R_BINCU_COUNTER, 1); + udma_filter_csr.wfo(utra::udma_filter::REG_BINCU_CNT_R_BINCU_COUNTER, baz); + let bar = udma_filter_csr.rf(utra::udma_filter::REG_BINCU_CNT_R_BINCU_EN_COUNTER); + udma_filter_csr.rmwf(utra::udma_filter::REG_BINCU_CNT_R_BINCU_EN_COUNTER, bar); + let mut baz = udma_filter_csr.zf(utra::udma_filter::REG_BINCU_CNT_R_BINCU_EN_COUNTER, bar); + baz |= udma_filter_csr.ms(utra::udma_filter::REG_BINCU_CNT_R_BINCU_EN_COUNTER, 1); + udma_filter_csr.wfo(utra::udma_filter::REG_BINCU_CNT_R_BINCU_EN_COUNTER, baz); + + let foo = udma_filter_csr.r(utra::udma_filter::REG_BINCU_SETUP); + udma_filter_csr.wo(utra::udma_filter::REG_BINCU_SETUP, foo); + let bar = udma_filter_csr.rf(utra::udma_filter::REG_BINCU_SETUP_R_BINCU_DATASIZE); + udma_filter_csr.rmwf(utra::udma_filter::REG_BINCU_SETUP_R_BINCU_DATASIZE, bar); + let mut baz = udma_filter_csr.zf(utra::udma_filter::REG_BINCU_SETUP_R_BINCU_DATASIZE, bar); + baz |= udma_filter_csr.ms(utra::udma_filter::REG_BINCU_SETUP_R_BINCU_DATASIZE, 1); + udma_filter_csr.wfo(utra::udma_filter::REG_BINCU_SETUP_R_BINCU_DATASIZE, baz); + + let foo = udma_filter_csr.r(utra::udma_filter::REG_BINCU_VAL); + udma_filter_csr.wo(utra::udma_filter::REG_BINCU_VAL, foo); + let bar = udma_filter_csr.rf(utra::udma_filter::REG_BINCU_VAL_BINCU_COUNTER_I); + udma_filter_csr.rmwf(utra::udma_filter::REG_BINCU_VAL_BINCU_COUNTER_I, bar); + let mut baz = udma_filter_csr.zf(utra::udma_filter::REG_BINCU_VAL_BINCU_COUNTER_I, bar); + baz |= udma_filter_csr.ms(utra::udma_filter::REG_BINCU_VAL_BINCU_COUNTER_I, 1); + udma_filter_csr.wfo(utra::udma_filter::REG_BINCU_VAL_BINCU_COUNTER_I, baz); + + let foo = udma_filter_csr.r(utra::udma_filter::REG_FILT); + udma_filter_csr.wo(utra::udma_filter::REG_FILT, foo); + let bar = udma_filter_csr.rf(utra::udma_filter::REG_FILT_R_FILTER_MODE); + udma_filter_csr.rmwf(utra::udma_filter::REG_FILT_R_FILTER_MODE, bar); + let mut baz = udma_filter_csr.zf(utra::udma_filter::REG_FILT_R_FILTER_MODE, bar); + baz |= udma_filter_csr.ms(utra::udma_filter::REG_FILT_R_FILTER_MODE, 1); + udma_filter_csr.wfo(utra::udma_filter::REG_FILT_R_FILTER_MODE, baz); + + let foo = udma_filter_csr.r(utra::udma_filter::REG_STATUS); + udma_filter_csr.wo(utra::udma_filter::REG_STATUS, foo); + let bar = udma_filter_csr.rf(utra::udma_filter::REG_STATUS_R_FILTER_DONE); + udma_filter_csr.rmwf(utra::udma_filter::REG_STATUS_R_FILTER_DONE, bar); + let mut baz = udma_filter_csr.zf(utra::udma_filter::REG_STATUS_R_FILTER_DONE, bar); + baz |= udma_filter_csr.ms(utra::udma_filter::REG_STATUS_R_FILTER_DONE, 1); + udma_filter_csr.wfo(utra::udma_filter::REG_STATUS_R_FILTER_DONE, baz); + } + + #[test] + #[ignore] + fn compile_check_udma_scif_csr() { + use super::*; + let mut udma_scif_csr = CSR::new(HW_UDMA_SCIF_BASE as *mut u32); + + let foo = udma_scif_csr.r(utra::udma_scif::REG_RX_SADDR); + udma_scif_csr.wo(utra::udma_scif::REG_RX_SADDR, foo); + let bar = udma_scif_csr.rf(utra::udma_scif::REG_RX_SADDR_R_RX_STARTADDR); + udma_scif_csr.rmwf(utra::udma_scif::REG_RX_SADDR_R_RX_STARTADDR, bar); + let mut baz = udma_scif_csr.zf(utra::udma_scif::REG_RX_SADDR_R_RX_STARTADDR, bar); + baz |= udma_scif_csr.ms(utra::udma_scif::REG_RX_SADDR_R_RX_STARTADDR, 1); + udma_scif_csr.wfo(utra::udma_scif::REG_RX_SADDR_R_RX_STARTADDR, baz); + + let foo = udma_scif_csr.r(utra::udma_scif::REG_RX_SIZE); + udma_scif_csr.wo(utra::udma_scif::REG_RX_SIZE, foo); + let bar = udma_scif_csr.rf(utra::udma_scif::REG_RX_SIZE_R_RX_SIZE); + udma_scif_csr.rmwf(utra::udma_scif::REG_RX_SIZE_R_RX_SIZE, bar); + let mut baz = udma_scif_csr.zf(utra::udma_scif::REG_RX_SIZE_R_RX_SIZE, bar); + baz |= udma_scif_csr.ms(utra::udma_scif::REG_RX_SIZE_R_RX_SIZE, 1); + udma_scif_csr.wfo(utra::udma_scif::REG_RX_SIZE_R_RX_SIZE, baz); + + let foo = udma_scif_csr.r(utra::udma_scif::REG_RX_CFG); + udma_scif_csr.wo(utra::udma_scif::REG_RX_CFG, foo); + let bar = udma_scif_csr.rf(utra::udma_scif::REG_RX_CFG_R_RX_CONTINUOUS); + udma_scif_csr.rmwf(utra::udma_scif::REG_RX_CFG_R_RX_CONTINUOUS, bar); + 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 foo = udma_scif_csr.r(utra::udma_scif::REG_TX_SADDR); + udma_scif_csr.wo(utra::udma_scif::REG_TX_SADDR, foo); + let bar = udma_scif_csr.rf(utra::udma_scif::REG_TX_SADDR_R_TX_STARTADDR); + udma_scif_csr.rmwf(utra::udma_scif::REG_TX_SADDR_R_TX_STARTADDR, bar); + let mut baz = udma_scif_csr.zf(utra::udma_scif::REG_TX_SADDR_R_TX_STARTADDR, bar); + baz |= udma_scif_csr.ms(utra::udma_scif::REG_TX_SADDR_R_TX_STARTADDR, 1); + udma_scif_csr.wfo(utra::udma_scif::REG_TX_SADDR_R_TX_STARTADDR, baz); + + let foo = udma_scif_csr.r(utra::udma_scif::REG_TX_SIZE); + udma_scif_csr.wo(utra::udma_scif::REG_TX_SIZE, foo); + let bar = udma_scif_csr.rf(utra::udma_scif::REG_TX_SIZE_R_TX_SIZE); + udma_scif_csr.rmwf(utra::udma_scif::REG_TX_SIZE_R_TX_SIZE, bar); + let mut baz = udma_scif_csr.zf(utra::udma_scif::REG_TX_SIZE_R_TX_SIZE, bar); + baz |= udma_scif_csr.ms(utra::udma_scif::REG_TX_SIZE_R_TX_SIZE, 1); + udma_scif_csr.wfo(utra::udma_scif::REG_TX_SIZE_R_TX_SIZE, baz); + + let foo = udma_scif_csr.r(utra::udma_scif::REG_TX_CFG); + udma_scif_csr.wo(utra::udma_scif::REG_TX_CFG, foo); + let bar = udma_scif_csr.rf(utra::udma_scif::REG_TX_CFG_R_TX_CONTINUOUS); + udma_scif_csr.rmwf(utra::udma_scif::REG_TX_CFG_R_TX_CONTINUOUS, bar); + 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 foo = udma_scif_csr.r(utra::udma_scif::REG_STATUS); + udma_scif_csr.wo(utra::udma_scif::REG_STATUS, foo); + let bar = udma_scif_csr.rf(utra::udma_scif::REG_STATUS_STATUS_I); + udma_scif_csr.rmwf(utra::udma_scif::REG_STATUS_STATUS_I, bar); + let mut baz = udma_scif_csr.zf(utra::udma_scif::REG_STATUS_STATUS_I, bar); + baz |= udma_scif_csr.ms(utra::udma_scif::REG_STATUS_STATUS_I, 1); + udma_scif_csr.wfo(utra::udma_scif::REG_STATUS_STATUS_I, baz); + + let foo = udma_scif_csr.r(utra::udma_scif::REG_SCIF_SETUP); + udma_scif_csr.wo(utra::udma_scif::REG_SCIF_SETUP, foo); + let bar = udma_scif_csr.rf(utra::udma_scif::REG_SCIF_SETUP_R_SCIF_PARITY_EN); + udma_scif_csr.rmwf(utra::udma_scif::REG_SCIF_SETUP_R_SCIF_PARITY_EN, bar); + let mut baz = udma_scif_csr.zf(utra::udma_scif::REG_SCIF_SETUP_R_SCIF_PARITY_EN, bar); + baz |= udma_scif_csr.ms(utra::udma_scif::REG_SCIF_SETUP_R_SCIF_PARITY_EN, 1); + udma_scif_csr.wfo(utra::udma_scif::REG_SCIF_SETUP_R_SCIF_PARITY_EN, baz); + let bar = udma_scif_csr.rf(utra::udma_scif::REG_SCIF_SETUP_R_SCIF_BITS); + udma_scif_csr.rmwf(utra::udma_scif::REG_SCIF_SETUP_R_SCIF_BITS, bar); + let mut baz = udma_scif_csr.zf(utra::udma_scif::REG_SCIF_SETUP_R_SCIF_BITS, bar); + baz |= udma_scif_csr.ms(utra::udma_scif::REG_SCIF_SETUP_R_SCIF_BITS, 1); + udma_scif_csr.wfo(utra::udma_scif::REG_SCIF_SETUP_R_SCIF_BITS, baz); + let bar = udma_scif_csr.rf(utra::udma_scif::REG_SCIF_SETUP_R_SCIF_STOP_BITS); + udma_scif_csr.rmwf(utra::udma_scif::REG_SCIF_SETUP_R_SCIF_STOP_BITS, bar); + let mut baz = udma_scif_csr.zf(utra::udma_scif::REG_SCIF_SETUP_R_SCIF_STOP_BITS, bar); + baz |= udma_scif_csr.ms(utra::udma_scif::REG_SCIF_SETUP_R_SCIF_STOP_BITS, 1); + udma_scif_csr.wfo(utra::udma_scif::REG_SCIF_SETUP_R_SCIF_STOP_BITS, baz); + let bar = udma_scif_csr.rf(utra::udma_scif::REG_SCIF_SETUP_R_SCIF_RX_POLLING_EN); + udma_scif_csr.rmwf(utra::udma_scif::REG_SCIF_SETUP_R_SCIF_RX_POLLING_EN, bar); + let mut baz = udma_scif_csr.zf(utra::udma_scif::REG_SCIF_SETUP_R_SCIF_RX_POLLING_EN, bar); + baz |= udma_scif_csr.ms(utra::udma_scif::REG_SCIF_SETUP_R_SCIF_RX_POLLING_EN, 1); + udma_scif_csr.wfo(utra::udma_scif::REG_SCIF_SETUP_R_SCIF_RX_POLLING_EN, baz); + let bar = udma_scif_csr.rf(utra::udma_scif::REG_SCIF_SETUP_R_SCIF_RX_CLEAN_FIFO); + udma_scif_csr.rmwf(utra::udma_scif::REG_SCIF_SETUP_R_SCIF_RX_CLEAN_FIFO, bar); + let mut baz = udma_scif_csr.zf(utra::udma_scif::REG_SCIF_SETUP_R_SCIF_RX_CLEAN_FIFO, bar); + baz |= udma_scif_csr.ms(utra::udma_scif::REG_SCIF_SETUP_R_SCIF_RX_CLEAN_FIFO, 1); + udma_scif_csr.wfo(utra::udma_scif::REG_SCIF_SETUP_R_SCIF_RX_CLEAN_FIFO, baz); + let bar = udma_scif_csr.rf(utra::udma_scif::REG_SCIF_SETUP_R_SCIF_EN_TX); + udma_scif_csr.rmwf(utra::udma_scif::REG_SCIF_SETUP_R_SCIF_EN_TX, bar); + let mut baz = udma_scif_csr.zf(utra::udma_scif::REG_SCIF_SETUP_R_SCIF_EN_TX, bar); + baz |= udma_scif_csr.ms(utra::udma_scif::REG_SCIF_SETUP_R_SCIF_EN_TX, 1); + udma_scif_csr.wfo(utra::udma_scif::REG_SCIF_SETUP_R_SCIF_EN_TX, baz); + let bar = udma_scif_csr.rf(utra::udma_scif::REG_SCIF_SETUP_R_SCIF_EN_RX); + udma_scif_csr.rmwf(utra::udma_scif::REG_SCIF_SETUP_R_SCIF_EN_RX, bar); + let mut baz = udma_scif_csr.zf(utra::udma_scif::REG_SCIF_SETUP_R_SCIF_EN_RX, bar); + baz |= udma_scif_csr.ms(utra::udma_scif::REG_SCIF_SETUP_R_SCIF_EN_RX, 1); + udma_scif_csr.wfo(utra::udma_scif::REG_SCIF_SETUP_R_SCIF_EN_RX, baz); + let bar = udma_scif_csr.rf(utra::udma_scif::REG_SCIF_SETUP_R_SCIF_CLKSEL); + udma_scif_csr.rmwf(utra::udma_scif::REG_SCIF_SETUP_R_SCIF_CLKSEL, bar); + let mut baz = udma_scif_csr.zf(utra::udma_scif::REG_SCIF_SETUP_R_SCIF_CLKSEL, bar); + baz |= udma_scif_csr.ms(utra::udma_scif::REG_SCIF_SETUP_R_SCIF_CLKSEL, 1); + udma_scif_csr.wfo(utra::udma_scif::REG_SCIF_SETUP_R_SCIF_CLKSEL, baz); + let bar = udma_scif_csr.rf(utra::udma_scif::REG_SCIF_SETUP_R_SCIF_DIV); + udma_scif_csr.rmwf(utra::udma_scif::REG_SCIF_SETUP_R_SCIF_DIV, bar); + let mut baz = udma_scif_csr.zf(utra::udma_scif::REG_SCIF_SETUP_R_SCIF_DIV, bar); + baz |= udma_scif_csr.ms(utra::udma_scif::REG_SCIF_SETUP_R_SCIF_DIV, 1); + udma_scif_csr.wfo(utra::udma_scif::REG_SCIF_SETUP_R_SCIF_DIV, baz); + + let foo = udma_scif_csr.r(utra::udma_scif::REG_ERROR); + udma_scif_csr.wo(utra::udma_scif::REG_ERROR, foo); + let bar = udma_scif_csr.rf(utra::udma_scif::REG_ERROR_R_ERR_OVERFLOW); + udma_scif_csr.rmwf(utra::udma_scif::REG_ERROR_R_ERR_OVERFLOW, bar); + let mut baz = udma_scif_csr.zf(utra::udma_scif::REG_ERROR_R_ERR_OVERFLOW, bar); + baz |= udma_scif_csr.ms(utra::udma_scif::REG_ERROR_R_ERR_OVERFLOW, 1); + udma_scif_csr.wfo(utra::udma_scif::REG_ERROR_R_ERR_OVERFLOW, baz); + let bar = udma_scif_csr.rf(utra::udma_scif::REG_ERROR_R_ERR_PARITY); + udma_scif_csr.rmwf(utra::udma_scif::REG_ERROR_R_ERR_PARITY, bar); + let mut baz = udma_scif_csr.zf(utra::udma_scif::REG_ERROR_R_ERR_PARITY, bar); + baz |= udma_scif_csr.ms(utra::udma_scif::REG_ERROR_R_ERR_PARITY, 1); + udma_scif_csr.wfo(utra::udma_scif::REG_ERROR_R_ERR_PARITY, baz); + + let foo = udma_scif_csr.r(utra::udma_scif::REG_IRQ_EN); + udma_scif_csr.wo(utra::udma_scif::REG_IRQ_EN, foo); + let bar = udma_scif_csr.rf(utra::udma_scif::REG_IRQ_EN_R_SCIF_RX_IRQ_EN); + udma_scif_csr.rmwf(utra::udma_scif::REG_IRQ_EN_R_SCIF_RX_IRQ_EN, bar); + let mut baz = udma_scif_csr.zf(utra::udma_scif::REG_IRQ_EN_R_SCIF_RX_IRQ_EN, bar); + baz |= udma_scif_csr.ms(utra::udma_scif::REG_IRQ_EN_R_SCIF_RX_IRQ_EN, 1); + udma_scif_csr.wfo(utra::udma_scif::REG_IRQ_EN_R_SCIF_RX_IRQ_EN, baz); + let bar = udma_scif_csr.rf(utra::udma_scif::REG_IRQ_EN_R_SCIF_ERR_IRQ_EN); + udma_scif_csr.rmwf(utra::udma_scif::REG_IRQ_EN_R_SCIF_ERR_IRQ_EN, bar); + let mut baz = udma_scif_csr.zf(utra::udma_scif::REG_IRQ_EN_R_SCIF_ERR_IRQ_EN, bar); + baz |= udma_scif_csr.ms(utra::udma_scif::REG_IRQ_EN_R_SCIF_ERR_IRQ_EN, 1); + udma_scif_csr.wfo(utra::udma_scif::REG_IRQ_EN_R_SCIF_ERR_IRQ_EN, baz); + + let foo = udma_scif_csr.r(utra::udma_scif::REG_VALID); + udma_scif_csr.wo(utra::udma_scif::REG_VALID, foo); + let bar = udma_scif_csr.rf(utra::udma_scif::REG_VALID_R_SCIF_RX_DATA_VALID); + udma_scif_csr.rmwf(utra::udma_scif::REG_VALID_R_SCIF_RX_DATA_VALID, bar); + let mut baz = udma_scif_csr.zf(utra::udma_scif::REG_VALID_R_SCIF_RX_DATA_VALID, bar); + baz |= udma_scif_csr.ms(utra::udma_scif::REG_VALID_R_SCIF_RX_DATA_VALID, 1); + udma_scif_csr.wfo(utra::udma_scif::REG_VALID_R_SCIF_RX_DATA_VALID, baz); + + let foo = udma_scif_csr.r(utra::udma_scif::REG_DATA); + udma_scif_csr.wo(utra::udma_scif::REG_DATA, foo); + let bar = udma_scif_csr.rf(utra::udma_scif::REG_DATA_R_SCIF_RX_DATA); + udma_scif_csr.rmwf(utra::udma_scif::REG_DATA_R_SCIF_RX_DATA, bar); + let mut baz = udma_scif_csr.zf(utra::udma_scif::REG_DATA_R_SCIF_RX_DATA, bar); + baz |= udma_scif_csr.ms(utra::udma_scif::REG_DATA_R_SCIF_RX_DATA, 1); + udma_scif_csr.wfo(utra::udma_scif::REG_DATA_R_SCIF_RX_DATA, baz); + + let foo = udma_scif_csr.r(utra::udma_scif::REG_SCIF_ETU); + udma_scif_csr.wo(utra::udma_scif::REG_SCIF_ETU, foo); + let bar = udma_scif_csr.rf(utra::udma_scif::REG_SCIF_ETU_R_SCIF_ETU); + udma_scif_csr.rmwf(utra::udma_scif::REG_SCIF_ETU_R_SCIF_ETU, bar); + let mut baz = udma_scif_csr.zf(utra::udma_scif::REG_SCIF_ETU_R_SCIF_ETU, bar); + baz |= udma_scif_csr.ms(utra::udma_scif::REG_SCIF_ETU_R_SCIF_ETU, 1); + udma_scif_csr.wfo(utra::udma_scif::REG_SCIF_ETU_R_SCIF_ETU, baz); + } + + #[test] + #[ignore] + fn compile_check_udma_spis_0_csr() { + use super::*; + let mut udma_spis_0_csr = CSR::new(HW_UDMA_SPIS_0_BASE as *mut u32); + + let foo = udma_spis_0_csr.r(utra::udma_spis_0::REG_RX_SADDR); + udma_spis_0_csr.wo(utra::udma_spis_0::REG_RX_SADDR, foo); + let bar = udma_spis_0_csr.rf(utra::udma_spis_0::REG_RX_SADDR_R_RX_STARTADDR); + udma_spis_0_csr.rmwf(utra::udma_spis_0::REG_RX_SADDR_R_RX_STARTADDR, bar); + let mut baz = udma_spis_0_csr.zf(utra::udma_spis_0::REG_RX_SADDR_R_RX_STARTADDR, bar); + baz |= udma_spis_0_csr.ms(utra::udma_spis_0::REG_RX_SADDR_R_RX_STARTADDR, 1); + udma_spis_0_csr.wfo(utra::udma_spis_0::REG_RX_SADDR_R_RX_STARTADDR, baz); + + let foo = udma_spis_0_csr.r(utra::udma_spis_0::REG_RX_SIZE); + udma_spis_0_csr.wo(utra::udma_spis_0::REG_RX_SIZE, foo); + let bar = udma_spis_0_csr.rf(utra::udma_spis_0::REG_RX_SIZE_R_RX_SIZE); + udma_spis_0_csr.rmwf(utra::udma_spis_0::REG_RX_SIZE_R_RX_SIZE, bar); + let mut baz = udma_spis_0_csr.zf(utra::udma_spis_0::REG_RX_SIZE_R_RX_SIZE, bar); + baz |= udma_spis_0_csr.ms(utra::udma_spis_0::REG_RX_SIZE_R_RX_SIZE, 1); + udma_spis_0_csr.wfo(utra::udma_spis_0::REG_RX_SIZE_R_RX_SIZE, baz); + + let foo = udma_spis_0_csr.r(utra::udma_spis_0::REG_RX_CFG); + udma_spis_0_csr.wo(utra::udma_spis_0::REG_RX_CFG, foo); + let bar = udma_spis_0_csr.rf(utra::udma_spis_0::REG_RX_CFG_R_RX_CONTINUOUS); + udma_spis_0_csr.rmwf(utra::udma_spis_0::REG_RX_CFG_R_RX_CONTINUOUS, bar); + let mut baz = udma_spis_0_csr.zf(utra::udma_spis_0::REG_RX_CFG_R_RX_CONTINUOUS, bar); + baz |= udma_spis_0_csr.ms(utra::udma_spis_0::REG_RX_CFG_R_RX_CONTINUOUS, 1); + udma_spis_0_csr.wfo(utra::udma_spis_0::REG_RX_CFG_R_RX_CONTINUOUS, baz); + let bar = udma_spis_0_csr.rf(utra::udma_spis_0::REG_RX_CFG_R_RX_EN); + udma_spis_0_csr.rmwf(utra::udma_spis_0::REG_RX_CFG_R_RX_EN, bar); + let mut baz = udma_spis_0_csr.zf(utra::udma_spis_0::REG_RX_CFG_R_RX_EN, bar); + baz |= udma_spis_0_csr.ms(utra::udma_spis_0::REG_RX_CFG_R_RX_EN, 1); + udma_spis_0_csr.wfo(utra::udma_spis_0::REG_RX_CFG_R_RX_EN, baz); + let bar = udma_spis_0_csr.rf(utra::udma_spis_0::REG_RX_CFG_R_RX_CLR); + udma_spis_0_csr.rmwf(utra::udma_spis_0::REG_RX_CFG_R_RX_CLR, bar); + let mut baz = udma_spis_0_csr.zf(utra::udma_spis_0::REG_RX_CFG_R_RX_CLR, bar); + baz |= udma_spis_0_csr.ms(utra::udma_spis_0::REG_RX_CFG_R_RX_CLR, 1); + udma_spis_0_csr.wfo(utra::udma_spis_0::REG_RX_CFG_R_RX_CLR, baz); + + let foo = udma_spis_0_csr.r(utra::udma_spis_0::REG_TX_SADDR); + udma_spis_0_csr.wo(utra::udma_spis_0::REG_TX_SADDR, foo); + let bar = udma_spis_0_csr.rf(utra::udma_spis_0::REG_TX_SADDR_R_TX_STARTADDR); + udma_spis_0_csr.rmwf(utra::udma_spis_0::REG_TX_SADDR_R_TX_STARTADDR, bar); + let mut baz = udma_spis_0_csr.zf(utra::udma_spis_0::REG_TX_SADDR_R_TX_STARTADDR, bar); + baz |= udma_spis_0_csr.ms(utra::udma_spis_0::REG_TX_SADDR_R_TX_STARTADDR, 1); + udma_spis_0_csr.wfo(utra::udma_spis_0::REG_TX_SADDR_R_TX_STARTADDR, baz); + + let foo = udma_spis_0_csr.r(utra::udma_spis_0::REG_TX_SIZE); + udma_spis_0_csr.wo(utra::udma_spis_0::REG_TX_SIZE, foo); + let bar = udma_spis_0_csr.rf(utra::udma_spis_0::REG_TX_SIZE_R_TX_SIZE); + udma_spis_0_csr.rmwf(utra::udma_spis_0::REG_TX_SIZE_R_TX_SIZE, bar); + let mut baz = udma_spis_0_csr.zf(utra::udma_spis_0::REG_TX_SIZE_R_TX_SIZE, bar); + baz |= udma_spis_0_csr.ms(utra::udma_spis_0::REG_TX_SIZE_R_TX_SIZE, 1); + udma_spis_0_csr.wfo(utra::udma_spis_0::REG_TX_SIZE_R_TX_SIZE, baz); + + let foo = udma_spis_0_csr.r(utra::udma_spis_0::REG_TX_CFG); + udma_spis_0_csr.wo(utra::udma_spis_0::REG_TX_CFG, foo); + let bar = udma_spis_0_csr.rf(utra::udma_spis_0::REG_TX_CFG_R_TX_CONTINUOUS); + udma_spis_0_csr.rmwf(utra::udma_spis_0::REG_TX_CFG_R_TX_CONTINUOUS, bar); + let mut baz = udma_spis_0_csr.zf(utra::udma_spis_0::REG_TX_CFG_R_TX_CONTINUOUS, bar); + baz |= udma_spis_0_csr.ms(utra::udma_spis_0::REG_TX_CFG_R_TX_CONTINUOUS, 1); + udma_spis_0_csr.wfo(utra::udma_spis_0::REG_TX_CFG_R_TX_CONTINUOUS, baz); + let bar = udma_spis_0_csr.rf(utra::udma_spis_0::REG_TX_CFG_R_TX_EN); + udma_spis_0_csr.rmwf(utra::udma_spis_0::REG_TX_CFG_R_TX_EN, bar); + let mut baz = udma_spis_0_csr.zf(utra::udma_spis_0::REG_TX_CFG_R_TX_EN, bar); + baz |= udma_spis_0_csr.ms(utra::udma_spis_0::REG_TX_CFG_R_TX_EN, 1); + udma_spis_0_csr.wfo(utra::udma_spis_0::REG_TX_CFG_R_TX_EN, baz); + let bar = udma_spis_0_csr.rf(utra::udma_spis_0::REG_TX_CFG_R_TX_CLR); + udma_spis_0_csr.rmwf(utra::udma_spis_0::REG_TX_CFG_R_TX_CLR, bar); + let mut baz = udma_spis_0_csr.zf(utra::udma_spis_0::REG_TX_CFG_R_TX_CLR, bar); + baz |= udma_spis_0_csr.ms(utra::udma_spis_0::REG_TX_CFG_R_TX_CLR, 1); + udma_spis_0_csr.wfo(utra::udma_spis_0::REG_TX_CFG_R_TX_CLR, baz); + + let foo = udma_spis_0_csr.r(utra::udma_spis_0::REG_SPIS_SETUP); + udma_spis_0_csr.wo(utra::udma_spis_0::REG_SPIS_SETUP, foo); + let bar = udma_spis_0_csr.rf(utra::udma_spis_0::REG_SPIS_SETUP_CFGCPOL); + udma_spis_0_csr.rmwf(utra::udma_spis_0::REG_SPIS_SETUP_CFGCPOL, bar); + let mut baz = udma_spis_0_csr.zf(utra::udma_spis_0::REG_SPIS_SETUP_CFGCPOL, bar); + baz |= udma_spis_0_csr.ms(utra::udma_spis_0::REG_SPIS_SETUP_CFGCPOL, 1); + udma_spis_0_csr.wfo(utra::udma_spis_0::REG_SPIS_SETUP_CFGCPOL, baz); + let bar = udma_spis_0_csr.rf(utra::udma_spis_0::REG_SPIS_SETUP_CFGCPHA); + udma_spis_0_csr.rmwf(utra::udma_spis_0::REG_SPIS_SETUP_CFGCPHA, bar); + let mut baz = udma_spis_0_csr.zf(utra::udma_spis_0::REG_SPIS_SETUP_CFGCPHA, bar); + baz |= udma_spis_0_csr.ms(utra::udma_spis_0::REG_SPIS_SETUP_CFGCPHA, 1); + udma_spis_0_csr.wfo(utra::udma_spis_0::REG_SPIS_SETUP_CFGCPHA, baz); + + let foo = udma_spis_0_csr.r(utra::udma_spis_0::REG_SEOT_CNT); + udma_spis_0_csr.wo(utra::udma_spis_0::REG_SEOT_CNT, foo); + let bar = udma_spis_0_csr.rf(utra::udma_spis_0::REG_SEOT_CNT_SR_SEOT_CNT); + udma_spis_0_csr.rmwf(utra::udma_spis_0::REG_SEOT_CNT_SR_SEOT_CNT, bar); + let mut baz = udma_spis_0_csr.zf(utra::udma_spis_0::REG_SEOT_CNT_SR_SEOT_CNT, bar); + baz |= udma_spis_0_csr.ms(utra::udma_spis_0::REG_SEOT_CNT_SR_SEOT_CNT, 1); + udma_spis_0_csr.wfo(utra::udma_spis_0::REG_SEOT_CNT_SR_SEOT_CNT, baz); + + let foo = udma_spis_0_csr.r(utra::udma_spis_0::REG_SPIS_IRQ_EN); + udma_spis_0_csr.wo(utra::udma_spis_0::REG_SPIS_IRQ_EN, foo); + let bar = udma_spis_0_csr.rf(utra::udma_spis_0::REG_SPIS_IRQ_EN_SEOT_IRQ_EN); + udma_spis_0_csr.rmwf(utra::udma_spis_0::REG_SPIS_IRQ_EN_SEOT_IRQ_EN, bar); + let mut baz = udma_spis_0_csr.zf(utra::udma_spis_0::REG_SPIS_IRQ_EN_SEOT_IRQ_EN, bar); + baz |= udma_spis_0_csr.ms(utra::udma_spis_0::REG_SPIS_IRQ_EN_SEOT_IRQ_EN, 1); + udma_spis_0_csr.wfo(utra::udma_spis_0::REG_SPIS_IRQ_EN_SEOT_IRQ_EN, baz); + + let foo = udma_spis_0_csr.r(utra::udma_spis_0::REG_SPIS_RXCNT); + udma_spis_0_csr.wo(utra::udma_spis_0::REG_SPIS_RXCNT, foo); + let bar = udma_spis_0_csr.rf(utra::udma_spis_0::REG_SPIS_RXCNT_CFGRXCNT); + udma_spis_0_csr.rmwf(utra::udma_spis_0::REG_SPIS_RXCNT_CFGRXCNT, bar); + let mut baz = udma_spis_0_csr.zf(utra::udma_spis_0::REG_SPIS_RXCNT_CFGRXCNT, bar); + baz |= udma_spis_0_csr.ms(utra::udma_spis_0::REG_SPIS_RXCNT_CFGRXCNT, 1); + udma_spis_0_csr.wfo(utra::udma_spis_0::REG_SPIS_RXCNT_CFGRXCNT, baz); + + let foo = udma_spis_0_csr.r(utra::udma_spis_0::REG_SPIS_TXCNT); + udma_spis_0_csr.wo(utra::udma_spis_0::REG_SPIS_TXCNT, foo); + let bar = udma_spis_0_csr.rf(utra::udma_spis_0::REG_SPIS_TXCNT_CFGTXCNT); + udma_spis_0_csr.rmwf(utra::udma_spis_0::REG_SPIS_TXCNT_CFGTXCNT, bar); + let mut baz = udma_spis_0_csr.zf(utra::udma_spis_0::REG_SPIS_TXCNT_CFGTXCNT, bar); + baz |= udma_spis_0_csr.ms(utra::udma_spis_0::REG_SPIS_TXCNT_CFGTXCNT, 1); + udma_spis_0_csr.wfo(utra::udma_spis_0::REG_SPIS_TXCNT_CFGTXCNT, baz); + + let foo = udma_spis_0_csr.r(utra::udma_spis_0::REG_SPIS_DMCNT); + udma_spis_0_csr.wo(utra::udma_spis_0::REG_SPIS_DMCNT, foo); + let bar = udma_spis_0_csr.rf(utra::udma_spis_0::REG_SPIS_DMCNT_CFGDMCNT); + udma_spis_0_csr.rmwf(utra::udma_spis_0::REG_SPIS_DMCNT_CFGDMCNT, bar); + let mut baz = udma_spis_0_csr.zf(utra::udma_spis_0::REG_SPIS_DMCNT_CFGDMCNT, bar); + baz |= udma_spis_0_csr.ms(utra::udma_spis_0::REG_SPIS_DMCNT_CFGDMCNT, 1); + udma_spis_0_csr.wfo(utra::udma_spis_0::REG_SPIS_DMCNT_CFGDMCNT, baz); + } + + #[test] + #[ignore] + fn compile_check_udma_spis_1_csr() { + use super::*; + let mut udma_spis_1_csr = CSR::new(HW_UDMA_SPIS_1_BASE as *mut u32); + + let foo = udma_spis_1_csr.r(utra::udma_spis_1::REG_RX_SADDR); + udma_spis_1_csr.wo(utra::udma_spis_1::REG_RX_SADDR, foo); + let bar = udma_spis_1_csr.rf(utra::udma_spis_1::REG_RX_SADDR_R_RX_STARTADDR); + udma_spis_1_csr.rmwf(utra::udma_spis_1::REG_RX_SADDR_R_RX_STARTADDR, bar); + let mut baz = udma_spis_1_csr.zf(utra::udma_spis_1::REG_RX_SADDR_R_RX_STARTADDR, bar); + baz |= udma_spis_1_csr.ms(utra::udma_spis_1::REG_RX_SADDR_R_RX_STARTADDR, 1); + udma_spis_1_csr.wfo(utra::udma_spis_1::REG_RX_SADDR_R_RX_STARTADDR, baz); + + let foo = udma_spis_1_csr.r(utra::udma_spis_1::REG_RX_SIZE); + udma_spis_1_csr.wo(utra::udma_spis_1::REG_RX_SIZE, foo); + let bar = udma_spis_1_csr.rf(utra::udma_spis_1::REG_RX_SIZE_R_RX_SIZE); + udma_spis_1_csr.rmwf(utra::udma_spis_1::REG_RX_SIZE_R_RX_SIZE, bar); + let mut baz = udma_spis_1_csr.zf(utra::udma_spis_1::REG_RX_SIZE_R_RX_SIZE, bar); + baz |= udma_spis_1_csr.ms(utra::udma_spis_1::REG_RX_SIZE_R_RX_SIZE, 1); + udma_spis_1_csr.wfo(utra::udma_spis_1::REG_RX_SIZE_R_RX_SIZE, baz); + + let foo = udma_spis_1_csr.r(utra::udma_spis_1::REG_RX_CFG); + udma_spis_1_csr.wo(utra::udma_spis_1::REG_RX_CFG, foo); + let bar = udma_spis_1_csr.rf(utra::udma_spis_1::REG_RX_CFG_R_RX_CONTINUOUS); + udma_spis_1_csr.rmwf(utra::udma_spis_1::REG_RX_CFG_R_RX_CONTINUOUS, bar); + let mut baz = udma_spis_1_csr.zf(utra::udma_spis_1::REG_RX_CFG_R_RX_CONTINUOUS, bar); + baz |= udma_spis_1_csr.ms(utra::udma_spis_1::REG_RX_CFG_R_RX_CONTINUOUS, 1); + udma_spis_1_csr.wfo(utra::udma_spis_1::REG_RX_CFG_R_RX_CONTINUOUS, baz); + let bar = udma_spis_1_csr.rf(utra::udma_spis_1::REG_RX_CFG_R_RX_EN); + udma_spis_1_csr.rmwf(utra::udma_spis_1::REG_RX_CFG_R_RX_EN, bar); + let mut baz = udma_spis_1_csr.zf(utra::udma_spis_1::REG_RX_CFG_R_RX_EN, bar); + baz |= udma_spis_1_csr.ms(utra::udma_spis_1::REG_RX_CFG_R_RX_EN, 1); + udma_spis_1_csr.wfo(utra::udma_spis_1::REG_RX_CFG_R_RX_EN, baz); + let bar = udma_spis_1_csr.rf(utra::udma_spis_1::REG_RX_CFG_R_RX_CLR); + udma_spis_1_csr.rmwf(utra::udma_spis_1::REG_RX_CFG_R_RX_CLR, bar); + let mut baz = udma_spis_1_csr.zf(utra::udma_spis_1::REG_RX_CFG_R_RX_CLR, bar); + baz |= udma_spis_1_csr.ms(utra::udma_spis_1::REG_RX_CFG_R_RX_CLR, 1); + udma_spis_1_csr.wfo(utra::udma_spis_1::REG_RX_CFG_R_RX_CLR, baz); + + let foo = udma_spis_1_csr.r(utra::udma_spis_1::REG_TX_SADDR); + udma_spis_1_csr.wo(utra::udma_spis_1::REG_TX_SADDR, foo); + let bar = udma_spis_1_csr.rf(utra::udma_spis_1::REG_TX_SADDR_R_TX_STARTADDR); + udma_spis_1_csr.rmwf(utra::udma_spis_1::REG_TX_SADDR_R_TX_STARTADDR, bar); + let mut baz = udma_spis_1_csr.zf(utra::udma_spis_1::REG_TX_SADDR_R_TX_STARTADDR, bar); + baz |= udma_spis_1_csr.ms(utra::udma_spis_1::REG_TX_SADDR_R_TX_STARTADDR, 1); + udma_spis_1_csr.wfo(utra::udma_spis_1::REG_TX_SADDR_R_TX_STARTADDR, baz); + + let foo = udma_spis_1_csr.r(utra::udma_spis_1::REG_TX_SIZE); + udma_spis_1_csr.wo(utra::udma_spis_1::REG_TX_SIZE, foo); + let bar = udma_spis_1_csr.rf(utra::udma_spis_1::REG_TX_SIZE_R_TX_SIZE); + udma_spis_1_csr.rmwf(utra::udma_spis_1::REG_TX_SIZE_R_TX_SIZE, bar); + let mut baz = udma_spis_1_csr.zf(utra::udma_spis_1::REG_TX_SIZE_R_TX_SIZE, bar); + baz |= udma_spis_1_csr.ms(utra::udma_spis_1::REG_TX_SIZE_R_TX_SIZE, 1); + udma_spis_1_csr.wfo(utra::udma_spis_1::REG_TX_SIZE_R_TX_SIZE, baz); + + let foo = udma_spis_1_csr.r(utra::udma_spis_1::REG_TX_CFG); + udma_spis_1_csr.wo(utra::udma_spis_1::REG_TX_CFG, foo); + let bar = udma_spis_1_csr.rf(utra::udma_spis_1::REG_TX_CFG_R_TX_CONTINUOUS); + udma_spis_1_csr.rmwf(utra::udma_spis_1::REG_TX_CFG_R_TX_CONTINUOUS, bar); + let mut baz = udma_spis_1_csr.zf(utra::udma_spis_1::REG_TX_CFG_R_TX_CONTINUOUS, bar); + baz |= udma_spis_1_csr.ms(utra::udma_spis_1::REG_TX_CFG_R_TX_CONTINUOUS, 1); + udma_spis_1_csr.wfo(utra::udma_spis_1::REG_TX_CFG_R_TX_CONTINUOUS, baz); + let bar = udma_spis_1_csr.rf(utra::udma_spis_1::REG_TX_CFG_R_TX_EN); + udma_spis_1_csr.rmwf(utra::udma_spis_1::REG_TX_CFG_R_TX_EN, bar); + let mut baz = udma_spis_1_csr.zf(utra::udma_spis_1::REG_TX_CFG_R_TX_EN, bar); + baz |= udma_spis_1_csr.ms(utra::udma_spis_1::REG_TX_CFG_R_TX_EN, 1); + udma_spis_1_csr.wfo(utra::udma_spis_1::REG_TX_CFG_R_TX_EN, baz); + let bar = udma_spis_1_csr.rf(utra::udma_spis_1::REG_TX_CFG_R_TX_CLR); + udma_spis_1_csr.rmwf(utra::udma_spis_1::REG_TX_CFG_R_TX_CLR, bar); + let mut baz = udma_spis_1_csr.zf(utra::udma_spis_1::REG_TX_CFG_R_TX_CLR, bar); + baz |= udma_spis_1_csr.ms(utra::udma_spis_1::REG_TX_CFG_R_TX_CLR, 1); + udma_spis_1_csr.wfo(utra::udma_spis_1::REG_TX_CFG_R_TX_CLR, baz); + + let foo = udma_spis_1_csr.r(utra::udma_spis_1::REG_SPIS_SETUP); + udma_spis_1_csr.wo(utra::udma_spis_1::REG_SPIS_SETUP, foo); + let bar = udma_spis_1_csr.rf(utra::udma_spis_1::REG_SPIS_SETUP_CFGCPOL); + udma_spis_1_csr.rmwf(utra::udma_spis_1::REG_SPIS_SETUP_CFGCPOL, bar); + let mut baz = udma_spis_1_csr.zf(utra::udma_spis_1::REG_SPIS_SETUP_CFGCPOL, bar); + baz |= udma_spis_1_csr.ms(utra::udma_spis_1::REG_SPIS_SETUP_CFGCPOL, 1); + udma_spis_1_csr.wfo(utra::udma_spis_1::REG_SPIS_SETUP_CFGCPOL, baz); + let bar = udma_spis_1_csr.rf(utra::udma_spis_1::REG_SPIS_SETUP_CFGCPHA); + udma_spis_1_csr.rmwf(utra::udma_spis_1::REG_SPIS_SETUP_CFGCPHA, bar); + let mut baz = udma_spis_1_csr.zf(utra::udma_spis_1::REG_SPIS_SETUP_CFGCPHA, bar); + baz |= udma_spis_1_csr.ms(utra::udma_spis_1::REG_SPIS_SETUP_CFGCPHA, 1); + udma_spis_1_csr.wfo(utra::udma_spis_1::REG_SPIS_SETUP_CFGCPHA, baz); + + let foo = udma_spis_1_csr.r(utra::udma_spis_1::REG_SEOT_CNT); + udma_spis_1_csr.wo(utra::udma_spis_1::REG_SEOT_CNT, foo); + let bar = udma_spis_1_csr.rf(utra::udma_spis_1::REG_SEOT_CNT_SR_SEOT_CNT); + udma_spis_1_csr.rmwf(utra::udma_spis_1::REG_SEOT_CNT_SR_SEOT_CNT, bar); + let mut baz = udma_spis_1_csr.zf(utra::udma_spis_1::REG_SEOT_CNT_SR_SEOT_CNT, bar); + baz |= udma_spis_1_csr.ms(utra::udma_spis_1::REG_SEOT_CNT_SR_SEOT_CNT, 1); + udma_spis_1_csr.wfo(utra::udma_spis_1::REG_SEOT_CNT_SR_SEOT_CNT, baz); + + let foo = udma_spis_1_csr.r(utra::udma_spis_1::REG_SPIS_IRQ_EN); + udma_spis_1_csr.wo(utra::udma_spis_1::REG_SPIS_IRQ_EN, foo); + let bar = udma_spis_1_csr.rf(utra::udma_spis_1::REG_SPIS_IRQ_EN_SEOT_IRQ_EN); + udma_spis_1_csr.rmwf(utra::udma_spis_1::REG_SPIS_IRQ_EN_SEOT_IRQ_EN, bar); + let mut baz = udma_spis_1_csr.zf(utra::udma_spis_1::REG_SPIS_IRQ_EN_SEOT_IRQ_EN, bar); + baz |= udma_spis_1_csr.ms(utra::udma_spis_1::REG_SPIS_IRQ_EN_SEOT_IRQ_EN, 1); + udma_spis_1_csr.wfo(utra::udma_spis_1::REG_SPIS_IRQ_EN_SEOT_IRQ_EN, baz); + + let foo = udma_spis_1_csr.r(utra::udma_spis_1::REG_SPIS_RXCNT); + udma_spis_1_csr.wo(utra::udma_spis_1::REG_SPIS_RXCNT, foo); + let bar = udma_spis_1_csr.rf(utra::udma_spis_1::REG_SPIS_RXCNT_CFGRXCNT); + udma_spis_1_csr.rmwf(utra::udma_spis_1::REG_SPIS_RXCNT_CFGRXCNT, bar); + let mut baz = udma_spis_1_csr.zf(utra::udma_spis_1::REG_SPIS_RXCNT_CFGRXCNT, bar); + baz |= udma_spis_1_csr.ms(utra::udma_spis_1::REG_SPIS_RXCNT_CFGRXCNT, 1); + udma_spis_1_csr.wfo(utra::udma_spis_1::REG_SPIS_RXCNT_CFGRXCNT, baz); + + let foo = udma_spis_1_csr.r(utra::udma_spis_1::REG_SPIS_TXCNT); + udma_spis_1_csr.wo(utra::udma_spis_1::REG_SPIS_TXCNT, foo); + let bar = udma_spis_1_csr.rf(utra::udma_spis_1::REG_SPIS_TXCNT_CFGTXCNT); + udma_spis_1_csr.rmwf(utra::udma_spis_1::REG_SPIS_TXCNT_CFGTXCNT, bar); + let mut baz = udma_spis_1_csr.zf(utra::udma_spis_1::REG_SPIS_TXCNT_CFGTXCNT, bar); + baz |= udma_spis_1_csr.ms(utra::udma_spis_1::REG_SPIS_TXCNT_CFGTXCNT, 1); + udma_spis_1_csr.wfo(utra::udma_spis_1::REG_SPIS_TXCNT_CFGTXCNT, baz); + + let foo = udma_spis_1_csr.r(utra::udma_spis_1::REG_SPIS_DMCNT); + udma_spis_1_csr.wo(utra::udma_spis_1::REG_SPIS_DMCNT, foo); + let bar = udma_spis_1_csr.rf(utra::udma_spis_1::REG_SPIS_DMCNT_CFGDMCNT); + udma_spis_1_csr.rmwf(utra::udma_spis_1::REG_SPIS_DMCNT_CFGDMCNT, bar); + let mut baz = udma_spis_1_csr.zf(utra::udma_spis_1::REG_SPIS_DMCNT_CFGDMCNT, bar); + baz |= udma_spis_1_csr.ms(utra::udma_spis_1::REG_SPIS_DMCNT_CFGDMCNT, 1); + udma_spis_1_csr.wfo(utra::udma_spis_1::REG_SPIS_DMCNT_CFGDMCNT, baz); + } + #[test] #[ignore] fn compile_check_aes_csr() {