From 2c53eb0508533e88986c8fbf5ea4737a10270d90 Mon Sep 17 00:00:00 2001 From: bunnie Date: Mon, 17 Jul 2023 18:24:10 +0800 Subject: [PATCH] add cramium targets to utralib --- utralib/Cargo.lock | 2 - utralib/build.rs | 12 +- utralib/cramium/core.svd | 11450 ++++++++++++++++ utralib/cramium/daric.svd | 9418 ++++++++++++++ utralib/cramium/soc.svd | 735 ++ utralib/src/generated.rs | 10 + utralib/src/generated/cramium_fpga.rs | 16478 ++++++++++++++++++++++++ 7 files changed, 38102 insertions(+), 3 deletions(-) create mode 100644 utralib/cramium/core.svd create mode 100644 utralib/cramium/daric.svd create mode 100644 utralib/cramium/soc.svd create mode 100644 utralib/src/generated/cramium_fpga.rs diff --git a/utralib/Cargo.lock b/utralib/Cargo.lock index 3ce078c68..ba6927142 100644 --- a/utralib/Cargo.lock +++ b/utralib/Cargo.lock @@ -20,8 +20,6 @@ dependencies = [ [[package]] name = "svd2utra" version = "0.1.18" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2ba87b81de81a553ec5904993a676aa29d1583a4f6ab96e03f8b44e4d6c05a61" dependencies = [ "quick-xml", ] diff --git a/utralib/build.rs b/utralib/build.rs index 172e88407..75caedd48 100644 --- a/utralib/build.rs +++ b/utralib/build.rs @@ -85,7 +85,7 @@ fn main() { // This script retains the use of an explicit "hosted" flag because we want to catch // unintentional build system misconfigurations that meant to build for a target other // than "hosted", rather than just falling back silently to defaults. - allow_single_target_feature!("precursor", "hosted", "renode", "atsama5d27"); + allow_single_target_feature!("precursor", "hosted", "renode", "atsama5d27", "cramium-soc", "cramium-fpga"); #[cfg(feature = "precursor")] allow_single_gitrev_feature!( @@ -120,6 +120,16 @@ fn main() { #[cfg(feature = "atsama5d27")] let generated_filename = "src/generated/atsama5d27.rs"; + #[cfg(feature = "cramium-soc")] + let svd_filenames = vec!["cramium/core.svd", "cramium/daric.svd"]; + #[cfg(feature = "cramium-soc")] + let generated_filename = "src/generated/cramium_soc.rs"; + + #[cfg(feature = "cramium-fpga")] + let svd_filenames = vec!["cramium/soc.svd", "cramium/core.svd", "cramium/daric.svd"]; + #[cfg(feature = "cramium-fpga")] + let generated_filename = "src/generated/cramium_fpga.rs"; + // ----- control file generation and rebuild sequence ----- // check and see if the configuration has changed since the last build. This should be // passed by the build system (e.g. xtask) if the feature is used. diff --git a/utralib/cramium/core.svd b/utralib/cramium/core.svd new file mode 100644 index 000000000..1756d8b22 --- /dev/null +++ b/utralib/cramium/core.svd @@ -0,0 +1,11450 @@ + + + + litex + SOC + + + 8 + 32 + 32 + read-write + 0x00000000 + 0xFFFFFFFF + + + + D11CTIME + 0xE0000000 + D11CTIME + + + CONTROL + 0x0000 + 0x61a80 + 32 + + + count + 31 + [31:0] + 0 + + + + + + HEARTBEAT + 0x0004 + 0x00 + 32 + + + beat + 0 + [0:0] + 0 + + + + + + + 0 + 0x8 + registers + + + + SUSRES + 0xE0001000 + SUSRES + + + CONTROL + 0x0000 + 0x00 + 32 + + + pause + 0 + [0:0] + 0 + + + + load + 1 + [1:1] + 1 + + + + + + RESUME_TIME1 + + 0x0004 + 0x00 + 32 + + + resume_time + 31 + [31:0] + 0 + + + + + RESUME_TIME0 + + 0x0008 + 0x00 + 32 + + + resume_time + 31 + [31:0] + 0 + + + + + TIME1 + + 0x000c + 0x00 + 32 + + + time + 31 + [31:0] + 0 + + + + + TIME0 + + 0x0010 + 0x00 + 32 + + + time + 31 + [31:0] + 0 + + + + + STATUS + 0x0014 + 0x00 + 32 + + + paused + 0 + [0:0] + 0 + + + + + + STATE + 0x0018 + 0x00 + 32 + + + resume + 0 + [0:0] + 0 + + + + was_forced + 1 + [1:1] + 1 + + + + + + INTERRUPT + 0x001c + 0x00 + 32 + + + interrupt + 0 + [0:0] + 0 + + + + + + EV_STATUS + + 0x0020 + 0x00 + 32 + + + soft_int + 0 + [0:0] + 0 + + + + + + EV_PENDING + + 0x0024 + 0x00 + 32 + + + soft_int + 0 + [0:0] + 0 + + + + + + EV_ENABLE + + 0x0028 + 0x00 + 32 + + + soft_int + 0 + [0:0] + 0 + + + + + + + 0 + 0x2c + registers + + + susres + 21 + + + + COREUSER + 0xE0002000 + COREUSER + + + SET_ASID + 0x0000 + 0x00 + 32 + + + asid + 8 + [8:0] + 0 + + + + trusted + 9 + [9:9] + 9 + + + + + + GET_ASID_ADDR + 0x0004 + 0x00 + 32 + + + asid + 8 + [8:0] + 0 + + + + + + GET_ASID_VALUE + 0x0008 + 0x00 + 32 + + + value + 0 + [0:0] + 0 + + + + + + SET_PRIVILEGE + 0x000c + 0x00 + 32 + + + mpp + 1 + [1:0] + 0 + + + + + + CONTROL + 0x0010 + 0x00 + 32 + + + enable + 0 + [0:0] + 0 + + + + asid + 1 + [1:1] + 1 + + + + ppn_a + 2 + [2:2] + 2 + + + + ppn_b + 3 + [3:3] + 3 + + + + privilege + 4 + [4:4] + 4 + + + + + + PROTECT + + 0x0014 + 0x00 + 32 + + + protect + 0 + [0:0] + 0 + + + + + WINDOW_AL + 0x0018 + 0x00 + 32 + + + ppn + 21 + [21:0] + 0 + + + + + + WINDOW_AH + 0x001c + 0x00 + 32 + + + ppn + 21 + [21:0] + 0 + + + + + + WINDOW_BL + 0x0020 + 0x00 + 32 + + + ppn + 21 + [21:0] + 0 + + + + + + WINDOW_BH + 0x0024 + 0x00 + 32 + + + ppn + 21 + [21:0] + 0 + + + + + + + 0 + 0x28 + registers + + + + CSRTEST + 0xE0003000 + CSRTEST + + + WTEST + + 0x0000 + 0x00 + 32 + + + wtest + 31 + [31:0] + 0 + + + + + RTEST + + 0x0004 + 0x00 + 32 + + + rtest + 31 + [31:0] + 0 + + + + + + 0 + 0x8 + registers + + + + IRQARRAY0 + 0xE0004000 + IRQARRAY0 + + + EV_SOFT + + 0x0000 + 0x00 + 32 + + + trigger + 19 + [19:0] + 0 + + + + + + EV_STATUS + + 0x0004 + 0x00 + 32 + + + source0 + 0 + [0:0] + 0 + + + + source1 + 1 + [1:1] + 1 + + + + source2 + 2 + [2:2] + 2 + + + + source3 + 3 + [3:3] + 3 + + + + source4 + 4 + [4:4] + 4 + + + + source5 + 5 + [5:5] + 5 + + + + source6 + 6 + [6:6] + 6 + + + + source7 + 7 + [7:7] + 7 + + + + source8 + 8 + [8:8] + 8 + + + + source9 + 9 + [9:9] + 9 + + + + source10 + 10 + [10:10] + 10 + + + + source11 + 11 + [11:11] + 11 + + + + source12 + 12 + [12:12] + 12 + + + + source13 + 13 + [13:13] + 13 + + + + source14 + 14 + [14:14] + 14 + + + + source15 + 15 + [15:15] + 15 + + + + source16 + 16 + [16:16] + 16 + + + + source17 + 17 + [17:17] + 17 + + + + source18 + 18 + [18:18] + 18 + + + + source19 + 19 + [19:19] + 19 + + + + + + EV_PENDING + + 0x0008 + 0x00 + 32 + + + source0 + 0 + [0:0] + 0 + + + + source1 + 1 + [1:1] + 1 + + + + source2 + 2 + [2:2] + 2 + + + + source3 + 3 + [3:3] + 3 + + + + source4 + 4 + [4:4] + 4 + + + + source5 + 5 + [5:5] + 5 + + + + source6 + 6 + [6:6] + 6 + + + + source7 + 7 + [7:7] + 7 + + + + source8 + 8 + [8:8] + 8 + + + + source9 + 9 + [9:9] + 9 + + + + source10 + 10 + [10:10] + 10 + + + + source11 + 11 + [11:11] + 11 + + + + source12 + 12 + [12:12] + 12 + + + + source13 + 13 + [13:13] + 13 + + + + source14 + 14 + [14:14] + 14 + + + + source15 + 15 + [15:15] + 15 + + + + source16 + 16 + [16:16] + 16 + + + + source17 + 17 + [17:17] + 17 + + + + source18 + 18 + [18:18] + 18 + + + + source19 + 19 + [19:19] + 19 + + + + + + EV_ENABLE + + 0x000c + 0x00 + 32 + + + source0 + 0 + [0:0] + 0 + + + + source1 + 1 + [1:1] + 1 + + + + source2 + 2 + [2:2] + 2 + + + + source3 + 3 + [3:3] + 3 + + + + source4 + 4 + [4:4] + 4 + + + + source5 + 5 + [5:5] + 5 + + + + source6 + 6 + [6:6] + 6 + + + + source7 + 7 + [7:7] + 7 + + + + source8 + 8 + [8:8] + 8 + + + + source9 + 9 + [9:9] + 9 + + + + source10 + 10 + [10:10] + 10 + + + + source11 + 11 + [11:11] + 11 + + + + source12 + 12 + [12:12] + 12 + + + + source13 + 13 + [13:13] + 13 + + + + source14 + 14 + [14:14] + 14 + + + + source15 + 15 + [15:15] + 15 + + + + source16 + 16 + [16:16] + 16 + + + + source17 + 17 + [17:17] + 17 + + + + source18 + 18 + [18:18] + 18 + + + + source19 + 19 + [19:19] + 19 + + + + + + + 0 + 0x10 + registers + + + irqarray0 + 0 + + + + IRQARRAY1 + 0xE0005000 + IRQARRAY1 + + + EV_SOFT + + 0x0000 + 0x00 + 32 + + + trigger + 19 + [19:0] + 0 + + + + + + EV_STATUS + + 0x0004 + 0x00 + 32 + + + source0 + 0 + [0:0] + 0 + + + + source1 + 1 + [1:1] + 1 + + + + source2 + 2 + [2:2] + 2 + + + + source3 + 3 + [3:3] + 3 + + + + source4 + 4 + [4:4] + 4 + + + + source5 + 5 + [5:5] + 5 + + + + source6 + 6 + [6:6] + 6 + + + + source7 + 7 + [7:7] + 7 + + + + source8 + 8 + [8:8] + 8 + + + + source9 + 9 + [9:9] + 9 + + + + source10 + 10 + [10:10] + 10 + + + + source11 + 11 + [11:11] + 11 + + + + source12 + 12 + [12:12] + 12 + + + + source13 + 13 + [13:13] + 13 + + + + source14 + 14 + [14:14] + 14 + + + + source15 + 15 + [15:15] + 15 + + + + source16 + 16 + [16:16] + 16 + + + + source17 + 17 + [17:17] + 17 + + + + source18 + 18 + [18:18] + 18 + + + + source19 + 19 + [19:19] + 19 + + + + + + EV_PENDING + + 0x0008 + 0x00 + 32 + + + source0 + 0 + [0:0] + 0 + + + + source1 + 1 + [1:1] + 1 + + + + source2 + 2 + [2:2] + 2 + + + + source3 + 3 + [3:3] + 3 + + + + source4 + 4 + [4:4] + 4 + + + + source5 + 5 + [5:5] + 5 + + + + source6 + 6 + [6:6] + 6 + + + + source7 + 7 + [7:7] + 7 + + + + source8 + 8 + [8:8] + 8 + + + + source9 + 9 + [9:9] + 9 + + + + source10 + 10 + [10:10] + 10 + + + + source11 + 11 + [11:11] + 11 + + + + source12 + 12 + [12:12] + 12 + + + + source13 + 13 + [13:13] + 13 + + + + source14 + 14 + [14:14] + 14 + + + + source15 + 15 + [15:15] + 15 + + + + source16 + 16 + [16:16] + 16 + + + + source17 + 17 + [17:17] + 17 + + + + source18 + 18 + [18:18] + 18 + + + + source19 + 19 + [19:19] + 19 + + + + + + EV_ENABLE + + 0x000c + 0x00 + 32 + + + source0 + 0 + [0:0] + 0 + + + + source1 + 1 + [1:1] + 1 + + + + source2 + 2 + [2:2] + 2 + + + + source3 + 3 + [3:3] + 3 + + + + source4 + 4 + [4:4] + 4 + + + + source5 + 5 + [5:5] + 5 + + + + source6 + 6 + [6:6] + 6 + + + + source7 + 7 + [7:7] + 7 + + + + source8 + 8 + [8:8] + 8 + + + + source9 + 9 + [9:9] + 9 + + + + source10 + 10 + [10:10] + 10 + + + + source11 + 11 + [11:11] + 11 + + + + source12 + 12 + [12:12] + 12 + + + + source13 + 13 + [13:13] + 13 + + + + source14 + 14 + [14:14] + 14 + + + + source15 + 15 + [15:15] + 15 + + + + source16 + 16 + [16:16] + 16 + + + + source17 + 17 + [17:17] + 17 + + + + source18 + 18 + [18:18] + 18 + + + + source19 + 19 + [19:19] + 19 + + + + + + + 0 + 0x10 + registers + + + irqarray1 + 1 + + + + IRQARRAY10 + 0xE0006000 + IRQARRAY10 + + + EV_SOFT + + 0x0000 + 0x00 + 32 + + + trigger + 19 + [19:0] + 0 + + + + + + EV_STATUS + + 0x0004 + 0x00 + 32 + + + source0 + 0 + [0:0] + 0 + + + + source1 + 1 + [1:1] + 1 + + + + source2 + 2 + [2:2] + 2 + + + + source3 + 3 + [3:3] + 3 + + + + source4 + 4 + [4:4] + 4 + + + + source5 + 5 + [5:5] + 5 + + + + source6 + 6 + [6:6] + 6 + + + + source7 + 7 + [7:7] + 7 + + + + source8 + 8 + [8:8] + 8 + + + + source9 + 9 + [9:9] + 9 + + + + source10 + 10 + [10:10] + 10 + + + + source11 + 11 + [11:11] + 11 + + + + source12 + 12 + [12:12] + 12 + + + + source13 + 13 + [13:13] + 13 + + + + source14 + 14 + [14:14] + 14 + + + + source15 + 15 + [15:15] + 15 + + + + source16 + 16 + [16:16] + 16 + + + + source17 + 17 + [17:17] + 17 + + + + source18 + 18 + [18:18] + 18 + + + + source19 + 19 + [19:19] + 19 + + + + + + EV_PENDING + + 0x0008 + 0x00 + 32 + + + source0 + 0 + [0:0] + 0 + + + + source1 + 1 + [1:1] + 1 + + + + source2 + 2 + [2:2] + 2 + + + + source3 + 3 + [3:3] + 3 + + + + source4 + 4 + [4:4] + 4 + + + + source5 + 5 + [5:5] + 5 + + + + source6 + 6 + [6:6] + 6 + + + + source7 + 7 + [7:7] + 7 + + + + source8 + 8 + [8:8] + 8 + + + + source9 + 9 + [9:9] + 9 + + + + source10 + 10 + [10:10] + 10 + + + + source11 + 11 + [11:11] + 11 + + + + source12 + 12 + [12:12] + 12 + + + + source13 + 13 + [13:13] + 13 + + + + source14 + 14 + [14:14] + 14 + + + + source15 + 15 + [15:15] + 15 + + + + source16 + 16 + [16:16] + 16 + + + + source17 + 17 + [17:17] + 17 + + + + source18 + 18 + [18:18] + 18 + + + + source19 + 19 + [19:19] + 19 + + + + + + EV_ENABLE + + 0x000c + 0x00 + 32 + + + source0 + 0 + [0:0] + 0 + + + + source1 + 1 + [1:1] + 1 + + + + source2 + 2 + [2:2] + 2 + + + + source3 + 3 + [3:3] + 3 + + + + source4 + 4 + [4:4] + 4 + + + + source5 + 5 + [5:5] + 5 + + + + source6 + 6 + [6:6] + 6 + + + + source7 + 7 + [7:7] + 7 + + + + source8 + 8 + [8:8] + 8 + + + + source9 + 9 + [9:9] + 9 + + + + source10 + 10 + [10:10] + 10 + + + + source11 + 11 + [11:11] + 11 + + + + source12 + 12 + [12:12] + 12 + + + + source13 + 13 + [13:13] + 13 + + + + source14 + 14 + [14:14] + 14 + + + + source15 + 15 + [15:15] + 15 + + + + source16 + 16 + [16:16] + 16 + + + + source17 + 17 + [17:17] + 17 + + + + source18 + 18 + [18:18] + 18 + + + + source19 + 19 + [19:19] + 19 + + + + + + + 0 + 0x10 + registers + + + irqarray10 + 10 + + + + IRQARRAY11 + 0xE0007000 + IRQARRAY11 + + + EV_SOFT + + 0x0000 + 0x00 + 32 + + + trigger + 19 + [19:0] + 0 + + + + + + EV_STATUS + + 0x0004 + 0x00 + 32 + + + source0 + 0 + [0:0] + 0 + + + + source1 + 1 + [1:1] + 1 + + + + source2 + 2 + [2:2] + 2 + + + + source3 + 3 + [3:3] + 3 + + + + source4 + 4 + [4:4] + 4 + + + + source5 + 5 + [5:5] + 5 + + + + source6 + 6 + [6:6] + 6 + + + + source7 + 7 + [7:7] + 7 + + + + source8 + 8 + [8:8] + 8 + + + + source9 + 9 + [9:9] + 9 + + + + source10 + 10 + [10:10] + 10 + + + + source11 + 11 + [11:11] + 11 + + + + source12 + 12 + [12:12] + 12 + + + + source13 + 13 + [13:13] + 13 + + + + source14 + 14 + [14:14] + 14 + + + + source15 + 15 + [15:15] + 15 + + + + source16 + 16 + [16:16] + 16 + + + + source17 + 17 + [17:17] + 17 + + + + source18 + 18 + [18:18] + 18 + + + + source19 + 19 + [19:19] + 19 + + + + + + EV_PENDING + + 0x0008 + 0x00 + 32 + + + source0 + 0 + [0:0] + 0 + + + + source1 + 1 + [1:1] + 1 + + + + source2 + 2 + [2:2] + 2 + + + + source3 + 3 + [3:3] + 3 + + + + source4 + 4 + [4:4] + 4 + + + + source5 + 5 + [5:5] + 5 + + + + source6 + 6 + [6:6] + 6 + + + + source7 + 7 + [7:7] + 7 + + + + source8 + 8 + [8:8] + 8 + + + + source9 + 9 + [9:9] + 9 + + + + source10 + 10 + [10:10] + 10 + + + + source11 + 11 + [11:11] + 11 + + + + source12 + 12 + [12:12] + 12 + + + + source13 + 13 + [13:13] + 13 + + + + source14 + 14 + [14:14] + 14 + + + + source15 + 15 + [15:15] + 15 + + + + source16 + 16 + [16:16] + 16 + + + + source17 + 17 + [17:17] + 17 + + + + source18 + 18 + [18:18] + 18 + + + + source19 + 19 + [19:19] + 19 + + + + + + EV_ENABLE + + 0x000c + 0x00 + 32 + + + source0 + 0 + [0:0] + 0 + + + + source1 + 1 + [1:1] + 1 + + + + source2 + 2 + [2:2] + 2 + + + + source3 + 3 + [3:3] + 3 + + + + source4 + 4 + [4:4] + 4 + + + + source5 + 5 + [5:5] + 5 + + + + source6 + 6 + [6:6] + 6 + + + + source7 + 7 + [7:7] + 7 + + + + source8 + 8 + [8:8] + 8 + + + + source9 + 9 + [9:9] + 9 + + + + source10 + 10 + [10:10] + 10 + + + + source11 + 11 + [11:11] + 11 + + + + source12 + 12 + [12:12] + 12 + + + + source13 + 13 + [13:13] + 13 + + + + source14 + 14 + [14:14] + 14 + + + + source15 + 15 + [15:15] + 15 + + + + source16 + 16 + [16:16] + 16 + + + + source17 + 17 + [17:17] + 17 + + + + source18 + 18 + [18:18] + 18 + + + + source19 + 19 + [19:19] + 19 + + + + + + + 0 + 0x10 + registers + + + irqarray11 + 11 + + + + IRQARRAY12 + 0xE0008000 + IRQARRAY12 + + + EV_SOFT + + 0x0000 + 0x00 + 32 + + + trigger + 19 + [19:0] + 0 + + + + + + EV_STATUS + + 0x0004 + 0x00 + 32 + + + source0 + 0 + [0:0] + 0 + + + + source1 + 1 + [1:1] + 1 + + + + source2 + 2 + [2:2] + 2 + + + + source3 + 3 + [3:3] + 3 + + + + source4 + 4 + [4:4] + 4 + + + + source5 + 5 + [5:5] + 5 + + + + source6 + 6 + [6:6] + 6 + + + + source7 + 7 + [7:7] + 7 + + + + source8 + 8 + [8:8] + 8 + + + + source9 + 9 + [9:9] + 9 + + + + source10 + 10 + [10:10] + 10 + + + + source11 + 11 + [11:11] + 11 + + + + source12 + 12 + [12:12] + 12 + + + + source13 + 13 + [13:13] + 13 + + + + source14 + 14 + [14:14] + 14 + + + + source15 + 15 + [15:15] + 15 + + + + source16 + 16 + [16:16] + 16 + + + + source17 + 17 + [17:17] + 17 + + + + source18 + 18 + [18:18] + 18 + + + + source19 + 19 + [19:19] + 19 + + + + + + EV_PENDING + + 0x0008 + 0x00 + 32 + + + source0 + 0 + [0:0] + 0 + + + + source1 + 1 + [1:1] + 1 + + + + source2 + 2 + [2:2] + 2 + + + + source3 + 3 + [3:3] + 3 + + + + source4 + 4 + [4:4] + 4 + + + + source5 + 5 + [5:5] + 5 + + + + source6 + 6 + [6:6] + 6 + + + + source7 + 7 + [7:7] + 7 + + + + source8 + 8 + [8:8] + 8 + + + + source9 + 9 + [9:9] + 9 + + + + source10 + 10 + [10:10] + 10 + + + + source11 + 11 + [11:11] + 11 + + + + source12 + 12 + [12:12] + 12 + + + + source13 + 13 + [13:13] + 13 + + + + source14 + 14 + [14:14] + 14 + + + + source15 + 15 + [15:15] + 15 + + + + source16 + 16 + [16:16] + 16 + + + + source17 + 17 + [17:17] + 17 + + + + source18 + 18 + [18:18] + 18 + + + + source19 + 19 + [19:19] + 19 + + + + + + EV_ENABLE + + 0x000c + 0x00 + 32 + + + source0 + 0 + [0:0] + 0 + + + + source1 + 1 + [1:1] + 1 + + + + source2 + 2 + [2:2] + 2 + + + + source3 + 3 + [3:3] + 3 + + + + source4 + 4 + [4:4] + 4 + + + + source5 + 5 + [5:5] + 5 + + + + source6 + 6 + [6:6] + 6 + + + + source7 + 7 + [7:7] + 7 + + + + source8 + 8 + [8:8] + 8 + + + + source9 + 9 + [9:9] + 9 + + + + source10 + 10 + [10:10] + 10 + + + + source11 + 11 + [11:11] + 11 + + + + source12 + 12 + [12:12] + 12 + + + + source13 + 13 + [13:13] + 13 + + + + source14 + 14 + [14:14] + 14 + + + + source15 + 15 + [15:15] + 15 + + + + source16 + 16 + [16:16] + 16 + + + + source17 + 17 + [17:17] + 17 + + + + source18 + 18 + [18:18] + 18 + + + + source19 + 19 + [19:19] + 19 + + + + + + + 0 + 0x10 + registers + + + irqarray12 + 12 + + + + IRQARRAY13 + 0xE0009000 + IRQARRAY13 + + + EV_SOFT + + 0x0000 + 0x00 + 32 + + + trigger + 19 + [19:0] + 0 + + + + + + EV_STATUS + + 0x0004 + 0x00 + 32 + + + source0 + 0 + [0:0] + 0 + + + + source1 + 1 + [1:1] + 1 + + + + source2 + 2 + [2:2] + 2 + + + + source3 + 3 + [3:3] + 3 + + + + source4 + 4 + [4:4] + 4 + + + + source5 + 5 + [5:5] + 5 + + + + source6 + 6 + [6:6] + 6 + + + + source7 + 7 + [7:7] + 7 + + + + source8 + 8 + [8:8] + 8 + + + + source9 + 9 + [9:9] + 9 + + + + source10 + 10 + [10:10] + 10 + + + + source11 + 11 + [11:11] + 11 + + + + source12 + 12 + [12:12] + 12 + + + + source13 + 13 + [13:13] + 13 + + + + source14 + 14 + [14:14] + 14 + + + + source15 + 15 + [15:15] + 15 + + + + source16 + 16 + [16:16] + 16 + + + + source17 + 17 + [17:17] + 17 + + + + source18 + 18 + [18:18] + 18 + + + + source19 + 19 + [19:19] + 19 + + + + + + EV_PENDING + + 0x0008 + 0x00 + 32 + + + source0 + 0 + [0:0] + 0 + + + + source1 + 1 + [1:1] + 1 + + + + source2 + 2 + [2:2] + 2 + + + + source3 + 3 + [3:3] + 3 + + + + source4 + 4 + [4:4] + 4 + + + + source5 + 5 + [5:5] + 5 + + + + source6 + 6 + [6:6] + 6 + + + + source7 + 7 + [7:7] + 7 + + + + source8 + 8 + [8:8] + 8 + + + + source9 + 9 + [9:9] + 9 + + + + source10 + 10 + [10:10] + 10 + + + + source11 + 11 + [11:11] + 11 + + + + source12 + 12 + [12:12] + 12 + + + + source13 + 13 + [13:13] + 13 + + + + source14 + 14 + [14:14] + 14 + + + + source15 + 15 + [15:15] + 15 + + + + source16 + 16 + [16:16] + 16 + + + + source17 + 17 + [17:17] + 17 + + + + source18 + 18 + [18:18] + 18 + + + + source19 + 19 + [19:19] + 19 + + + + + + EV_ENABLE + + 0x000c + 0x00 + 32 + + + source0 + 0 + [0:0] + 0 + + + + source1 + 1 + [1:1] + 1 + + + + source2 + 2 + [2:2] + 2 + + + + source3 + 3 + [3:3] + 3 + + + + source4 + 4 + [4:4] + 4 + + + + source5 + 5 + [5:5] + 5 + + + + source6 + 6 + [6:6] + 6 + + + + source7 + 7 + [7:7] + 7 + + + + source8 + 8 + [8:8] + 8 + + + + source9 + 9 + [9:9] + 9 + + + + source10 + 10 + [10:10] + 10 + + + + source11 + 11 + [11:11] + 11 + + + + source12 + 12 + [12:12] + 12 + + + + source13 + 13 + [13:13] + 13 + + + + source14 + 14 + [14:14] + 14 + + + + source15 + 15 + [15:15] + 15 + + + + source16 + 16 + [16:16] + 16 + + + + source17 + 17 + [17:17] + 17 + + + + source18 + 18 + [18:18] + 18 + + + + source19 + 19 + [19:19] + 19 + + + + + + + 0 + 0x10 + registers + + + irqarray13 + 13 + + + + IRQARRAY14 + 0xE000A000 + IRQARRAY14 + + + EV_SOFT + + 0x0000 + 0x00 + 32 + + + trigger + 19 + [19:0] + 0 + + + + + + EV_STATUS + + 0x0004 + 0x00 + 32 + + + source0 + 0 + [0:0] + 0 + + + + source1 + 1 + [1:1] + 1 + + + + source2 + 2 + [2:2] + 2 + + + + source3 + 3 + [3:3] + 3 + + + + source4 + 4 + [4:4] + 4 + + + + source5 + 5 + [5:5] + 5 + + + + source6 + 6 + [6:6] + 6 + + + + source7 + 7 + [7:7] + 7 + + + + source8 + 8 + [8:8] + 8 + + + + source9 + 9 + [9:9] + 9 + + + + source10 + 10 + [10:10] + 10 + + + + source11 + 11 + [11:11] + 11 + + + + source12 + 12 + [12:12] + 12 + + + + source13 + 13 + [13:13] + 13 + + + + source14 + 14 + [14:14] + 14 + + + + source15 + 15 + [15:15] + 15 + + + + source16 + 16 + [16:16] + 16 + + + + source17 + 17 + [17:17] + 17 + + + + source18 + 18 + [18:18] + 18 + + + + source19 + 19 + [19:19] + 19 + + + + + + EV_PENDING + + 0x0008 + 0x00 + 32 + + + source0 + 0 + [0:0] + 0 + + + + source1 + 1 + [1:1] + 1 + + + + source2 + 2 + [2:2] + 2 + + + + source3 + 3 + [3:3] + 3 + + + + source4 + 4 + [4:4] + 4 + + + + source5 + 5 + [5:5] + 5 + + + + source6 + 6 + [6:6] + 6 + + + + source7 + 7 + [7:7] + 7 + + + + source8 + 8 + [8:8] + 8 + + + + source9 + 9 + [9:9] + 9 + + + + source10 + 10 + [10:10] + 10 + + + + source11 + 11 + [11:11] + 11 + + + + source12 + 12 + [12:12] + 12 + + + + source13 + 13 + [13:13] + 13 + + + + source14 + 14 + [14:14] + 14 + + + + source15 + 15 + [15:15] + 15 + + + + source16 + 16 + [16:16] + 16 + + + + source17 + 17 + [17:17] + 17 + + + + source18 + 18 + [18:18] + 18 + + + + source19 + 19 + [19:19] + 19 + + + + + + EV_ENABLE + + 0x000c + 0x00 + 32 + + + source0 + 0 + [0:0] + 0 + + + + source1 + 1 + [1:1] + 1 + + + + source2 + 2 + [2:2] + 2 + + + + source3 + 3 + [3:3] + 3 + + + + source4 + 4 + [4:4] + 4 + + + + source5 + 5 + [5:5] + 5 + + + + source6 + 6 + [6:6] + 6 + + + + source7 + 7 + [7:7] + 7 + + + + source8 + 8 + [8:8] + 8 + + + + source9 + 9 + [9:9] + 9 + + + + source10 + 10 + [10:10] + 10 + + + + source11 + 11 + [11:11] + 11 + + + + source12 + 12 + [12:12] + 12 + + + + source13 + 13 + [13:13] + 13 + + + + source14 + 14 + [14:14] + 14 + + + + source15 + 15 + [15:15] + 15 + + + + source16 + 16 + [16:16] + 16 + + + + source17 + 17 + [17:17] + 17 + + + + source18 + 18 + [18:18] + 18 + + + + source19 + 19 + [19:19] + 19 + + + + + + + 0 + 0x10 + registers + + + irqarray14 + 14 + + + + IRQARRAY15 + 0xE000B000 + IRQARRAY15 + + + EV_SOFT + + 0x0000 + 0x00 + 32 + + + trigger + 19 + [19:0] + 0 + + + + + + EV_STATUS + + 0x0004 + 0x00 + 32 + + + source0 + 0 + [0:0] + 0 + + + + source1 + 1 + [1:1] + 1 + + + + source2 + 2 + [2:2] + 2 + + + + source3 + 3 + [3:3] + 3 + + + + source4 + 4 + [4:4] + 4 + + + + source5 + 5 + [5:5] + 5 + + + + source6 + 6 + [6:6] + 6 + + + + source7 + 7 + [7:7] + 7 + + + + source8 + 8 + [8:8] + 8 + + + + source9 + 9 + [9:9] + 9 + + + + source10 + 10 + [10:10] + 10 + + + + source11 + 11 + [11:11] + 11 + + + + source12 + 12 + [12:12] + 12 + + + + source13 + 13 + [13:13] + 13 + + + + source14 + 14 + [14:14] + 14 + + + + source15 + 15 + [15:15] + 15 + + + + source16 + 16 + [16:16] + 16 + + + + source17 + 17 + [17:17] + 17 + + + + source18 + 18 + [18:18] + 18 + + + + source19 + 19 + [19:19] + 19 + + + + + + EV_PENDING + + 0x0008 + 0x00 + 32 + + + source0 + 0 + [0:0] + 0 + + + + source1 + 1 + [1:1] + 1 + + + + source2 + 2 + [2:2] + 2 + + + + source3 + 3 + [3:3] + 3 + + + + source4 + 4 + [4:4] + 4 + + + + source5 + 5 + [5:5] + 5 + + + + source6 + 6 + [6:6] + 6 + + + + source7 + 7 + [7:7] + 7 + + + + source8 + 8 + [8:8] + 8 + + + + source9 + 9 + [9:9] + 9 + + + + source10 + 10 + [10:10] + 10 + + + + source11 + 11 + [11:11] + 11 + + + + source12 + 12 + [12:12] + 12 + + + + source13 + 13 + [13:13] + 13 + + + + source14 + 14 + [14:14] + 14 + + + + source15 + 15 + [15:15] + 15 + + + + source16 + 16 + [16:16] + 16 + + + + source17 + 17 + [17:17] + 17 + + + + source18 + 18 + [18:18] + 18 + + + + source19 + 19 + [19:19] + 19 + + + + + + EV_ENABLE + + 0x000c + 0x00 + 32 + + + source0 + 0 + [0:0] + 0 + + + + source1 + 1 + [1:1] + 1 + + + + source2 + 2 + [2:2] + 2 + + + + source3 + 3 + [3:3] + 3 + + + + source4 + 4 + [4:4] + 4 + + + + source5 + 5 + [5:5] + 5 + + + + source6 + 6 + [6:6] + 6 + + + + source7 + 7 + [7:7] + 7 + + + + source8 + 8 + [8:8] + 8 + + + + source9 + 9 + [9:9] + 9 + + + + source10 + 10 + [10:10] + 10 + + + + source11 + 11 + [11:11] + 11 + + + + source12 + 12 + [12:12] + 12 + + + + source13 + 13 + [13:13] + 13 + + + + source14 + 14 + [14:14] + 14 + + + + source15 + 15 + [15:15] + 15 + + + + source16 + 16 + [16:16] + 16 + + + + source17 + 17 + [17:17] + 17 + + + + source18 + 18 + [18:18] + 18 + + + + source19 + 19 + [19:19] + 19 + + + + + + + 0 + 0x10 + registers + + + irqarray15 + 15 + + + + IRQARRAY16 + 0xE000C000 + IRQARRAY16 + + + EV_SOFT + + 0x0000 + 0x00 + 32 + + + trigger + 19 + [19:0] + 0 + + + + + + EV_STATUS + + 0x0004 + 0x00 + 32 + + + source0 + 0 + [0:0] + 0 + + + + source1 + 1 + [1:1] + 1 + + + + source2 + 2 + [2:2] + 2 + + + + source3 + 3 + [3:3] + 3 + + + + source4 + 4 + [4:4] + 4 + + + + source5 + 5 + [5:5] + 5 + + + + source6 + 6 + [6:6] + 6 + + + + source7 + 7 + [7:7] + 7 + + + + source8 + 8 + [8:8] + 8 + + + + source9 + 9 + [9:9] + 9 + + + + source10 + 10 + [10:10] + 10 + + + + source11 + 11 + [11:11] + 11 + + + + source12 + 12 + [12:12] + 12 + + + + source13 + 13 + [13:13] + 13 + + + + source14 + 14 + [14:14] + 14 + + + + source15 + 15 + [15:15] + 15 + + + + source16 + 16 + [16:16] + 16 + + + + source17 + 17 + [17:17] + 17 + + + + source18 + 18 + [18:18] + 18 + + + + source19 + 19 + [19:19] + 19 + + + + + + EV_PENDING + + 0x0008 + 0x00 + 32 + + + source0 + 0 + [0:0] + 0 + + + + source1 + 1 + [1:1] + 1 + + + + source2 + 2 + [2:2] + 2 + + + + source3 + 3 + [3:3] + 3 + + + + source4 + 4 + [4:4] + 4 + + + + source5 + 5 + [5:5] + 5 + + + + source6 + 6 + [6:6] + 6 + + + + source7 + 7 + [7:7] + 7 + + + + source8 + 8 + [8:8] + 8 + + + + source9 + 9 + [9:9] + 9 + + + + source10 + 10 + [10:10] + 10 + + + + source11 + 11 + [11:11] + 11 + + + + source12 + 12 + [12:12] + 12 + + + + source13 + 13 + [13:13] + 13 + + + + source14 + 14 + [14:14] + 14 + + + + source15 + 15 + [15:15] + 15 + + + + source16 + 16 + [16:16] + 16 + + + + source17 + 17 + [17:17] + 17 + + + + source18 + 18 + [18:18] + 18 + + + + source19 + 19 + [19:19] + 19 + + + + + + EV_ENABLE + + 0x000c + 0x00 + 32 + + + source0 + 0 + [0:0] + 0 + + + + source1 + 1 + [1:1] + 1 + + + + source2 + 2 + [2:2] + 2 + + + + source3 + 3 + [3:3] + 3 + + + + source4 + 4 + [4:4] + 4 + + + + source5 + 5 + [5:5] + 5 + + + + source6 + 6 + [6:6] + 6 + + + + source7 + 7 + [7:7] + 7 + + + + source8 + 8 + [8:8] + 8 + + + + source9 + 9 + [9:9] + 9 + + + + source10 + 10 + [10:10] + 10 + + + + source11 + 11 + [11:11] + 11 + + + + source12 + 12 + [12:12] + 12 + + + + source13 + 13 + [13:13] + 13 + + + + source14 + 14 + [14:14] + 14 + + + + source15 + 15 + [15:15] + 15 + + + + source16 + 16 + [16:16] + 16 + + + + source17 + 17 + [17:17] + 17 + + + + source18 + 18 + [18:18] + 18 + + + + source19 + 19 + [19:19] + 19 + + + + + + + 0 + 0x10 + registers + + + irqarray16 + 16 + + + + IRQARRAY17 + 0xE000D000 + IRQARRAY17 + + + EV_SOFT + + 0x0000 + 0x00 + 32 + + + trigger + 19 + [19:0] + 0 + + + + + + EV_STATUS + + 0x0004 + 0x00 + 32 + + + source0 + 0 + [0:0] + 0 + + + + source1 + 1 + [1:1] + 1 + + + + source2 + 2 + [2:2] + 2 + + + + source3 + 3 + [3:3] + 3 + + + + source4 + 4 + [4:4] + 4 + + + + source5 + 5 + [5:5] + 5 + + + + source6 + 6 + [6:6] + 6 + + + + source7 + 7 + [7:7] + 7 + + + + source8 + 8 + [8:8] + 8 + + + + source9 + 9 + [9:9] + 9 + + + + source10 + 10 + [10:10] + 10 + + + + source11 + 11 + [11:11] + 11 + + + + source12 + 12 + [12:12] + 12 + + + + source13 + 13 + [13:13] + 13 + + + + source14 + 14 + [14:14] + 14 + + + + source15 + 15 + [15:15] + 15 + + + + source16 + 16 + [16:16] + 16 + + + + source17 + 17 + [17:17] + 17 + + + + source18 + 18 + [18:18] + 18 + + + + source19 + 19 + [19:19] + 19 + + + + + + EV_PENDING + + 0x0008 + 0x00 + 32 + + + source0 + 0 + [0:0] + 0 + + + + source1 + 1 + [1:1] + 1 + + + + source2 + 2 + [2:2] + 2 + + + + source3 + 3 + [3:3] + 3 + + + + source4 + 4 + [4:4] + 4 + + + + source5 + 5 + [5:5] + 5 + + + + source6 + 6 + [6:6] + 6 + + + + source7 + 7 + [7:7] + 7 + + + + source8 + 8 + [8:8] + 8 + + + + source9 + 9 + [9:9] + 9 + + + + source10 + 10 + [10:10] + 10 + + + + source11 + 11 + [11:11] + 11 + + + + source12 + 12 + [12:12] + 12 + + + + source13 + 13 + [13:13] + 13 + + + + source14 + 14 + [14:14] + 14 + + + + source15 + 15 + [15:15] + 15 + + + + source16 + 16 + [16:16] + 16 + + + + source17 + 17 + [17:17] + 17 + + + + source18 + 18 + [18:18] + 18 + + + + source19 + 19 + [19:19] + 19 + + + + + + EV_ENABLE + + 0x000c + 0x00 + 32 + + + source0 + 0 + [0:0] + 0 + + + + source1 + 1 + [1:1] + 1 + + + + source2 + 2 + [2:2] + 2 + + + + source3 + 3 + [3:3] + 3 + + + + source4 + 4 + [4:4] + 4 + + + + source5 + 5 + [5:5] + 5 + + + + source6 + 6 + [6:6] + 6 + + + + source7 + 7 + [7:7] + 7 + + + + source8 + 8 + [8:8] + 8 + + + + source9 + 9 + [9:9] + 9 + + + + source10 + 10 + [10:10] + 10 + + + + source11 + 11 + [11:11] + 11 + + + + source12 + 12 + [12:12] + 12 + + + + source13 + 13 + [13:13] + 13 + + + + source14 + 14 + [14:14] + 14 + + + + source15 + 15 + [15:15] + 15 + + + + source16 + 16 + [16:16] + 16 + + + + source17 + 17 + [17:17] + 17 + + + + source18 + 18 + [18:18] + 18 + + + + source19 + 19 + [19:19] + 19 + + + + + + + 0 + 0x10 + registers + + + irqarray17 + 17 + + + + IRQARRAY18 + 0xE000E000 + IRQARRAY18 + + + EV_SOFT + + 0x0000 + 0x00 + 32 + + + trigger + 19 + [19:0] + 0 + + + + + + EV_STATUS + + 0x0004 + 0x00 + 32 + + + source0 + 0 + [0:0] + 0 + + + + source1 + 1 + [1:1] + 1 + + + + source2 + 2 + [2:2] + 2 + + + + source3 + 3 + [3:3] + 3 + + + + source4 + 4 + [4:4] + 4 + + + + source5 + 5 + [5:5] + 5 + + + + source6 + 6 + [6:6] + 6 + + + + source7 + 7 + [7:7] + 7 + + + + source8 + 8 + [8:8] + 8 + + + + source9 + 9 + [9:9] + 9 + + + + source10 + 10 + [10:10] + 10 + + + + source11 + 11 + [11:11] + 11 + + + + source12 + 12 + [12:12] + 12 + + + + source13 + 13 + [13:13] + 13 + + + + source14 + 14 + [14:14] + 14 + + + + source15 + 15 + [15:15] + 15 + + + + source16 + 16 + [16:16] + 16 + + + + source17 + 17 + [17:17] + 17 + + + + source18 + 18 + [18:18] + 18 + + + + source19 + 19 + [19:19] + 19 + + + + + + EV_PENDING + + 0x0008 + 0x00 + 32 + + + source0 + 0 + [0:0] + 0 + + + + source1 + 1 + [1:1] + 1 + + + + source2 + 2 + [2:2] + 2 + + + + source3 + 3 + [3:3] + 3 + + + + source4 + 4 + [4:4] + 4 + + + + source5 + 5 + [5:5] + 5 + + + + source6 + 6 + [6:6] + 6 + + + + source7 + 7 + [7:7] + 7 + + + + source8 + 8 + [8:8] + 8 + + + + source9 + 9 + [9:9] + 9 + + + + source10 + 10 + [10:10] + 10 + + + + source11 + 11 + [11:11] + 11 + + + + source12 + 12 + [12:12] + 12 + + + + source13 + 13 + [13:13] + 13 + + + + source14 + 14 + [14:14] + 14 + + + + source15 + 15 + [15:15] + 15 + + + + source16 + 16 + [16:16] + 16 + + + + source17 + 17 + [17:17] + 17 + + + + source18 + 18 + [18:18] + 18 + + + + source19 + 19 + [19:19] + 19 + + + + + + EV_ENABLE + + 0x000c + 0x00 + 32 + + + source0 + 0 + [0:0] + 0 + + + + source1 + 1 + [1:1] + 1 + + + + source2 + 2 + [2:2] + 2 + + + + source3 + 3 + [3:3] + 3 + + + + source4 + 4 + [4:4] + 4 + + + + source5 + 5 + [5:5] + 5 + + + + source6 + 6 + [6:6] + 6 + + + + source7 + 7 + [7:7] + 7 + + + + source8 + 8 + [8:8] + 8 + + + + source9 + 9 + [9:9] + 9 + + + + source10 + 10 + [10:10] + 10 + + + + source11 + 11 + [11:11] + 11 + + + + source12 + 12 + [12:12] + 12 + + + + source13 + 13 + [13:13] + 13 + + + + source14 + 14 + [14:14] + 14 + + + + source15 + 15 + [15:15] + 15 + + + + source16 + 16 + [16:16] + 16 + + + + source17 + 17 + [17:17] + 17 + + + + source18 + 18 + [18:18] + 18 + + + + source19 + 19 + [19:19] + 19 + + + + + + + 0 + 0x10 + registers + + + irqarray18 + 18 + + + + IRQARRAY19 + 0xE000F000 + IRQARRAY19 + + + EV_SOFT + + 0x0000 + 0x00 + 32 + + + trigger + 19 + [19:0] + 0 + + + + + + EV_STATUS + + 0x0004 + 0x00 + 32 + + + source0 + 0 + [0:0] + 0 + + + + source1 + 1 + [1:1] + 1 + + + + source2 + 2 + [2:2] + 2 + + + + source3 + 3 + [3:3] + 3 + + + + source4 + 4 + [4:4] + 4 + + + + source5 + 5 + [5:5] + 5 + + + + source6 + 6 + [6:6] + 6 + + + + source7 + 7 + [7:7] + 7 + + + + source8 + 8 + [8:8] + 8 + + + + source9 + 9 + [9:9] + 9 + + + + source10 + 10 + [10:10] + 10 + + + + source11 + 11 + [11:11] + 11 + + + + source12 + 12 + [12:12] + 12 + + + + source13 + 13 + [13:13] + 13 + + + + source14 + 14 + [14:14] + 14 + + + + source15 + 15 + [15:15] + 15 + + + + source16 + 16 + [16:16] + 16 + + + + source17 + 17 + [17:17] + 17 + + + + source18 + 18 + [18:18] + 18 + + + + source19 + 19 + [19:19] + 19 + + + + + + EV_PENDING + + 0x0008 + 0x00 + 32 + + + source0 + 0 + [0:0] + 0 + + + + source1 + 1 + [1:1] + 1 + + + + source2 + 2 + [2:2] + 2 + + + + source3 + 3 + [3:3] + 3 + + + + source4 + 4 + [4:4] + 4 + + + + source5 + 5 + [5:5] + 5 + + + + source6 + 6 + [6:6] + 6 + + + + source7 + 7 + [7:7] + 7 + + + + source8 + 8 + [8:8] + 8 + + + + source9 + 9 + [9:9] + 9 + + + + source10 + 10 + [10:10] + 10 + + + + source11 + 11 + [11:11] + 11 + + + + source12 + 12 + [12:12] + 12 + + + + source13 + 13 + [13:13] + 13 + + + + source14 + 14 + [14:14] + 14 + + + + source15 + 15 + [15:15] + 15 + + + + source16 + 16 + [16:16] + 16 + + + + source17 + 17 + [17:17] + 17 + + + + source18 + 18 + [18:18] + 18 + + + + source19 + 19 + [19:19] + 19 + + + + + + EV_ENABLE + + 0x000c + 0x00 + 32 + + + source0 + 0 + [0:0] + 0 + + + + source1 + 1 + [1:1] + 1 + + + + source2 + 2 + [2:2] + 2 + + + + source3 + 3 + [3:3] + 3 + + + + source4 + 4 + [4:4] + 4 + + + + source5 + 5 + [5:5] + 5 + + + + source6 + 6 + [6:6] + 6 + + + + source7 + 7 + [7:7] + 7 + + + + source8 + 8 + [8:8] + 8 + + + + source9 + 9 + [9:9] + 9 + + + + source10 + 10 + [10:10] + 10 + + + + source11 + 11 + [11:11] + 11 + + + + source12 + 12 + [12:12] + 12 + + + + source13 + 13 + [13:13] + 13 + + + + source14 + 14 + [14:14] + 14 + + + + source15 + 15 + [15:15] + 15 + + + + source16 + 16 + [16:16] + 16 + + + + source17 + 17 + [17:17] + 17 + + + + source18 + 18 + [18:18] + 18 + + + + source19 + 19 + [19:19] + 19 + + + + + + + 0 + 0x10 + registers + + + irqarray19 + 19 + + + + IRQARRAY2 + 0xE0010000 + IRQARRAY2 + + + EV_SOFT + + 0x0000 + 0x00 + 32 + + + trigger + 19 + [19:0] + 0 + + + + + + EV_STATUS + + 0x0004 + 0x00 + 32 + + + source0 + 0 + [0:0] + 0 + + + + source1 + 1 + [1:1] + 1 + + + + source2 + 2 + [2:2] + 2 + + + + source3 + 3 + [3:3] + 3 + + + + source4 + 4 + [4:4] + 4 + + + + source5 + 5 + [5:5] + 5 + + + + source6 + 6 + [6:6] + 6 + + + + source7 + 7 + [7:7] + 7 + + + + source8 + 8 + [8:8] + 8 + + + + source9 + 9 + [9:9] + 9 + + + + source10 + 10 + [10:10] + 10 + + + + source11 + 11 + [11:11] + 11 + + + + source12 + 12 + [12:12] + 12 + + + + source13 + 13 + [13:13] + 13 + + + + source14 + 14 + [14:14] + 14 + + + + source15 + 15 + [15:15] + 15 + + + + source16 + 16 + [16:16] + 16 + + + + source17 + 17 + [17:17] + 17 + + + + source18 + 18 + [18:18] + 18 + + + + source19 + 19 + [19:19] + 19 + + + + + + EV_PENDING + + 0x0008 + 0x00 + 32 + + + source0 + 0 + [0:0] + 0 + + + + source1 + 1 + [1:1] + 1 + + + + source2 + 2 + [2:2] + 2 + + + + source3 + 3 + [3:3] + 3 + + + + source4 + 4 + [4:4] + 4 + + + + source5 + 5 + [5:5] + 5 + + + + source6 + 6 + [6:6] + 6 + + + + source7 + 7 + [7:7] + 7 + + + + source8 + 8 + [8:8] + 8 + + + + source9 + 9 + [9:9] + 9 + + + + source10 + 10 + [10:10] + 10 + + + + source11 + 11 + [11:11] + 11 + + + + source12 + 12 + [12:12] + 12 + + + + source13 + 13 + [13:13] + 13 + + + + source14 + 14 + [14:14] + 14 + + + + source15 + 15 + [15:15] + 15 + + + + source16 + 16 + [16:16] + 16 + + + + source17 + 17 + [17:17] + 17 + + + + source18 + 18 + [18:18] + 18 + + + + source19 + 19 + [19:19] + 19 + + + + + + EV_ENABLE + + 0x000c + 0x00 + 32 + + + source0 + 0 + [0:0] + 0 + + + + source1 + 1 + [1:1] + 1 + + + + source2 + 2 + [2:2] + 2 + + + + source3 + 3 + [3:3] + 3 + + + + source4 + 4 + [4:4] + 4 + + + + source5 + 5 + [5:5] + 5 + + + + source6 + 6 + [6:6] + 6 + + + + source7 + 7 + [7:7] + 7 + + + + source8 + 8 + [8:8] + 8 + + + + source9 + 9 + [9:9] + 9 + + + + source10 + 10 + [10:10] + 10 + + + + source11 + 11 + [11:11] + 11 + + + + source12 + 12 + [12:12] + 12 + + + + source13 + 13 + [13:13] + 13 + + + + source14 + 14 + [14:14] + 14 + + + + source15 + 15 + [15:15] + 15 + + + + source16 + 16 + [16:16] + 16 + + + + source17 + 17 + [17:17] + 17 + + + + source18 + 18 + [18:18] + 18 + + + + source19 + 19 + [19:19] + 19 + + + + + + + 0 + 0x10 + registers + + + irqarray2 + 2 + + + + IRQARRAY3 + 0xE0011000 + IRQARRAY3 + + + EV_SOFT + + 0x0000 + 0x00 + 32 + + + trigger + 19 + [19:0] + 0 + + + + + + EV_STATUS + + 0x0004 + 0x00 + 32 + + + source0 + 0 + [0:0] + 0 + + + + source1 + 1 + [1:1] + 1 + + + + source2 + 2 + [2:2] + 2 + + + + source3 + 3 + [3:3] + 3 + + + + source4 + 4 + [4:4] + 4 + + + + source5 + 5 + [5:5] + 5 + + + + source6 + 6 + [6:6] + 6 + + + + source7 + 7 + [7:7] + 7 + + + + source8 + 8 + [8:8] + 8 + + + + source9 + 9 + [9:9] + 9 + + + + source10 + 10 + [10:10] + 10 + + + + source11 + 11 + [11:11] + 11 + + + + source12 + 12 + [12:12] + 12 + + + + source13 + 13 + [13:13] + 13 + + + + source14 + 14 + [14:14] + 14 + + + + source15 + 15 + [15:15] + 15 + + + + source16 + 16 + [16:16] + 16 + + + + source17 + 17 + [17:17] + 17 + + + + source18 + 18 + [18:18] + 18 + + + + source19 + 19 + [19:19] + 19 + + + + + + EV_PENDING + + 0x0008 + 0x00 + 32 + + + source0 + 0 + [0:0] + 0 + + + + source1 + 1 + [1:1] + 1 + + + + source2 + 2 + [2:2] + 2 + + + + source3 + 3 + [3:3] + 3 + + + + source4 + 4 + [4:4] + 4 + + + + source5 + 5 + [5:5] + 5 + + + + source6 + 6 + [6:6] + 6 + + + + source7 + 7 + [7:7] + 7 + + + + source8 + 8 + [8:8] + 8 + + + + source9 + 9 + [9:9] + 9 + + + + source10 + 10 + [10:10] + 10 + + + + source11 + 11 + [11:11] + 11 + + + + source12 + 12 + [12:12] + 12 + + + + source13 + 13 + [13:13] + 13 + + + + source14 + 14 + [14:14] + 14 + + + + source15 + 15 + [15:15] + 15 + + + + source16 + 16 + [16:16] + 16 + + + + source17 + 17 + [17:17] + 17 + + + + source18 + 18 + [18:18] + 18 + + + + source19 + 19 + [19:19] + 19 + + + + + + EV_ENABLE + + 0x000c + 0x00 + 32 + + + source0 + 0 + [0:0] + 0 + + + + source1 + 1 + [1:1] + 1 + + + + source2 + 2 + [2:2] + 2 + + + + source3 + 3 + [3:3] + 3 + + + + source4 + 4 + [4:4] + 4 + + + + source5 + 5 + [5:5] + 5 + + + + source6 + 6 + [6:6] + 6 + + + + source7 + 7 + [7:7] + 7 + + + + source8 + 8 + [8:8] + 8 + + + + source9 + 9 + [9:9] + 9 + + + + source10 + 10 + [10:10] + 10 + + + + source11 + 11 + [11:11] + 11 + + + + source12 + 12 + [12:12] + 12 + + + + source13 + 13 + [13:13] + 13 + + + + source14 + 14 + [14:14] + 14 + + + + source15 + 15 + [15:15] + 15 + + + + source16 + 16 + [16:16] + 16 + + + + source17 + 17 + [17:17] + 17 + + + + source18 + 18 + [18:18] + 18 + + + + source19 + 19 + [19:19] + 19 + + + + + + + 0 + 0x10 + registers + + + irqarray3 + 3 + + + + IRQARRAY4 + 0xE0012000 + IRQARRAY4 + + + EV_SOFT + + 0x0000 + 0x00 + 32 + + + trigger + 19 + [19:0] + 0 + + + + + + EV_STATUS + + 0x0004 + 0x00 + 32 + + + source0 + 0 + [0:0] + 0 + + + + source1 + 1 + [1:1] + 1 + + + + source2 + 2 + [2:2] + 2 + + + + source3 + 3 + [3:3] + 3 + + + + source4 + 4 + [4:4] + 4 + + + + source5 + 5 + [5:5] + 5 + + + + source6 + 6 + [6:6] + 6 + + + + source7 + 7 + [7:7] + 7 + + + + source8 + 8 + [8:8] + 8 + + + + source9 + 9 + [9:9] + 9 + + + + source10 + 10 + [10:10] + 10 + + + + source11 + 11 + [11:11] + 11 + + + + source12 + 12 + [12:12] + 12 + + + + source13 + 13 + [13:13] + 13 + + + + source14 + 14 + [14:14] + 14 + + + + source15 + 15 + [15:15] + 15 + + + + source16 + 16 + [16:16] + 16 + + + + source17 + 17 + [17:17] + 17 + + + + source18 + 18 + [18:18] + 18 + + + + source19 + 19 + [19:19] + 19 + + + + + + EV_PENDING + + 0x0008 + 0x00 + 32 + + + source0 + 0 + [0:0] + 0 + + + + source1 + 1 + [1:1] + 1 + + + + source2 + 2 + [2:2] + 2 + + + + source3 + 3 + [3:3] + 3 + + + + source4 + 4 + [4:4] + 4 + + + + source5 + 5 + [5:5] + 5 + + + + source6 + 6 + [6:6] + 6 + + + + source7 + 7 + [7:7] + 7 + + + + source8 + 8 + [8:8] + 8 + + + + source9 + 9 + [9:9] + 9 + + + + source10 + 10 + [10:10] + 10 + + + + source11 + 11 + [11:11] + 11 + + + + source12 + 12 + [12:12] + 12 + + + + source13 + 13 + [13:13] + 13 + + + + source14 + 14 + [14:14] + 14 + + + + source15 + 15 + [15:15] + 15 + + + + source16 + 16 + [16:16] + 16 + + + + source17 + 17 + [17:17] + 17 + + + + source18 + 18 + [18:18] + 18 + + + + source19 + 19 + [19:19] + 19 + + + + + + EV_ENABLE + + 0x000c + 0x00 + 32 + + + source0 + 0 + [0:0] + 0 + + + + source1 + 1 + [1:1] + 1 + + + + source2 + 2 + [2:2] + 2 + + + + source3 + 3 + [3:3] + 3 + + + + source4 + 4 + [4:4] + 4 + + + + source5 + 5 + [5:5] + 5 + + + + source6 + 6 + [6:6] + 6 + + + + source7 + 7 + [7:7] + 7 + + + + source8 + 8 + [8:8] + 8 + + + + source9 + 9 + [9:9] + 9 + + + + source10 + 10 + [10:10] + 10 + + + + source11 + 11 + [11:11] + 11 + + + + source12 + 12 + [12:12] + 12 + + + + source13 + 13 + [13:13] + 13 + + + + source14 + 14 + [14:14] + 14 + + + + source15 + 15 + [15:15] + 15 + + + + source16 + 16 + [16:16] + 16 + + + + source17 + 17 + [17:17] + 17 + + + + source18 + 18 + [18:18] + 18 + + + + source19 + 19 + [19:19] + 19 + + + + + + + 0 + 0x10 + registers + + + irqarray4 + 4 + + + + IRQARRAY5 + 0xE0013000 + IRQARRAY5 + + + EV_SOFT + + 0x0000 + 0x00 + 32 + + + trigger + 19 + [19:0] + 0 + + + + + + EV_STATUS + + 0x0004 + 0x00 + 32 + + + source0 + 0 + [0:0] + 0 + + + + source1 + 1 + [1:1] + 1 + + + + source2 + 2 + [2:2] + 2 + + + + source3 + 3 + [3:3] + 3 + + + + source4 + 4 + [4:4] + 4 + + + + source5 + 5 + [5:5] + 5 + + + + source6 + 6 + [6:6] + 6 + + + + source7 + 7 + [7:7] + 7 + + + + source8 + 8 + [8:8] + 8 + + + + source9 + 9 + [9:9] + 9 + + + + source10 + 10 + [10:10] + 10 + + + + source11 + 11 + [11:11] + 11 + + + + source12 + 12 + [12:12] + 12 + + + + source13 + 13 + [13:13] + 13 + + + + source14 + 14 + [14:14] + 14 + + + + source15 + 15 + [15:15] + 15 + + + + source16 + 16 + [16:16] + 16 + + + + source17 + 17 + [17:17] + 17 + + + + source18 + 18 + [18:18] + 18 + + + + source19 + 19 + [19:19] + 19 + + + + + + EV_PENDING + + 0x0008 + 0x00 + 32 + + + source0 + 0 + [0:0] + 0 + + + + source1 + 1 + [1:1] + 1 + + + + source2 + 2 + [2:2] + 2 + + + + source3 + 3 + [3:3] + 3 + + + + source4 + 4 + [4:4] + 4 + + + + source5 + 5 + [5:5] + 5 + + + + source6 + 6 + [6:6] + 6 + + + + source7 + 7 + [7:7] + 7 + + + + source8 + 8 + [8:8] + 8 + + + + source9 + 9 + [9:9] + 9 + + + + source10 + 10 + [10:10] + 10 + + + + source11 + 11 + [11:11] + 11 + + + + source12 + 12 + [12:12] + 12 + + + + source13 + 13 + [13:13] + 13 + + + + source14 + 14 + [14:14] + 14 + + + + source15 + 15 + [15:15] + 15 + + + + source16 + 16 + [16:16] + 16 + + + + source17 + 17 + [17:17] + 17 + + + + source18 + 18 + [18:18] + 18 + + + + source19 + 19 + [19:19] + 19 + + + + + + EV_ENABLE + + 0x000c + 0x00 + 32 + + + source0 + 0 + [0:0] + 0 + + + + source1 + 1 + [1:1] + 1 + + + + source2 + 2 + [2:2] + 2 + + + + source3 + 3 + [3:3] + 3 + + + + source4 + 4 + [4:4] + 4 + + + + source5 + 5 + [5:5] + 5 + + + + source6 + 6 + [6:6] + 6 + + + + source7 + 7 + [7:7] + 7 + + + + source8 + 8 + [8:8] + 8 + + + + source9 + 9 + [9:9] + 9 + + + + source10 + 10 + [10:10] + 10 + + + + source11 + 11 + [11:11] + 11 + + + + source12 + 12 + [12:12] + 12 + + + + source13 + 13 + [13:13] + 13 + + + + source14 + 14 + [14:14] + 14 + + + + source15 + 15 + [15:15] + 15 + + + + source16 + 16 + [16:16] + 16 + + + + source17 + 17 + [17:17] + 17 + + + + source18 + 18 + [18:18] + 18 + + + + source19 + 19 + [19:19] + 19 + + + + + + + 0 + 0x10 + registers + + + irqarray5 + 5 + + + + IRQARRAY6 + 0xE0014000 + IRQARRAY6 + + + EV_SOFT + + 0x0000 + 0x00 + 32 + + + trigger + 19 + [19:0] + 0 + + + + + + EV_STATUS + + 0x0004 + 0x00 + 32 + + + source0 + 0 + [0:0] + 0 + + + + source1 + 1 + [1:1] + 1 + + + + source2 + 2 + [2:2] + 2 + + + + source3 + 3 + [3:3] + 3 + + + + source4 + 4 + [4:4] + 4 + + + + source5 + 5 + [5:5] + 5 + + + + source6 + 6 + [6:6] + 6 + + + + source7 + 7 + [7:7] + 7 + + + + source8 + 8 + [8:8] + 8 + + + + source9 + 9 + [9:9] + 9 + + + + source10 + 10 + [10:10] + 10 + + + + source11 + 11 + [11:11] + 11 + + + + source12 + 12 + [12:12] + 12 + + + + source13 + 13 + [13:13] + 13 + + + + source14 + 14 + [14:14] + 14 + + + + source15 + 15 + [15:15] + 15 + + + + source16 + 16 + [16:16] + 16 + + + + source17 + 17 + [17:17] + 17 + + + + source18 + 18 + [18:18] + 18 + + + + source19 + 19 + [19:19] + 19 + + + + + + EV_PENDING + + 0x0008 + 0x00 + 32 + + + source0 + 0 + [0:0] + 0 + + + + source1 + 1 + [1:1] + 1 + + + + source2 + 2 + [2:2] + 2 + + + + source3 + 3 + [3:3] + 3 + + + + source4 + 4 + [4:4] + 4 + + + + source5 + 5 + [5:5] + 5 + + + + source6 + 6 + [6:6] + 6 + + + + source7 + 7 + [7:7] + 7 + + + + source8 + 8 + [8:8] + 8 + + + + source9 + 9 + [9:9] + 9 + + + + source10 + 10 + [10:10] + 10 + + + + source11 + 11 + [11:11] + 11 + + + + source12 + 12 + [12:12] + 12 + + + + source13 + 13 + [13:13] + 13 + + + + source14 + 14 + [14:14] + 14 + + + + source15 + 15 + [15:15] + 15 + + + + source16 + 16 + [16:16] + 16 + + + + source17 + 17 + [17:17] + 17 + + + + source18 + 18 + [18:18] + 18 + + + + source19 + 19 + [19:19] + 19 + + + + + + EV_ENABLE + + 0x000c + 0x00 + 32 + + + source0 + 0 + [0:0] + 0 + + + + source1 + 1 + [1:1] + 1 + + + + source2 + 2 + [2:2] + 2 + + + + source3 + 3 + [3:3] + 3 + + + + source4 + 4 + [4:4] + 4 + + + + source5 + 5 + [5:5] + 5 + + + + source6 + 6 + [6:6] + 6 + + + + source7 + 7 + [7:7] + 7 + + + + source8 + 8 + [8:8] + 8 + + + + source9 + 9 + [9:9] + 9 + + + + source10 + 10 + [10:10] + 10 + + + + source11 + 11 + [11:11] + 11 + + + + source12 + 12 + [12:12] + 12 + + + + source13 + 13 + [13:13] + 13 + + + + source14 + 14 + [14:14] + 14 + + + + source15 + 15 + [15:15] + 15 + + + + source16 + 16 + [16:16] + 16 + + + + source17 + 17 + [17:17] + 17 + + + + source18 + 18 + [18:18] + 18 + + + + source19 + 19 + [19:19] + 19 + + + + + + + 0 + 0x10 + registers + + + irqarray6 + 6 + + + + IRQARRAY7 + 0xE0015000 + IRQARRAY7 + + + EV_SOFT + + 0x0000 + 0x00 + 32 + + + trigger + 19 + [19:0] + 0 + + + + + + EV_STATUS + + 0x0004 + 0x00 + 32 + + + source0 + 0 + [0:0] + 0 + + + + source1 + 1 + [1:1] + 1 + + + + source2 + 2 + [2:2] + 2 + + + + source3 + 3 + [3:3] + 3 + + + + source4 + 4 + [4:4] + 4 + + + + source5 + 5 + [5:5] + 5 + + + + source6 + 6 + [6:6] + 6 + + + + source7 + 7 + [7:7] + 7 + + + + source8 + 8 + [8:8] + 8 + + + + source9 + 9 + [9:9] + 9 + + + + source10 + 10 + [10:10] + 10 + + + + source11 + 11 + [11:11] + 11 + + + + source12 + 12 + [12:12] + 12 + + + + source13 + 13 + [13:13] + 13 + + + + source14 + 14 + [14:14] + 14 + + + + source15 + 15 + [15:15] + 15 + + + + source16 + 16 + [16:16] + 16 + + + + source17 + 17 + [17:17] + 17 + + + + source18 + 18 + [18:18] + 18 + + + + source19 + 19 + [19:19] + 19 + + + + + + EV_PENDING + + 0x0008 + 0x00 + 32 + + + source0 + 0 + [0:0] + 0 + + + + source1 + 1 + [1:1] + 1 + + + + source2 + 2 + [2:2] + 2 + + + + source3 + 3 + [3:3] + 3 + + + + source4 + 4 + [4:4] + 4 + + + + source5 + 5 + [5:5] + 5 + + + + source6 + 6 + [6:6] + 6 + + + + source7 + 7 + [7:7] + 7 + + + + source8 + 8 + [8:8] + 8 + + + + source9 + 9 + [9:9] + 9 + + + + source10 + 10 + [10:10] + 10 + + + + source11 + 11 + [11:11] + 11 + + + + source12 + 12 + [12:12] + 12 + + + + source13 + 13 + [13:13] + 13 + + + + source14 + 14 + [14:14] + 14 + + + + source15 + 15 + [15:15] + 15 + + + + source16 + 16 + [16:16] + 16 + + + + source17 + 17 + [17:17] + 17 + + + + source18 + 18 + [18:18] + 18 + + + + source19 + 19 + [19:19] + 19 + + + + + + EV_ENABLE + + 0x000c + 0x00 + 32 + + + source0 + 0 + [0:0] + 0 + + + + source1 + 1 + [1:1] + 1 + + + + source2 + 2 + [2:2] + 2 + + + + source3 + 3 + [3:3] + 3 + + + + source4 + 4 + [4:4] + 4 + + + + source5 + 5 + [5:5] + 5 + + + + source6 + 6 + [6:6] + 6 + + + + source7 + 7 + [7:7] + 7 + + + + source8 + 8 + [8:8] + 8 + + + + source9 + 9 + [9:9] + 9 + + + + source10 + 10 + [10:10] + 10 + + + + source11 + 11 + [11:11] + 11 + + + + source12 + 12 + [12:12] + 12 + + + + source13 + 13 + [13:13] + 13 + + + + source14 + 14 + [14:14] + 14 + + + + source15 + 15 + [15:15] + 15 + + + + source16 + 16 + [16:16] + 16 + + + + source17 + 17 + [17:17] + 17 + + + + source18 + 18 + [18:18] + 18 + + + + source19 + 19 + [19:19] + 19 + + + + + + + 0 + 0x10 + registers + + + irqarray7 + 7 + + + + IRQARRAY8 + 0xE0016000 + IRQARRAY8 + + + EV_SOFT + + 0x0000 + 0x00 + 32 + + + trigger + 19 + [19:0] + 0 + + + + + + EV_STATUS + + 0x0004 + 0x00 + 32 + + + source0 + 0 + [0:0] + 0 + + + + source1 + 1 + [1:1] + 1 + + + + source2 + 2 + [2:2] + 2 + + + + source3 + 3 + [3:3] + 3 + + + + source4 + 4 + [4:4] + 4 + + + + source5 + 5 + [5:5] + 5 + + + + source6 + 6 + [6:6] + 6 + + + + source7 + 7 + [7:7] + 7 + + + + source8 + 8 + [8:8] + 8 + + + + source9 + 9 + [9:9] + 9 + + + + source10 + 10 + [10:10] + 10 + + + + source11 + 11 + [11:11] + 11 + + + + source12 + 12 + [12:12] + 12 + + + + source13 + 13 + [13:13] + 13 + + + + source14 + 14 + [14:14] + 14 + + + + source15 + 15 + [15:15] + 15 + + + + source16 + 16 + [16:16] + 16 + + + + source17 + 17 + [17:17] + 17 + + + + source18 + 18 + [18:18] + 18 + + + + source19 + 19 + [19:19] + 19 + + + + + + EV_PENDING + + 0x0008 + 0x00 + 32 + + + source0 + 0 + [0:0] + 0 + + + + source1 + 1 + [1:1] + 1 + + + + source2 + 2 + [2:2] + 2 + + + + source3 + 3 + [3:3] + 3 + + + + source4 + 4 + [4:4] + 4 + + + + source5 + 5 + [5:5] + 5 + + + + source6 + 6 + [6:6] + 6 + + + + source7 + 7 + [7:7] + 7 + + + + source8 + 8 + [8:8] + 8 + + + + source9 + 9 + [9:9] + 9 + + + + source10 + 10 + [10:10] + 10 + + + + source11 + 11 + [11:11] + 11 + + + + source12 + 12 + [12:12] + 12 + + + + source13 + 13 + [13:13] + 13 + + + + source14 + 14 + [14:14] + 14 + + + + source15 + 15 + [15:15] + 15 + + + + source16 + 16 + [16:16] + 16 + + + + source17 + 17 + [17:17] + 17 + + + + source18 + 18 + [18:18] + 18 + + + + source19 + 19 + [19:19] + 19 + + + + + + EV_ENABLE + + 0x000c + 0x00 + 32 + + + source0 + 0 + [0:0] + 0 + + + + source1 + 1 + [1:1] + 1 + + + + source2 + 2 + [2:2] + 2 + + + + source3 + 3 + [3:3] + 3 + + + + source4 + 4 + [4:4] + 4 + + + + source5 + 5 + [5:5] + 5 + + + + source6 + 6 + [6:6] + 6 + + + + source7 + 7 + [7:7] + 7 + + + + source8 + 8 + [8:8] + 8 + + + + source9 + 9 + [9:9] + 9 + + + + source10 + 10 + [10:10] + 10 + + + + source11 + 11 + [11:11] + 11 + + + + source12 + 12 + [12:12] + 12 + + + + source13 + 13 + [13:13] + 13 + + + + source14 + 14 + [14:14] + 14 + + + + source15 + 15 + [15:15] + 15 + + + + source16 + 16 + [16:16] + 16 + + + + source17 + 17 + [17:17] + 17 + + + + source18 + 18 + [18:18] + 18 + + + + source19 + 19 + [19:19] + 19 + + + + + + + 0 + 0x10 + registers + + + irqarray8 + 8 + + + + IRQARRAY9 + 0xE0017000 + IRQARRAY9 + + + EV_SOFT + + 0x0000 + 0x00 + 32 + + + trigger + 19 + [19:0] + 0 + + + + + + EV_STATUS + + 0x0004 + 0x00 + 32 + + + source0 + 0 + [0:0] + 0 + + + + source1 + 1 + [1:1] + 1 + + + + source2 + 2 + [2:2] + 2 + + + + source3 + 3 + [3:3] + 3 + + + + source4 + 4 + [4:4] + 4 + + + + source5 + 5 + [5:5] + 5 + + + + source6 + 6 + [6:6] + 6 + + + + source7 + 7 + [7:7] + 7 + + + + source8 + 8 + [8:8] + 8 + + + + source9 + 9 + [9:9] + 9 + + + + source10 + 10 + [10:10] + 10 + + + + source11 + 11 + [11:11] + 11 + + + + source12 + 12 + [12:12] + 12 + + + + source13 + 13 + [13:13] + 13 + + + + source14 + 14 + [14:14] + 14 + + + + source15 + 15 + [15:15] + 15 + + + + source16 + 16 + [16:16] + 16 + + + + source17 + 17 + [17:17] + 17 + + + + source18 + 18 + [18:18] + 18 + + + + source19 + 19 + [19:19] + 19 + + + + + + EV_PENDING + + 0x0008 + 0x00 + 32 + + + source0 + 0 + [0:0] + 0 + + + + source1 + 1 + [1:1] + 1 + + + + source2 + 2 + [2:2] + 2 + + + + source3 + 3 + [3:3] + 3 + + + + source4 + 4 + [4:4] + 4 + + + + source5 + 5 + [5:5] + 5 + + + + source6 + 6 + [6:6] + 6 + + + + source7 + 7 + [7:7] + 7 + + + + source8 + 8 + [8:8] + 8 + + + + source9 + 9 + [9:9] + 9 + + + + source10 + 10 + [10:10] + 10 + + + + source11 + 11 + [11:11] + 11 + + + + source12 + 12 + [12:12] + 12 + + + + source13 + 13 + [13:13] + 13 + + + + source14 + 14 + [14:14] + 14 + + + + source15 + 15 + [15:15] + 15 + + + + source16 + 16 + [16:16] + 16 + + + + source17 + 17 + [17:17] + 17 + + + + source18 + 18 + [18:18] + 18 + + + + source19 + 19 + [19:19] + 19 + + + + + + EV_ENABLE + + 0x000c + 0x00 + 32 + + + source0 + 0 + [0:0] + 0 + + + + source1 + 1 + [1:1] + 1 + + + + source2 + 2 + [2:2] + 2 + + + + source3 + 3 + [3:3] + 3 + + + + source4 + 4 + [4:4] + 4 + + + + source5 + 5 + [5:5] + 5 + + + + source6 + 6 + [6:6] + 6 + + + + source7 + 7 + [7:7] + 7 + + + + source8 + 8 + [8:8] + 8 + + + + source9 + 9 + [9:9] + 9 + + + + source10 + 10 + [10:10] + 10 + + + + source11 + 11 + [11:11] + 11 + + + + source12 + 12 + [12:12] + 12 + + + + source13 + 13 + [13:13] + 13 + + + + source14 + 14 + [14:14] + 14 + + + + source15 + 15 + [15:15] + 15 + + + + source16 + 16 + [16:16] + 16 + + + + source17 + 17 + [17:17] + 17 + + + + source18 + 18 + [18:18] + 18 + + + + source19 + 19 + [19:19] + 19 + + + + + + + 0 + 0x10 + registers + + + irqarray9 + 9 + + + + MAILBOX + 0xE0018000 + MAILBOX + + + WDATA + + 0x0000 + 0x00 + 32 + + + wdata + 31 + [31:0] + 0 + + + + + RDATA + + 0x0004 + 0x00 + 32 + + + rdata + 31 + [31:0] + 0 + + + + + EV_STATUS + + 0x0008 + 0x00 + 32 + + + available + 0 + [0:0] + 0 + + + + abort_init + 1 + [1:1] + 1 + + + + abort_done + 2 + [2:2] + 2 + + + + error + 3 + [3:3] + 3 + + + + + + EV_PENDING + + 0x000c + 0x00 + 32 + + + available + 0 + [0:0] + 0 + + + + abort_init + 1 + [1:1] + 1 + + + + abort_done + 2 + [2:2] + 2 + + + + error + 3 + [3:3] + 3 + + + + + + EV_ENABLE + + 0x0010 + 0x00 + 32 + + + available + 0 + [0:0] + 0 + + + + abort_init + 1 + [1:1] + 1 + + + + abort_done + 2 + [2:2] + 2 + + + + error + 3 + [3:3] + 3 + + + + + + STATUS + 0x0014 + 0x00 + 32 + + + rx_words + 10 + [10:0] + 0 + + + + tx_words + 21 + [21:11] + 11 + + + + abort_in_progress + 22 + [22:22] + 22 + + + + abort_ack + 23 + [23:23] + 23 + + + + tx_err + 24 + [24:24] + 24 + + + + rx_err + 25 + [25:25] + 25 + + + + + + CONTROL + 0x0018 + 0x00 + 32 + + + abort + 0 + [0:0] + 0 + + + + + + DONE + 0x001c + 0x00 + 32 + + + done + 0 + [0:0] + 0 + + + + + + + 0 + 0x20 + registers + + + mailbox + 22 + + + + MB_CLIENT + 0xE0019000 + MB_CLIENT + + + WDATA + + 0x0000 + 0x00 + 32 + + + wdata + 31 + [31:0] + 0 + + + + + RDATA + + 0x0004 + 0x00 + 32 + + + rdata + 31 + [31:0] + 0 + + + + + EV_STATUS + + 0x0008 + 0x00 + 32 + + + available + 0 + [0:0] + 0 + + + + abort_init + 1 + [1:1] + 1 + + + + abort_done + 2 + [2:2] + 2 + + + + error + 3 + [3:3] + 3 + + + + + + EV_PENDING + + 0x000c + 0x00 + 32 + + + available + 0 + [0:0] + 0 + + + + abort_init + 1 + [1:1] + 1 + + + + abort_done + 2 + [2:2] + 2 + + + + error + 3 + [3:3] + 3 + + + + + + EV_ENABLE + + 0x0010 + 0x00 + 32 + + + available + 0 + [0:0] + 0 + + + + abort_init + 1 + [1:1] + 1 + + + + abort_done + 2 + [2:2] + 2 + + + + error + 3 + [3:3] + 3 + + + + + + STATUS + 0x0014 + 0x00 + 32 + + + rx_avail + 0 + [0:0] + 0 + + + + tx_free + 1 + [1:1] + 1 + + + + abort_in_progress + 2 + [2:2] + 2 + + + + abort_ack + 3 + [3:3] + 3 + + + + tx_err + 4 + [4:4] + 4 + + + + rx_err + 5 + [5:5] + 5 + + + + + + CONTROL + 0x0018 + 0x00 + 32 + + + abort + 0 + [0:0] + 0 + + + + + + DONE + 0x001c + 0x00 + 32 + + + done + 0 + [0:0] + 0 + + + + + + + 0 + 0x20 + registers + + + mb_client + 23 + + + + RESETVALUE + 0xE001A000 + RESETVALUE + + + PC + + 0x0000 + 0x00 + 32 + + + pc + 31 + [31:0] + 0 + + + + + + 0 + 0x4 + registers + + + + TICKTIMER + 0xE001B000 + TICKTIMER + + + CONTROL + 0x0000 + 0x00 + 32 + + + reset + 0 + [0:0] + 0 + + + + + + TIME1 + + 0x0004 + 0x00 + 32 + + + time + 31 + [31:0] + 0 + + + + + TIME0 + + 0x0008 + 0x00 + 32 + + + time + 31 + [31:0] + 0 + + + + + MSLEEP_TARGET1 + + 0x000c + 0x00 + 32 + + + msleep_target + 31 + [31:0] + 0 + + + + + MSLEEP_TARGET0 + + 0x0010 + 0x00 + 32 + + + msleep_target + 31 + [31:0] + 0 + + + + + EV_STATUS + + 0x0014 + 0x00 + 32 + + + alarm + 0 + [0:0] + 0 + + + + + + EV_PENDING + + 0x0018 + 0x00 + 32 + + + alarm + 0 + [0:0] + 0 + + + + + + EV_ENABLE + + 0x001c + 0x00 + 32 + + + alarm + 0 + [0:0] + 0 + + + + + + CLOCKS_PER_TICK + + 0x0020 + 0xc3500 + 32 + + + clocks_per_tick + 31 + [31:0] + 0 + + + + + + 0 + 0x24 + registers + + + ticktimer + 20 + + + + + + + CSR + 0xE0000000 + 0x00040000 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/utralib/cramium/daric.svd b/utralib/cramium/daric.svd new file mode 100644 index 000000000..4b18fc041 --- /dev/null +++ b/utralib/cramium/daric.svd @@ -0,0 +1,9418 @@ + + + + cramium + SOC + + + 8 + 32 + 32 + read-write + 0x00000000 + 0xFFFFFFFF + + + + + PL230 + PL230 DMA Controller Core + 1073811456 + + 0x0 + 0x40 + registers + + + 0x40 + 0xc + reserved + + + 0x4c + 0x4 + registers + + + + STATUS + DMA Status Register + 0x00 + 32 + read-only + 0x101f0000 + 0xffffff0f + + + TEST_STATUS + Test status configuration + 28 + 4 + read-only + + + CHNLS_MINUS1 + Number of available DMA channels minus 1 + 16 + 5 + read-only + + + STATE + Current state of the control machine + 4 + 4 + read-only + + + MASTER_ENABLE + Master enable status + 0 + 1 + read-only + + + + + CFG + DMA Configuration Register + 0x04 + 32 + write-only + 0x00000000 + 0x00000000 + + + CHNL_PROT_CTRL + Set AHB-Lite configuration + 5 + 3 + read-only + + + MASTER_ENABLE + MASTER_ENABLE + 0 + 1 + write-only + + + + + CTRLBASEPTR + DMA Control Data Base Pointer Register + 0x08 + 32 + read-write + 0x00000000 + 0xffffffff + + + CTRL_BASE_PTR + CTRL_BASE_PTR + 8 + 24 + read-write + + + + + ALTCTRLBASEPTR + DMA Channel Alternate Control Data Base Pointer Register + 0x0C + 32 + read-only + 0x00000000 + 0xffffffff + + + ALT_CTRL_BASE_PTR + ALT_CTRL_BASE_PTR + 0 + 32 + read-only + + + + + DMA_WAITONREQ_STATUS + Channel wait on request status + 0x10 + 32 + read-only + 0x00000000 + 0xffffffff + + + DMA_WAITONREQ_STATUS + Wait on request status, one bit per channel + 0 + 8 + read-only + + + + + CHNLSWREQUEST + DMA Channel Software Request Register + 0x14 + 32 + write-only + 0x00000000 + 0x00000000 + + + CHNL_SW_REQUEST + CHNL_SW_REQUEST + 0 + 8 + write-only + + + + + CHNLUSEBURSTSET + DMA Channel Useburst Set Register + 0x18 + 32 + read-write + 0x00000000 + 0xffffffff + + + CHNL_USEBURST_SET + CHNL_USEBURST_SET + 0 + 8 + read-write + + + + + CHNLUSEBURSTCLR + DMA Channel Useburst Clear Register + 0x1C + 32 + write-only + 0x00000000 + 0x00000000 + + + CHNL_USEBURST_CLR + CHNL_USEBURST_CLR + 0 + 8 + write-only + + + + + CHNLREQMASKSET + DMA Channel Request Mask Set Register + 0x20 + 32 + read-write + 0x00000000 + 0xffffffff + + + CHNL_REQ_MASK_SET + CHNL_REQ_MASK_SET + 0 + 8 + read-write + + + + + CHNLREQMASKCLR + DMA Channel Request Mask Clear Register + 0x24 + 32 + write-only + 0x00000000 + 0x00000000 + + + CHNL_REQ_MASK_CLR + CHNL_REQ_MASK_CLR + 0 + 8 + write-only + + + + + CHNLENABLESET + DMA Channel Enable Set Register + 0x28 + 32 + read-write + 0x00000000 + 0xffffffff + + + CHNL_ENABLE_SET + CHNL_ENABLE_SET + 0 + 8 + read-write + + + + + CHNLENABLECLR + DMA Channel Enable Clear Register + 0x2C + 32 + write-only + 0x00000000 + 0x00000000 + + + CHNL_ENABLE_CLR + CHNL_ENABLE_CLR + 0 + 8 + write-only + + + + + CHNLPRIALTSET + DMA Channel Primary-Alternate Set Register + 0x30 + 32 + read-write + 0x00000000 + 0xffffffff + + + CHNL_PRI_ALT_SET + CHNL_PRI_ALT_SET + 0 + 8 + read-write + + + + + CHNLPRIALTCLR + DMA Channel Primary-Alternate Clear Register + 0x34 + 32 + write-only + 0x00000000 + 0x00000000 + + + CHNL_PRI_ALT_CLR + CHNL_PRI_ALT_CLR + 0 + 8 + write-only + + + + + CHNLPRIORITYSET + DMA Channel Priority Set Register + 0x38 + 32 + read-write + 0x00000000 + 0xffffffff + + + CHNL_PRIORITY_SET + CHNL_PRIORITY_SET + 0 + 8 + read-write + + + + + CHNLPRIORITYCLR + DMA Channel Priority Clear Register + 0x3C + 32 + write-only + 0x00000000 + 0x00000000 + + + CHNL_PRIORITY_CLR + CHNL_PRIORITY_CLR + 0 + 8 + write-only + + + + + ERRCLR + DMA Bus Error Clear Register + 0x4C + 32 + read-write + 0x00000000 + 0xffffffff + + + ERR_CLR + ERR_CLR + 0 + 1 + read-write + + + + + PERIPH_ID_0 + Peripheral ID byte 0 + 0xFE0 + 32 + read-write + 0x00000000 + 0xffffffff + + + PART_NUMBER_LSB + Identifies the part number + 0 + 8 + read-only + + + + + PERIPH_ID_1 + Peripheral ID byte 1 + 0xFE4 + 32 + read-write + 0x00000000 + 0xffffffff + + + PART_NUMBER_MSB + Identifies the part number + 0 + 4 + read-only + + + JEP106_LSB + Designer ID LSB + 4 + 3 + read-only + + + + + PERIPH_ID_2 + Peripheral ID byte 2 + 0xFE8 + 32 + read-write + 0x00000000 + 0xffffffff + + + JEP106_MSB + Designer ID MSB + 0 + 3 + read-only + + + JEDEC_USED + Identifies if JP106 ID code is used + 3 + 1 + read-only + + + REVISION + Identifies revision number of peripheral + 4 + 4 + read-only + + + + + + + AES + 0x4002D000 + AES + + + SFR_CRFUNC + 0x0000 + 0x00 + 32 + + + sfr_crfunc + 7 + [7:0] + 0 + + + + + + SFR_AR + 0x0004 + 0x00 + 32 + + + sfr_ar + 31 + [31:0] + 0 + + + + + + SFR_SRMFSM + 0x0008 + 0x00 + 32 + + + sfr_srmfsm + 7 + [7:0] + 0 + + + + + + SFR_FR + 0x000c + 0x00 + 32 + + + mfsm_done + 0 + [0:0] + 0 + + + + acore_done + 1 + [1:1] + 1 + + + + chnlo_done + 2 + [2:2] + 2 + + + + chnli_done + 3 + [3:3] + 3 + + + + + + SFR_OPT + 0x0010 + 0x00 + 32 + + + opt_klen0 + 3 + [3:0] + 0 + + + + opt_mode0 + 7 + [7:4] + 4 + + + + opt_ifstart0 + 8 + [8:8] + 8 + + + + + + SFR_OPT1 + 0x0014 + 0x00 + 32 + + + sfr_opt1 + 15 + [15:0] + 0 + + + + + + SFR_SEGPTR_PTRID_IV + 0x0030 + 0x00 + 32 + + + PTRID_IV + 11 + [11:0] + 0 + + + + + + SFR_SEGPTR_PTRID_AKEY + 0x0034 + 0x00 + 32 + + + PTRID_AKEY + 11 + [11:0] + 0 + + + + + + SFR_SEGPTR_PTRID_AIB + 0x0038 + 0x00 + 32 + + + PTRID_AIB + 11 + [11:0] + 0 + + + + + + SFR_SEGPTR_PTRID_AOB + 0x003c + 0x00 + 32 + + + PTRID_AOB + 11 + [11:0] + 0 + + + + + + + 0 + 0x40 + registers + + + + COMBOHASH + 0x4002B000 + COMBOHASH + + + SFR_CRFUNC + 0x0000 + 0x00 + 32 + + + cr_func + 7 + [7:0] + 0 + + + + + + SFR_AR + 0x0004 + 0x00 + 32 + + + sfr_ar + 31 + [31:0] + 0 + + + + + + SFR_SRMFSM + 0x0008 + 0x00 + 32 + + + mfsm + 7 + [7:0] + 0 + + + + + + SFR_FR + 0x000c + 0x00 + 32 + + + mfsm_done + 0 + [0:0] + 0 + + + + hash_done + 1 + [1:1] + 1 + + + + chnlo_done + 2 + [2:2] + 2 + + + + chnli_done + 3 + [3:3] + 3 + + + + + + SFR_OPT1 + 0x0010 + 0x00 + 32 + + + cr_opt_hashcnt + 15 + [15:0] + 0 + + + + + + SFR_OPT2 + 0x0014 + 0x00 + 32 + + + cr_opt_scrtchk + 0 + [0:0] + 0 + + + + cr_opt_ifsob + 1 + [1:1] + 1 + + + + cr_opt_ifstart + 2 + [2:2] + 2 + + + + + + SFR_SEGPTR_SEGID_LKEY + 0x0020 + 0x00 + 32 + + + SEGID_LKEY + 11 + [11:0] + 0 + + + + + + SFR_SEGPTR_SEGID_KEY + 0x0024 + 0x00 + 32 + + + SEGID_KEY + 11 + [11:0] + 0 + + + + + + SFR_SEGPTR_SEGID_SCRT + 0x002c + 0x00 + 32 + + + SEGID_SCRT + 11 + [11:0] + 0 + + + + + + SFR_SEGPTR_SEGID_MSG + 0x0030 + 0x00 + 32 + + + SEGID_MSG + 11 + [11:0] + 0 + + + + + + SFR_SEGPTR_SEGID_HOUT + 0x0034 + 0x00 + 32 + + + SEGID_HOUT + 11 + [11:0] + 0 + + + + + + SFR_SEGPTR_SEGID_SOB + 0x0038 + 0x00 + 32 + + + SEGID_SOB + 11 + [11:0] + 0 + + + + + + + 0 + 0x3c + registers + + + + PKE + 0x4002C000 + PKE + + + SFR_CRFUNC + 0x0000 + 0x00 + 32 + + + sfr_crfunc + 7 + [7:0] + 0 + + + + + + SFR_AR + 0x0004 + 0x00 + 32 + + + sfr_ar + 31 + [31:0] + 0 + + + + + + SFR_SRMFSM + 0x0008 + 0x00 + 32 + + + mfsm + 7 + [7:0] + 0 + + + + modinvready + 8 + [8:8] + 8 + + + + + + SFR_FR + 0x000c + 0x00 + 32 + + + mfsm_done + 0 + [0:0] + 0 + + + + pcore_done + 1 + [1:1] + 1 + + + + chnlo_done + 2 + [2:2] + 2 + + + + chnli_done + 3 + [3:3] + 3 + + + + chnlx_done + 4 + [4:4] + 4 + + + + + + SFR_OPTNW + 0x0010 + 0x00 + 32 + + + sfr_optnw + 12 + [12:0] + 0 + + + + + + SFR_OPTEW + 0x0014 + 0x00 + 32 + + + sfr_optew + 12 + [12:0] + 0 + + + + + + SFR_OPTMASK + 0x0020 + 0x00 + 32 + + + sfr_optmask + 15 + [15:0] + 0 + + + + + + SFR_SEGPTR_PTRID_PCON + 0x0030 + 0x00 + 32 + + + PTRID_PCON + 11 + [11:0] + 0 + + + + + + SFR_SEGPTR_PTRID_PIB0 + 0x0034 + 0x00 + 32 + + + PTRID_PIB0 + 11 + [11:0] + 0 + + + + + + SFR_SEGPTR_PTRID_PIB1 + 0x0038 + 0x00 + 32 + + + PTRID_PIB1 + 11 + [11:0] + 0 + + + + + + SFR_SEGPTR_PTRID_PKB + 0x003c + 0x00 + 32 + + + PTRID_PKB + 11 + [11:0] + 0 + + + + + + SFR_SEGPTR_PTRID_POB + 0x0040 + 0x00 + 32 + + + PTRID_POB + 11 + [11:0] + 0 + + + + + + + 0 + 0x44 + registers + + + + SCEDMA + 0x40029000 + SCEDMA + + + SFR_SCHSTART_AR + 0x0000 + 0x00 + 32 + + + sfr_schstart_ar + 31 + [31:0] + 0 + + + + + + SFR_XCH_FUNC + 0x0010 + 0x00 + 32 + + + sfr_xch_func + 0 + [0:0] + 0 + + + + + + SFR_XCH_OPT + 0x0014 + 0x00 + 32 + + + sfr_xch_opt + 7 + [7:0] + 0 + + + + + + SFR_XCH_AXSTART + 0x0018 + 0x00 + 32 + + + sfr_xch_axstart + 31 + [31:0] + 0 + + + + + + SFR_XCH_SEGID + 0x001c + 0x00 + 32 + + + sfr_xch_segid + 7 + [7:0] + 0 + + + + + + SFR_XCH_SEGSTART + 0x0020 + 0x00 + 32 + + + xchcr_segstart + 11 + [11:0] + 0 + + + + + + SFR_XCH_TRANSIZE + 0x0024 + 0x00 + 32 + + + xchcr_transize + 29 + [29:0] + 0 + + + + + + SFR_SCH_FUNC + 0x0030 + 0x00 + 32 + + + sfr_sch_func + 0 + [0:0] + 0 + + + + + + SFR_SCH_OPT + 0x0034 + 0x00 + 32 + + + sfr_sch_opt + 7 + [7:0] + 0 + + + + + + SFR_SCH_AXSTART + 0x0038 + 0x00 + 32 + + + sfr_sch_axstart + 31 + [31:0] + 0 + + + + + + SFR_SCH_SEGID + 0x003c + 0x00 + 32 + + + sfr_sch_segid + 7 + [7:0] + 0 + + + + + + SFR_SCH_SEGSTART + 0x0040 + 0x00 + 32 + + + schcr_segstart + 11 + [11:0] + 0 + + + + + + SFR_SCH_TRANSIZE + 0x0044 + 0x00 + 32 + + + schcr_transize + 29 + [29:0] + 0 + + + + + + SFR_ICH_OPT + 0x0050 + 0x00 + 32 + + + sfr_ich_opt + 3 + [3:0] + 0 + + + + + + SFR_ICH_SEGID + 0x0054 + 0x00 + 32 + + + sfr_ich_segid + 15 + [15:0] + 0 + + + + + + SFR_ICH_RPSTART + 0x0058 + 0x00 + 32 + + + ichcr_rpstart + 11 + [11:0] + 0 + + + + + + SFR_ICH_WPSTART + 0x005c + 0x00 + 32 + + + ichcr_wpstart + 11 + [11:0] + 0 + + + + + + SFR_ICH_TRANSIZE + 0x0060 + 0x00 + 32 + + + ichcr_transize + 11 + [11:0] + 0 + + + + + + + 0 + 0x64 + registers + + + + SCE_GLBSFR + 0x40028000 + SCE_GLBSFR + + + SFR_SCEMODE + 0x0000 + 0x00 + 32 + + + cr_scemode + 1 + [1:0] + 0 + + + + + + SFR_SUBEN + 0x0004 + 0x00 + 32 + + + cr_suben + 15 + [15:0] + 0 + + + + + + SFR_AHBS + 0x0008 + 0x00 + 32 + + + cr_ahbsopt + 4 + [4:0] + 0 + + + + + + SFR_SRBUSY + 0x0010 + 0x00 + 32 + + + sr_busy + 15 + [15:0] + 0 + + + + + + SFR_FRDONE + 0x0014 + 0x00 + 32 + + + fr_done + 15 + [15:0] + 0 + + + + + + SFR_FRERR + 0x0018 + 0x00 + 32 + + + fr_err + 15 + [15:0] + 0 + + + + + + SFR_ARCLR + 0x001c + 0x00 + 32 + + + ar_clrram + 31 + [31:0] + 0 + + + + + + SFR_TICKCYC + 0x0020 + 0x00 + 32 + + + sfr_tickcyc + 7 + [7:0] + 0 + + + + + + SFR_TICKCNT + 0x0024 + 0x00 + 32 + + + sfr_tickcnt + 31 + [31:0] + 0 + + + + + + SFR_FFEN + 0x0030 + 0x00 + 32 + + + cr_ffen + 5 + [5:0] + 0 + + + + + + SFR_FFCLR + 0x0034 + 0x00 + 32 + + + ar_ffclr + 31 + [31:0] + 0 + + + + + + SFR_FFCNT_SR_FF0 + 0x0040 + 0x00 + 32 + + + sr_ff0 + 15 + [15:0] + 0 + + + + + + SFR_FFCNT_SR_FF1 + 0x0044 + 0x00 + 32 + + + sr_ff1 + 15 + [15:0] + 0 + + + + + + SFR_FFCNT_SR_FF2 + 0x0048 + 0x00 + 32 + + + sr_ff2 + 15 + [15:0] + 0 + + + + + + SFR_FFCNT_SR_FF3 + 0x004c + 0x00 + 32 + + + sr_ff3 + 15 + [15:0] + 0 + + + + + + SFR_FFCNT_SR_FF4 + 0x0050 + 0x00 + 32 + + + sr_ff4 + 15 + [15:0] + 0 + + + + + + SFR_FFCNT_SR_FF5 + 0x0054 + 0x00 + 32 + + + sr_ff5 + 15 + [15:0] + 0 + + + + + + + 0 + 0x58 + registers + + + + TRNG + 0x4002E000 + TRNG + + + SFR_CRFUNC + 0x0000 + 0x00 + 32 + + + cr_func + 7 + [7:0] + 0 + + + + + + SFR_AR + 0x0004 + 0x00 + 32 + + + start + 31 + [31:0] + 0 + + + + + + SFR_SRMFSM + 0x0008 + 0x00 + 32 + + + mfsm + 0 + [0:0] + 0 + + + + modinvready + 1 + [1:1] + 1 + + + + + + SFR_FR + 0x000c + 0x00 + 32 + + + mfsm_done + 0 + [0:0] + 0 + + + + pcore_done + 1 + [1:1] + 1 + + + + chnlo_done + 2 + [2:2] + 2 + + + + chnli_done + 3 + [3:3] + 3 + + + + chnlx_done + 4 + [4:4] + 4 + + + + + + SFR_OPTNW + 0x0010 + 0x00 + 32 + + + opt_nw + 12 + [12:0] + 0 + + + + + + SFR_OPTEW + 0x0014 + 0x00 + 32 + + + opt_ew + 12 + [12:0] + 0 + + + + + + SFR_OPTMASK + 0x0020 + 0x00 + 32 + + + opt_mask + 15 + [15:0] + 0 + + + + + + SFR_SEGPTR_CR_SEGPTRSTART0 + 0x0030 + 0x00 + 32 + + + cr_segptrstart0 + 11 + [11:0] + 0 + + + + + + SFR_SEGPTR_CR_SEGPTRSTART1 + 0x0034 + 0x00 + 32 + + + cr_segptrstart1 + 11 + [11:0] + 0 + + + + + + SFR_SEGPTR_CR_SEGPTRSTART2 + 0x0038 + 0x00 + 32 + + + cr_segptrstart2 + 11 + [11:0] + 0 + + + + + + SFR_SEGPTR_CR_SEGPTRSTART3 + 0x003c + 0x00 + 32 + + + cr_segptrstart3 + 11 + [11:0] + 0 + + + + + + SFR_SEGPTR_CR_SEGPTRSTART4 + 0x0040 + 0x00 + 32 + + + cr_segptrstart4 + 11 + [11:0] + 0 + + + + + + + 0 + 0x44 + registers + + + + ALU + 0x4002F000 + ALU + + + + 0 + 0x4 + registers + + + + DUART + 0x40042000 + DUART + + + SFR_TXD + 0x0000 + 0x00 + 32 + + + sfr_txd + 7 + [7:0] + 0 + + + + + + SFR_CR + 0x0004 + 0x00 + 32 + + + sfr_cr + 0 + [0:0] + 0 + + + + + + SFR_SR + 0x0008 + 0x00 + 32 + + + sfr_sr + 0 + [0:0] + 0 + + + + + + SFR_ETUC + 0x000c + 0x00 + 32 + + + sfr_etuc + 15 + [15:0] + 0 + + + + + + + 0 + 0x10 + registers + + + + WDG_INTF + 0x40041000 + WDG_INTF + + + + 0 + 0x4 + registers + + + + TIMER_INTF + 0x40043000 + TIMER_INTF + + + + 0 + 0x4 + registers + + + + EVC + 0x40044000 + EVC + + + SFR_CM7EVSEL_CM7EVSEL0 + 0x0000 + 0x00 + 32 + + + cm7evsel0 + 7 + [7:0] + 0 + + + + + + SFR_CM7EVSEL_CM7EVSEL1 + 0x0004 + 0x00 + 32 + + + cm7evsel1 + 7 + [7:0] + 0 + + + + + + SFR_CM7EVSEL_CM7EVSEL2 + 0x0008 + 0x00 + 32 + + + cm7evsel2 + 7 + [7:0] + 0 + + + + + + SFR_CM7EVSEL_CM7EVSEL3 + 0x000c + 0x00 + 32 + + + cm7evsel3 + 7 + [7:0] + 0 + + + + + + SFR_CM7EVSEL_CM7EVSEL4 + 0x0010 + 0x00 + 32 + + + cm7evsel4 + 7 + [7:0] + 0 + + + + + + SFR_CM7EVSEL_CM7EVSEL5 + 0x0014 + 0x00 + 32 + + + cm7evsel5 + 7 + [7:0] + 0 + + + + + + SFR_CM7EVSEL_CM7EVSEL6 + 0x0018 + 0x00 + 32 + + + cm7evsel6 + 7 + [7:0] + 0 + + + + + + SFR_CM7EVSEL_CM7EVSEL7 + 0x001c + 0x00 + 32 + + + cm7evsel7 + 7 + [7:0] + 0 + + + + + + SFR_CM7EVEN + 0x0020 + 0x00 + 32 + + + cm7even + 7 + [7:0] + 0 + + + + + + SFR_CM7EVFR + 0x0024 + 0x00 + 32 + + + cm7evs + 7 + [7:0] + 0 + + + + + + SFR_TMREVSEL + 0x0030 + 0x00 + 32 + + + tmr_evsel + 15 + [15:0] + 0 + + + + + + SFR_PWMEVSEL + 0x0034 + 0x00 + 32 + + + pwm_evsel + 31 + [31:0] + 0 + + + + + + SFR_IFEVEN_IFEVEN0 + 0x0040 + 0x00 + 32 + + + ifeven0 + 31 + [31:0] + 0 + + + + + + SFR_IFEVEN_IFEVEN1 + 0x0044 + 0x00 + 32 + + + ifeven1 + 31 + [31:0] + 0 + + + + + + SFR_IFEVEN_IFEVEN2 + 0x0048 + 0x00 + 32 + + + ifeven2 + 31 + [31:0] + 0 + + + + + + SFR_IFEVEN_IFEVEN3 + 0x004c + 0x00 + 32 + + + ifeven3 + 31 + [31:0] + 0 + + + + + + SFR_IFEVEN_IFEVEN4 + 0x0050 + 0x00 + 32 + + + ifeven4 + 31 + [31:0] + 0 + + + + + + SFR_IFEVEN_IFEVEN5 + 0x0054 + 0x00 + 32 + + + ifeven5 + 31 + [31:0] + 0 + + + + + + SFR_IFEVEN_IFEVEN6 + 0x0058 + 0x00 + 32 + + + ifeven6 + 31 + [31:0] + 0 + + + + + + SFR_IFEVEN_IFEVEN7 + 0x005c + 0x00 + 32 + + + ifeven7 + 31 + [31:0] + 0 + + + + + + SFR_IFEVERRFR + 0x0060 + 0x00 + 32 + + + ifev_errs + 31 + [31:0] + 0 + + + + + + SFR_CM7ERRFR + 0x0080 + 0x00 + 32 + + + errin + 31 + [31:0] + 0 + + + + + + + 0 + 0x84 + registers + + + + SYSCTRL + 0x40040000 + SYSCTRL + + + SFR_CGUSEC + 0x0000 + 0x00 + 32 + + + sfr_cgusec + 15 + [15:0] + 0 + + + + + + SFR_CGULP + 0x0004 + 0x00 + 32 + + + sfr_cgulp + 15 + [15:0] + 0 + + + + + + SFR_CGUSEL0 + 0x0010 + 0x00 + 32 + + + sfr_cgusel0 + 1 + [1:0] + 0 + + + + + + SFR_CGUFD_CFGFDCR0 + 0x0014 + 0x00 + 32 + + + cfgfdcr0 + 15 + [15:0] + 0 + + + + + + SFR_CGUFD_CFGFDCR1 + 0x0018 + 0x00 + 32 + + + cfgfdcr1 + 15 + [15:0] + 0 + + + + + + SFR_CGUFD_CFGFDCR2 + 0x001c + 0x00 + 32 + + + cfgfdcr2 + 15 + [15:0] + 0 + + + + + + SFR_CGUFD_CFGFDCR3 + 0x0020 + 0x00 + 32 + + + cfgfdcr3 + 15 + [15:0] + 0 + + + + + + SFR_CGUFD_CFGFDCR4 + 0x0024 + 0x00 + 32 + + + cfgfdcr4 + 15 + [15:0] + 0 + + + + + + SFR_CGUSET + 0x002c + 0x00 + 32 + + + sfr_cguset + 31 + [31:0] + 0 + + + + + + SFR_CGUSEL1 + 0x0030 + 0x00 + 32 + + + sfr_cgusel1 + 0 + [0:0] + 0 + + + + + + SFR_CGUFSSR_FSFREQ0 + 0x0040 + 0x00 + 32 + + + fsfreq0 + 15 + [15:0] + 0 + + + + + + SFR_CGUFSSR_FSFREQ1 + 0x0044 + 0x00 + 32 + + + fsfreq1 + 15 + [15:0] + 0 + + + + + + SFR_CGUFSSR_FSFREQ2 + 0x0048 + 0x00 + 32 + + + fsfreq2 + 15 + [15:0] + 0 + + + + + + SFR_CGUFSSR_FSFREQ3 + 0x004c + 0x00 + 32 + + + fsfreq3 + 15 + [15:0] + 0 + + + + + + SFR_CGUFSVLD + 0x0050 + 0x00 + 32 + + + sfr_cgufsvld + 3 + [3:0] + 0 + + + + + + SFR_CGUFSCR + 0x0054 + 0x00 + 32 + + + sfr_cgufscr + 15 + [15:0] + 0 + + + + + + SFR_ACLKGR + 0x0060 + 0x00 + 32 + + + sfr_aclkgr + 7 + [7:0] + 0 + + + + + + SFR_HCLKGR + 0x0064 + 0x00 + 32 + + + sfr_hclkgr + 7 + [7:0] + 0 + + + + + + SFR_ICLKGR + 0x0068 + 0x00 + 32 + + + sfr_iclkgr + 7 + [7:0] + 0 + + + + + + SFR_PCLKGR + 0x006c + 0x00 + 32 + + + sfr_pclkgr + 7 + [7:0] + 0 + + + + + + SFR_RCURST0 + 0x0080 + 0x00 + 32 + + + sfr_rcurst0 + 31 + [31:0] + 0 + + + + + + SFR_RCURST1 + 0x0084 + 0x00 + 32 + + + sfr_rcurst1 + 31 + [31:0] + 0 + + + + + + SFR_RCUSRCFR + 0x0088 + 0x00 + 32 + + + sfr_rcusrcfr + 15 + [15:0] + 0 + + + + + + SFR_IPCARIPFLOW + 0x0090 + 0x00 + 32 + + + sfr_ipcaripflow + 31 + [31:0] + 0 + + + + + + SFR_IPCEN + 0x0094 + 0x00 + 32 + + + sfr_ipcen + 15 + [15:0] + 0 + + + + + + SFR_IPCLPEN + 0x0098 + 0x00 + 32 + + + sfr_ipclpen + 15 + [15:0] + 0 + + + + + + SFR_IPCOSC + 0x009c + 0x00 + 32 + + + sfr_ipcosc + 6 + [6:0] + 0 + + + + + + SFR_IPCPLLMN + 0x00a0 + 0x00 + 32 + + + sfr_ipcpllmn + 16 + [16:0] + 0 + + + + + + SFR_IPCPLLF + 0x00a4 + 0x00 + 32 + + + sfr_ipcpllf + 24 + [24:0] + 0 + + + + + + SFR_IPCPLLQ + 0x00a8 + 0x00 + 32 + + + sfr_ipcpllq + 14 + [14:0] + 0 + + + + + + SFR_IPCCR + 0x00ac + 0x00 + 32 + + + sfr_ipccr + 15 + [15:0] + 0 + + + + + + + 0 + 0xb0 + registers + + + + APB_THRU + 0x50122000 + APB_THRU + + + + 0 + 0x4 + registers + + + + IOX + 0x5012F000 + IOX + + + SFR_AFSEL_CRAFSEL0 + 0x0000 + 0x00 + 32 + + + crafsel0 + 15 + [15:0] + 0 + + + + + + SFR_AFSEL_CRAFSEL1 + 0x0004 + 0x00 + 32 + + + crafsel1 + 15 + [15:0] + 0 + + + + + + SFR_AFSEL_CRAFSEL2 + 0x0008 + 0x00 + 32 + + + crafsel2 + 15 + [15:0] + 0 + + + + + + SFR_AFSEL_CRAFSEL3 + 0x000c + 0x00 + 32 + + + crafsel3 + 15 + [15:0] + 0 + + + + + + SFR_AFSEL_CRAFSEL4 + 0x0010 + 0x00 + 32 + + + crafsel4 + 15 + [15:0] + 0 + + + + + + SFR_AFSEL_CRAFSEL5 + 0x0014 + 0x00 + 32 + + + crafsel5 + 15 + [15:0] + 0 + + + + + + SFR_AFSEL_CRAFSEL6 + 0x0018 + 0x00 + 32 + + + crafsel6 + 15 + [15:0] + 0 + + + + + + SFR_AFSEL_CRAFSEL7 + 0x001c + 0x00 + 32 + + + crafsel7 + 15 + [15:0] + 0 + + + + + + SFR_INTCR_CRINT0 + 0x0100 + 0x00 + 32 + + + crint0 + 9 + [9:0] + 0 + + + + + + SFR_INTCR_CRINT1 + 0x0104 + 0x00 + 32 + + + crint1 + 9 + [9:0] + 0 + + + + + + SFR_INTCR_CRINT2 + 0x0108 + 0x00 + 32 + + + crint2 + 9 + [9:0] + 0 + + + + + + SFR_INTCR_CRINT3 + 0x010c + 0x00 + 32 + + + crint3 + 9 + [9:0] + 0 + + + + + + SFR_INTCR_CRINT4 + 0x0110 + 0x00 + 32 + + + crint4 + 9 + [9:0] + 0 + + + + + + SFR_INTCR_CRINT5 + 0x0114 + 0x00 + 32 + + + crint5 + 9 + [9:0] + 0 + + + + + + SFR_INTCR_CRINT6 + 0x0118 + 0x00 + 32 + + + crint6 + 9 + [9:0] + 0 + + + + + + SFR_INTCR_CRINT7 + 0x011c + 0x00 + 32 + + + crint7 + 9 + [9:0] + 0 + + + + + + SFR_INTFR + 0x0120 + 0x00 + 32 + + + frint + 7 + [7:0] + 0 + + + + + + SFR_GPIOOUT_CRGO0 + 0x0130 + 0x00 + 32 + + + crgo0 + 15 + [15:0] + 0 + + + + + + SFR_GPIOOUT_CRGO1 + 0x0134 + 0x00 + 32 + + + crgo1 + 15 + [15:0] + 0 + + + + + + SFR_GPIOOUT_CRGO2 + 0x0138 + 0x00 + 32 + + + crgo2 + 15 + [15:0] + 0 + + + + + + SFR_GPIOOUT_CRGO3 + 0x013c + 0x00 + 32 + + + crgo3 + 15 + [15:0] + 0 + + + + + + SFR_GPIOOE_CRGOE0 + 0x0140 + 0x00 + 32 + + + crgoe0 + 15 + [15:0] + 0 + + + + + + SFR_GPIOOE_CRGOE1 + 0x0144 + 0x00 + 32 + + + crgoe1 + 15 + [15:0] + 0 + + + + + + SFR_GPIOOE_CRGOE2 + 0x0148 + 0x00 + 32 + + + crgoe2 + 15 + [15:0] + 0 + + + + + + SFR_GPIOOE_CRGOE3 + 0x014c + 0x00 + 32 + + + crgoe3 + 15 + [15:0] + 0 + + + + + + SFR_GPIOPU_CRGPU0 + 0x0150 + 0x00 + 32 + + + crgpu0 + 15 + [15:0] + 0 + + + + + + SFR_GPIOPU_CRGPU1 + 0x0154 + 0x00 + 32 + + + crgpu1 + 15 + [15:0] + 0 + + + + + + SFR_GPIOPU_CRGPU2 + 0x0158 + 0x00 + 32 + + + crgpu2 + 15 + [15:0] + 0 + + + + + + SFR_GPIOPU_CRGPU3 + 0x015c + 0x00 + 32 + + + crgpu3 + 15 + [15:0] + 0 + + + + + + SFR_GPIOIN_SRGI0 + 0x0160 + 0x00 + 32 + + + srgi0 + 15 + [15:0] + 0 + + + + + + SFR_GPIOIN_SRGI1 + 0x0164 + 0x00 + 32 + + + srgi1 + 15 + [15:0] + 0 + + + + + + SFR_GPIOIN_SRGI2 + 0x0168 + 0x00 + 32 + + + srgi2 + 15 + [15:0] + 0 + + + + + + SFR_GPIOIN_SRGI3 + 0x016c + 0x00 + 32 + + + srgi3 + 15 + [15:0] + 0 + + + + + + SFR_PIOSEL + 0x0200 + 0x00 + 32 + + + piosel + 31 + [31:0] + 0 + + + + + + SFR_CFG_SCHM_CR_CFG_SCHMSEL0 + 0x0230 + 0x00 + 32 + + + cr_cfg_schmsel0 + 15 + [15:0] + 0 + + + + + + SFR_CFG_SCHM_CR_CFG_SCHMSEL1 + 0x0234 + 0x00 + 32 + + + cr_cfg_schmsel1 + 15 + [15:0] + 0 + + + + + + SFR_CFG_SCHM_CR_CFG_SCHMSEL2 + 0x0238 + 0x00 + 32 + + + cr_cfg_schmsel2 + 15 + [15:0] + 0 + + + + + + SFR_CFG_SCHM_CR_CFG_SCHMSEL3 + 0x023c + 0x00 + 32 + + + cr_cfg_schmsel3 + 15 + [15:0] + 0 + + + + + + SFR_CFG_SLEW_CR_CFG_SLEWSLOW0 + 0x0240 + 0x00 + 32 + + + cr_cfg_slewslow0 + 15 + [15:0] + 0 + + + + + + SFR_CFG_SLEW_CR_CFG_SLEWSLOW1 + 0x0244 + 0x00 + 32 + + + cr_cfg_slewslow1 + 15 + [15:0] + 0 + + + + + + SFR_CFG_SLEW_CR_CFG_SLEWSLOW2 + 0x0248 + 0x00 + 32 + + + cr_cfg_slewslow2 + 15 + [15:0] + 0 + + + + + + SFR_CFG_SLEW_CR_CFG_SLEWSLOW3 + 0x024c + 0x00 + 32 + + + cr_cfg_slewslow3 + 15 + [15:0] + 0 + + + + + + SFR_CFG_DRVSEL_CR_CFG_DRVSEL0 + 0x0250 + 0x00 + 32 + + + cr_cfg_drvsel0 + 31 + [31:0] + 0 + + + + + + SFR_CFG_DRVSEL_CR_CFG_DRVSEL1 + 0x0254 + 0x00 + 32 + + + cr_cfg_drvsel1 + 31 + [31:0] + 0 + + + + + + SFR_CFG_DRVSEL_CR_CFG_DRVSEL2 + 0x0258 + 0x00 + 32 + + + cr_cfg_drvsel2 + 31 + [31:0] + 0 + + + + + + SFR_CFG_DRVSEL_CR_CFG_DRVSEL3 + 0x025c + 0x00 + 32 + + + cr_cfg_drvsel3 + 31 + [31:0] + 0 + + + + + + + 0 + 0x260 + registers + + + + PWM + 0x50120000 + PWM + + + + 0 + 0x4 + registers + + + + SDDC + 0x50121000 + SDDC + + + SFR_IO + 0x0000 + 0x00 + 32 + + + sfr_io + 1 + [1:0] + 0 + + + + + + SFR_AR + 0x0004 + 0x00 + 32 + + + sfr_ar + 31 + [31:0] + 0 + + + + + + CR_OCR + 0x0010 + 0x00 + 32 + + + cr_ocr + 23 + [23:0] + 0 + + + + + + CR_RDFFTHRES + 0x0014 + 0x00 + 32 + + + cr_rdffthres + 7 + [7:0] + 0 + + + + + + CR_REV + 0x0018 + 0x00 + 32 + + + cfg_reg_sd_spec_revision + 7 + [7:0] + 0 + + + + cfg_reg_cccr_sdio_revision + 15 + [15:8] + 8 + + + + + + CR_BACSA + 0x001c + 0x00 + 32 + + + cfg_base_addr_csa + 17 + [17:0] + 0 + + + + + + CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC0 + 0x0020 + 0x00 + 32 + + + cfg_base_addr_io_func0 + 17 + [17:0] + 0 + + + + + + CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC1 + 0x0024 + 0x00 + 32 + + + cfg_base_addr_io_func1 + 17 + [17:0] + 0 + + + + + + CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC2 + 0x0028 + 0x00 + 32 + + + cfg_base_addr_io_func2 + 17 + [17:0] + 0 + + + + + + CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC3 + 0x002c + 0x00 + 32 + + + cfg_base_addr_io_func3 + 17 + [17:0] + 0 + + + + + + CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC4 + 0x0030 + 0x00 + 32 + + + cfg_base_addr_io_func4 + 17 + [17:0] + 0 + + + + + + CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC5 + 0x0034 + 0x00 + 32 + + + cfg_base_addr_io_func5 + 17 + [17:0] + 0 + + + + + + CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC6 + 0x0038 + 0x00 + 32 + + + cfg_base_addr_io_func6 + 17 + [17:0] + 0 + + + + + + CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC7 + 0x003c + 0x00 + 32 + + + cfg_base_addr_io_func7 + 17 + [17:0] + 0 + + + + + + CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR0 + 0x0040 + 0x00 + 32 + + + cfg_reg_func_cis_ptr0 + 16 + [16:0] + 0 + + + + + + CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR1 + 0x0044 + 0x00 + 32 + + + cfg_reg_func_cis_ptr1 + 16 + [16:0] + 0 + + + + + + CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR2 + 0x0048 + 0x00 + 32 + + + cfg_reg_func_cis_ptr2 + 16 + [16:0] + 0 + + + + + + CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR3 + 0x004c + 0x00 + 32 + + + cfg_reg_func_cis_ptr3 + 16 + [16:0] + 0 + + + + + + CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR4 + 0x0050 + 0x00 + 32 + + + cfg_reg_func_cis_ptr4 + 16 + [16:0] + 0 + + + + + + CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR5 + 0x0054 + 0x00 + 32 + + + cfg_reg_func_cis_ptr5 + 16 + [16:0] + 0 + + + + + + CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR6 + 0x0058 + 0x00 + 32 + + + cfg_reg_func_cis_ptr6 + 16 + [16:0] + 0 + + + + + + CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR7 + 0x005c + 0x00 + 32 + + + cfg_reg_func_cis_ptr7 + 16 + [16:0] + 0 + + + + + + CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE0 + 0x0060 + 0x00 + 32 + + + cfg_reg_func_ext_std_code0 + 7 + [7:0] + 0 + + + + + + CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE1 + 0x0064 + 0x00 + 32 + + + cfg_reg_func_ext_std_code1 + 7 + [7:0] + 0 + + + + + + CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE2 + 0x0068 + 0x00 + 32 + + + cfg_reg_func_ext_std_code2 + 7 + [7:0] + 0 + + + + + + CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE3 + 0x006c + 0x00 + 32 + + + cfg_reg_func_ext_std_code3 + 7 + [7:0] + 0 + + + + + + CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE4 + 0x0070 + 0x00 + 32 + + + cfg_reg_func_ext_std_code4 + 7 + [7:0] + 0 + + + + + + CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE5 + 0x0074 + 0x00 + 32 + + + cfg_reg_func_ext_std_code5 + 7 + [7:0] + 0 + + + + + + CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE6 + 0x0078 + 0x00 + 32 + + + cfg_reg_func_ext_std_code6 + 7 + [7:0] + 0 + + + + + + CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE7 + 0x007c + 0x00 + 32 + + + cfg_reg_func_ext_std_code7 + 7 + [7:0] + 0 + + + + + + CR_WRITE_PROTECT + 0x0080 + 0x00 + 32 + + + cr_write_protect + 0 + [0:0] + 0 + + + + + + CR_REG_DSR + 0x0084 + 0x00 + 32 + + + cr_reg_dsr + 15 + [15:0] + 0 + + + + + + CR_REG_CID_CFG_REG_CID0 + 0x0088 + 0x00 + 32 + + + cfg_reg_cid0 + 31 + [31:0] + 0 + + + + + + CR_REG_CID_CFG_REG_CID1 + 0x008c + 0x00 + 32 + + + cfg_reg_cid1 + 31 + [31:0] + 0 + + + + + + CR_REG_CID_CFG_REG_CID2 + 0x0090 + 0x00 + 32 + + + cfg_reg_cid2 + 31 + [31:0] + 0 + + + + + + CR_REG_CID_CFG_REG_CID3 + 0x0094 + 0x00 + 32 + + + cfg_reg_cid3 + 31 + [31:0] + 0 + + + + + + CR_REG_CSD_CFG_REG_CSD0 + 0x0098 + 0x00 + 32 + + + cfg_reg_csd0 + 31 + [31:0] + 0 + + + + + + CR_REG_CSD_CFG_REG_CSD1 + 0x009c + 0x00 + 32 + + + cfg_reg_csd1 + 31 + [31:0] + 0 + + + + + + CR_REG_CSD_CFG_REG_CSD2 + 0x00a0 + 0x00 + 32 + + + cfg_reg_csd2 + 31 + [31:0] + 0 + + + + + + CR_REG_CSD_CFG_REG_CSD3 + 0x00a4 + 0x00 + 32 + + + cfg_reg_csd3 + 31 + [31:0] + 0 + + + + + + CR_REG_SCR_CFG_REG_SCR0 + 0x00a8 + 0x00 + 32 + + + cfg_reg_scr0 + 31 + [31:0] + 0 + + + + + + CR_REG_SCR_CFG_REG_SCR1 + 0x00ac + 0x00 + 32 + + + cfg_reg_scr1 + 31 + [31:0] + 0 + + + + + + CR_REG_SD_STATUS_CFG_REG_SD_STATUS0 + 0x00b0 + 0x00 + 32 + + + cfg_reg_sd_status0 + 31 + [31:0] + 0 + + + + + + CR_REG_SD_STATUS_CFG_REG_SD_STATUS1 + 0x00b4 + 0x00 + 32 + + + cfg_reg_sd_status1 + 31 + [31:0] + 0 + + + + + + CR_REG_SD_STATUS_CFG_REG_SD_STATUS2 + 0x00b8 + 0x00 + 32 + + + cfg_reg_sd_status2 + 31 + [31:0] + 0 + + + + + + CR_REG_SD_STATUS_CFG_REG_SD_STATUS3 + 0x00bc + 0x00 + 32 + + + cfg_reg_sd_status3 + 31 + [31:0] + 0 + + + + + + CR_REG_SD_STATUS_CFG_REG_SD_STATUS4 + 0x00c0 + 0x00 + 32 + + + cfg_reg_sd_status4 + 31 + [31:0] + 0 + + + + + + CR_REG_SD_STATUS_CFG_REG_SD_STATUS5 + 0x00c4 + 0x00 + 32 + + + cfg_reg_sd_status5 + 31 + [31:0] + 0 + + + + + + CR_REG_SD_STATUS_CFG_REG_SD_STATUS6 + 0x00c8 + 0x00 + 32 + + + cfg_reg_sd_status6 + 31 + [31:0] + 0 + + + + + + CR_REG_SD_STATUS_CFG_REG_SD_STATUS7 + 0x00cc + 0x00 + 32 + + + cfg_reg_sd_status7 + 31 + [31:0] + 0 + + + + + + CR_REG_SD_STATUS_CFG_REG_SD_STATUS8 + 0x00d0 + 0x00 + 32 + + + cfg_reg_sd_status8 + 31 + [31:0] + 0 + + + + + + CR_REG_SD_STATUS_CFG_REG_SD_STATUS9 + 0x00d4 + 0x00 + 32 + + + cfg_reg_sd_status9 + 31 + [31:0] + 0 + + + + + + CR_REG_SD_STATUS_CFG_REG_SD_STATUS10 + 0x00d8 + 0x00 + 32 + + + cfg_reg_sd_status10 + 31 + [31:0] + 0 + + + + + + CR_REG_SD_STATUS_CFG_REG_SD_STATUS11 + 0x00dc + 0x00 + 32 + + + cfg_reg_sd_status11 + 31 + [31:0] + 0 + + + + + + CR_REG_SD_STATUS_CFG_REG_SD_STATUS12 + 0x00e0 + 0x00 + 32 + + + cfg_reg_sd_status12 + 31 + [31:0] + 0 + + + + + + CR_REG_SD_STATUS_CFG_REG_SD_STATUS13 + 0x00e4 + 0x00 + 32 + + + cfg_reg_sd_status13 + 31 + [31:0] + 0 + + + + + + CR_REG_SD_STATUS_CFG_REG_SD_STATUS14 + 0x00e8 + 0x00 + 32 + + + cfg_reg_sd_status14 + 31 + [31:0] + 0 + + + + + + CR_REG_SD_STATUS_CFG_REG_SD_STATUS15 + 0x00ec + 0x00 + 32 + + + cfg_reg_sd_status15 + 31 + [31:0] + 0 + + + + + + CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC0 + 0x0100 + 0x00 + 32 + + + cfg_base_addr_mem_func0 + 17 + [17:0] + 0 + + + + + + CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC1 + 0x0104 + 0x00 + 32 + + + cfg_base_addr_mem_func1 + 17 + [17:0] + 0 + + + + + + CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC2 + 0x0108 + 0x00 + 32 + + + cfg_base_addr_mem_func2 + 17 + [17:0] + 0 + + + + + + CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC3 + 0x010c + 0x00 + 32 + + + cfg_base_addr_mem_func3 + 17 + [17:0] + 0 + + + + + + CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC4 + 0x0110 + 0x00 + 32 + + + cfg_base_addr_mem_func4 + 17 + [17:0] + 0 + + + + + + CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC5 + 0x0114 + 0x00 + 32 + + + cfg_base_addr_mem_func5 + 17 + [17:0] + 0 + + + + + + CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC6 + 0x0118 + 0x00 + 32 + + + cfg_base_addr_mem_func6 + 17 + [17:0] + 0 + + + + + + CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC7 + 0x011c + 0x00 + 32 + + + cfg_base_addr_mem_func7 + 17 + [17:0] + 0 + + + + + + CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC8 + 0x0120 + 0x00 + 32 + + + cfg_base_addr_mem_func8 + 17 + [17:0] + 0 + + + + + + CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC9 + 0x0124 + 0x00 + 32 + + + cfg_base_addr_mem_func9 + 17 + [17:0] + 0 + + + + + + CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC10 + 0x0128 + 0x00 + 32 + + + cfg_base_addr_mem_func10 + 17 + [17:0] + 0 + + + + + + CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC11 + 0x012c + 0x00 + 32 + + + cfg_base_addr_mem_func11 + 17 + [17:0] + 0 + + + + + + CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC12 + 0x0130 + 0x00 + 32 + + + cfg_base_addr_mem_func12 + 17 + [17:0] + 0 + + + + + + CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC13 + 0x0134 + 0x00 + 32 + + + cfg_base_addr_mem_func13 + 17 + [17:0] + 0 + + + + + + CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC14 + 0x0138 + 0x00 + 32 + + + cfg_base_addr_mem_func14 + 17 + [17:0] + 0 + + + + + + CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC15 + 0x013c + 0x00 + 32 + + + cfg_base_addr_mem_func15 + 17 + [17:0] + 0 + + + + + + CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC16 + 0x0140 + 0x00 + 32 + + + cfg_base_addr_mem_func16 + 17 + [17:0] + 0 + + + + + + CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC17 + 0x0144 + 0x00 + 32 + + + cfg_base_addr_mem_func17 + 17 + [17:0] + 0 + + + + + + CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE0 + 0x0148 + 0x00 + 32 + + + cfg_reg_func_isdio_interface_code0 + 7 + [7:0] + 0 + + + + + + CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE1 + 0x014c + 0x00 + 32 + + + cfg_reg_func_isdio_interface_code1 + 7 + [7:0] + 0 + + + + + + CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE2 + 0x0150 + 0x00 + 32 + + + cfg_reg_func_isdio_interface_code2 + 7 + [7:0] + 0 + + + + + + CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE3 + 0x0154 + 0x00 + 32 + + + cfg_reg_func_isdio_interface_code3 + 7 + [7:0] + 0 + + + + + + CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE4 + 0x0158 + 0x00 + 32 + + + cfg_reg_func_isdio_interface_code4 + 7 + [7:0] + 0 + + + + + + CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE5 + 0x015c + 0x00 + 32 + + + cfg_reg_func_isdio_interface_code5 + 7 + [7:0] + 0 + + + + + + CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE6 + 0x0160 + 0x00 + 32 + + + cfg_reg_func_isdio_interface_code6 + 7 + [7:0] + 0 + + + + + + CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE0 + 0x0168 + 0x00 + 32 + + + cfg_reg_func_manufact_code0 + 15 + [15:0] + 0 + + + + + + CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE1 + 0x016c + 0x00 + 32 + + + cfg_reg_func_manufact_code1 + 15 + [15:0] + 0 + + + + + + CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE2 + 0x0170 + 0x00 + 32 + + + cfg_reg_func_manufact_code2 + 15 + [15:0] + 0 + + + + + + CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE3 + 0x0174 + 0x00 + 32 + + + cfg_reg_func_manufact_code3 + 15 + [15:0] + 0 + + + + + + CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE4 + 0x0178 + 0x00 + 32 + + + cfg_reg_func_manufact_code4 + 15 + [15:0] + 0 + + + + + + CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE5 + 0x017c + 0x00 + 32 + + + cfg_reg_func_manufact_code5 + 15 + [15:0] + 0 + + + + + + CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE6 + 0x0180 + 0x00 + 32 + + + cfg_reg_func_manufact_code6 + 15 + [15:0] + 0 + + + + + + CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO0 + 0x0188 + 0x00 + 32 + + + cfg_reg_func_manufact_info0 + 15 + [15:0] + 0 + + + + + + CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO1 + 0x018c + 0x00 + 32 + + + cfg_reg_func_manufact_info1 + 15 + [15:0] + 0 + + + + + + CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO2 + 0x0190 + 0x00 + 32 + + + cfg_reg_func_manufact_info2 + 15 + [15:0] + 0 + + + + + + CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO3 + 0x0194 + 0x00 + 32 + + + cfg_reg_func_manufact_info3 + 15 + [15:0] + 0 + + + + + + CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO4 + 0x0198 + 0x00 + 32 + + + cfg_reg_func_manufact_info4 + 15 + [15:0] + 0 + + + + + + CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO5 + 0x019c + 0x00 + 32 + + + cfg_reg_func_manufact_info5 + 15 + [15:0] + 0 + + + + + + CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO6 + 0x01a0 + 0x00 + 32 + + + cfg_reg_func_manufact_info6 + 15 + [15:0] + 0 + + + + + + CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE0 + 0x01a8 + 0x00 + 32 + + + cfg_reg_func_isdio_type_sup_code0 + 7 + [7:0] + 0 + + + + + + CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE1 + 0x01ac + 0x00 + 32 + + + cfg_reg_func_isdio_type_sup_code1 + 7 + [7:0] + 0 + + + + + + CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE2 + 0x01b0 + 0x00 + 32 + + + cfg_reg_func_isdio_type_sup_code2 + 7 + [7:0] + 0 + + + + + + CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE3 + 0x01b4 + 0x00 + 32 + + + cfg_reg_func_isdio_type_sup_code3 + 7 + [7:0] + 0 + + + + + + CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE4 + 0x01b8 + 0x00 + 32 + + + cfg_reg_func_isdio_type_sup_code4 + 7 + [7:0] + 0 + + + + + + CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE5 + 0x01bc + 0x00 + 32 + + + cfg_reg_func_isdio_type_sup_code5 + 7 + [7:0] + 0 + + + + + + CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE6 + 0x01c0 + 0x00 + 32 + + + cfg_reg_func_isdio_type_sup_code6 + 7 + [7:0] + 0 + + + + + + CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO0 + 0x01c8 + 0x00 + 32 + + + cfg_reg_func_info0 + 15 + [15:0] + 0 + + + + + + CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO1 + 0x01cc + 0x00 + 32 + + + cfg_reg_func_info1 + 15 + [15:0] + 0 + + + + + + CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO2 + 0x01d0 + 0x00 + 32 + + + cfg_reg_func_info2 + 15 + [15:0] + 0 + + + + + + CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO3 + 0x01d4 + 0x00 + 32 + + + cfg_reg_func_info3 + 15 + [15:0] + 0 + + + + + + CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO4 + 0x01d8 + 0x00 + 32 + + + cfg_reg_func_info4 + 15 + [15:0] + 0 + + + + + + CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO5 + 0x01dc + 0x00 + 32 + + + cfg_reg_func_info5 + 15 + [15:0] + 0 + + + + + + CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO6 + 0x01e0 + 0x00 + 32 + + + cfg_reg_func_info6 + 15 + [15:0] + 0 + + + + + + CR_REG_UHS_1_SUPPORT + 0x01f0 + 0x00 + 32 + + + cfg_reg_max_current + 15 + [15:0] + 0 + + + + cfg_reg_data_strc_version + 23 + [23:16] + 16 + + + + cfg_reg_uhs_1_support + 31 + [31:24] + 24 + + + + + + + 0 + 0x1f4 + registers + + + + RP_PIO + 0x50123000 + RP_PIO + + + SFR_CTRL + 0x0000 + 0x00 + 32 + + + en + 3 + [3:0] + 0 + + + + restart + 7 + [7:4] + 4 + + + + clkdiv_restart + 11 + [11:8] + 8 + + + + + + SFR_FSTAT + 0x0004 + 0x00 + 32 + + + rx_full + 3 + [3:0] + 0 + + + + constant0 + 7 + [7:4] + 4 + + + + rx_empty + 11 + [11:8] + 8 + + + + constant1 + 15 + [15:12] + 12 + + + + tx_full + 19 + [19:16] + 16 + + + + constant2 + 23 + [23:20] + 20 + + + + tx_empty + 27 + [27:24] + 24 + + + + constant3 + 31 + [31:28] + 28 + + + + + + SFR_FDEBUG + 0x0008 + 0x00 + 32 + + + rxstall + 3 + [3:0] + 0 + + + + nc_dbg3 + 7 + [7:4] + 4 + + + + rxunder + 11 + [11:8] + 8 + + + + nc_dbg2 + 15 + [15:12] + 12 + + + + txover + 19 + [19:16] + 16 + + + + nc_dbg1 + 23 + [23:20] + 20 + + + + txstall + 27 + [27:24] + 24 + + + + nc_dbg0 + 31 + [31:28] + 28 + + + + + + SFR_FLEVEL + 0x000c + 0x00 + 32 + + + tx_level0 + 2 + [2:0] + 0 + + + + constant0 + 3 + [3:3] + 3 + + + + rx_level0 + 6 + [6:4] + 4 + + + + constant1 + 7 + [7:7] + 7 + + + + tx_level1 + 10 + [10:8] + 8 + + + + constant2 + 11 + [11:11] + 11 + + + + rx_level1 + 14 + [14:12] + 12 + + + + constant3 + 15 + [15:15] + 15 + + + + tx_level2 + 18 + [18:16] + 16 + + + + constant4 + 19 + [19:19] + 19 + + + + rx_level2 + 22 + [22:20] + 20 + + + + constant5 + 23 + [23:23] + 23 + + + + tx_level3 + 26 + [26:24] + 24 + + + + constant6 + 27 + [27:27] + 27 + + + + rx_level3 + 30 + [30:28] + 28 + + + + constant7 + 31 + [31:31] + 31 + + + + + + SFR_TXF0 + 0x0010 + 0x00 + 32 + + + fdin + 31 + [31:0] + 0 + + + + + + SFR_TXF1 + 0x0014 + 0x00 + 32 + + + fdin + 31 + [31:0] + 0 + + + + + + SFR_TXF2 + 0x0018 + 0x00 + 32 + + + fdin + 31 + [31:0] + 0 + + + + + + SFR_TXF3 + 0x001c + 0x00 + 32 + + + fdin + 31 + [31:0] + 0 + + + + + + SFR_RXF0 + 0x0020 + 0x00 + 32 + + + pdout + 31 + [31:0] + 0 + + + + + + SFR_RXF1 + 0x0024 + 0x00 + 32 + + + pdout + 31 + [31:0] + 0 + + + + + + SFR_RXF2 + 0x0028 + 0x00 + 32 + + + pdout + 31 + [31:0] + 0 + + + + + + SFR_RXF3 + 0x002c + 0x00 + 32 + + + pdout + 31 + [31:0] + 0 + + + + + + SFR_IRQ + 0x0030 + 0x00 + 32 + + + sfr_irq + 7 + [7:0] + 0 + + + + + + SFR_IRQ_FORCE + 0x0034 + 0x00 + 32 + + + sfr_irq_force + 7 + [7:0] + 0 + + + + + + SFR_SYNC_BYPASS + 0x0038 + 0x00 + 32 + + + sfr_sync_bypass + 31 + [31:0] + 0 + + + + + + SFR_DBG_PADOUT + 0x003c + 0x00 + 32 + + + sfr_dbg_padout + 31 + [31:0] + 0 + + + + + + SFR_DBG_PADOE + 0x0040 + 0x00 + 32 + + + sfr_dbg_padoe + 31 + [31:0] + 0 + + + + + + SFR_DBG_CFGINFO + 0x0044 + 0x00 + 32 + + + constant0 + 7 + [7:0] + 0 + + + + constant1 + 15 + [15:8] + 8 + + + + constant2 + 31 + [31:16] + 16 + + + + + + SFR_INSTR_MEM0 + 0x0048 + 0x00 + 32 + + + instr + 15 + [15:0] + 0 + + + + + + SFR_INSTR_MEM1 + 0x004c + 0x00 + 32 + + + instr + 15 + [15:0] + 0 + + + + + + SFR_INSTR_MEM2 + 0x0050 + 0x00 + 32 + + + instr + 15 + [15:0] + 0 + + + + + + SFR_INSTR_MEM3 + 0x0054 + 0x00 + 32 + + + instr + 15 + [15:0] + 0 + + + + + + SFR_INSTR_MEM4 + 0x0058 + 0x00 + 32 + + + instr + 15 + [15:0] + 0 + + + + + + SFR_INSTR_MEM5 + 0x005c + 0x00 + 32 + + + instr + 15 + [15:0] + 0 + + + + + + SFR_INSTR_MEM6 + 0x0060 + 0x00 + 32 + + + instr + 15 + [15:0] + 0 + + + + + + SFR_INSTR_MEM7 + 0x0064 + 0x00 + 32 + + + instr + 15 + [15:0] + 0 + + + + + + SFR_INSTR_MEM8 + 0x0068 + 0x00 + 32 + + + instr + 15 + [15:0] + 0 + + + + + + SFR_INSTR_MEM9 + 0x006c + 0x00 + 32 + + + instr + 15 + [15:0] + 0 + + + + + + SFR_INSTR_MEM10 + 0x0070 + 0x00 + 32 + + + instr + 15 + [15:0] + 0 + + + + + + SFR_INSTR_MEM11 + 0x0074 + 0x00 + 32 + + + instr + 15 + [15:0] + 0 + + + + + + SFR_INSTR_MEM12 + 0x0078 + 0x00 + 32 + + + instr + 15 + [15:0] + 0 + + + + + + SFR_INSTR_MEM13 + 0x007c + 0x00 + 32 + + + instr + 15 + [15:0] + 0 + + + + + + SFR_INSTR_MEM14 + 0x0080 + 0x00 + 32 + + + instr + 15 + [15:0] + 0 + + + + + + SFR_INSTR_MEM15 + 0x0084 + 0x00 + 32 + + + instr + 15 + [15:0] + 0 + + + + + + SFR_INSTR_MEM16 + 0x0088 + 0x00 + 32 + + + instr + 15 + [15:0] + 0 + + + + + + SFR_INSTR_MEM17 + 0x008c + 0x00 + 32 + + + instr + 15 + [15:0] + 0 + + + + + + SFR_INSTR_MEM18 + 0x0090 + 0x00 + 32 + + + instr + 15 + [15:0] + 0 + + + + + + SFR_INSTR_MEM19 + 0x0094 + 0x00 + 32 + + + instr + 15 + [15:0] + 0 + + + + + + SFR_INSTR_MEM20 + 0x0098 + 0x00 + 32 + + + instr + 15 + [15:0] + 0 + + + + + + SFR_INSTR_MEM21 + 0x009c + 0x00 + 32 + + + instr + 15 + [15:0] + 0 + + + + + + SFR_INSTR_MEM22 + 0x00a0 + 0x00 + 32 + + + instr + 15 + [15:0] + 0 + + + + + + SFR_INSTR_MEM23 + 0x00a4 + 0x00 + 32 + + + instr + 15 + [15:0] + 0 + + + + + + SFR_INSTR_MEM24 + 0x00a8 + 0x00 + 32 + + + instr + 15 + [15:0] + 0 + + + + + + SFR_INSTR_MEM25 + 0x00ac + 0x00 + 32 + + + instr + 15 + [15:0] + 0 + + + + + + SFR_INSTR_MEM26 + 0x00b0 + 0x00 + 32 + + + instr + 15 + [15:0] + 0 + + + + + + SFR_INSTR_MEM27 + 0x00b4 + 0x00 + 32 + + + instr + 15 + [15:0] + 0 + + + + + + SFR_INSTR_MEM28 + 0x00b8 + 0x00 + 32 + + + instr + 15 + [15:0] + 0 + + + + + + SFR_INSTR_MEM29 + 0x00bc + 0x00 + 32 + + + instr + 15 + [15:0] + 0 + + + + + + SFR_INSTR_MEM30 + 0x00c0 + 0x00 + 32 + + + instr + 15 + [15:0] + 0 + + + + + + SFR_INSTR_MEM31 + 0x00c4 + 0x00 + 32 + + + instr + 15 + [15:0] + 0 + + + + + + SFR_SM0_CLKDIV + 0x00c8 + 0x00 + 32 + + + unused_div + 7 + [7:0] + 0 + + + + div_frac + 15 + [15:8] + 8 + + + + div_int + 31 + [31:16] + 16 + + + + + + SFR_SM0_EXECCTRL + 0x00cc + 0x00 + 32 + + + status_n + 3 + [3:0] + 0 + + + + status_sel + 4 + [4:4] + 4 + + + + resvd_exec + 6 + [6:5] + 5 + + + + wrap_target + 11 + [11:7] + 7 + + + + pend + 16 + [16:12] + 12 + + + + out_sticky + 17 + [17:17] + 17 + + + + inline_out_en + 18 + [18:18] + 18 + + + + out_en_sel + 23 + [23:19] + 19 + + + + jmp_pin + 28 + [28:24] + 24 + + + + side_pindir + 29 + [29:29] + 29 + + + + sideset_enable_bit + 30 + [30:30] + 30 + + + + exec_stalled_ro0 + 31 + [31:31] + 31 + + + + + + SFR_SM0_SHIFTCTRL + 0x00d0 + 0x00 + 32 + + + resvd_shift + 15 + [15:0] + 0 + + + + auto_push + 16 + [16:16] + 16 + + + + auto_pull + 17 + [17:17] + 17 + + + + in_shift_dir + 18 + [18:18] + 18 + + + + out_shift_dir + 19 + [19:19] + 19 + + + + isr_threshold + 24 + [24:20] + 20 + + + + osr_threshold + 29 + [29:25] + 25 + + + + join_tx + 30 + [30:30] + 30 + + + + join_rx + 31 + [31:31] + 31 + + + + + + SFR_SM0_ADDR + 0x00d4 + 0x00 + 32 + + + pc + 4 + [4:0] + 0 + + + + + + SFR_SM0_INSTR + 0x00d8 + 0x00 + 32 + + + imm_instr + 15 + [15:0] + 0 + + + + + + SFR_SM0_PINCTRL + 0x00dc + 0x00 + 32 + + + pins_out_base + 4 + [4:0] + 0 + + + + pins_set_base + 9 + [9:5] + 5 + + + + pins_side_base + 14 + [14:10] + 10 + + + + pins_in_base + 19 + [19:15] + 15 + + + + pins_out_count + 25 + [25:20] + 20 + + + + pins_set_count + 28 + [28:26] + 26 + + + + pins_side_count + 31 + [31:29] + 29 + + + + + + SFR_SM1_CLKDIV + 0x00e0 + 0x00 + 32 + + + unused_div + 7 + [7:0] + 0 + + + + div_frac + 15 + [15:8] + 8 + + + + div_int + 31 + [31:16] + 16 + + + + + + SFR_SM1_EXECCTRL + 0x00e4 + 0x00 + 32 + + + status_n + 3 + [3:0] + 0 + + + + status_sel + 4 + [4:4] + 4 + + + + resvd_exec + 6 + [6:5] + 5 + + + + wrap_target + 11 + [11:7] + 7 + + + + pend + 16 + [16:12] + 12 + + + + out_sticky + 17 + [17:17] + 17 + + + + inline_out_en + 18 + [18:18] + 18 + + + + out_en_sel + 23 + [23:19] + 19 + + + + jmp_pin + 28 + [28:24] + 24 + + + + side_pindir + 29 + [29:29] + 29 + + + + sideset_enable_bit + 30 + [30:30] + 30 + + + + exec_stalled_ro1 + 31 + [31:31] + 31 + + + + + + SFR_SM1_SHIFTCTRL + 0x00e8 + 0x00 + 32 + + + resvd_shift + 15 + [15:0] + 0 + + + + auto_push + 16 + [16:16] + 16 + + + + auto_pull + 17 + [17:17] + 17 + + + + in_shift_dir + 18 + [18:18] + 18 + + + + out_shift_dir + 19 + [19:19] + 19 + + + + isr_threshold + 24 + [24:20] + 20 + + + + osr_threshold + 29 + [29:25] + 25 + + + + join_tx + 30 + [30:30] + 30 + + + + join_rx + 31 + [31:31] + 31 + + + + + + SFR_SM1_ADDR + 0x00ec + 0x00 + 32 + + + pc + 4 + [4:0] + 0 + + + + + + SFR_SM1_INSTR + 0x00f0 + 0x00 + 32 + + + imm_instr + 15 + [15:0] + 0 + + + + + + SFR_SM1_PINCTRL + 0x00f4 + 0x00 + 32 + + + pins_out_base + 4 + [4:0] + 0 + + + + pins_set_base + 9 + [9:5] + 5 + + + + pins_side_base + 14 + [14:10] + 10 + + + + pins_in_base + 19 + [19:15] + 15 + + + + pins_out_count + 25 + [25:20] + 20 + + + + pins_set_count + 28 + [28:26] + 26 + + + + pins_side_count + 31 + [31:29] + 29 + + + + + + SFR_SM2_CLKDIV + 0x00f8 + 0x00 + 32 + + + unused_div + 7 + [7:0] + 0 + + + + div_frac + 15 + [15:8] + 8 + + + + div_int + 31 + [31:16] + 16 + + + + + + SFR_SM2_EXECCTRL + 0x00fc + 0x00 + 32 + + + status_n + 3 + [3:0] + 0 + + + + status_sel + 4 + [4:4] + 4 + + + + resvd_exec + 6 + [6:5] + 5 + + + + wrap_target + 11 + [11:7] + 7 + + + + pend + 16 + [16:12] + 12 + + + + out_sticky + 17 + [17:17] + 17 + + + + inline_out_en + 18 + [18:18] + 18 + + + + out_en_sel + 23 + [23:19] + 19 + + + + jmp_pin + 28 + [28:24] + 24 + + + + side_pindir + 29 + [29:29] + 29 + + + + sideset_enable_bit + 30 + [30:30] + 30 + + + + exec_stalled_ro2 + 31 + [31:31] + 31 + + + + + + SFR_SM2_SHIFTCTRL + 0x0100 + 0x00 + 32 + + + resvd_shift + 15 + [15:0] + 0 + + + + auto_push + 16 + [16:16] + 16 + + + + auto_pull + 17 + [17:17] + 17 + + + + in_shift_dir + 18 + [18:18] + 18 + + + + out_shift_dir + 19 + [19:19] + 19 + + + + isr_threshold + 24 + [24:20] + 20 + + + + osr_threshold + 29 + [29:25] + 25 + + + + join_tx + 30 + [30:30] + 30 + + + + join_rx + 31 + [31:31] + 31 + + + + + + SFR_SM2_ADDR + 0x0104 + 0x00 + 32 + + + pc + 4 + [4:0] + 0 + + + + + + SFR_SM2_INSTR + 0x0108 + 0x00 + 32 + + + imm_instr + 15 + [15:0] + 0 + + + + + + SFR_SM2_PINCTRL + 0x010c + 0x00 + 32 + + + pins_out_base + 4 + [4:0] + 0 + + + + pins_set_base + 9 + [9:5] + 5 + + + + pins_side_base + 14 + [14:10] + 10 + + + + pins_in_base + 19 + [19:15] + 15 + + + + pins_out_count + 25 + [25:20] + 20 + + + + pins_set_count + 28 + [28:26] + 26 + + + + pins_side_count + 31 + [31:29] + 29 + + + + + + SFR_SM3_CLKDIV + 0x0110 + 0x00 + 32 + + + unused_div + 7 + [7:0] + 0 + + + + div_frac + 15 + [15:8] + 8 + + + + div_int + 31 + [31:16] + 16 + + + + + + SFR_SM3_EXECCTRL + 0x0114 + 0x00 + 32 + + + status_n + 3 + [3:0] + 0 + + + + status_sel + 4 + [4:4] + 4 + + + + resvd_exec + 6 + [6:5] + 5 + + + + wrap_target + 11 + [11:7] + 7 + + + + pend + 16 + [16:12] + 12 + + + + out_sticky + 17 + [17:17] + 17 + + + + inline_out_en + 18 + [18:18] + 18 + + + + out_en_sel + 23 + [23:19] + 19 + + + + jmp_pin + 28 + [28:24] + 24 + + + + side_pindir + 29 + [29:29] + 29 + + + + sideset_enable_bit + 30 + [30:30] + 30 + + + + exec_stalled_ro3 + 31 + [31:31] + 31 + + + + + + SFR_SM3_SHIFTCTRL + 0x0118 + 0x00 + 32 + + + resvd_shift + 15 + [15:0] + 0 + + + + auto_push + 16 + [16:16] + 16 + + + + auto_pull + 17 + [17:17] + 17 + + + + in_shift_dir + 18 + [18:18] + 18 + + + + out_shift_dir + 19 + [19:19] + 19 + + + + isr_threshold + 24 + [24:20] + 20 + + + + osr_threshold + 29 + [29:25] + 25 + + + + join_tx + 30 + [30:30] + 30 + + + + join_rx + 31 + [31:31] + 31 + + + + + + SFR_SM3_ADDR + 0x011c + 0x00 + 32 + + + pc + 4 + [4:0] + 0 + + + + + + SFR_SM3_INSTR + 0x0120 + 0x00 + 32 + + + imm_instr + 15 + [15:0] + 0 + + + + + + SFR_SM3_PINCTRL + 0x0124 + 0x00 + 32 + + + pins_out_base + 4 + [4:0] + 0 + + + + pins_set_base + 9 + [9:5] + 5 + + + + pins_side_base + 14 + [14:10] + 10 + + + + pins_in_base + 19 + [19:15] + 15 + + + + pins_out_count + 25 + [25:20] + 20 + + + + pins_set_count + 28 + [28:26] + 26 + + + + pins_side_count + 31 + [31:29] + 29 + + + + + + SFR_INTR + 0x0128 + 0x00 + 32 + + + intr_rxnempty + 3 + [3:0] + 0 + + + + intr_txnfull + 7 + [7:4] + 4 + + + + intr_sm + 11 + [11:8] + 8 + + + + + + SFR_IRQ0_INTE + 0x012c + 0x00 + 32 + + + irq0_inte_rxnempty + 3 + [3:0] + 0 + + + + irq0_inte_txnfull + 7 + [7:4] + 4 + + + + irq0_inte_sm + 11 + [11:8] + 8 + + + + + + SFR_IRQ0_INTF + 0x0130 + 0x00 + 32 + + + irq0_intf_rxnempty + 3 + [3:0] + 0 + + + + irq0_intf_txnfull + 7 + [7:4] + 4 + + + + irq0_intf_sm + 11 + [11:8] + 8 + + + + + + SFR_IRQ0_INTS + 0x0134 + 0x00 + 32 + + + irq0_ints_rxnempty + 3 + [3:0] + 0 + + + + irq0_ints_txnfull + 7 + [7:4] + 4 + + + + irq0_ints_sm + 11 + [11:8] + 8 + + + + + + SFR_IRQ1_INTE + 0x0138 + 0x00 + 32 + + + irq1_inte_rxnempty + 3 + [3:0] + 0 + + + + irq1_inte_txnfull + 7 + [7:4] + 4 + + + + irq1_inte_sm + 11 + [11:8] + 8 + + + + + + SFR_IRQ1_INTF + 0x013c + 0x00 + 32 + + + irq1_intf_rxnempty + 3 + [3:0] + 0 + + + + irq1_intf_txnfull + 7 + [7:4] + 4 + + + + irq1_intf_sm + 11 + [11:8] + 8 + + + + + + SFR_IRQ1_INTS + 0x0140 + 0x00 + 32 + + + irq1_ints_rxnempty + 3 + [3:0] + 0 + + + + irq1_ints_txnfull + 7 + [7:4] + 4 + + + + irq1_ints_sm + 11 + [11:8] + 8 + + + + + + SFR_IO_OE_INV + 0x0180 + 0x00 + 32 + + + sfr_io_oe_inv + 31 + [31:0] + 0 + + + + + + SFR_IO_O_INV + 0x0184 + 0x00 + 32 + + + sfr_io_o_inv + 31 + [31:0] + 0 + + + + + + SFR_IO_I_INV + 0x0188 + 0x00 + 32 + + + sfr_io_i_inv + 31 + [31:0] + 0 + + + + + + SFR_FIFO_MARGIN + 0x018c + 0x00 + 32 + + + fifo_tx_margin0 + 1 + [1:0] + 0 + + + + fifo_rx_margin0 + 3 + [3:2] + 2 + + + + fifo_tx_margin1 + 5 + [5:4] + 4 + + + + fifo_rx_margin1 + 7 + [7:6] + 6 + + + + fifo_tx_margin2 + 9 + [9:8] + 8 + + + + fifo_rx_margin2 + 11 + [11:10] + 10 + + + + fifo_tx_margin3 + 13 + [13:12] + 12 + + + + fifo_rx_margin3 + 15 + [15:14] + 14 + + + + + + SFR_ZERO0 + 0x0190 + 0x00 + 32 + + + sfr_zero0 + 31 + [31:0] + 0 + + + + + + SFR_ZERO1 + 0x0194 + 0x00 + 32 + + + sfr_zero1 + 31 + [31:0] + 0 + + + + + + SFR_ZERO2 + 0x0198 + 0x00 + 32 + + + sfr_zero2 + 31 + [31:0] + 0 + + + + + + SFR_ZERO3 + 0x019c + 0x00 + 32 + + + sfr_zero3 + 31 + [31:0] + 0 + + + + + + + 0 + 0x1a0 + registers + + + + MDMA + 0x40002000 + MDMA + + + SFR_EVSEL_CR_EVSEL0 + 0x0000 + 0x00 + 32 + + + cr_evsel0 + 7 + [7:0] + 0 + + + + + + SFR_EVSEL_CR_EVSEL1 + 0x0004 + 0x00 + 32 + + + cr_evsel1 + 7 + [7:0] + 0 + + + + + + SFR_EVSEL_CR_EVSEL2 + 0x0008 + 0x00 + 32 + + + cr_evsel2 + 7 + [7:0] + 0 + + + + + + SFR_EVSEL_CR_EVSEL3 + 0x000c + 0x00 + 32 + + + cr_evsel3 + 7 + [7:0] + 0 + + + + + + SFR_EVSEL_CR_EVSEL4 + 0x0010 + 0x00 + 32 + + + cr_evsel4 + 7 + [7:0] + 0 + + + + + + SFR_EVSEL_CR_EVSEL5 + 0x0014 + 0x00 + 32 + + + cr_evsel5 + 7 + [7:0] + 0 + + + + + + SFR_EVSEL_CR_EVSEL6 + 0x0018 + 0x00 + 32 + + + cr_evsel6 + 7 + [7:0] + 0 + + + + + + SFR_EVSEL_CR_EVSEL7 + 0x001c + 0x00 + 32 + + + cr_evsel7 + 7 + [7:0] + 0 + + + + + + SFR_CR_CR_MDMAREQ0 + 0x0020 + 0x00 + 32 + + + cr_mdmareq0 + 4 + [4:0] + 0 + + + + + + SFR_CR_CR_MDMAREQ1 + 0x0024 + 0x00 + 32 + + + cr_mdmareq1 + 4 + [4:0] + 0 + + + + + + SFR_CR_CR_MDMAREQ2 + 0x0028 + 0x00 + 32 + + + cr_mdmareq2 + 4 + [4:0] + 0 + + + + + + SFR_CR_CR_MDMAREQ3 + 0x002c + 0x00 + 32 + + + cr_mdmareq3 + 4 + [4:0] + 0 + + + + + + SFR_CR_CR_MDMAREQ4 + 0x0030 + 0x00 + 32 + + + cr_mdmareq4 + 4 + [4:0] + 0 + + + + + + SFR_CR_CR_MDMAREQ5 + 0x0034 + 0x00 + 32 + + + cr_mdmareq5 + 4 + [4:0] + 0 + + + + + + SFR_CR_CR_MDMAREQ6 + 0x0038 + 0x00 + 32 + + + cr_mdmareq6 + 4 + [4:0] + 0 + + + + + + SFR_CR_CR_MDMAREQ7 + 0x003c + 0x00 + 32 + + + cr_mdmareq7 + 4 + [4:0] + 0 + + + + + + SFR_SR_SR_MDMAREQ0 + 0x0040 + 0x00 + 32 + + + sr_mdmareq0 + 4 + [4:0] + 0 + + + + + + SFR_SR_SR_MDMAREQ1 + 0x0044 + 0x00 + 32 + + + sr_mdmareq1 + 4 + [4:0] + 0 + + + + + + SFR_SR_SR_MDMAREQ2 + 0x0048 + 0x00 + 32 + + + sr_mdmareq2 + 4 + [4:0] + 0 + + + + + + SFR_SR_SR_MDMAREQ3 + 0x004c + 0x00 + 32 + + + sr_mdmareq3 + 4 + [4:0] + 0 + + + + + + SFR_SR_SR_MDMAREQ4 + 0x0050 + 0x00 + 32 + + + sr_mdmareq4 + 4 + [4:0] + 0 + + + + + + SFR_SR_SR_MDMAREQ5 + 0x0054 + 0x00 + 32 + + + sr_mdmareq5 + 4 + [4:0] + 0 + + + + + + SFR_SR_SR_MDMAREQ6 + 0x0058 + 0x00 + 32 + + + sr_mdmareq6 + 4 + [4:0] + 0 + + + + + + SFR_SR_SR_MDMAREQ7 + 0x005c + 0x00 + 32 + + + sr_mdmareq7 + 4 + [4:0] + 0 + + + + + + + 0 + 0x60 + registers + + + + QFC + 0x40000000 + QFC + + + SFR_IO + 0x0000 + 0x00 + 32 + + + sfr_io + 7 + [7:0] + 0 + + + + + + SFR_AR + 0x0004 + 0x00 + 32 + + + sfr_ar + 31 + [31:0] + 0 + + + + + + SFR_IODRV + 0x0008 + 0x00 + 32 + + + paddrvsel + 11 + [11:0] + 0 + + + + + + CR_XIP_ADDRMODE + 0x0010 + 0x00 + 32 + + + cr_xip_addrmode + 1 + [1:0] + 0 + + + + + + CR_XIP_OPCODE + 0x0014 + 0x00 + 32 + + + cr_xip_opcode + 31 + [31:0] + 0 + + + + + + CR_XIP_WIDTH + 0x0018 + 0x00 + 32 + + + cr_xip_width + 5 + [5:0] + 0 + + + + + + CR_XIP_SSEL + 0x001c + 0x00 + 32 + + + cr_xip_ssel + 6 + [6:0] + 0 + + + + + + CR_XIP_DUMCYC + 0x0020 + 0x00 + 32 + + + cr_xip_dumcyc + 15 + [15:0] + 0 + + + + + + CR_XIP_CFG + 0x0024 + 0x00 + 32 + + + cr_xip_cfg + 13 + [13:0] + 0 + + + + + + CR_AESKEY_AESKEYIN0 + 0x0040 + 0x00 + 32 + + + aeskeyin0 + 31 + [31:0] + 0 + + + + + + CR_AESKEY_AESKEYIN1 + 0x0044 + 0x00 + 32 + + + aeskeyin1 + 31 + [31:0] + 0 + + + + + + CR_AESKEY_AESKEYIN2 + 0x0048 + 0x00 + 32 + + + aeskeyin2 + 31 + [31:0] + 0 + + + + + + CR_AESKEY_AESKEYIN3 + 0x004c + 0x00 + 32 + + + aeskeyin3 + 31 + [31:0] + 0 + + + + + + CR_AESENA + 0x0050 + 0x00 + 32 + + + cr_aesena + 0 + [0:0] + 0 + + + + + + + 0 + 0x54 + registers + + + + PL230_PLACEHOLDER + 0x40011000 + PL230_PLACEHOLDER + + + + 0 + 0x4 + registers + + + + GLUECHAIN + 0x40054000 + GLUECHAIN + + + SFR_GCMASK + 0x0000 + 0x00 + 32 + + + cr_gcmask + 31 + [31:0] + 0 + + + + + + SFR_GCSR + 0x0004 + 0x00 + 32 + + + gluereg + 31 + [31:0] + 0 + + + + + + SFR_GCRST + 0x0008 + 0x00 + 32 + + + gluerst + 31 + [31:0] + 0 + + + + + + SFR_GCTEST + 0x000c + 0x00 + 32 + + + gluetest + 31 + [31:0] + 0 + + + + + + + 0 + 0x10 + registers + + + + MESH + 0x40052000 + MESH + + + SFR_MLDRV_CR_MLDRV0 + 0x0000 + 0x00 + 32 + + + cr_mldrv0 + 31 + [31:0] + 0 + + + + + + SFR_MLIE_CR_MLIE0 + 0x0004 + 0x00 + 32 + + + cr_mlie0 + 31 + [31:0] + 0 + + + + + + SFR_MLSR_SR_MLSR0 + 0x0008 + 0x00 + 32 + + + sr_mlsr0 + 31 + [31:0] + 0 + + + + + + SFR_MLSR_SR_MLSR1 + 0x000c + 0x00 + 32 + + + sr_mlsr1 + 31 + [31:0] + 0 + + + + + + SFR_MLSR_SR_MLSR2 + 0x0010 + 0x00 + 32 + + + sr_mlsr2 + 31 + [31:0] + 0 + + + + + + SFR_MLSR_SR_MLSR3 + 0x0014 + 0x00 + 32 + + + sr_mlsr3 + 31 + [31:0] + 0 + + + + + + SFR_MLSR_SR_MLSR4 + 0x0018 + 0x00 + 32 + + + sr_mlsr4 + 31 + [31:0] + 0 + + + + + + SFR_MLSR_SR_MLSR5 + 0x001c + 0x00 + 32 + + + sr_mlsr5 + 31 + [31:0] + 0 + + + + + + SFR_MLSR_SR_MLSR6 + 0x0020 + 0x00 + 32 + + + sr_mlsr6 + 31 + [31:0] + 0 + + + + + + SFR_MLSR_SR_MLSR7 + 0x0024 + 0x00 + 32 + + + sr_mlsr7 + 31 + [31:0] + 0 + + + + + + + 0 + 0x28 + registers + + + + SENSORC + 0x40053000 + SENSORC + + + SFR_VDMASK0 + 0x0000 + 0x00 + 32 + + + cr_vdmask0 + 7 + [7:0] + 0 + + + + + + SFR_VDMASK1 + 0x0004 + 0x00 + 32 + + + cr_vdmask1 + 7 + [7:0] + 0 + + + + + + SFR_VDSR + 0x0008 + 0x00 + 32 + + + sr_vdsr + 7 + [7:0] + 0 + + + + + + SFR_LDMASK + 0x0010 + 0x00 + 32 + + + cr_ldmask + 3 + [3:0] + 0 + + + + + + SFR_LDSR + 0x0014 + 0x00 + 32 + + + sr_ldsr + 3 + [3:0] + 0 + + + + + + SFR_LDCFG + 0x0018 + 0x00 + 32 + + + sfr_ldcfg + 3 + [3:0] + 0 + + + + + + SFR_VDCFG_CR_VDCFG0 + 0x0020 + 0x00 + 32 + + + cr_vdcfg0 + 3 + [3:0] + 0 + + + + + + SFR_VDCFG_CR_VDCFG1 + 0x0024 + 0x00 + 32 + + + cr_vdcfg1 + 3 + [3:0] + 0 + + + + + + SFR_VDCFG_CR_VDCFG2 + 0x0028 + 0x00 + 32 + + + cr_vdcfg2 + 3 + [3:0] + 0 + + + + + + SFR_VDCFG_CR_VDCFG3 + 0x002c + 0x00 + 32 + + + cr_vdcfg3 + 3 + [3:0] + 0 + + + + + + SFR_VDCFG_CR_VDCFG4 + 0x0030 + 0x00 + 32 + + + cr_vdcfg4 + 3 + [3:0] + 0 + + + + + + SFR_VDCFG_CR_VDCFG5 + 0x0034 + 0x00 + 32 + + + cr_vdcfg5 + 3 + [3:0] + 0 + + + + + + SFR_VDCFG_CR_VDCFG6 + 0x0038 + 0x00 + 32 + + + cr_vdcfg6 + 3 + [3:0] + 0 + + + + + + SFR_VDCFG_CR_VDCFG7 + 0x003c + 0x00 + 32 + + + cr_vdcfg7 + 3 + [3:0] + 0 + + + + + + + 0 + 0x40 + registers + + + + + + PL230 + PL230 DMA Controller Core + 1073811456 + + 0x0 + 0x40 + registers + + + 0x40 + 0xc + reserved + + + 0x4c + 0x4 + registers + + + + STATUS + DMA Status Register + 0x00 + 32 + read-only + 0x101f0000 + 0xffffff0f + + + TEST_STATUS + Test status configuration + 28 + 4 + read-only + + + CHNLS_MINUS1 + Number of available DMA channels minus 1 + 16 + 5 + read-only + + + STATE + Current state of the control machine + 4 + 4 + read-only + + + MASTER_ENABLE + Master enable status + 0 + 1 + read-only + + + + + CFG + DMA Configuration Register + 0x04 + 32 + write-only + 0x00000000 + 0x00000000 + + + CHNL_PROT_CTRL + Set AHB-Lite configuration + 5 + 3 + read-only + + + MASTER_ENABLE + MASTER_ENABLE + 0 + 1 + write-only + + + + + CTRLBASEPTR + DMA Control Data Base Pointer Register + 0x08 + 32 + read-write + 0x00000000 + 0xffffffff + + + CTRL_BASE_PTR + CTRL_BASE_PTR + 8 + 24 + read-write + + + + + ALTCTRLBASEPTR + DMA Channel Alternate Control Data Base Pointer Register + 0x0C + 32 + read-only + 0x00000000 + 0xffffffff + + + ALT_CTRL_BASE_PTR + ALT_CTRL_BASE_PTR + 0 + 32 + read-only + + + + + DMA_WAITONREQ_STATUS + Channel wait on request status + 0x10 + 32 + read-only + 0x00000000 + 0xffffffff + + + DMA_WAITONREQ_STATUS + Wait on request status, one bit per channel + 0 + 8 + read-only + + + + + CHNLSWREQUEST + DMA Channel Software Request Register + 0x14 + 32 + write-only + 0x00000000 + 0x00000000 + + + CHNL_SW_REQUEST + CHNL_SW_REQUEST + 0 + 8 + write-only + + + + + CHNLUSEBURSTSET + DMA Channel Useburst Set Register + 0x18 + 32 + read-write + 0x00000000 + 0xffffffff + + + CHNL_USEBURST_SET + CHNL_USEBURST_SET + 0 + 8 + read-write + + + + + CHNLUSEBURSTCLR + DMA Channel Useburst Clear Register + 0x1C + 32 + write-only + 0x00000000 + 0x00000000 + + + CHNL_USEBURST_CLR + CHNL_USEBURST_CLR + 0 + 8 + write-only + + + + + CHNLREQMASKSET + DMA Channel Request Mask Set Register + 0x20 + 32 + read-write + 0x00000000 + 0xffffffff + + + CHNL_REQ_MASK_SET + CHNL_REQ_MASK_SET + 0 + 8 + read-write + + + + + CHNLREQMASKCLR + DMA Channel Request Mask Clear Register + 0x24 + 32 + write-only + 0x00000000 + 0x00000000 + + + CHNL_REQ_MASK_CLR + CHNL_REQ_MASK_CLR + 0 + 8 + write-only + + + + + CHNLENABLESET + DMA Channel Enable Set Register + 0x28 + 32 + read-write + 0x00000000 + 0xffffffff + + + CHNL_ENABLE_SET + CHNL_ENABLE_SET + 0 + 8 + read-write + + + + + CHNLENABLECLR + DMA Channel Enable Clear Register + 0x2C + 32 + write-only + 0x00000000 + 0x00000000 + + + CHNL_ENABLE_CLR + CHNL_ENABLE_CLR + 0 + 8 + write-only + + + + + CHNLPRIALTSET + DMA Channel Primary-Alternate Set Register + 0x30 + 32 + read-write + 0x00000000 + 0xffffffff + + + CHNL_PRI_ALT_SET + CHNL_PRI_ALT_SET + 0 + 8 + read-write + + + + + CHNLPRIALTCLR + DMA Channel Primary-Alternate Clear Register + 0x34 + 32 + write-only + 0x00000000 + 0x00000000 + + + CHNL_PRI_ALT_CLR + CHNL_PRI_ALT_CLR + 0 + 8 + write-only + + + + + CHNLPRIORITYSET + DMA Channel Priority Set Register + 0x38 + 32 + read-write + 0x00000000 + 0xffffffff + + + CHNL_PRIORITY_SET + CHNL_PRIORITY_SET + 0 + 8 + read-write + + + + + CHNLPRIORITYCLR + DMA Channel Priority Clear Register + 0x3C + 32 + write-only + 0x00000000 + 0x00000000 + + + CHNL_PRIORITY_CLR + CHNL_PRIORITY_CLR + 0 + 8 + write-only + + + + + ERRCLR + DMA Bus Error Clear Register + 0x4C + 32 + read-write + 0x00000000 + 0xffffffff + + + ERR_CLR + ERR_CLR + 0 + 1 + read-write + + + + + PERIPH_ID_0 + Peripheral ID byte 0 + 0xFE0 + 32 + read-write + 0x00000000 + 0xffffffff + + + PART_NUMBER_LSB + Identifies the part number + 0 + 8 + read-only + + + + + PERIPH_ID_1 + Peripheral ID byte 1 + 0xFE4 + 32 + read-write + 0x00000000 + 0xffffffff + + + PART_NUMBER_MSB + Identifies the part number + 0 + 4 + read-only + + + JEP106_LSB + Designer ID LSB + 4 + 3 + read-only + + + + + PERIPH_ID_2 + Peripheral ID byte 2 + 0xFE8 + 32 + read-write + 0x00000000 + 0xffffffff + + + JEP106_MSB + Designer ID MSB + 0 + 3 + read-only + + + JEDEC_USED + Identifies if JP106 ID code is used + 3 + 1 + read-only + + + REVISION + Identifies revision number of peripheral + 4 + 4 + read-only + + + + + + + + + SCE + 0x40028000 + 0x00008000 + + + SYSCTRL + 0x40040000 + 0x00010000 + + + IFSUB + 0x50120000 + 0x00010000 + + + CORESUB + 0x40000000 + 0x00010000 + + + SECSUB + 0x40050000 + 0x00010000 + + + PIO + 0x50123000 + 0x00001000 + + + SEG_LKEY + 0x40020000 + 0x00000100 + + + SEG_KEY + 0x40020100 + 0x00000100 + + + SEG_SKEY + 0x40020200 + 0x00000100 + + + SEG_SCRT + 0x40020300 + 0x00000100 + + + SEG_MSG + 0x40020400 + 0x00000200 + + + SEG_HOUT + 0x40020600 + 0x00000100 + + + SEG_SOB + 0x40020700 + 0x00000100 + + + SEG_PCON + 0x40020800 + 0x00000100 + + + SEG_PKB + 0x40020900 + 0x00000100 + + + SEG_PIB + 0x40020A00 + 0x00000400 + + + SEG_PSIB + 0x40020E00 + 0x00000400 + + + SEG_POB + 0x40021200 + 0x00000400 + + + SEG_PSOB + 0x40021600 + 0x00000400 + + + SEG_AKEY + 0x40021A00 + 0x00000100 + + + SEG_AIB + 0x40021B00 + 0x00000100 + + + SEG_AOB + 0x40021C00 + 0x00000100 + + + SEG_RNGA + 0x40021D00 + 0x00000400 + + + SEG_RNGB + 0x40022100 + 0x00000400 + + + IFRAM0 + 0x50000000 + 0x00020000 + + + IFRAM1 + 0x50020000 + 0x00020000 + + + NULL + 0x50040000 + 0x00010000 + + + UDMA + 0x50100000 + 0x00020000 + + + UDP + 0x50122000 + 0x00001000 + + + SDDC_DAT + 0x50140000 + 0x00010000 + + + UDC + 0x50200000 + 0x00010000 + + + SRAM + 0x61000000 + 0x00200000 + + + RERAM + 0x60000000 + 0x00400000 + + + XIP + 0x70000000 + 0x08000000 + + + + + + \ No newline at end of file diff --git a/utralib/cramium/soc.svd b/utralib/cramium/soc.svd new file mode 100644 index 000000000..a7e8e7d34 --- /dev/null +++ b/utralib/cramium/soc.svd @@ -0,0 +1,735 @@ + + + + litex + SOC + + + 8 + 32 + 32 + read-write + 0x00000000 + 0xFFFFFFFF + + + + GPIO + 0x40080000 + GPIO + + + UARTSEL + + 0x0000 + 0x00 + 32 + + + uartsel + 1 + [1:0] + 0 + + + + + + 0 + 0x4 + registers + + + + UART + 0x40082000 + UART + + + RXTX + 0x0000 + 0x00 + 32 + + + rxtx + 7 + [7:0] + 0 + + + + + TXFULL + + 0x0004 + 0x00 + 32 + + + txfull + 0 + [0:0] + 0 + + + + + RXEMPTY + + 0x0008 + 0x00 + 32 + + + rxempty + 0 + [0:0] + 0 + + + + + EV_STATUS + + 0x000c + 0x00 + 32 + + + tx + 0 + [0:0] + 0 + + + + rx + 1 + [1:1] + 1 + + + + + + EV_PENDING + + 0x0010 + 0x00 + 32 + + + tx + 0 + [0:0] + 0 + + + + rx + 1 + [1:1] + 1 + + + + + + EV_ENABLE + + 0x0014 + 0x00 + 32 + + + tx + 0 + [0:0] + 0 + + + + rx + 1 + [1:1] + 1 + + + + + + TXEMPTY + + 0x0018 + 0x00 + 32 + + + txempty + 0 + [0:0] + 0 + + + + + RXFULL + + 0x001c + 0x00 + 32 + + + rxfull + 0 + [0:0] + 0 + + + + + + 0 + 0x20 + registers + + + uart + 0 + + + + CONSOLE + 0x40084000 + CONSOLE + + + RXTX + 0x0000 + 0x00 + 32 + + + rxtx + 7 + [7:0] + 0 + + + + + TXFULL + + 0x0004 + 0x00 + 32 + + + txfull + 0 + [0:0] + 0 + + + + + RXEMPTY + + 0x0008 + 0x00 + 32 + + + rxempty + 0 + [0:0] + 0 + + + + + EV_STATUS + + 0x000c + 0x00 + 32 + + + tx + 0 + [0:0] + 0 + + + + rx + 1 + [1:1] + 1 + + + + + + EV_PENDING + + 0x0010 + 0x00 + 32 + + + tx + 0 + [0:0] + 0 + + + + rx + 1 + [1:1] + 1 + + + + + + EV_ENABLE + + 0x0014 + 0x00 + 32 + + + tx + 0 + [0:0] + 0 + + + + rx + 1 + [1:1] + 1 + + + + + + TXEMPTY + + 0x0018 + 0x00 + 32 + + + txempty + 0 + [0:0] + 0 + + + + + RXFULL + + 0x001c + 0x00 + 32 + + + rxfull + 0 + [0:0] + 0 + + + + + + 0 + 0x20 + registers + + + console + 1 + + + + APP_UART + 0x40086000 + APP_UART + + + RXTX + 0x0000 + 0x00 + 32 + + + rxtx + 7 + [7:0] + 0 + + + + + TXFULL + + 0x0004 + 0x00 + 32 + + + txfull + 0 + [0:0] + 0 + + + + + RXEMPTY + + 0x0008 + 0x00 + 32 + + + rxempty + 0 + [0:0] + 0 + + + + + EV_STATUS + + 0x000c + 0x00 + 32 + + + tx + 0 + [0:0] + 0 + + + + rx + 1 + [1:1] + 1 + + + + + + EV_PENDING + + 0x0010 + 0x00 + 32 + + + tx + 0 + [0:0] + 0 + + + + rx + 1 + [1:1] + 1 + + + + + + EV_ENABLE + + 0x0014 + 0x00 + 32 + + + tx + 0 + [0:0] + 0 + + + + rx + 1 + [1:1] + 1 + + + + + + TXEMPTY + + 0x0018 + 0x00 + 32 + + + txempty + 0 + [0:0] + 0 + + + + + RXFULL + + 0x001c + 0x00 + 32 + + + rxfull + 0 + [0:0] + 0 + + + + + + 0 + 0x20 + registers + + + app_uart + 2 + + + + IDENTIFIER_MEM + 0x40087000 + IDENTIFIER_MEM + + + IDENTIFIER_MEM + + 0x0000 + 0x00 + 32 + + + identifier_mem + 7 + [7:0] + 0 + + + + + + 0 + 0x4 + registers + + + + MAIN + 0x40088000 + MAIN + + + REPORT + + 0x0000 + 0x00 + 32 + + + report + 31 + [31:0] + 0 + + + + + SUCCESS + + 0x0004 + 0x00 + 32 + + + success + 0 + [0:0] + 0 + + + + + DONE + + 0x0008 + 0x00 + 32 + + + done + 0 + [0:0] + 0 + + + + + WDATA + + 0x000c + 0x00 + 32 + + + wdata + 31 + [31:0] + 0 + + + + + RDATA + + 0x0010 + 0x00 + 32 + + + rdata + 31 + [31:0] + 0 + + + + + RINC + + 0x0014 + 0x00 + 32 + + + rinc + 31 + [31:0] + 0 + + + + + IRQTEST0 + 0x0018 + 0x00 + 32 + + + trigger + 19 + [19:0] + 0 + + + + + + IRQTEST1 + 0x001c + 0x00 + 32 + + + trigger + 19 + [19:0] + 0 + + + + + + + 0 + 0x20 + registers + + + + + + + RERAM + 0x60000000 + 0x00400000 + + + SRAM + 0x61000000 + 0x00200000 + + + XIP + 0x70000000 + 0x08000000 + + + VEXRISCV_DEBUG + 0xEFFF0000 + 0x00001000 + + + CSR + 0x40080000 + 0x00040000 + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/utralib/src/generated.rs b/utralib/src/generated.rs index 36e99d56f..717cac140 100644 --- a/utralib/src/generated.rs +++ b/utralib/src/generated.rs @@ -26,6 +26,16 @@ mod atsama5d27; #[cfg(feature = "atsama5d27")] pub use atsama5d27::*; +#[cfg(feature="cramium-soc")] +mod cramium_soc; +#[cfg(feature="cramium-soc")] +pub use cramium_soc::*; + +#[cfg(feature="cramium-fpga")] +mod cramium_fpga; +#[cfg(feature="cramium-fpga")] +pub use cramium_fpga::*; + // Hosted mode includes nothing, as it relies on the abstract host // architecture for I/O; so this file is empty when the "hosted" // configuration is selected and there are no corresponding "hosted" diff --git a/utralib/src/generated/cramium_fpga.rs b/utralib/src/generated/cramium_fpga.rs new file mode 100644 index 000000000..7669a4222 --- /dev/null +++ b/utralib/src/generated/cramium_fpga.rs @@ -0,0 +1,16478 @@ + +#![allow(dead_code)] +use core::convert::TryInto; +#[cfg(feature="std")] +use core::sync::atomic::AtomicPtr; +#[cfg(feature="std")] +use std::sync::Arc; + +#[derive(Debug, Copy, Clone)] +pub struct Register { + /// Offset of this register within this CSR + offset: usize, + /// Mask of SVD-specified bits for the register + mask: usize, +} +impl Register { + pub const fn new(offset: usize, mask: usize) -> Register { + Register { offset, mask } + } + pub const fn offset(&self) -> usize { self.offset } + pub const fn mask(&self) -> usize { self.mask } +} +#[derive(Debug, Copy, Clone)] +pub struct Field { + /// A bitmask we use to AND to the value, unshifted. + /// E.g. for a width of `3` bits, this mask would be 0b111. + mask: usize, + /// Offset of the first bit in this field + offset: usize, + /// A copy of the register address that this field + /// is a member of. Ideally this is optimized out by the + /// compiler. + register: Register, +} +impl Field { + /// Define a new CSR field with the given width at a specified + /// offset from the start of the register. + pub const fn new(width: usize, offset: usize, register: Register) -> Field { + let mask = if width < 32 { (1 << width) - 1 } else {0xFFFF_FFFF}; + Field { + mask, + offset, + register, + } + } + pub const fn offset(&self) -> usize { self.offset } + pub const fn mask(&self) -> usize { self.mask } +} +#[derive(Debug, Copy, Clone)] +pub struct CSR { + base: *mut T, +} +impl CSR +where + T: core::convert::TryFrom + core::convert::TryInto + core::default::Default, +{ + pub fn new(base: *mut T) -> Self { + CSR { base } + } + /// Retrieve the raw pointer used as the base of the CSR. This is unsafe because the copied + /// value can be used to do all kinds of awful shared mutable operations (like creating + /// another CSR accessor owned by another thread). However, sometimes this is unavoidable + /// because hardware is in fact shared mutable state. + pub unsafe fn base(&self) -> *mut T { + self.base + } + /// Read the contents of this register + pub fn r(&self, reg: Register) -> T { + // prevent re-ordering + core::sync::atomic::compiler_fence(core::sync::atomic::Ordering::SeqCst); + + let usize_base: *mut usize = unsafe { core::mem::transmute(self.base) }; + unsafe { usize_base.add(reg.offset).read_volatile() } + .try_into() + .unwrap_or_default() + } + /// Read a field from this CSR + pub fn rf(&self, field: Field) -> T { + // prevent re-ordering + core::sync::atomic::compiler_fence(core::sync::atomic::Ordering::SeqCst); + + let usize_base: *mut usize = unsafe { core::mem::transmute(self.base) }; + ((unsafe { usize_base.add(field.register.offset).read_volatile() } >> field.offset) + & field.mask) + .try_into() + .unwrap_or_default() + } + /// Read-modify-write a given field in this CSR + pub fn rmwf(&mut self, field: Field, value: T) { + let usize_base: *mut usize = unsafe { core::mem::transmute(self.base) }; + let value_as_usize: usize = value.try_into().unwrap_or_default() << field.offset; + let previous = + unsafe { usize_base.add(field.register.offset).read_volatile() } & !(field.mask << field.offset); + unsafe { + usize_base + .add(field.register.offset) + .write_volatile(previous | value_as_usize) + }; + // prevent re-ordering + core::sync::atomic::compiler_fence(core::sync::atomic::Ordering::SeqCst); + } + /// Write a given field without reading it first + pub fn wfo(&mut self, field: Field, value: T) { + let usize_base: *mut usize = unsafe { core::mem::transmute(self.base) }; + let value_as_usize: usize = (value.try_into().unwrap_or_default() & field.mask) << field.offset; + unsafe { + usize_base + .add(field.register.offset) + .write_volatile(value_as_usize) + }; + // Ensure the compiler doesn't re-order the write. + // We use `SeqCst`, because `Acquire` only prevents later accesses from being reordered before + // *reads*, but this method only *writes* to the locations. + core::sync::atomic::compiler_fence(core::sync::atomic::Ordering::SeqCst); + } + /// Write the entire contents of a register without reading it first + pub fn wo(&mut self, reg: Register, value: T) { + let usize_base: *mut usize = unsafe { core::mem::transmute(self.base) }; + let value_as_usize: usize = value.try_into().unwrap_or_default(); + unsafe { usize_base.add(reg.offset).write_volatile(value_as_usize) }; + // Ensure the compiler doesn't re-order the write. + // We use `SeqCst`, because `Acquire` only prevents later accesses from being reordered before + // *reads*, but this method only *writes* to the locations. + core::sync::atomic::compiler_fence(core::sync::atomic::Ordering::SeqCst); + } + /// Zero a field from a provided value + pub fn zf(&self, field: Field, value: T) -> T { + let value_as_usize: usize = value.try_into().unwrap_or_default(); + (value_as_usize & !(field.mask << field.offset)) + .try_into() + .unwrap_or_default() + } + /// Shift & mask a value to its final field position + pub fn ms(&self, field: Field, value: T) -> T { + let value_as_usize: usize = value.try_into().unwrap_or_default(); + ((value_as_usize & field.mask) << field.offset) + .try_into() + .unwrap_or_default() + } +} + +#[derive(Debug)] +#[cfg(feature="std")] +pub struct AtomicCsr { + base: Arc::>, +} +#[cfg(feature="std")] +impl AtomicCsr +where + T: core::convert::TryFrom + core::convert::TryInto + core::default::Default, +{ + /// AtomicCsr wraps the CSR in an Arc + AtomicPtr, so that write operations don't require + /// a mutable reference. This allows us to stick CSR accesses into APIs that require + /// non-mutable references to hardware state (such as certain "standardized" USB APIs). + /// Hiding the fact that you're tweaking hardware registers behind Arc/AtomicPtr seems a little + /// scary, but, it does make for nicer Rust semantics. + pub fn new(base: *mut T) -> Self { + AtomicCsr { + base: Arc::new(AtomicPtr::new(base)) + } + } + pub fn clone(&self) -> Self { + AtomicCsr { + base: self.base.clone() + } + } + /// Read the contents of this register + pub fn r(&self, reg: Register) -> T { + // prevent re-ordering + core::sync::atomic::compiler_fence(core::sync::atomic::Ordering::SeqCst); + + let usize_base: *mut usize = unsafe { core::mem::transmute(self.base.load(core::sync::atomic::Ordering::SeqCst)) }; + unsafe { usize_base.add(reg.offset).read_volatile() } + .try_into() + .unwrap_or_default() + } + /// Read a field from this CSR + pub fn rf(&self, field: Field) -> T { + // prevent re-ordering + core::sync::atomic::compiler_fence(core::sync::atomic::Ordering::SeqCst); + + let usize_base: *mut usize = unsafe { core::mem::transmute(self.base.load(core::sync::atomic::Ordering::SeqCst)) }; + ((unsafe { usize_base.add(field.register.offset).read_volatile() } >> field.offset) + & field.mask) + .try_into() + .unwrap_or_default() + } + /// Read-modify-write a given field in this CSR + pub fn rmwf(&self, field: Field, value: T) { + let usize_base: *mut usize = unsafe { core::mem::transmute(self.base.load(core::sync::atomic::Ordering::SeqCst)) }; + let value_as_usize: usize = value.try_into().unwrap_or_default() << field.offset; + let previous = + unsafe { usize_base.add(field.register.offset).read_volatile() } & !(field.mask << field.offset); + unsafe { + usize_base + .add(field.register.offset) + .write_volatile(previous | value_as_usize) + }; + // prevent re-ordering + core::sync::atomic::compiler_fence(core::sync::atomic::Ordering::SeqCst); + } + /// Write a given field without reading it first + pub fn wfo(&self, field: Field, value: T) { + let usize_base: *mut usize = unsafe { core::mem::transmute(self.base.load(core::sync::atomic::Ordering::SeqCst)) }; + let value_as_usize: usize = (value.try_into().unwrap_or_default() & field.mask) << field.offset; + unsafe { + usize_base + .add(field.register.offset) + .write_volatile(value_as_usize) + }; + // Ensure the compiler doesn't re-order the write. + // We use `SeqCst`, because `Acquire` only prevents later accesses from being reordered before + // *reads*, but this method only *writes* to the locations. + core::sync::atomic::compiler_fence(core::sync::atomic::Ordering::SeqCst); + } + /// Write the entire contents of a register without reading it first + pub fn wo(&self, reg: Register, value: T) { + let usize_base: *mut usize = unsafe { core::mem::transmute(self.base.load(core::sync::atomic::Ordering::SeqCst)) }; + let value_as_usize: usize = value.try_into().unwrap_or_default(); + unsafe { usize_base.add(reg.offset).write_volatile(value_as_usize) }; + // Ensure the compiler doesn't re-order the write. + // We use `SeqCst`, because `Acquire` only prevents later accesses from being reordered before + // *reads*, but this method only *writes* to the locations. + core::sync::atomic::compiler_fence(core::sync::atomic::Ordering::SeqCst); + } + /// Zero a field from a provided value + pub fn zf(&self, field: Field, value: T) -> T { + let value_as_usize: usize = value.try_into().unwrap_or_default(); + (value_as_usize & !(field.mask << field.offset)) + .try_into() + .unwrap_or_default() + } + /// Shift & mask a value to its final field position + pub fn ms(&self, field: Field, value: T) -> T { + let value_as_usize: usize = value.try_into().unwrap_or_default(); + ((value_as_usize & field.mask) << field.offset) + .try_into() + .unwrap_or_default() + } +} +// Physical base addresses of memory regions +pub const HW_RERAM_MEM: usize = 0x60000000; +pub const HW_RERAM_MEM_LEN: usize = 4194304; +pub const HW_SRAM_MEM: usize = 0x61000000; +pub const HW_SRAM_MEM_LEN: usize = 2097152; +pub const HW_XIP_MEM: usize = 0x70000000; +pub const HW_XIP_MEM_LEN: usize = 134217728; +pub const HW_VEXRISCV_DEBUG_MEM: usize = 0xefff0000; +pub const HW_VEXRISCV_DEBUG_MEM_LEN: usize = 4096; +pub const HW_CSR_MEM: usize = 0x40080000; +pub const HW_CSR_MEM_LEN: usize = 262144; +pub const HW_CSR__MEM: usize = 0xe0000000; +pub const HW_CSR__MEM_LEN: usize = 262144; +pub const HW_SCE_MEM: usize = 0x40028000; +pub const HW_SCE_MEM_LEN: usize = 32768; +pub const HW_SYSCTRL_MEM: usize = 0x40040000; +pub const HW_SYSCTRL_MEM_LEN: usize = 65536; +pub const HW_IFSUB_MEM: usize = 0x50120000; +pub const HW_IFSUB_MEM_LEN: usize = 65536; +pub const HW_CORESUB_MEM: usize = 0x40000000; +pub const HW_CORESUB_MEM_LEN: usize = 65536; +pub const HW_SECSUB_MEM: usize = 0x40050000; +pub const HW_SECSUB_MEM_LEN: usize = 65536; +pub const HW_PIO_MEM: usize = 0x50123000; +pub const HW_PIO_MEM_LEN: usize = 4096; +pub const HW_SEG_LKEY_MEM: usize = 0x40020000; +pub const HW_SEG_LKEY_MEM_LEN: usize = 256; +pub const HW_SEG_KEY_MEM: usize = 0x40020100; +pub const HW_SEG_KEY_MEM_LEN: usize = 256; +pub const HW_SEG_SKEY_MEM: usize = 0x40020200; +pub const HW_SEG_SKEY_MEM_LEN: usize = 256; +pub const HW_SEG_SCRT_MEM: usize = 0x40020300; +pub const HW_SEG_SCRT_MEM_LEN: usize = 256; +pub const HW_SEG_MSG_MEM: usize = 0x40020400; +pub const HW_SEG_MSG_MEM_LEN: usize = 512; +pub const HW_SEG_HOUT_MEM: usize = 0x40020600; +pub const HW_SEG_HOUT_MEM_LEN: usize = 256; +pub const HW_SEG_SOB_MEM: usize = 0x40020700; +pub const HW_SEG_SOB_MEM_LEN: usize = 256; +pub const HW_SEG_PCON_MEM: usize = 0x40020800; +pub const HW_SEG_PCON_MEM_LEN: usize = 256; +pub const HW_SEG_PKB_MEM: usize = 0x40020900; +pub const HW_SEG_PKB_MEM_LEN: usize = 256; +pub const HW_SEG_PIB_MEM: usize = 0x40020a00; +pub const HW_SEG_PIB_MEM_LEN: usize = 1024; +pub const HW_SEG_PSIB_MEM: usize = 0x40020e00; +pub const HW_SEG_PSIB_MEM_LEN: usize = 1024; +pub const HW_SEG_POB_MEM: usize = 0x40021200; +pub const HW_SEG_POB_MEM_LEN: usize = 1024; +pub const HW_SEG_PSOB_MEM: usize = 0x40021600; +pub const HW_SEG_PSOB_MEM_LEN: usize = 1024; +pub const HW_SEG_AKEY_MEM: usize = 0x40021a00; +pub const HW_SEG_AKEY_MEM_LEN: usize = 256; +pub const HW_SEG_AIB_MEM: usize = 0x40021b00; +pub const HW_SEG_AIB_MEM_LEN: usize = 256; +pub const HW_SEG_AOB_MEM: usize = 0x40021c00; +pub const HW_SEG_AOB_MEM_LEN: usize = 256; +pub const HW_SEG_RNGA_MEM: usize = 0x40021d00; +pub const HW_SEG_RNGA_MEM_LEN: usize = 1024; +pub const HW_SEG_RNGB_MEM: usize = 0x40022100; +pub const HW_SEG_RNGB_MEM_LEN: usize = 1024; +pub const HW_IFRAM0_MEM: usize = 0x50000000; +pub const HW_IFRAM0_MEM_LEN: usize = 131072; +pub const HW_IFRAM1_MEM: usize = 0x50020000; +pub const HW_IFRAM1_MEM_LEN: usize = 131072; +pub const HW_NULL_MEM: usize = 0x50040000; +pub const HW_NULL_MEM_LEN: usize = 65536; +pub const HW_UDMA_MEM: usize = 0x50100000; +pub const HW_UDMA_MEM_LEN: usize = 131072; +pub const HW_UDP_MEM: usize = 0x50122000; +pub const HW_UDP_MEM_LEN: usize = 4096; +pub const HW_SDDC_DAT_MEM: usize = 0x50140000; +pub const HW_SDDC_DAT_MEM_LEN: usize = 65536; +pub const HW_UDC_MEM: usize = 0x50200000; +pub const HW_UDC_MEM_LEN: usize = 65536; +pub const HW_SRAM__MEM: usize = 0x61000000; +pub const HW_SRAM__MEM_LEN: usize = 2097152; +pub const HW_RERAM__MEM: usize = 0x60000000; +pub const HW_RERAM__MEM_LEN: usize = 4194304; +pub const HW_XIP__MEM: usize = 0x70000000; +pub const HW_XIP__MEM_LEN: usize = 134217728; + +// Physical base addresses of registers +pub const HW_GPIO_BASE : usize = 0x40080000; +pub const HW_UART_BASE : usize = 0x40082000; +pub const HW_CONSOLE_BASE : usize = 0x40084000; +pub const HW_APP_UART_BASE : usize = 0x40086000; +pub const HW_IDENTIFIER_MEM_BASE : usize = 0x40087000; +pub const HW_MAIN_BASE : usize = 0x40088000; +pub const HW_D11CTIME_BASE : usize = 0xe0000000; +pub const HW_SUSRES_BASE : usize = 0xe0001000; +pub const HW_COREUSER_BASE : usize = 0xe0002000; +pub const HW_CSRTEST_BASE : usize = 0xe0003000; +pub const HW_IRQARRAY0_BASE : usize = 0xe0004000; +pub const HW_IRQARRAY1_BASE : usize = 0xe0005000; +pub const HW_IRQARRAY10_BASE : usize = 0xe0006000; +pub const HW_IRQARRAY11_BASE : usize = 0xe0007000; +pub const HW_IRQARRAY12_BASE : usize = 0xe0008000; +pub const HW_IRQARRAY13_BASE : usize = 0xe0009000; +pub const HW_IRQARRAY14_BASE : usize = 0xe000a000; +pub const HW_IRQARRAY15_BASE : usize = 0xe000b000; +pub const HW_IRQARRAY16_BASE : usize = 0xe000c000; +pub const HW_IRQARRAY17_BASE : usize = 0xe000d000; +pub const HW_IRQARRAY18_BASE : usize = 0xe000e000; +pub const HW_IRQARRAY19_BASE : usize = 0xe000f000; +pub const HW_IRQARRAY2_BASE : usize = 0xe0010000; +pub const HW_IRQARRAY3_BASE : usize = 0xe0011000; +pub const HW_IRQARRAY4_BASE : usize = 0xe0012000; +pub const HW_IRQARRAY5_BASE : usize = 0xe0013000; +pub const HW_IRQARRAY6_BASE : usize = 0xe0014000; +pub const HW_IRQARRAY7_BASE : usize = 0xe0015000; +pub const HW_IRQARRAY8_BASE : usize = 0xe0016000; +pub const HW_IRQARRAY9_BASE : usize = 0xe0017000; +pub const HW_MAILBOX_BASE : usize = 0xe0018000; +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_AES_BASE : usize = 0x4002d000; +pub const HW_COMBOHASH_BASE : usize = 0x4002b000; +pub const HW_PKE_BASE : usize = 0x4002c000; +pub const HW_SCEDMA_BASE : usize = 0x40029000; +pub const HW_SCE_GLBSFR_BASE : usize = 0x40028000; +pub const HW_TRNG_BASE : usize = 0x4002e000; +pub const HW_ALU_BASE : usize = 0x4002f000; +pub const HW_DUART_BASE : usize = 0x40042000; +pub const HW_WDG_INTF_BASE : usize = 0x40041000; +pub const HW_TIMER_INTF_BASE : usize = 0x40043000; +pub const HW_EVC_BASE : usize = 0x40044000; +pub const HW_SYSCTRL_BASE : usize = 0x40040000; +pub const HW_APB_THRU_BASE : usize = 0x50122000; +pub const HW_IOX_BASE : usize = 0x5012f000; +pub const HW_PWM_BASE : usize = 0x50120000; +pub const HW_SDDC_BASE : usize = 0x50121000; +pub const HW_RP_PIO_BASE : usize = 0x50123000; +pub const HW_MDMA_BASE : usize = 0x40002000; +pub const HW_QFC_BASE : usize = 0x40000000; +pub const HW_PL230_PLACEHOLDER_BASE : usize = 0x40011000; +pub const HW_GLUECHAIN_BASE : usize = 0x40054000; +pub const HW_MESH_BASE : usize = 0x40052000; +pub const HW_SENSORC_BASE : usize = 0x40053000; + + +pub mod utra { + + pub mod gpio { + pub const GPIO_NUMREGS: usize = 1; + + pub const UARTSEL: crate::Register = crate::Register::new(0, 0x3); + pub const UARTSEL_UARTSEL: crate::Field = crate::Field::new(2, 0, UARTSEL); + + pub const HW_GPIO_BASE: usize = 0x40080000; + } + + pub mod uart { + pub const UART_NUMREGS: usize = 8; + + pub const RXTX: crate::Register = crate::Register::new(0, 0xff); + pub const RXTX_RXTX: crate::Field = crate::Field::new(8, 0, RXTX); + + pub const TXFULL: crate::Register = crate::Register::new(1, 0x1); + pub const TXFULL_TXFULL: crate::Field = crate::Field::new(1, 0, TXFULL); + + pub const RXEMPTY: crate::Register = crate::Register::new(2, 0x1); + pub const RXEMPTY_RXEMPTY: crate::Field = crate::Field::new(1, 0, RXEMPTY); + + pub const EV_STATUS: crate::Register = crate::Register::new(3, 0x3); + pub const EV_STATUS_TX: crate::Field = crate::Field::new(1, 0, EV_STATUS); + pub const EV_STATUS_RX: crate::Field = crate::Field::new(1, 1, EV_STATUS); + + pub const EV_PENDING: crate::Register = crate::Register::new(4, 0x3); + pub const EV_PENDING_TX: crate::Field = crate::Field::new(1, 0, EV_PENDING); + pub const EV_PENDING_RX: crate::Field = crate::Field::new(1, 1, EV_PENDING); + + pub const EV_ENABLE: crate::Register = crate::Register::new(5, 0x3); + pub const EV_ENABLE_TX: crate::Field = crate::Field::new(1, 0, EV_ENABLE); + pub const EV_ENABLE_RX: crate::Field = crate::Field::new(1, 1, EV_ENABLE); + + pub const TXEMPTY: crate::Register = crate::Register::new(6, 0x1); + pub const TXEMPTY_TXEMPTY: crate::Field = crate::Field::new(1, 0, TXEMPTY); + + pub const RXFULL: crate::Register = crate::Register::new(7, 0x1); + pub const RXFULL_RXFULL: crate::Field = crate::Field::new(1, 0, RXFULL); + + pub const UART_IRQ: usize = 0; + pub const HW_UART_BASE: usize = 0x40082000; + } + + pub mod console { + pub const CONSOLE_NUMREGS: usize = 8; + + pub const RXTX: crate::Register = crate::Register::new(0, 0xff); + pub const RXTX_RXTX: crate::Field = crate::Field::new(8, 0, RXTX); + + pub const TXFULL: crate::Register = crate::Register::new(1, 0x1); + pub const TXFULL_TXFULL: crate::Field = crate::Field::new(1, 0, TXFULL); + + pub const RXEMPTY: crate::Register = crate::Register::new(2, 0x1); + pub const RXEMPTY_RXEMPTY: crate::Field = crate::Field::new(1, 0, RXEMPTY); + + pub const EV_STATUS: crate::Register = crate::Register::new(3, 0x3); + pub const EV_STATUS_TX: crate::Field = crate::Field::new(1, 0, EV_STATUS); + pub const EV_STATUS_RX: crate::Field = crate::Field::new(1, 1, EV_STATUS); + + pub const EV_PENDING: crate::Register = crate::Register::new(4, 0x3); + pub const EV_PENDING_TX: crate::Field = crate::Field::new(1, 0, EV_PENDING); + pub const EV_PENDING_RX: crate::Field = crate::Field::new(1, 1, EV_PENDING); + + pub const EV_ENABLE: crate::Register = crate::Register::new(5, 0x3); + pub const EV_ENABLE_TX: crate::Field = crate::Field::new(1, 0, EV_ENABLE); + pub const EV_ENABLE_RX: crate::Field = crate::Field::new(1, 1, EV_ENABLE); + + pub const TXEMPTY: crate::Register = crate::Register::new(6, 0x1); + pub const TXEMPTY_TXEMPTY: crate::Field = crate::Field::new(1, 0, TXEMPTY); + + pub const RXFULL: crate::Register = crate::Register::new(7, 0x1); + pub const RXFULL_RXFULL: crate::Field = crate::Field::new(1, 0, RXFULL); + + pub const CONSOLE_IRQ: usize = 1; + pub const HW_CONSOLE_BASE: usize = 0x40084000; + } + + pub mod app_uart { + pub const APP_UART_NUMREGS: usize = 8; + + pub const RXTX: crate::Register = crate::Register::new(0, 0xff); + pub const RXTX_RXTX: crate::Field = crate::Field::new(8, 0, RXTX); + + pub const TXFULL: crate::Register = crate::Register::new(1, 0x1); + pub const TXFULL_TXFULL: crate::Field = crate::Field::new(1, 0, TXFULL); + + pub const RXEMPTY: crate::Register = crate::Register::new(2, 0x1); + pub const RXEMPTY_RXEMPTY: crate::Field = crate::Field::new(1, 0, RXEMPTY); + + pub const EV_STATUS: crate::Register = crate::Register::new(3, 0x3); + pub const EV_STATUS_TX: crate::Field = crate::Field::new(1, 0, EV_STATUS); + pub const EV_STATUS_RX: crate::Field = crate::Field::new(1, 1, EV_STATUS); + + pub const EV_PENDING: crate::Register = crate::Register::new(4, 0x3); + pub const EV_PENDING_TX: crate::Field = crate::Field::new(1, 0, EV_PENDING); + pub const EV_PENDING_RX: crate::Field = crate::Field::new(1, 1, EV_PENDING); + + pub const EV_ENABLE: crate::Register = crate::Register::new(5, 0x3); + pub const EV_ENABLE_TX: crate::Field = crate::Field::new(1, 0, EV_ENABLE); + pub const EV_ENABLE_RX: crate::Field = crate::Field::new(1, 1, EV_ENABLE); + + pub const TXEMPTY: crate::Register = crate::Register::new(6, 0x1); + pub const TXEMPTY_TXEMPTY: crate::Field = crate::Field::new(1, 0, TXEMPTY); + + pub const RXFULL: crate::Register = crate::Register::new(7, 0x1); + pub const RXFULL_RXFULL: crate::Field = crate::Field::new(1, 0, RXFULL); + + pub const APP_UART_IRQ: usize = 2; + pub const HW_APP_UART_BASE: usize = 0x40086000; + } + + pub mod identifier_mem { + pub const IDENTIFIER_MEM_NUMREGS: usize = 1; + + pub const IDENTIFIER_MEM: crate::Register = crate::Register::new(0, 0xff); + pub const IDENTIFIER_MEM_IDENTIFIER_MEM: crate::Field = crate::Field::new(8, 0, IDENTIFIER_MEM); + + pub const HW_IDENTIFIER_MEM_BASE: usize = 0x40087000; + } + + pub mod main { + pub const MAIN_NUMREGS: usize = 8; + + pub const REPORT: crate::Register = crate::Register::new(0, 0xffffffff); + pub const REPORT_REPORT: crate::Field = crate::Field::new(32, 0, REPORT); + + pub const SUCCESS: crate::Register = crate::Register::new(1, 0x1); + pub const SUCCESS_SUCCESS: crate::Field = crate::Field::new(1, 0, SUCCESS); + + pub const DONE: crate::Register = crate::Register::new(2, 0x1); + pub const DONE_DONE: crate::Field = crate::Field::new(1, 0, DONE); + + pub const WDATA: crate::Register = crate::Register::new(3, 0xffffffff); + pub const WDATA_WDATA: crate::Field = crate::Field::new(32, 0, WDATA); + + pub const RDATA: crate::Register = crate::Register::new(4, 0xffffffff); + pub const RDATA_RDATA: crate::Field = crate::Field::new(32, 0, RDATA); + + pub const RINC: crate::Register = crate::Register::new(5, 0xffffffff); + pub const RINC_RINC: crate::Field = crate::Field::new(32, 0, RINC); + + pub const IRQTEST0: crate::Register = crate::Register::new(6, 0xfffff); + pub const IRQTEST0_TRIGGER: crate::Field = crate::Field::new(20, 0, IRQTEST0); + + pub const IRQTEST1: crate::Register = crate::Register::new(7, 0xfffff); + pub const IRQTEST1_TRIGGER: crate::Field = crate::Field::new(20, 0, IRQTEST1); + + pub const HW_MAIN_BASE: usize = 0x40088000; + } + + pub mod d11ctime { + pub const D11CTIME_NUMREGS: usize = 2; + + pub const CONTROL: crate::Register = crate::Register::new(0, 0xffffffff); + pub const CONTROL_COUNT: crate::Field = crate::Field::new(32, 0, CONTROL); + + pub const HEARTBEAT: crate::Register = crate::Register::new(1, 0x1); + pub const HEARTBEAT_BEAT: crate::Field = crate::Field::new(1, 0, HEARTBEAT); + + pub const HW_D11CTIME_BASE: usize = 0xe0000000; + } + + pub mod susres { + pub const SUSRES_NUMREGS: usize = 11; + + pub const CONTROL: crate::Register = crate::Register::new(0, 0x3); + pub const CONTROL_PAUSE: crate::Field = crate::Field::new(1, 0, CONTROL); + pub const CONTROL_LOAD: crate::Field = crate::Field::new(1, 1, CONTROL); + + pub const RESUME_TIME1: crate::Register = crate::Register::new(1, 0xffffffff); + pub const RESUME_TIME1_RESUME_TIME: crate::Field = crate::Field::new(32, 0, RESUME_TIME1); + + pub const RESUME_TIME0: crate::Register = crate::Register::new(2, 0xffffffff); + pub const RESUME_TIME0_RESUME_TIME: crate::Field = crate::Field::new(32, 0, RESUME_TIME0); + + pub const TIME1: crate::Register = crate::Register::new(3, 0xffffffff); + pub const TIME1_TIME: crate::Field = crate::Field::new(32, 0, TIME1); + + pub const TIME0: crate::Register = crate::Register::new(4, 0xffffffff); + pub const TIME0_TIME: crate::Field = crate::Field::new(32, 0, TIME0); + + pub const STATUS: crate::Register = crate::Register::new(5, 0x1); + pub const STATUS_PAUSED: crate::Field = crate::Field::new(1, 0, STATUS); + + pub const STATE: crate::Register = crate::Register::new(6, 0x3); + pub const STATE_RESUME: crate::Field = crate::Field::new(1, 0, STATE); + pub const STATE_WAS_FORCED: crate::Field = crate::Field::new(1, 1, STATE); + + pub const INTERRUPT: crate::Register = crate::Register::new(7, 0x1); + pub const INTERRUPT_INTERRUPT: crate::Field = crate::Field::new(1, 0, INTERRUPT); + + pub const EV_STATUS: crate::Register = crate::Register::new(8, 0x1); + pub const EV_STATUS_SOFT_INT: crate::Field = crate::Field::new(1, 0, EV_STATUS); + + pub const EV_PENDING: crate::Register = crate::Register::new(9, 0x1); + pub const EV_PENDING_SOFT_INT: crate::Field = crate::Field::new(1, 0, EV_PENDING); + + pub const EV_ENABLE: crate::Register = crate::Register::new(10, 0x1); + pub const EV_ENABLE_SOFT_INT: crate::Field = crate::Field::new(1, 0, EV_ENABLE); + + pub const SUSRES_IRQ: usize = 21; + pub const HW_SUSRES_BASE: usize = 0xe0001000; + } + + pub mod coreuser { + pub const COREUSER_NUMREGS: usize = 10; + + pub const SET_ASID: crate::Register = crate::Register::new(0, 0x3ff); + pub const SET_ASID_ASID: crate::Field = crate::Field::new(9, 0, SET_ASID); + pub const SET_ASID_TRUSTED: crate::Field = crate::Field::new(1, 9, SET_ASID); + + pub const GET_ASID_ADDR: crate::Register = crate::Register::new(1, 0x1ff); + pub const GET_ASID_ADDR_ASID: crate::Field = crate::Field::new(9, 0, GET_ASID_ADDR); + + pub const GET_ASID_VALUE: crate::Register = crate::Register::new(2, 0x1); + pub const GET_ASID_VALUE_VALUE: crate::Field = crate::Field::new(1, 0, GET_ASID_VALUE); + + pub const SET_PRIVILEGE: crate::Register = crate::Register::new(3, 0x3); + pub const SET_PRIVILEGE_MPP: crate::Field = crate::Field::new(2, 0, SET_PRIVILEGE); + + pub const CONTROL: crate::Register = crate::Register::new(4, 0x1f); + pub const CONTROL_ENABLE: crate::Field = crate::Field::new(1, 0, CONTROL); + pub const CONTROL_ASID: crate::Field = crate::Field::new(1, 1, CONTROL); + pub const CONTROL_PPN_A: crate::Field = crate::Field::new(1, 2, CONTROL); + pub const CONTROL_PPN_B: crate::Field = crate::Field::new(1, 3, CONTROL); + pub const CONTROL_PRIVILEGE: crate::Field = crate::Field::new(1, 4, CONTROL); + + pub const PROTECT: crate::Register = crate::Register::new(5, 0x1); + pub const PROTECT_PROTECT: crate::Field = crate::Field::new(1, 0, PROTECT); + + pub const WINDOW_AL: crate::Register = crate::Register::new(6, 0x3fffff); + pub const WINDOW_AL_PPN: crate::Field = crate::Field::new(22, 0, WINDOW_AL); + + pub const WINDOW_AH: crate::Register = crate::Register::new(7, 0x3fffff); + pub const WINDOW_AH_PPN: crate::Field = crate::Field::new(22, 0, WINDOW_AH); + + pub const WINDOW_BL: crate::Register = crate::Register::new(8, 0x3fffff); + pub const WINDOW_BL_PPN: crate::Field = crate::Field::new(22, 0, WINDOW_BL); + + pub const WINDOW_BH: crate::Register = crate::Register::new(9, 0x3fffff); + pub const WINDOW_BH_PPN: crate::Field = crate::Field::new(22, 0, WINDOW_BH); + + pub const HW_COREUSER_BASE: usize = 0xe0002000; + } + + pub mod csrtest { + pub const CSRTEST_NUMREGS: usize = 2; + + pub const WTEST: crate::Register = crate::Register::new(0, 0xffffffff); + pub const WTEST_WTEST: crate::Field = crate::Field::new(32, 0, WTEST); + + pub const RTEST: crate::Register = crate::Register::new(1, 0xffffffff); + pub const RTEST_RTEST: crate::Field = crate::Field::new(32, 0, RTEST); + + pub const HW_CSRTEST_BASE: usize = 0xe0003000; + } + + pub mod irqarray0 { + pub const IRQARRAY0_NUMREGS: usize = 4; + + pub const EV_SOFT: crate::Register = crate::Register::new(0, 0xfffff); + pub const EV_SOFT_TRIGGER: crate::Field = crate::Field::new(20, 0, EV_SOFT); + + pub const EV_STATUS: crate::Register = crate::Register::new(1, 0xfffff); + pub const EV_STATUS_SOURCE0: crate::Field = crate::Field::new(1, 0, EV_STATUS); + pub const EV_STATUS_SOURCE1: crate::Field = crate::Field::new(1, 1, EV_STATUS); + pub const EV_STATUS_SOURCE2: crate::Field = crate::Field::new(1, 2, EV_STATUS); + pub const EV_STATUS_SOURCE3: crate::Field = crate::Field::new(1, 3, EV_STATUS); + pub const EV_STATUS_SOURCE4: crate::Field = crate::Field::new(1, 4, EV_STATUS); + pub const EV_STATUS_SOURCE5: crate::Field = crate::Field::new(1, 5, EV_STATUS); + pub const EV_STATUS_SOURCE6: crate::Field = crate::Field::new(1, 6, EV_STATUS); + pub const EV_STATUS_SOURCE7: crate::Field = crate::Field::new(1, 7, EV_STATUS); + pub const EV_STATUS_SOURCE8: crate::Field = crate::Field::new(1, 8, EV_STATUS); + pub const EV_STATUS_SOURCE9: crate::Field = crate::Field::new(1, 9, EV_STATUS); + pub const EV_STATUS_SOURCE10: crate::Field = crate::Field::new(1, 10, EV_STATUS); + pub const EV_STATUS_SOURCE11: crate::Field = crate::Field::new(1, 11, EV_STATUS); + pub const EV_STATUS_SOURCE12: crate::Field = crate::Field::new(1, 12, EV_STATUS); + pub const EV_STATUS_SOURCE13: crate::Field = crate::Field::new(1, 13, EV_STATUS); + pub const EV_STATUS_SOURCE14: crate::Field = crate::Field::new(1, 14, EV_STATUS); + pub const EV_STATUS_SOURCE15: crate::Field = crate::Field::new(1, 15, EV_STATUS); + pub const EV_STATUS_SOURCE16: crate::Field = crate::Field::new(1, 16, EV_STATUS); + pub const EV_STATUS_SOURCE17: crate::Field = crate::Field::new(1, 17, EV_STATUS); + pub const EV_STATUS_SOURCE18: crate::Field = crate::Field::new(1, 18, EV_STATUS); + pub const EV_STATUS_SOURCE19: crate::Field = crate::Field::new(1, 19, EV_STATUS); + + pub const EV_PENDING: crate::Register = crate::Register::new(2, 0xfffff); + pub const EV_PENDING_SOURCE0: crate::Field = crate::Field::new(1, 0, EV_PENDING); + pub const EV_PENDING_SOURCE1: crate::Field = crate::Field::new(1, 1, EV_PENDING); + pub const EV_PENDING_SOURCE2: crate::Field = crate::Field::new(1, 2, EV_PENDING); + pub const EV_PENDING_SOURCE3: crate::Field = crate::Field::new(1, 3, EV_PENDING); + pub const EV_PENDING_SOURCE4: crate::Field = crate::Field::new(1, 4, EV_PENDING); + pub const EV_PENDING_SOURCE5: crate::Field = crate::Field::new(1, 5, EV_PENDING); + pub const EV_PENDING_SOURCE6: crate::Field = crate::Field::new(1, 6, EV_PENDING); + pub const EV_PENDING_SOURCE7: crate::Field = crate::Field::new(1, 7, EV_PENDING); + pub const EV_PENDING_SOURCE8: crate::Field = crate::Field::new(1, 8, EV_PENDING); + pub const EV_PENDING_SOURCE9: crate::Field = crate::Field::new(1, 9, EV_PENDING); + pub const EV_PENDING_SOURCE10: crate::Field = crate::Field::new(1, 10, EV_PENDING); + pub const EV_PENDING_SOURCE11: crate::Field = crate::Field::new(1, 11, EV_PENDING); + pub const EV_PENDING_SOURCE12: crate::Field = crate::Field::new(1, 12, EV_PENDING); + pub const EV_PENDING_SOURCE13: crate::Field = crate::Field::new(1, 13, EV_PENDING); + pub const EV_PENDING_SOURCE14: crate::Field = crate::Field::new(1, 14, EV_PENDING); + pub const EV_PENDING_SOURCE15: crate::Field = crate::Field::new(1, 15, EV_PENDING); + pub const EV_PENDING_SOURCE16: crate::Field = crate::Field::new(1, 16, EV_PENDING); + pub const EV_PENDING_SOURCE17: crate::Field = crate::Field::new(1, 17, EV_PENDING); + pub const EV_PENDING_SOURCE18: crate::Field = crate::Field::new(1, 18, EV_PENDING); + pub const EV_PENDING_SOURCE19: crate::Field = crate::Field::new(1, 19, EV_PENDING); + + pub const EV_ENABLE: crate::Register = crate::Register::new(3, 0xfffff); + pub const EV_ENABLE_SOURCE0: crate::Field = crate::Field::new(1, 0, EV_ENABLE); + pub const EV_ENABLE_SOURCE1: crate::Field = crate::Field::new(1, 1, EV_ENABLE); + pub const EV_ENABLE_SOURCE2: crate::Field = crate::Field::new(1, 2, EV_ENABLE); + pub const EV_ENABLE_SOURCE3: crate::Field = crate::Field::new(1, 3, EV_ENABLE); + pub const EV_ENABLE_SOURCE4: crate::Field = crate::Field::new(1, 4, EV_ENABLE); + pub const EV_ENABLE_SOURCE5: crate::Field = crate::Field::new(1, 5, EV_ENABLE); + pub const EV_ENABLE_SOURCE6: crate::Field = crate::Field::new(1, 6, EV_ENABLE); + pub const EV_ENABLE_SOURCE7: crate::Field = crate::Field::new(1, 7, EV_ENABLE); + pub const EV_ENABLE_SOURCE8: crate::Field = crate::Field::new(1, 8, EV_ENABLE); + pub const EV_ENABLE_SOURCE9: crate::Field = crate::Field::new(1, 9, EV_ENABLE); + pub const EV_ENABLE_SOURCE10: crate::Field = crate::Field::new(1, 10, EV_ENABLE); + pub const EV_ENABLE_SOURCE11: crate::Field = crate::Field::new(1, 11, EV_ENABLE); + pub const EV_ENABLE_SOURCE12: crate::Field = crate::Field::new(1, 12, EV_ENABLE); + pub const EV_ENABLE_SOURCE13: crate::Field = crate::Field::new(1, 13, EV_ENABLE); + pub const EV_ENABLE_SOURCE14: crate::Field = crate::Field::new(1, 14, EV_ENABLE); + pub const EV_ENABLE_SOURCE15: crate::Field = crate::Field::new(1, 15, EV_ENABLE); + pub const EV_ENABLE_SOURCE16: crate::Field = crate::Field::new(1, 16, EV_ENABLE); + pub const EV_ENABLE_SOURCE17: crate::Field = crate::Field::new(1, 17, EV_ENABLE); + pub const EV_ENABLE_SOURCE18: crate::Field = crate::Field::new(1, 18, EV_ENABLE); + pub const EV_ENABLE_SOURCE19: crate::Field = crate::Field::new(1, 19, EV_ENABLE); + + pub const IRQARRAY0_IRQ: usize = 0; + pub const HW_IRQARRAY0_BASE: usize = 0xe0004000; + } + + pub mod irqarray1 { + pub const IRQARRAY1_NUMREGS: usize = 4; + + pub const EV_SOFT: crate::Register = crate::Register::new(0, 0xfffff); + pub const EV_SOFT_TRIGGER: crate::Field = crate::Field::new(20, 0, EV_SOFT); + + pub const EV_STATUS: crate::Register = crate::Register::new(1, 0xfffff); + pub const EV_STATUS_SOURCE0: crate::Field = crate::Field::new(1, 0, EV_STATUS); + pub const EV_STATUS_SOURCE1: crate::Field = crate::Field::new(1, 1, EV_STATUS); + pub const EV_STATUS_SOURCE2: crate::Field = crate::Field::new(1, 2, EV_STATUS); + pub const EV_STATUS_SOURCE3: crate::Field = crate::Field::new(1, 3, EV_STATUS); + pub const EV_STATUS_SOURCE4: crate::Field = crate::Field::new(1, 4, EV_STATUS); + pub const EV_STATUS_SOURCE5: crate::Field = crate::Field::new(1, 5, EV_STATUS); + pub const EV_STATUS_SOURCE6: crate::Field = crate::Field::new(1, 6, EV_STATUS); + pub const EV_STATUS_SOURCE7: crate::Field = crate::Field::new(1, 7, EV_STATUS); + pub const EV_STATUS_SOURCE8: crate::Field = crate::Field::new(1, 8, EV_STATUS); + pub const EV_STATUS_SOURCE9: crate::Field = crate::Field::new(1, 9, EV_STATUS); + pub const EV_STATUS_SOURCE10: crate::Field = crate::Field::new(1, 10, EV_STATUS); + pub const EV_STATUS_SOURCE11: crate::Field = crate::Field::new(1, 11, EV_STATUS); + pub const EV_STATUS_SOURCE12: crate::Field = crate::Field::new(1, 12, EV_STATUS); + pub const EV_STATUS_SOURCE13: crate::Field = crate::Field::new(1, 13, EV_STATUS); + pub const EV_STATUS_SOURCE14: crate::Field = crate::Field::new(1, 14, EV_STATUS); + pub const EV_STATUS_SOURCE15: crate::Field = crate::Field::new(1, 15, EV_STATUS); + pub const EV_STATUS_SOURCE16: crate::Field = crate::Field::new(1, 16, EV_STATUS); + pub const EV_STATUS_SOURCE17: crate::Field = crate::Field::new(1, 17, EV_STATUS); + pub const EV_STATUS_SOURCE18: crate::Field = crate::Field::new(1, 18, EV_STATUS); + pub const EV_STATUS_SOURCE19: crate::Field = crate::Field::new(1, 19, EV_STATUS); + + pub const EV_PENDING: crate::Register = crate::Register::new(2, 0xfffff); + pub const EV_PENDING_SOURCE0: crate::Field = crate::Field::new(1, 0, EV_PENDING); + pub const EV_PENDING_SOURCE1: crate::Field = crate::Field::new(1, 1, EV_PENDING); + pub const EV_PENDING_SOURCE2: crate::Field = crate::Field::new(1, 2, EV_PENDING); + pub const EV_PENDING_SOURCE3: crate::Field = crate::Field::new(1, 3, EV_PENDING); + pub const EV_PENDING_SOURCE4: crate::Field = crate::Field::new(1, 4, EV_PENDING); + pub const EV_PENDING_SOURCE5: crate::Field = crate::Field::new(1, 5, EV_PENDING); + pub const EV_PENDING_SOURCE6: crate::Field = crate::Field::new(1, 6, EV_PENDING); + pub const EV_PENDING_SOURCE7: crate::Field = crate::Field::new(1, 7, EV_PENDING); + pub const EV_PENDING_SOURCE8: crate::Field = crate::Field::new(1, 8, EV_PENDING); + pub const EV_PENDING_SOURCE9: crate::Field = crate::Field::new(1, 9, EV_PENDING); + pub const EV_PENDING_SOURCE10: crate::Field = crate::Field::new(1, 10, EV_PENDING); + pub const EV_PENDING_SOURCE11: crate::Field = crate::Field::new(1, 11, EV_PENDING); + pub const EV_PENDING_SOURCE12: crate::Field = crate::Field::new(1, 12, EV_PENDING); + pub const EV_PENDING_SOURCE13: crate::Field = crate::Field::new(1, 13, EV_PENDING); + pub const EV_PENDING_SOURCE14: crate::Field = crate::Field::new(1, 14, EV_PENDING); + pub const EV_PENDING_SOURCE15: crate::Field = crate::Field::new(1, 15, EV_PENDING); + pub const EV_PENDING_SOURCE16: crate::Field = crate::Field::new(1, 16, EV_PENDING); + pub const EV_PENDING_SOURCE17: crate::Field = crate::Field::new(1, 17, EV_PENDING); + pub const EV_PENDING_SOURCE18: crate::Field = crate::Field::new(1, 18, EV_PENDING); + pub const EV_PENDING_SOURCE19: crate::Field = crate::Field::new(1, 19, EV_PENDING); + + pub const EV_ENABLE: crate::Register = crate::Register::new(3, 0xfffff); + pub const EV_ENABLE_SOURCE0: crate::Field = crate::Field::new(1, 0, EV_ENABLE); + pub const EV_ENABLE_SOURCE1: crate::Field = crate::Field::new(1, 1, EV_ENABLE); + pub const EV_ENABLE_SOURCE2: crate::Field = crate::Field::new(1, 2, EV_ENABLE); + pub const EV_ENABLE_SOURCE3: crate::Field = crate::Field::new(1, 3, EV_ENABLE); + pub const EV_ENABLE_SOURCE4: crate::Field = crate::Field::new(1, 4, EV_ENABLE); + pub const EV_ENABLE_SOURCE5: crate::Field = crate::Field::new(1, 5, EV_ENABLE); + pub const EV_ENABLE_SOURCE6: crate::Field = crate::Field::new(1, 6, EV_ENABLE); + pub const EV_ENABLE_SOURCE7: crate::Field = crate::Field::new(1, 7, EV_ENABLE); + pub const EV_ENABLE_SOURCE8: crate::Field = crate::Field::new(1, 8, EV_ENABLE); + pub const EV_ENABLE_SOURCE9: crate::Field = crate::Field::new(1, 9, EV_ENABLE); + pub const EV_ENABLE_SOURCE10: crate::Field = crate::Field::new(1, 10, EV_ENABLE); + pub const EV_ENABLE_SOURCE11: crate::Field = crate::Field::new(1, 11, EV_ENABLE); + pub const EV_ENABLE_SOURCE12: crate::Field = crate::Field::new(1, 12, EV_ENABLE); + pub const EV_ENABLE_SOURCE13: crate::Field = crate::Field::new(1, 13, EV_ENABLE); + pub const EV_ENABLE_SOURCE14: crate::Field = crate::Field::new(1, 14, EV_ENABLE); + pub const EV_ENABLE_SOURCE15: crate::Field = crate::Field::new(1, 15, EV_ENABLE); + pub const EV_ENABLE_SOURCE16: crate::Field = crate::Field::new(1, 16, EV_ENABLE); + pub const EV_ENABLE_SOURCE17: crate::Field = crate::Field::new(1, 17, EV_ENABLE); + pub const EV_ENABLE_SOURCE18: crate::Field = crate::Field::new(1, 18, EV_ENABLE); + pub const EV_ENABLE_SOURCE19: crate::Field = crate::Field::new(1, 19, EV_ENABLE); + + pub const IRQARRAY1_IRQ: usize = 1; + pub const HW_IRQARRAY1_BASE: usize = 0xe0005000; + } + + pub mod irqarray10 { + pub const IRQARRAY10_NUMREGS: usize = 4; + + pub const EV_SOFT: crate::Register = crate::Register::new(0, 0xfffff); + pub const EV_SOFT_TRIGGER: crate::Field = crate::Field::new(20, 0, EV_SOFT); + + pub const EV_STATUS: crate::Register = crate::Register::new(1, 0xfffff); + pub const EV_STATUS_SOURCE0: crate::Field = crate::Field::new(1, 0, EV_STATUS); + pub const EV_STATUS_SOURCE1: crate::Field = crate::Field::new(1, 1, EV_STATUS); + pub const EV_STATUS_SOURCE2: crate::Field = crate::Field::new(1, 2, EV_STATUS); + pub const EV_STATUS_SOURCE3: crate::Field = crate::Field::new(1, 3, EV_STATUS); + pub const EV_STATUS_SOURCE4: crate::Field = crate::Field::new(1, 4, EV_STATUS); + pub const EV_STATUS_SOURCE5: crate::Field = crate::Field::new(1, 5, EV_STATUS); + pub const EV_STATUS_SOURCE6: crate::Field = crate::Field::new(1, 6, EV_STATUS); + pub const EV_STATUS_SOURCE7: crate::Field = crate::Field::new(1, 7, EV_STATUS); + pub const EV_STATUS_SOURCE8: crate::Field = crate::Field::new(1, 8, EV_STATUS); + pub const EV_STATUS_SOURCE9: crate::Field = crate::Field::new(1, 9, EV_STATUS); + pub const EV_STATUS_SOURCE10: crate::Field = crate::Field::new(1, 10, EV_STATUS); + pub const EV_STATUS_SOURCE11: crate::Field = crate::Field::new(1, 11, EV_STATUS); + pub const EV_STATUS_SOURCE12: crate::Field = crate::Field::new(1, 12, EV_STATUS); + pub const EV_STATUS_SOURCE13: crate::Field = crate::Field::new(1, 13, EV_STATUS); + pub const EV_STATUS_SOURCE14: crate::Field = crate::Field::new(1, 14, EV_STATUS); + pub const EV_STATUS_SOURCE15: crate::Field = crate::Field::new(1, 15, EV_STATUS); + pub const EV_STATUS_SOURCE16: crate::Field = crate::Field::new(1, 16, EV_STATUS); + pub const EV_STATUS_SOURCE17: crate::Field = crate::Field::new(1, 17, EV_STATUS); + pub const EV_STATUS_SOURCE18: crate::Field = crate::Field::new(1, 18, EV_STATUS); + pub const EV_STATUS_SOURCE19: crate::Field = crate::Field::new(1, 19, EV_STATUS); + + pub const EV_PENDING: crate::Register = crate::Register::new(2, 0xfffff); + pub const EV_PENDING_SOURCE0: crate::Field = crate::Field::new(1, 0, EV_PENDING); + pub const EV_PENDING_SOURCE1: crate::Field = crate::Field::new(1, 1, EV_PENDING); + pub const EV_PENDING_SOURCE2: crate::Field = crate::Field::new(1, 2, EV_PENDING); + pub const EV_PENDING_SOURCE3: crate::Field = crate::Field::new(1, 3, EV_PENDING); + pub const EV_PENDING_SOURCE4: crate::Field = crate::Field::new(1, 4, EV_PENDING); + pub const EV_PENDING_SOURCE5: crate::Field = crate::Field::new(1, 5, EV_PENDING); + pub const EV_PENDING_SOURCE6: crate::Field = crate::Field::new(1, 6, EV_PENDING); + pub const EV_PENDING_SOURCE7: crate::Field = crate::Field::new(1, 7, EV_PENDING); + pub const EV_PENDING_SOURCE8: crate::Field = crate::Field::new(1, 8, EV_PENDING); + pub const EV_PENDING_SOURCE9: crate::Field = crate::Field::new(1, 9, EV_PENDING); + pub const EV_PENDING_SOURCE10: crate::Field = crate::Field::new(1, 10, EV_PENDING); + pub const EV_PENDING_SOURCE11: crate::Field = crate::Field::new(1, 11, EV_PENDING); + pub const EV_PENDING_SOURCE12: crate::Field = crate::Field::new(1, 12, EV_PENDING); + pub const EV_PENDING_SOURCE13: crate::Field = crate::Field::new(1, 13, EV_PENDING); + pub const EV_PENDING_SOURCE14: crate::Field = crate::Field::new(1, 14, EV_PENDING); + pub const EV_PENDING_SOURCE15: crate::Field = crate::Field::new(1, 15, EV_PENDING); + pub const EV_PENDING_SOURCE16: crate::Field = crate::Field::new(1, 16, EV_PENDING); + pub const EV_PENDING_SOURCE17: crate::Field = crate::Field::new(1, 17, EV_PENDING); + pub const EV_PENDING_SOURCE18: crate::Field = crate::Field::new(1, 18, EV_PENDING); + pub const EV_PENDING_SOURCE19: crate::Field = crate::Field::new(1, 19, EV_PENDING); + + pub const EV_ENABLE: crate::Register = crate::Register::new(3, 0xfffff); + pub const EV_ENABLE_SOURCE0: crate::Field = crate::Field::new(1, 0, EV_ENABLE); + pub const EV_ENABLE_SOURCE1: crate::Field = crate::Field::new(1, 1, EV_ENABLE); + pub const EV_ENABLE_SOURCE2: crate::Field = crate::Field::new(1, 2, EV_ENABLE); + pub const EV_ENABLE_SOURCE3: crate::Field = crate::Field::new(1, 3, EV_ENABLE); + pub const EV_ENABLE_SOURCE4: crate::Field = crate::Field::new(1, 4, EV_ENABLE); + pub const EV_ENABLE_SOURCE5: crate::Field = crate::Field::new(1, 5, EV_ENABLE); + pub const EV_ENABLE_SOURCE6: crate::Field = crate::Field::new(1, 6, EV_ENABLE); + pub const EV_ENABLE_SOURCE7: crate::Field = crate::Field::new(1, 7, EV_ENABLE); + pub const EV_ENABLE_SOURCE8: crate::Field = crate::Field::new(1, 8, EV_ENABLE); + pub const EV_ENABLE_SOURCE9: crate::Field = crate::Field::new(1, 9, EV_ENABLE); + pub const EV_ENABLE_SOURCE10: crate::Field = crate::Field::new(1, 10, EV_ENABLE); + pub const EV_ENABLE_SOURCE11: crate::Field = crate::Field::new(1, 11, EV_ENABLE); + pub const EV_ENABLE_SOURCE12: crate::Field = crate::Field::new(1, 12, EV_ENABLE); + pub const EV_ENABLE_SOURCE13: crate::Field = crate::Field::new(1, 13, EV_ENABLE); + pub const EV_ENABLE_SOURCE14: crate::Field = crate::Field::new(1, 14, EV_ENABLE); + pub const EV_ENABLE_SOURCE15: crate::Field = crate::Field::new(1, 15, EV_ENABLE); + pub const EV_ENABLE_SOURCE16: crate::Field = crate::Field::new(1, 16, EV_ENABLE); + pub const EV_ENABLE_SOURCE17: crate::Field = crate::Field::new(1, 17, EV_ENABLE); + pub const EV_ENABLE_SOURCE18: crate::Field = crate::Field::new(1, 18, EV_ENABLE); + pub const EV_ENABLE_SOURCE19: crate::Field = crate::Field::new(1, 19, EV_ENABLE); + + pub const IRQARRAY10_IRQ: usize = 10; + pub const HW_IRQARRAY10_BASE: usize = 0xe0006000; + } + + pub mod irqarray11 { + pub const IRQARRAY11_NUMREGS: usize = 4; + + pub const EV_SOFT: crate::Register = crate::Register::new(0, 0xfffff); + pub const EV_SOFT_TRIGGER: crate::Field = crate::Field::new(20, 0, EV_SOFT); + + pub const EV_STATUS: crate::Register = crate::Register::new(1, 0xfffff); + pub const EV_STATUS_SOURCE0: crate::Field = crate::Field::new(1, 0, EV_STATUS); + pub const EV_STATUS_SOURCE1: crate::Field = crate::Field::new(1, 1, EV_STATUS); + pub const EV_STATUS_SOURCE2: crate::Field = crate::Field::new(1, 2, EV_STATUS); + pub const EV_STATUS_SOURCE3: crate::Field = crate::Field::new(1, 3, EV_STATUS); + pub const EV_STATUS_SOURCE4: crate::Field = crate::Field::new(1, 4, EV_STATUS); + pub const EV_STATUS_SOURCE5: crate::Field = crate::Field::new(1, 5, EV_STATUS); + pub const EV_STATUS_SOURCE6: crate::Field = crate::Field::new(1, 6, EV_STATUS); + pub const EV_STATUS_SOURCE7: crate::Field = crate::Field::new(1, 7, EV_STATUS); + pub const EV_STATUS_SOURCE8: crate::Field = crate::Field::new(1, 8, EV_STATUS); + pub const EV_STATUS_SOURCE9: crate::Field = crate::Field::new(1, 9, EV_STATUS); + pub const EV_STATUS_SOURCE10: crate::Field = crate::Field::new(1, 10, EV_STATUS); + pub const EV_STATUS_SOURCE11: crate::Field = crate::Field::new(1, 11, EV_STATUS); + pub const EV_STATUS_SOURCE12: crate::Field = crate::Field::new(1, 12, EV_STATUS); + pub const EV_STATUS_SOURCE13: crate::Field = crate::Field::new(1, 13, EV_STATUS); + pub const EV_STATUS_SOURCE14: crate::Field = crate::Field::new(1, 14, EV_STATUS); + pub const EV_STATUS_SOURCE15: crate::Field = crate::Field::new(1, 15, EV_STATUS); + pub const EV_STATUS_SOURCE16: crate::Field = crate::Field::new(1, 16, EV_STATUS); + pub const EV_STATUS_SOURCE17: crate::Field = crate::Field::new(1, 17, EV_STATUS); + pub const EV_STATUS_SOURCE18: crate::Field = crate::Field::new(1, 18, EV_STATUS); + pub const EV_STATUS_SOURCE19: crate::Field = crate::Field::new(1, 19, EV_STATUS); + + pub const EV_PENDING: crate::Register = crate::Register::new(2, 0xfffff); + pub const EV_PENDING_SOURCE0: crate::Field = crate::Field::new(1, 0, EV_PENDING); + pub const EV_PENDING_SOURCE1: crate::Field = crate::Field::new(1, 1, EV_PENDING); + pub const EV_PENDING_SOURCE2: crate::Field = crate::Field::new(1, 2, EV_PENDING); + pub const EV_PENDING_SOURCE3: crate::Field = crate::Field::new(1, 3, EV_PENDING); + pub const EV_PENDING_SOURCE4: crate::Field = crate::Field::new(1, 4, EV_PENDING); + pub const EV_PENDING_SOURCE5: crate::Field = crate::Field::new(1, 5, EV_PENDING); + pub const EV_PENDING_SOURCE6: crate::Field = crate::Field::new(1, 6, EV_PENDING); + pub const EV_PENDING_SOURCE7: crate::Field = crate::Field::new(1, 7, EV_PENDING); + pub const EV_PENDING_SOURCE8: crate::Field = crate::Field::new(1, 8, EV_PENDING); + pub const EV_PENDING_SOURCE9: crate::Field = crate::Field::new(1, 9, EV_PENDING); + pub const EV_PENDING_SOURCE10: crate::Field = crate::Field::new(1, 10, EV_PENDING); + pub const EV_PENDING_SOURCE11: crate::Field = crate::Field::new(1, 11, EV_PENDING); + pub const EV_PENDING_SOURCE12: crate::Field = crate::Field::new(1, 12, EV_PENDING); + pub const EV_PENDING_SOURCE13: crate::Field = crate::Field::new(1, 13, EV_PENDING); + pub const EV_PENDING_SOURCE14: crate::Field = crate::Field::new(1, 14, EV_PENDING); + pub const EV_PENDING_SOURCE15: crate::Field = crate::Field::new(1, 15, EV_PENDING); + pub const EV_PENDING_SOURCE16: crate::Field = crate::Field::new(1, 16, EV_PENDING); + pub const EV_PENDING_SOURCE17: crate::Field = crate::Field::new(1, 17, EV_PENDING); + pub const EV_PENDING_SOURCE18: crate::Field = crate::Field::new(1, 18, EV_PENDING); + pub const EV_PENDING_SOURCE19: crate::Field = crate::Field::new(1, 19, EV_PENDING); + + pub const EV_ENABLE: crate::Register = crate::Register::new(3, 0xfffff); + pub const EV_ENABLE_SOURCE0: crate::Field = crate::Field::new(1, 0, EV_ENABLE); + pub const EV_ENABLE_SOURCE1: crate::Field = crate::Field::new(1, 1, EV_ENABLE); + pub const EV_ENABLE_SOURCE2: crate::Field = crate::Field::new(1, 2, EV_ENABLE); + pub const EV_ENABLE_SOURCE3: crate::Field = crate::Field::new(1, 3, EV_ENABLE); + pub const EV_ENABLE_SOURCE4: crate::Field = crate::Field::new(1, 4, EV_ENABLE); + pub const EV_ENABLE_SOURCE5: crate::Field = crate::Field::new(1, 5, EV_ENABLE); + pub const EV_ENABLE_SOURCE6: crate::Field = crate::Field::new(1, 6, EV_ENABLE); + pub const EV_ENABLE_SOURCE7: crate::Field = crate::Field::new(1, 7, EV_ENABLE); + pub const EV_ENABLE_SOURCE8: crate::Field = crate::Field::new(1, 8, EV_ENABLE); + pub const EV_ENABLE_SOURCE9: crate::Field = crate::Field::new(1, 9, EV_ENABLE); + pub const EV_ENABLE_SOURCE10: crate::Field = crate::Field::new(1, 10, EV_ENABLE); + pub const EV_ENABLE_SOURCE11: crate::Field = crate::Field::new(1, 11, EV_ENABLE); + pub const EV_ENABLE_SOURCE12: crate::Field = crate::Field::new(1, 12, EV_ENABLE); + pub const EV_ENABLE_SOURCE13: crate::Field = crate::Field::new(1, 13, EV_ENABLE); + pub const EV_ENABLE_SOURCE14: crate::Field = crate::Field::new(1, 14, EV_ENABLE); + pub const EV_ENABLE_SOURCE15: crate::Field = crate::Field::new(1, 15, EV_ENABLE); + pub const EV_ENABLE_SOURCE16: crate::Field = crate::Field::new(1, 16, EV_ENABLE); + pub const EV_ENABLE_SOURCE17: crate::Field = crate::Field::new(1, 17, EV_ENABLE); + pub const EV_ENABLE_SOURCE18: crate::Field = crate::Field::new(1, 18, EV_ENABLE); + pub const EV_ENABLE_SOURCE19: crate::Field = crate::Field::new(1, 19, EV_ENABLE); + + pub const IRQARRAY11_IRQ: usize = 11; + pub const HW_IRQARRAY11_BASE: usize = 0xe0007000; + } + + pub mod irqarray12 { + pub const IRQARRAY12_NUMREGS: usize = 4; + + pub const EV_SOFT: crate::Register = crate::Register::new(0, 0xfffff); + pub const EV_SOFT_TRIGGER: crate::Field = crate::Field::new(20, 0, EV_SOFT); + + pub const EV_STATUS: crate::Register = crate::Register::new(1, 0xfffff); + pub const EV_STATUS_SOURCE0: crate::Field = crate::Field::new(1, 0, EV_STATUS); + pub const EV_STATUS_SOURCE1: crate::Field = crate::Field::new(1, 1, EV_STATUS); + pub const EV_STATUS_SOURCE2: crate::Field = crate::Field::new(1, 2, EV_STATUS); + pub const EV_STATUS_SOURCE3: crate::Field = crate::Field::new(1, 3, EV_STATUS); + pub const EV_STATUS_SOURCE4: crate::Field = crate::Field::new(1, 4, EV_STATUS); + pub const EV_STATUS_SOURCE5: crate::Field = crate::Field::new(1, 5, EV_STATUS); + pub const EV_STATUS_SOURCE6: crate::Field = crate::Field::new(1, 6, EV_STATUS); + pub const EV_STATUS_SOURCE7: crate::Field = crate::Field::new(1, 7, EV_STATUS); + pub const EV_STATUS_SOURCE8: crate::Field = crate::Field::new(1, 8, EV_STATUS); + pub const EV_STATUS_SOURCE9: crate::Field = crate::Field::new(1, 9, EV_STATUS); + pub const EV_STATUS_SOURCE10: crate::Field = crate::Field::new(1, 10, EV_STATUS); + pub const EV_STATUS_SOURCE11: crate::Field = crate::Field::new(1, 11, EV_STATUS); + pub const EV_STATUS_SOURCE12: crate::Field = crate::Field::new(1, 12, EV_STATUS); + pub const EV_STATUS_SOURCE13: crate::Field = crate::Field::new(1, 13, EV_STATUS); + pub const EV_STATUS_SOURCE14: crate::Field = crate::Field::new(1, 14, EV_STATUS); + pub const EV_STATUS_SOURCE15: crate::Field = crate::Field::new(1, 15, EV_STATUS); + pub const EV_STATUS_SOURCE16: crate::Field = crate::Field::new(1, 16, EV_STATUS); + pub const EV_STATUS_SOURCE17: crate::Field = crate::Field::new(1, 17, EV_STATUS); + pub const EV_STATUS_SOURCE18: crate::Field = crate::Field::new(1, 18, EV_STATUS); + pub const EV_STATUS_SOURCE19: crate::Field = crate::Field::new(1, 19, EV_STATUS); + + pub const EV_PENDING: crate::Register = crate::Register::new(2, 0xfffff); + pub const EV_PENDING_SOURCE0: crate::Field = crate::Field::new(1, 0, EV_PENDING); + pub const EV_PENDING_SOURCE1: crate::Field = crate::Field::new(1, 1, EV_PENDING); + pub const EV_PENDING_SOURCE2: crate::Field = crate::Field::new(1, 2, EV_PENDING); + pub const EV_PENDING_SOURCE3: crate::Field = crate::Field::new(1, 3, EV_PENDING); + pub const EV_PENDING_SOURCE4: crate::Field = crate::Field::new(1, 4, EV_PENDING); + pub const EV_PENDING_SOURCE5: crate::Field = crate::Field::new(1, 5, EV_PENDING); + pub const EV_PENDING_SOURCE6: crate::Field = crate::Field::new(1, 6, EV_PENDING); + pub const EV_PENDING_SOURCE7: crate::Field = crate::Field::new(1, 7, EV_PENDING); + pub const EV_PENDING_SOURCE8: crate::Field = crate::Field::new(1, 8, EV_PENDING); + pub const EV_PENDING_SOURCE9: crate::Field = crate::Field::new(1, 9, EV_PENDING); + pub const EV_PENDING_SOURCE10: crate::Field = crate::Field::new(1, 10, EV_PENDING); + pub const EV_PENDING_SOURCE11: crate::Field = crate::Field::new(1, 11, EV_PENDING); + pub const EV_PENDING_SOURCE12: crate::Field = crate::Field::new(1, 12, EV_PENDING); + pub const EV_PENDING_SOURCE13: crate::Field = crate::Field::new(1, 13, EV_PENDING); + pub const EV_PENDING_SOURCE14: crate::Field = crate::Field::new(1, 14, EV_PENDING); + pub const EV_PENDING_SOURCE15: crate::Field = crate::Field::new(1, 15, EV_PENDING); + pub const EV_PENDING_SOURCE16: crate::Field = crate::Field::new(1, 16, EV_PENDING); + pub const EV_PENDING_SOURCE17: crate::Field = crate::Field::new(1, 17, EV_PENDING); + pub const EV_PENDING_SOURCE18: crate::Field = crate::Field::new(1, 18, EV_PENDING); + pub const EV_PENDING_SOURCE19: crate::Field = crate::Field::new(1, 19, EV_PENDING); + + pub const EV_ENABLE: crate::Register = crate::Register::new(3, 0xfffff); + pub const EV_ENABLE_SOURCE0: crate::Field = crate::Field::new(1, 0, EV_ENABLE); + pub const EV_ENABLE_SOURCE1: crate::Field = crate::Field::new(1, 1, EV_ENABLE); + pub const EV_ENABLE_SOURCE2: crate::Field = crate::Field::new(1, 2, EV_ENABLE); + pub const EV_ENABLE_SOURCE3: crate::Field = crate::Field::new(1, 3, EV_ENABLE); + pub const EV_ENABLE_SOURCE4: crate::Field = crate::Field::new(1, 4, EV_ENABLE); + pub const EV_ENABLE_SOURCE5: crate::Field = crate::Field::new(1, 5, EV_ENABLE); + pub const EV_ENABLE_SOURCE6: crate::Field = crate::Field::new(1, 6, EV_ENABLE); + pub const EV_ENABLE_SOURCE7: crate::Field = crate::Field::new(1, 7, EV_ENABLE); + pub const EV_ENABLE_SOURCE8: crate::Field = crate::Field::new(1, 8, EV_ENABLE); + pub const EV_ENABLE_SOURCE9: crate::Field = crate::Field::new(1, 9, EV_ENABLE); + pub const EV_ENABLE_SOURCE10: crate::Field = crate::Field::new(1, 10, EV_ENABLE); + pub const EV_ENABLE_SOURCE11: crate::Field = crate::Field::new(1, 11, EV_ENABLE); + pub const EV_ENABLE_SOURCE12: crate::Field = crate::Field::new(1, 12, EV_ENABLE); + pub const EV_ENABLE_SOURCE13: crate::Field = crate::Field::new(1, 13, EV_ENABLE); + pub const EV_ENABLE_SOURCE14: crate::Field = crate::Field::new(1, 14, EV_ENABLE); + pub const EV_ENABLE_SOURCE15: crate::Field = crate::Field::new(1, 15, EV_ENABLE); + pub const EV_ENABLE_SOURCE16: crate::Field = crate::Field::new(1, 16, EV_ENABLE); + pub const EV_ENABLE_SOURCE17: crate::Field = crate::Field::new(1, 17, EV_ENABLE); + pub const EV_ENABLE_SOURCE18: crate::Field = crate::Field::new(1, 18, EV_ENABLE); + pub const EV_ENABLE_SOURCE19: crate::Field = crate::Field::new(1, 19, EV_ENABLE); + + pub const IRQARRAY12_IRQ: usize = 12; + pub const HW_IRQARRAY12_BASE: usize = 0xe0008000; + } + + pub mod irqarray13 { + pub const IRQARRAY13_NUMREGS: usize = 4; + + pub const EV_SOFT: crate::Register = crate::Register::new(0, 0xfffff); + pub const EV_SOFT_TRIGGER: crate::Field = crate::Field::new(20, 0, EV_SOFT); + + pub const EV_STATUS: crate::Register = crate::Register::new(1, 0xfffff); + pub const EV_STATUS_SOURCE0: crate::Field = crate::Field::new(1, 0, EV_STATUS); + pub const EV_STATUS_SOURCE1: crate::Field = crate::Field::new(1, 1, EV_STATUS); + pub const EV_STATUS_SOURCE2: crate::Field = crate::Field::new(1, 2, EV_STATUS); + pub const EV_STATUS_SOURCE3: crate::Field = crate::Field::new(1, 3, EV_STATUS); + pub const EV_STATUS_SOURCE4: crate::Field = crate::Field::new(1, 4, EV_STATUS); + pub const EV_STATUS_SOURCE5: crate::Field = crate::Field::new(1, 5, EV_STATUS); + pub const EV_STATUS_SOURCE6: crate::Field = crate::Field::new(1, 6, EV_STATUS); + pub const EV_STATUS_SOURCE7: crate::Field = crate::Field::new(1, 7, EV_STATUS); + pub const EV_STATUS_SOURCE8: crate::Field = crate::Field::new(1, 8, EV_STATUS); + pub const EV_STATUS_SOURCE9: crate::Field = crate::Field::new(1, 9, EV_STATUS); + pub const EV_STATUS_SOURCE10: crate::Field = crate::Field::new(1, 10, EV_STATUS); + pub const EV_STATUS_SOURCE11: crate::Field = crate::Field::new(1, 11, EV_STATUS); + pub const EV_STATUS_SOURCE12: crate::Field = crate::Field::new(1, 12, EV_STATUS); + pub const EV_STATUS_SOURCE13: crate::Field = crate::Field::new(1, 13, EV_STATUS); + pub const EV_STATUS_SOURCE14: crate::Field = crate::Field::new(1, 14, EV_STATUS); + pub const EV_STATUS_SOURCE15: crate::Field = crate::Field::new(1, 15, EV_STATUS); + pub const EV_STATUS_SOURCE16: crate::Field = crate::Field::new(1, 16, EV_STATUS); + pub const EV_STATUS_SOURCE17: crate::Field = crate::Field::new(1, 17, EV_STATUS); + pub const EV_STATUS_SOURCE18: crate::Field = crate::Field::new(1, 18, EV_STATUS); + pub const EV_STATUS_SOURCE19: crate::Field = crate::Field::new(1, 19, EV_STATUS); + + pub const EV_PENDING: crate::Register = crate::Register::new(2, 0xfffff); + pub const EV_PENDING_SOURCE0: crate::Field = crate::Field::new(1, 0, EV_PENDING); + pub const EV_PENDING_SOURCE1: crate::Field = crate::Field::new(1, 1, EV_PENDING); + pub const EV_PENDING_SOURCE2: crate::Field = crate::Field::new(1, 2, EV_PENDING); + pub const EV_PENDING_SOURCE3: crate::Field = crate::Field::new(1, 3, EV_PENDING); + pub const EV_PENDING_SOURCE4: crate::Field = crate::Field::new(1, 4, EV_PENDING); + pub const EV_PENDING_SOURCE5: crate::Field = crate::Field::new(1, 5, EV_PENDING); + pub const EV_PENDING_SOURCE6: crate::Field = crate::Field::new(1, 6, EV_PENDING); + pub const EV_PENDING_SOURCE7: crate::Field = crate::Field::new(1, 7, EV_PENDING); + pub const EV_PENDING_SOURCE8: crate::Field = crate::Field::new(1, 8, EV_PENDING); + pub const EV_PENDING_SOURCE9: crate::Field = crate::Field::new(1, 9, EV_PENDING); + pub const EV_PENDING_SOURCE10: crate::Field = crate::Field::new(1, 10, EV_PENDING); + pub const EV_PENDING_SOURCE11: crate::Field = crate::Field::new(1, 11, EV_PENDING); + pub const EV_PENDING_SOURCE12: crate::Field = crate::Field::new(1, 12, EV_PENDING); + pub const EV_PENDING_SOURCE13: crate::Field = crate::Field::new(1, 13, EV_PENDING); + pub const EV_PENDING_SOURCE14: crate::Field = crate::Field::new(1, 14, EV_PENDING); + pub const EV_PENDING_SOURCE15: crate::Field = crate::Field::new(1, 15, EV_PENDING); + pub const EV_PENDING_SOURCE16: crate::Field = crate::Field::new(1, 16, EV_PENDING); + pub const EV_PENDING_SOURCE17: crate::Field = crate::Field::new(1, 17, EV_PENDING); + pub const EV_PENDING_SOURCE18: crate::Field = crate::Field::new(1, 18, EV_PENDING); + pub const EV_PENDING_SOURCE19: crate::Field = crate::Field::new(1, 19, EV_PENDING); + + pub const EV_ENABLE: crate::Register = crate::Register::new(3, 0xfffff); + pub const EV_ENABLE_SOURCE0: crate::Field = crate::Field::new(1, 0, EV_ENABLE); + pub const EV_ENABLE_SOURCE1: crate::Field = crate::Field::new(1, 1, EV_ENABLE); + pub const EV_ENABLE_SOURCE2: crate::Field = crate::Field::new(1, 2, EV_ENABLE); + pub const EV_ENABLE_SOURCE3: crate::Field = crate::Field::new(1, 3, EV_ENABLE); + pub const EV_ENABLE_SOURCE4: crate::Field = crate::Field::new(1, 4, EV_ENABLE); + pub const EV_ENABLE_SOURCE5: crate::Field = crate::Field::new(1, 5, EV_ENABLE); + pub const EV_ENABLE_SOURCE6: crate::Field = crate::Field::new(1, 6, EV_ENABLE); + pub const EV_ENABLE_SOURCE7: crate::Field = crate::Field::new(1, 7, EV_ENABLE); + pub const EV_ENABLE_SOURCE8: crate::Field = crate::Field::new(1, 8, EV_ENABLE); + pub const EV_ENABLE_SOURCE9: crate::Field = crate::Field::new(1, 9, EV_ENABLE); + pub const EV_ENABLE_SOURCE10: crate::Field = crate::Field::new(1, 10, EV_ENABLE); + pub const EV_ENABLE_SOURCE11: crate::Field = crate::Field::new(1, 11, EV_ENABLE); + pub const EV_ENABLE_SOURCE12: crate::Field = crate::Field::new(1, 12, EV_ENABLE); + pub const EV_ENABLE_SOURCE13: crate::Field = crate::Field::new(1, 13, EV_ENABLE); + pub const EV_ENABLE_SOURCE14: crate::Field = crate::Field::new(1, 14, EV_ENABLE); + pub const EV_ENABLE_SOURCE15: crate::Field = crate::Field::new(1, 15, EV_ENABLE); + pub const EV_ENABLE_SOURCE16: crate::Field = crate::Field::new(1, 16, EV_ENABLE); + pub const EV_ENABLE_SOURCE17: crate::Field = crate::Field::new(1, 17, EV_ENABLE); + pub const EV_ENABLE_SOURCE18: crate::Field = crate::Field::new(1, 18, EV_ENABLE); + pub const EV_ENABLE_SOURCE19: crate::Field = crate::Field::new(1, 19, EV_ENABLE); + + pub const IRQARRAY13_IRQ: usize = 13; + pub const HW_IRQARRAY13_BASE: usize = 0xe0009000; + } + + pub mod irqarray14 { + pub const IRQARRAY14_NUMREGS: usize = 4; + + pub const EV_SOFT: crate::Register = crate::Register::new(0, 0xfffff); + pub const EV_SOFT_TRIGGER: crate::Field = crate::Field::new(20, 0, EV_SOFT); + + pub const EV_STATUS: crate::Register = crate::Register::new(1, 0xfffff); + pub const EV_STATUS_SOURCE0: crate::Field = crate::Field::new(1, 0, EV_STATUS); + pub const EV_STATUS_SOURCE1: crate::Field = crate::Field::new(1, 1, EV_STATUS); + pub const EV_STATUS_SOURCE2: crate::Field = crate::Field::new(1, 2, EV_STATUS); + pub const EV_STATUS_SOURCE3: crate::Field = crate::Field::new(1, 3, EV_STATUS); + pub const EV_STATUS_SOURCE4: crate::Field = crate::Field::new(1, 4, EV_STATUS); + pub const EV_STATUS_SOURCE5: crate::Field = crate::Field::new(1, 5, EV_STATUS); + pub const EV_STATUS_SOURCE6: crate::Field = crate::Field::new(1, 6, EV_STATUS); + pub const EV_STATUS_SOURCE7: crate::Field = crate::Field::new(1, 7, EV_STATUS); + pub const EV_STATUS_SOURCE8: crate::Field = crate::Field::new(1, 8, EV_STATUS); + pub const EV_STATUS_SOURCE9: crate::Field = crate::Field::new(1, 9, EV_STATUS); + pub const EV_STATUS_SOURCE10: crate::Field = crate::Field::new(1, 10, EV_STATUS); + pub const EV_STATUS_SOURCE11: crate::Field = crate::Field::new(1, 11, EV_STATUS); + pub const EV_STATUS_SOURCE12: crate::Field = crate::Field::new(1, 12, EV_STATUS); + pub const EV_STATUS_SOURCE13: crate::Field = crate::Field::new(1, 13, EV_STATUS); + pub const EV_STATUS_SOURCE14: crate::Field = crate::Field::new(1, 14, EV_STATUS); + pub const EV_STATUS_SOURCE15: crate::Field = crate::Field::new(1, 15, EV_STATUS); + pub const EV_STATUS_SOURCE16: crate::Field = crate::Field::new(1, 16, EV_STATUS); + pub const EV_STATUS_SOURCE17: crate::Field = crate::Field::new(1, 17, EV_STATUS); + pub const EV_STATUS_SOURCE18: crate::Field = crate::Field::new(1, 18, EV_STATUS); + pub const EV_STATUS_SOURCE19: crate::Field = crate::Field::new(1, 19, EV_STATUS); + + pub const EV_PENDING: crate::Register = crate::Register::new(2, 0xfffff); + pub const EV_PENDING_SOURCE0: crate::Field = crate::Field::new(1, 0, EV_PENDING); + pub const EV_PENDING_SOURCE1: crate::Field = crate::Field::new(1, 1, EV_PENDING); + pub const EV_PENDING_SOURCE2: crate::Field = crate::Field::new(1, 2, EV_PENDING); + pub const EV_PENDING_SOURCE3: crate::Field = crate::Field::new(1, 3, EV_PENDING); + pub const EV_PENDING_SOURCE4: crate::Field = crate::Field::new(1, 4, EV_PENDING); + pub const EV_PENDING_SOURCE5: crate::Field = crate::Field::new(1, 5, EV_PENDING); + pub const EV_PENDING_SOURCE6: crate::Field = crate::Field::new(1, 6, EV_PENDING); + pub const EV_PENDING_SOURCE7: crate::Field = crate::Field::new(1, 7, EV_PENDING); + pub const EV_PENDING_SOURCE8: crate::Field = crate::Field::new(1, 8, EV_PENDING); + pub const EV_PENDING_SOURCE9: crate::Field = crate::Field::new(1, 9, EV_PENDING); + pub const EV_PENDING_SOURCE10: crate::Field = crate::Field::new(1, 10, EV_PENDING); + pub const EV_PENDING_SOURCE11: crate::Field = crate::Field::new(1, 11, EV_PENDING); + pub const EV_PENDING_SOURCE12: crate::Field = crate::Field::new(1, 12, EV_PENDING); + pub const EV_PENDING_SOURCE13: crate::Field = crate::Field::new(1, 13, EV_PENDING); + pub const EV_PENDING_SOURCE14: crate::Field = crate::Field::new(1, 14, EV_PENDING); + pub const EV_PENDING_SOURCE15: crate::Field = crate::Field::new(1, 15, EV_PENDING); + pub const EV_PENDING_SOURCE16: crate::Field = crate::Field::new(1, 16, EV_PENDING); + pub const EV_PENDING_SOURCE17: crate::Field = crate::Field::new(1, 17, EV_PENDING); + pub const EV_PENDING_SOURCE18: crate::Field = crate::Field::new(1, 18, EV_PENDING); + pub const EV_PENDING_SOURCE19: crate::Field = crate::Field::new(1, 19, EV_PENDING); + + pub const EV_ENABLE: crate::Register = crate::Register::new(3, 0xfffff); + pub const EV_ENABLE_SOURCE0: crate::Field = crate::Field::new(1, 0, EV_ENABLE); + pub const EV_ENABLE_SOURCE1: crate::Field = crate::Field::new(1, 1, EV_ENABLE); + pub const EV_ENABLE_SOURCE2: crate::Field = crate::Field::new(1, 2, EV_ENABLE); + pub const EV_ENABLE_SOURCE3: crate::Field = crate::Field::new(1, 3, EV_ENABLE); + pub const EV_ENABLE_SOURCE4: crate::Field = crate::Field::new(1, 4, EV_ENABLE); + pub const EV_ENABLE_SOURCE5: crate::Field = crate::Field::new(1, 5, EV_ENABLE); + pub const EV_ENABLE_SOURCE6: crate::Field = crate::Field::new(1, 6, EV_ENABLE); + pub const EV_ENABLE_SOURCE7: crate::Field = crate::Field::new(1, 7, EV_ENABLE); + pub const EV_ENABLE_SOURCE8: crate::Field = crate::Field::new(1, 8, EV_ENABLE); + pub const EV_ENABLE_SOURCE9: crate::Field = crate::Field::new(1, 9, EV_ENABLE); + pub const EV_ENABLE_SOURCE10: crate::Field = crate::Field::new(1, 10, EV_ENABLE); + pub const EV_ENABLE_SOURCE11: crate::Field = crate::Field::new(1, 11, EV_ENABLE); + pub const EV_ENABLE_SOURCE12: crate::Field = crate::Field::new(1, 12, EV_ENABLE); + pub const EV_ENABLE_SOURCE13: crate::Field = crate::Field::new(1, 13, EV_ENABLE); + pub const EV_ENABLE_SOURCE14: crate::Field = crate::Field::new(1, 14, EV_ENABLE); + pub const EV_ENABLE_SOURCE15: crate::Field = crate::Field::new(1, 15, EV_ENABLE); + pub const EV_ENABLE_SOURCE16: crate::Field = crate::Field::new(1, 16, EV_ENABLE); + pub const EV_ENABLE_SOURCE17: crate::Field = crate::Field::new(1, 17, EV_ENABLE); + pub const EV_ENABLE_SOURCE18: crate::Field = crate::Field::new(1, 18, EV_ENABLE); + pub const EV_ENABLE_SOURCE19: crate::Field = crate::Field::new(1, 19, EV_ENABLE); + + pub const IRQARRAY14_IRQ: usize = 14; + pub const HW_IRQARRAY14_BASE: usize = 0xe000a000; + } + + pub mod irqarray15 { + pub const IRQARRAY15_NUMREGS: usize = 4; + + pub const EV_SOFT: crate::Register = crate::Register::new(0, 0xfffff); + pub const EV_SOFT_TRIGGER: crate::Field = crate::Field::new(20, 0, EV_SOFT); + + pub const EV_STATUS: crate::Register = crate::Register::new(1, 0xfffff); + pub const EV_STATUS_SOURCE0: crate::Field = crate::Field::new(1, 0, EV_STATUS); + pub const EV_STATUS_SOURCE1: crate::Field = crate::Field::new(1, 1, EV_STATUS); + pub const EV_STATUS_SOURCE2: crate::Field = crate::Field::new(1, 2, EV_STATUS); + pub const EV_STATUS_SOURCE3: crate::Field = crate::Field::new(1, 3, EV_STATUS); + pub const EV_STATUS_SOURCE4: crate::Field = crate::Field::new(1, 4, EV_STATUS); + pub const EV_STATUS_SOURCE5: crate::Field = crate::Field::new(1, 5, EV_STATUS); + pub const EV_STATUS_SOURCE6: crate::Field = crate::Field::new(1, 6, EV_STATUS); + pub const EV_STATUS_SOURCE7: crate::Field = crate::Field::new(1, 7, EV_STATUS); + pub const EV_STATUS_SOURCE8: crate::Field = crate::Field::new(1, 8, EV_STATUS); + pub const EV_STATUS_SOURCE9: crate::Field = crate::Field::new(1, 9, EV_STATUS); + pub const EV_STATUS_SOURCE10: crate::Field = crate::Field::new(1, 10, EV_STATUS); + pub const EV_STATUS_SOURCE11: crate::Field = crate::Field::new(1, 11, EV_STATUS); + pub const EV_STATUS_SOURCE12: crate::Field = crate::Field::new(1, 12, EV_STATUS); + pub const EV_STATUS_SOURCE13: crate::Field = crate::Field::new(1, 13, EV_STATUS); + pub const EV_STATUS_SOURCE14: crate::Field = crate::Field::new(1, 14, EV_STATUS); + pub const EV_STATUS_SOURCE15: crate::Field = crate::Field::new(1, 15, EV_STATUS); + pub const EV_STATUS_SOURCE16: crate::Field = crate::Field::new(1, 16, EV_STATUS); + pub const EV_STATUS_SOURCE17: crate::Field = crate::Field::new(1, 17, EV_STATUS); + pub const EV_STATUS_SOURCE18: crate::Field = crate::Field::new(1, 18, EV_STATUS); + pub const EV_STATUS_SOURCE19: crate::Field = crate::Field::new(1, 19, EV_STATUS); + + pub const EV_PENDING: crate::Register = crate::Register::new(2, 0xfffff); + pub const EV_PENDING_SOURCE0: crate::Field = crate::Field::new(1, 0, EV_PENDING); + pub const EV_PENDING_SOURCE1: crate::Field = crate::Field::new(1, 1, EV_PENDING); + pub const EV_PENDING_SOURCE2: crate::Field = crate::Field::new(1, 2, EV_PENDING); + pub const EV_PENDING_SOURCE3: crate::Field = crate::Field::new(1, 3, EV_PENDING); + pub const EV_PENDING_SOURCE4: crate::Field = crate::Field::new(1, 4, EV_PENDING); + pub const EV_PENDING_SOURCE5: crate::Field = crate::Field::new(1, 5, EV_PENDING); + pub const EV_PENDING_SOURCE6: crate::Field = crate::Field::new(1, 6, EV_PENDING); + pub const EV_PENDING_SOURCE7: crate::Field = crate::Field::new(1, 7, EV_PENDING); + pub const EV_PENDING_SOURCE8: crate::Field = crate::Field::new(1, 8, EV_PENDING); + pub const EV_PENDING_SOURCE9: crate::Field = crate::Field::new(1, 9, EV_PENDING); + pub const EV_PENDING_SOURCE10: crate::Field = crate::Field::new(1, 10, EV_PENDING); + pub const EV_PENDING_SOURCE11: crate::Field = crate::Field::new(1, 11, EV_PENDING); + pub const EV_PENDING_SOURCE12: crate::Field = crate::Field::new(1, 12, EV_PENDING); + pub const EV_PENDING_SOURCE13: crate::Field = crate::Field::new(1, 13, EV_PENDING); + pub const EV_PENDING_SOURCE14: crate::Field = crate::Field::new(1, 14, EV_PENDING); + pub const EV_PENDING_SOURCE15: crate::Field = crate::Field::new(1, 15, EV_PENDING); + pub const EV_PENDING_SOURCE16: crate::Field = crate::Field::new(1, 16, EV_PENDING); + pub const EV_PENDING_SOURCE17: crate::Field = crate::Field::new(1, 17, EV_PENDING); + pub const EV_PENDING_SOURCE18: crate::Field = crate::Field::new(1, 18, EV_PENDING); + pub const EV_PENDING_SOURCE19: crate::Field = crate::Field::new(1, 19, EV_PENDING); + + pub const EV_ENABLE: crate::Register = crate::Register::new(3, 0xfffff); + pub const EV_ENABLE_SOURCE0: crate::Field = crate::Field::new(1, 0, EV_ENABLE); + pub const EV_ENABLE_SOURCE1: crate::Field = crate::Field::new(1, 1, EV_ENABLE); + pub const EV_ENABLE_SOURCE2: crate::Field = crate::Field::new(1, 2, EV_ENABLE); + pub const EV_ENABLE_SOURCE3: crate::Field = crate::Field::new(1, 3, EV_ENABLE); + pub const EV_ENABLE_SOURCE4: crate::Field = crate::Field::new(1, 4, EV_ENABLE); + pub const EV_ENABLE_SOURCE5: crate::Field = crate::Field::new(1, 5, EV_ENABLE); + pub const EV_ENABLE_SOURCE6: crate::Field = crate::Field::new(1, 6, EV_ENABLE); + pub const EV_ENABLE_SOURCE7: crate::Field = crate::Field::new(1, 7, EV_ENABLE); + pub const EV_ENABLE_SOURCE8: crate::Field = crate::Field::new(1, 8, EV_ENABLE); + pub const EV_ENABLE_SOURCE9: crate::Field = crate::Field::new(1, 9, EV_ENABLE); + pub const EV_ENABLE_SOURCE10: crate::Field = crate::Field::new(1, 10, EV_ENABLE); + pub const EV_ENABLE_SOURCE11: crate::Field = crate::Field::new(1, 11, EV_ENABLE); + pub const EV_ENABLE_SOURCE12: crate::Field = crate::Field::new(1, 12, EV_ENABLE); + pub const EV_ENABLE_SOURCE13: crate::Field = crate::Field::new(1, 13, EV_ENABLE); + pub const EV_ENABLE_SOURCE14: crate::Field = crate::Field::new(1, 14, EV_ENABLE); + pub const EV_ENABLE_SOURCE15: crate::Field = crate::Field::new(1, 15, EV_ENABLE); + pub const EV_ENABLE_SOURCE16: crate::Field = crate::Field::new(1, 16, EV_ENABLE); + pub const EV_ENABLE_SOURCE17: crate::Field = crate::Field::new(1, 17, EV_ENABLE); + pub const EV_ENABLE_SOURCE18: crate::Field = crate::Field::new(1, 18, EV_ENABLE); + pub const EV_ENABLE_SOURCE19: crate::Field = crate::Field::new(1, 19, EV_ENABLE); + + pub const IRQARRAY15_IRQ: usize = 15; + pub const HW_IRQARRAY15_BASE: usize = 0xe000b000; + } + + pub mod irqarray16 { + pub const IRQARRAY16_NUMREGS: usize = 4; + + pub const EV_SOFT: crate::Register = crate::Register::new(0, 0xfffff); + pub const EV_SOFT_TRIGGER: crate::Field = crate::Field::new(20, 0, EV_SOFT); + + pub const EV_STATUS: crate::Register = crate::Register::new(1, 0xfffff); + pub const EV_STATUS_SOURCE0: crate::Field = crate::Field::new(1, 0, EV_STATUS); + pub const EV_STATUS_SOURCE1: crate::Field = crate::Field::new(1, 1, EV_STATUS); + pub const EV_STATUS_SOURCE2: crate::Field = crate::Field::new(1, 2, EV_STATUS); + pub const EV_STATUS_SOURCE3: crate::Field = crate::Field::new(1, 3, EV_STATUS); + pub const EV_STATUS_SOURCE4: crate::Field = crate::Field::new(1, 4, EV_STATUS); + pub const EV_STATUS_SOURCE5: crate::Field = crate::Field::new(1, 5, EV_STATUS); + pub const EV_STATUS_SOURCE6: crate::Field = crate::Field::new(1, 6, EV_STATUS); + pub const EV_STATUS_SOURCE7: crate::Field = crate::Field::new(1, 7, EV_STATUS); + pub const EV_STATUS_SOURCE8: crate::Field = crate::Field::new(1, 8, EV_STATUS); + pub const EV_STATUS_SOURCE9: crate::Field = crate::Field::new(1, 9, EV_STATUS); + pub const EV_STATUS_SOURCE10: crate::Field = crate::Field::new(1, 10, EV_STATUS); + pub const EV_STATUS_SOURCE11: crate::Field = crate::Field::new(1, 11, EV_STATUS); + pub const EV_STATUS_SOURCE12: crate::Field = crate::Field::new(1, 12, EV_STATUS); + pub const EV_STATUS_SOURCE13: crate::Field = crate::Field::new(1, 13, EV_STATUS); + pub const EV_STATUS_SOURCE14: crate::Field = crate::Field::new(1, 14, EV_STATUS); + pub const EV_STATUS_SOURCE15: crate::Field = crate::Field::new(1, 15, EV_STATUS); + pub const EV_STATUS_SOURCE16: crate::Field = crate::Field::new(1, 16, EV_STATUS); + pub const EV_STATUS_SOURCE17: crate::Field = crate::Field::new(1, 17, EV_STATUS); + pub const EV_STATUS_SOURCE18: crate::Field = crate::Field::new(1, 18, EV_STATUS); + pub const EV_STATUS_SOURCE19: crate::Field = crate::Field::new(1, 19, EV_STATUS); + + pub const EV_PENDING: crate::Register = crate::Register::new(2, 0xfffff); + pub const EV_PENDING_SOURCE0: crate::Field = crate::Field::new(1, 0, EV_PENDING); + pub const EV_PENDING_SOURCE1: crate::Field = crate::Field::new(1, 1, EV_PENDING); + pub const EV_PENDING_SOURCE2: crate::Field = crate::Field::new(1, 2, EV_PENDING); + pub const EV_PENDING_SOURCE3: crate::Field = crate::Field::new(1, 3, EV_PENDING); + pub const EV_PENDING_SOURCE4: crate::Field = crate::Field::new(1, 4, EV_PENDING); + pub const EV_PENDING_SOURCE5: crate::Field = crate::Field::new(1, 5, EV_PENDING); + pub const EV_PENDING_SOURCE6: crate::Field = crate::Field::new(1, 6, EV_PENDING); + pub const EV_PENDING_SOURCE7: crate::Field = crate::Field::new(1, 7, EV_PENDING); + pub const EV_PENDING_SOURCE8: crate::Field = crate::Field::new(1, 8, EV_PENDING); + pub const EV_PENDING_SOURCE9: crate::Field = crate::Field::new(1, 9, EV_PENDING); + pub const EV_PENDING_SOURCE10: crate::Field = crate::Field::new(1, 10, EV_PENDING); + pub const EV_PENDING_SOURCE11: crate::Field = crate::Field::new(1, 11, EV_PENDING); + pub const EV_PENDING_SOURCE12: crate::Field = crate::Field::new(1, 12, EV_PENDING); + pub const EV_PENDING_SOURCE13: crate::Field = crate::Field::new(1, 13, EV_PENDING); + pub const EV_PENDING_SOURCE14: crate::Field = crate::Field::new(1, 14, EV_PENDING); + pub const EV_PENDING_SOURCE15: crate::Field = crate::Field::new(1, 15, EV_PENDING); + pub const EV_PENDING_SOURCE16: crate::Field = crate::Field::new(1, 16, EV_PENDING); + pub const EV_PENDING_SOURCE17: crate::Field = crate::Field::new(1, 17, EV_PENDING); + pub const EV_PENDING_SOURCE18: crate::Field = crate::Field::new(1, 18, EV_PENDING); + pub const EV_PENDING_SOURCE19: crate::Field = crate::Field::new(1, 19, EV_PENDING); + + pub const EV_ENABLE: crate::Register = crate::Register::new(3, 0xfffff); + pub const EV_ENABLE_SOURCE0: crate::Field = crate::Field::new(1, 0, EV_ENABLE); + pub const EV_ENABLE_SOURCE1: crate::Field = crate::Field::new(1, 1, EV_ENABLE); + pub const EV_ENABLE_SOURCE2: crate::Field = crate::Field::new(1, 2, EV_ENABLE); + pub const EV_ENABLE_SOURCE3: crate::Field = crate::Field::new(1, 3, EV_ENABLE); + pub const EV_ENABLE_SOURCE4: crate::Field = crate::Field::new(1, 4, EV_ENABLE); + pub const EV_ENABLE_SOURCE5: crate::Field = crate::Field::new(1, 5, EV_ENABLE); + pub const EV_ENABLE_SOURCE6: crate::Field = crate::Field::new(1, 6, EV_ENABLE); + pub const EV_ENABLE_SOURCE7: crate::Field = crate::Field::new(1, 7, EV_ENABLE); + pub const EV_ENABLE_SOURCE8: crate::Field = crate::Field::new(1, 8, EV_ENABLE); + pub const EV_ENABLE_SOURCE9: crate::Field = crate::Field::new(1, 9, EV_ENABLE); + pub const EV_ENABLE_SOURCE10: crate::Field = crate::Field::new(1, 10, EV_ENABLE); + pub const EV_ENABLE_SOURCE11: crate::Field = crate::Field::new(1, 11, EV_ENABLE); + pub const EV_ENABLE_SOURCE12: crate::Field = crate::Field::new(1, 12, EV_ENABLE); + pub const EV_ENABLE_SOURCE13: crate::Field = crate::Field::new(1, 13, EV_ENABLE); + pub const EV_ENABLE_SOURCE14: crate::Field = crate::Field::new(1, 14, EV_ENABLE); + pub const EV_ENABLE_SOURCE15: crate::Field = crate::Field::new(1, 15, EV_ENABLE); + pub const EV_ENABLE_SOURCE16: crate::Field = crate::Field::new(1, 16, EV_ENABLE); + pub const EV_ENABLE_SOURCE17: crate::Field = crate::Field::new(1, 17, EV_ENABLE); + pub const EV_ENABLE_SOURCE18: crate::Field = crate::Field::new(1, 18, EV_ENABLE); + pub const EV_ENABLE_SOURCE19: crate::Field = crate::Field::new(1, 19, EV_ENABLE); + + pub const IRQARRAY16_IRQ: usize = 16; + pub const HW_IRQARRAY16_BASE: usize = 0xe000c000; + } + + pub mod irqarray17 { + pub const IRQARRAY17_NUMREGS: usize = 4; + + pub const EV_SOFT: crate::Register = crate::Register::new(0, 0xfffff); + pub const EV_SOFT_TRIGGER: crate::Field = crate::Field::new(20, 0, EV_SOFT); + + pub const EV_STATUS: crate::Register = crate::Register::new(1, 0xfffff); + pub const EV_STATUS_SOURCE0: crate::Field = crate::Field::new(1, 0, EV_STATUS); + pub const EV_STATUS_SOURCE1: crate::Field = crate::Field::new(1, 1, EV_STATUS); + pub const EV_STATUS_SOURCE2: crate::Field = crate::Field::new(1, 2, EV_STATUS); + pub const EV_STATUS_SOURCE3: crate::Field = crate::Field::new(1, 3, EV_STATUS); + pub const EV_STATUS_SOURCE4: crate::Field = crate::Field::new(1, 4, EV_STATUS); + pub const EV_STATUS_SOURCE5: crate::Field = crate::Field::new(1, 5, EV_STATUS); + pub const EV_STATUS_SOURCE6: crate::Field = crate::Field::new(1, 6, EV_STATUS); + pub const EV_STATUS_SOURCE7: crate::Field = crate::Field::new(1, 7, EV_STATUS); + pub const EV_STATUS_SOURCE8: crate::Field = crate::Field::new(1, 8, EV_STATUS); + pub const EV_STATUS_SOURCE9: crate::Field = crate::Field::new(1, 9, EV_STATUS); + pub const EV_STATUS_SOURCE10: crate::Field = crate::Field::new(1, 10, EV_STATUS); + pub const EV_STATUS_SOURCE11: crate::Field = crate::Field::new(1, 11, EV_STATUS); + pub const EV_STATUS_SOURCE12: crate::Field = crate::Field::new(1, 12, EV_STATUS); + pub const EV_STATUS_SOURCE13: crate::Field = crate::Field::new(1, 13, EV_STATUS); + pub const EV_STATUS_SOURCE14: crate::Field = crate::Field::new(1, 14, EV_STATUS); + pub const EV_STATUS_SOURCE15: crate::Field = crate::Field::new(1, 15, EV_STATUS); + pub const EV_STATUS_SOURCE16: crate::Field = crate::Field::new(1, 16, EV_STATUS); + pub const EV_STATUS_SOURCE17: crate::Field = crate::Field::new(1, 17, EV_STATUS); + pub const EV_STATUS_SOURCE18: crate::Field = crate::Field::new(1, 18, EV_STATUS); + pub const EV_STATUS_SOURCE19: crate::Field = crate::Field::new(1, 19, EV_STATUS); + + pub const EV_PENDING: crate::Register = crate::Register::new(2, 0xfffff); + pub const EV_PENDING_SOURCE0: crate::Field = crate::Field::new(1, 0, EV_PENDING); + pub const EV_PENDING_SOURCE1: crate::Field = crate::Field::new(1, 1, EV_PENDING); + pub const EV_PENDING_SOURCE2: crate::Field = crate::Field::new(1, 2, EV_PENDING); + pub const EV_PENDING_SOURCE3: crate::Field = crate::Field::new(1, 3, EV_PENDING); + pub const EV_PENDING_SOURCE4: crate::Field = crate::Field::new(1, 4, EV_PENDING); + pub const EV_PENDING_SOURCE5: crate::Field = crate::Field::new(1, 5, EV_PENDING); + pub const EV_PENDING_SOURCE6: crate::Field = crate::Field::new(1, 6, EV_PENDING); + pub const EV_PENDING_SOURCE7: crate::Field = crate::Field::new(1, 7, EV_PENDING); + pub const EV_PENDING_SOURCE8: crate::Field = crate::Field::new(1, 8, EV_PENDING); + pub const EV_PENDING_SOURCE9: crate::Field = crate::Field::new(1, 9, EV_PENDING); + pub const EV_PENDING_SOURCE10: crate::Field = crate::Field::new(1, 10, EV_PENDING); + pub const EV_PENDING_SOURCE11: crate::Field = crate::Field::new(1, 11, EV_PENDING); + pub const EV_PENDING_SOURCE12: crate::Field = crate::Field::new(1, 12, EV_PENDING); + pub const EV_PENDING_SOURCE13: crate::Field = crate::Field::new(1, 13, EV_PENDING); + pub const EV_PENDING_SOURCE14: crate::Field = crate::Field::new(1, 14, EV_PENDING); + pub const EV_PENDING_SOURCE15: crate::Field = crate::Field::new(1, 15, EV_PENDING); + pub const EV_PENDING_SOURCE16: crate::Field = crate::Field::new(1, 16, EV_PENDING); + pub const EV_PENDING_SOURCE17: crate::Field = crate::Field::new(1, 17, EV_PENDING); + pub const EV_PENDING_SOURCE18: crate::Field = crate::Field::new(1, 18, EV_PENDING); + pub const EV_PENDING_SOURCE19: crate::Field = crate::Field::new(1, 19, EV_PENDING); + + pub const EV_ENABLE: crate::Register = crate::Register::new(3, 0xfffff); + pub const EV_ENABLE_SOURCE0: crate::Field = crate::Field::new(1, 0, EV_ENABLE); + pub const EV_ENABLE_SOURCE1: crate::Field = crate::Field::new(1, 1, EV_ENABLE); + pub const EV_ENABLE_SOURCE2: crate::Field = crate::Field::new(1, 2, EV_ENABLE); + pub const EV_ENABLE_SOURCE3: crate::Field = crate::Field::new(1, 3, EV_ENABLE); + pub const EV_ENABLE_SOURCE4: crate::Field = crate::Field::new(1, 4, EV_ENABLE); + pub const EV_ENABLE_SOURCE5: crate::Field = crate::Field::new(1, 5, EV_ENABLE); + pub const EV_ENABLE_SOURCE6: crate::Field = crate::Field::new(1, 6, EV_ENABLE); + pub const EV_ENABLE_SOURCE7: crate::Field = crate::Field::new(1, 7, EV_ENABLE); + pub const EV_ENABLE_SOURCE8: crate::Field = crate::Field::new(1, 8, EV_ENABLE); + pub const EV_ENABLE_SOURCE9: crate::Field = crate::Field::new(1, 9, EV_ENABLE); + pub const EV_ENABLE_SOURCE10: crate::Field = crate::Field::new(1, 10, EV_ENABLE); + pub const EV_ENABLE_SOURCE11: crate::Field = crate::Field::new(1, 11, EV_ENABLE); + pub const EV_ENABLE_SOURCE12: crate::Field = crate::Field::new(1, 12, EV_ENABLE); + pub const EV_ENABLE_SOURCE13: crate::Field = crate::Field::new(1, 13, EV_ENABLE); + pub const EV_ENABLE_SOURCE14: crate::Field = crate::Field::new(1, 14, EV_ENABLE); + pub const EV_ENABLE_SOURCE15: crate::Field = crate::Field::new(1, 15, EV_ENABLE); + pub const EV_ENABLE_SOURCE16: crate::Field = crate::Field::new(1, 16, EV_ENABLE); + pub const EV_ENABLE_SOURCE17: crate::Field = crate::Field::new(1, 17, EV_ENABLE); + pub const EV_ENABLE_SOURCE18: crate::Field = crate::Field::new(1, 18, EV_ENABLE); + pub const EV_ENABLE_SOURCE19: crate::Field = crate::Field::new(1, 19, EV_ENABLE); + + pub const IRQARRAY17_IRQ: usize = 17; + pub const HW_IRQARRAY17_BASE: usize = 0xe000d000; + } + + pub mod irqarray18 { + pub const IRQARRAY18_NUMREGS: usize = 4; + + pub const EV_SOFT: crate::Register = crate::Register::new(0, 0xfffff); + pub const EV_SOFT_TRIGGER: crate::Field = crate::Field::new(20, 0, EV_SOFT); + + pub const EV_STATUS: crate::Register = crate::Register::new(1, 0xfffff); + pub const EV_STATUS_SOURCE0: crate::Field = crate::Field::new(1, 0, EV_STATUS); + pub const EV_STATUS_SOURCE1: crate::Field = crate::Field::new(1, 1, EV_STATUS); + pub const EV_STATUS_SOURCE2: crate::Field = crate::Field::new(1, 2, EV_STATUS); + pub const EV_STATUS_SOURCE3: crate::Field = crate::Field::new(1, 3, EV_STATUS); + pub const EV_STATUS_SOURCE4: crate::Field = crate::Field::new(1, 4, EV_STATUS); + pub const EV_STATUS_SOURCE5: crate::Field = crate::Field::new(1, 5, EV_STATUS); + pub const EV_STATUS_SOURCE6: crate::Field = crate::Field::new(1, 6, EV_STATUS); + pub const EV_STATUS_SOURCE7: crate::Field = crate::Field::new(1, 7, EV_STATUS); + pub const EV_STATUS_SOURCE8: crate::Field = crate::Field::new(1, 8, EV_STATUS); + pub const EV_STATUS_SOURCE9: crate::Field = crate::Field::new(1, 9, EV_STATUS); + pub const EV_STATUS_SOURCE10: crate::Field = crate::Field::new(1, 10, EV_STATUS); + pub const EV_STATUS_SOURCE11: crate::Field = crate::Field::new(1, 11, EV_STATUS); + pub const EV_STATUS_SOURCE12: crate::Field = crate::Field::new(1, 12, EV_STATUS); + pub const EV_STATUS_SOURCE13: crate::Field = crate::Field::new(1, 13, EV_STATUS); + pub const EV_STATUS_SOURCE14: crate::Field = crate::Field::new(1, 14, EV_STATUS); + pub const EV_STATUS_SOURCE15: crate::Field = crate::Field::new(1, 15, EV_STATUS); + pub const EV_STATUS_SOURCE16: crate::Field = crate::Field::new(1, 16, EV_STATUS); + pub const EV_STATUS_SOURCE17: crate::Field = crate::Field::new(1, 17, EV_STATUS); + pub const EV_STATUS_SOURCE18: crate::Field = crate::Field::new(1, 18, EV_STATUS); + pub const EV_STATUS_SOURCE19: crate::Field = crate::Field::new(1, 19, EV_STATUS); + + pub const EV_PENDING: crate::Register = crate::Register::new(2, 0xfffff); + pub const EV_PENDING_SOURCE0: crate::Field = crate::Field::new(1, 0, EV_PENDING); + pub const EV_PENDING_SOURCE1: crate::Field = crate::Field::new(1, 1, EV_PENDING); + pub const EV_PENDING_SOURCE2: crate::Field = crate::Field::new(1, 2, EV_PENDING); + pub const EV_PENDING_SOURCE3: crate::Field = crate::Field::new(1, 3, EV_PENDING); + pub const EV_PENDING_SOURCE4: crate::Field = crate::Field::new(1, 4, EV_PENDING); + pub const EV_PENDING_SOURCE5: crate::Field = crate::Field::new(1, 5, EV_PENDING); + pub const EV_PENDING_SOURCE6: crate::Field = crate::Field::new(1, 6, EV_PENDING); + pub const EV_PENDING_SOURCE7: crate::Field = crate::Field::new(1, 7, EV_PENDING); + pub const EV_PENDING_SOURCE8: crate::Field = crate::Field::new(1, 8, EV_PENDING); + pub const EV_PENDING_SOURCE9: crate::Field = crate::Field::new(1, 9, EV_PENDING); + pub const EV_PENDING_SOURCE10: crate::Field = crate::Field::new(1, 10, EV_PENDING); + pub const EV_PENDING_SOURCE11: crate::Field = crate::Field::new(1, 11, EV_PENDING); + pub const EV_PENDING_SOURCE12: crate::Field = crate::Field::new(1, 12, EV_PENDING); + pub const EV_PENDING_SOURCE13: crate::Field = crate::Field::new(1, 13, EV_PENDING); + pub const EV_PENDING_SOURCE14: crate::Field = crate::Field::new(1, 14, EV_PENDING); + pub const EV_PENDING_SOURCE15: crate::Field = crate::Field::new(1, 15, EV_PENDING); + pub const EV_PENDING_SOURCE16: crate::Field = crate::Field::new(1, 16, EV_PENDING); + pub const EV_PENDING_SOURCE17: crate::Field = crate::Field::new(1, 17, EV_PENDING); + pub const EV_PENDING_SOURCE18: crate::Field = crate::Field::new(1, 18, EV_PENDING); + pub const EV_PENDING_SOURCE19: crate::Field = crate::Field::new(1, 19, EV_PENDING); + + pub const EV_ENABLE: crate::Register = crate::Register::new(3, 0xfffff); + pub const EV_ENABLE_SOURCE0: crate::Field = crate::Field::new(1, 0, EV_ENABLE); + pub const EV_ENABLE_SOURCE1: crate::Field = crate::Field::new(1, 1, EV_ENABLE); + pub const EV_ENABLE_SOURCE2: crate::Field = crate::Field::new(1, 2, EV_ENABLE); + pub const EV_ENABLE_SOURCE3: crate::Field = crate::Field::new(1, 3, EV_ENABLE); + pub const EV_ENABLE_SOURCE4: crate::Field = crate::Field::new(1, 4, EV_ENABLE); + pub const EV_ENABLE_SOURCE5: crate::Field = crate::Field::new(1, 5, EV_ENABLE); + pub const EV_ENABLE_SOURCE6: crate::Field = crate::Field::new(1, 6, EV_ENABLE); + pub const EV_ENABLE_SOURCE7: crate::Field = crate::Field::new(1, 7, EV_ENABLE); + pub const EV_ENABLE_SOURCE8: crate::Field = crate::Field::new(1, 8, EV_ENABLE); + pub const EV_ENABLE_SOURCE9: crate::Field = crate::Field::new(1, 9, EV_ENABLE); + pub const EV_ENABLE_SOURCE10: crate::Field = crate::Field::new(1, 10, EV_ENABLE); + pub const EV_ENABLE_SOURCE11: crate::Field = crate::Field::new(1, 11, EV_ENABLE); + pub const EV_ENABLE_SOURCE12: crate::Field = crate::Field::new(1, 12, EV_ENABLE); + pub const EV_ENABLE_SOURCE13: crate::Field = crate::Field::new(1, 13, EV_ENABLE); + pub const EV_ENABLE_SOURCE14: crate::Field = crate::Field::new(1, 14, EV_ENABLE); + pub const EV_ENABLE_SOURCE15: crate::Field = crate::Field::new(1, 15, EV_ENABLE); + pub const EV_ENABLE_SOURCE16: crate::Field = crate::Field::new(1, 16, EV_ENABLE); + pub const EV_ENABLE_SOURCE17: crate::Field = crate::Field::new(1, 17, EV_ENABLE); + pub const EV_ENABLE_SOURCE18: crate::Field = crate::Field::new(1, 18, EV_ENABLE); + pub const EV_ENABLE_SOURCE19: crate::Field = crate::Field::new(1, 19, EV_ENABLE); + + pub const IRQARRAY18_IRQ: usize = 18; + pub const HW_IRQARRAY18_BASE: usize = 0xe000e000; + } + + pub mod irqarray19 { + pub const IRQARRAY19_NUMREGS: usize = 4; + + pub const EV_SOFT: crate::Register = crate::Register::new(0, 0xfffff); + pub const EV_SOFT_TRIGGER: crate::Field = crate::Field::new(20, 0, EV_SOFT); + + pub const EV_STATUS: crate::Register = crate::Register::new(1, 0xfffff); + pub const EV_STATUS_SOURCE0: crate::Field = crate::Field::new(1, 0, EV_STATUS); + pub const EV_STATUS_SOURCE1: crate::Field = crate::Field::new(1, 1, EV_STATUS); + pub const EV_STATUS_SOURCE2: crate::Field = crate::Field::new(1, 2, EV_STATUS); + pub const EV_STATUS_SOURCE3: crate::Field = crate::Field::new(1, 3, EV_STATUS); + pub const EV_STATUS_SOURCE4: crate::Field = crate::Field::new(1, 4, EV_STATUS); + pub const EV_STATUS_SOURCE5: crate::Field = crate::Field::new(1, 5, EV_STATUS); + pub const EV_STATUS_SOURCE6: crate::Field = crate::Field::new(1, 6, EV_STATUS); + pub const EV_STATUS_SOURCE7: crate::Field = crate::Field::new(1, 7, EV_STATUS); + pub const EV_STATUS_SOURCE8: crate::Field = crate::Field::new(1, 8, EV_STATUS); + pub const EV_STATUS_SOURCE9: crate::Field = crate::Field::new(1, 9, EV_STATUS); + pub const EV_STATUS_SOURCE10: crate::Field = crate::Field::new(1, 10, EV_STATUS); + pub const EV_STATUS_SOURCE11: crate::Field = crate::Field::new(1, 11, EV_STATUS); + pub const EV_STATUS_SOURCE12: crate::Field = crate::Field::new(1, 12, EV_STATUS); + pub const EV_STATUS_SOURCE13: crate::Field = crate::Field::new(1, 13, EV_STATUS); + pub const EV_STATUS_SOURCE14: crate::Field = crate::Field::new(1, 14, EV_STATUS); + pub const EV_STATUS_SOURCE15: crate::Field = crate::Field::new(1, 15, EV_STATUS); + pub const EV_STATUS_SOURCE16: crate::Field = crate::Field::new(1, 16, EV_STATUS); + pub const EV_STATUS_SOURCE17: crate::Field = crate::Field::new(1, 17, EV_STATUS); + pub const EV_STATUS_SOURCE18: crate::Field = crate::Field::new(1, 18, EV_STATUS); + pub const EV_STATUS_SOURCE19: crate::Field = crate::Field::new(1, 19, EV_STATUS); + + pub const EV_PENDING: crate::Register = crate::Register::new(2, 0xfffff); + pub const EV_PENDING_SOURCE0: crate::Field = crate::Field::new(1, 0, EV_PENDING); + pub const EV_PENDING_SOURCE1: crate::Field = crate::Field::new(1, 1, EV_PENDING); + pub const EV_PENDING_SOURCE2: crate::Field = crate::Field::new(1, 2, EV_PENDING); + pub const EV_PENDING_SOURCE3: crate::Field = crate::Field::new(1, 3, EV_PENDING); + pub const EV_PENDING_SOURCE4: crate::Field = crate::Field::new(1, 4, EV_PENDING); + pub const EV_PENDING_SOURCE5: crate::Field = crate::Field::new(1, 5, EV_PENDING); + pub const EV_PENDING_SOURCE6: crate::Field = crate::Field::new(1, 6, EV_PENDING); + pub const EV_PENDING_SOURCE7: crate::Field = crate::Field::new(1, 7, EV_PENDING); + pub const EV_PENDING_SOURCE8: crate::Field = crate::Field::new(1, 8, EV_PENDING); + pub const EV_PENDING_SOURCE9: crate::Field = crate::Field::new(1, 9, EV_PENDING); + pub const EV_PENDING_SOURCE10: crate::Field = crate::Field::new(1, 10, EV_PENDING); + pub const EV_PENDING_SOURCE11: crate::Field = crate::Field::new(1, 11, EV_PENDING); + pub const EV_PENDING_SOURCE12: crate::Field = crate::Field::new(1, 12, EV_PENDING); + pub const EV_PENDING_SOURCE13: crate::Field = crate::Field::new(1, 13, EV_PENDING); + pub const EV_PENDING_SOURCE14: crate::Field = crate::Field::new(1, 14, EV_PENDING); + pub const EV_PENDING_SOURCE15: crate::Field = crate::Field::new(1, 15, EV_PENDING); + pub const EV_PENDING_SOURCE16: crate::Field = crate::Field::new(1, 16, EV_PENDING); + pub const EV_PENDING_SOURCE17: crate::Field = crate::Field::new(1, 17, EV_PENDING); + pub const EV_PENDING_SOURCE18: crate::Field = crate::Field::new(1, 18, EV_PENDING); + pub const EV_PENDING_SOURCE19: crate::Field = crate::Field::new(1, 19, EV_PENDING); + + pub const EV_ENABLE: crate::Register = crate::Register::new(3, 0xfffff); + pub const EV_ENABLE_SOURCE0: crate::Field = crate::Field::new(1, 0, EV_ENABLE); + pub const EV_ENABLE_SOURCE1: crate::Field = crate::Field::new(1, 1, EV_ENABLE); + pub const EV_ENABLE_SOURCE2: crate::Field = crate::Field::new(1, 2, EV_ENABLE); + pub const EV_ENABLE_SOURCE3: crate::Field = crate::Field::new(1, 3, EV_ENABLE); + pub const EV_ENABLE_SOURCE4: crate::Field = crate::Field::new(1, 4, EV_ENABLE); + pub const EV_ENABLE_SOURCE5: crate::Field = crate::Field::new(1, 5, EV_ENABLE); + pub const EV_ENABLE_SOURCE6: crate::Field = crate::Field::new(1, 6, EV_ENABLE); + pub const EV_ENABLE_SOURCE7: crate::Field = crate::Field::new(1, 7, EV_ENABLE); + pub const EV_ENABLE_SOURCE8: crate::Field = crate::Field::new(1, 8, EV_ENABLE); + pub const EV_ENABLE_SOURCE9: crate::Field = crate::Field::new(1, 9, EV_ENABLE); + pub const EV_ENABLE_SOURCE10: crate::Field = crate::Field::new(1, 10, EV_ENABLE); + pub const EV_ENABLE_SOURCE11: crate::Field = crate::Field::new(1, 11, EV_ENABLE); + pub const EV_ENABLE_SOURCE12: crate::Field = crate::Field::new(1, 12, EV_ENABLE); + pub const EV_ENABLE_SOURCE13: crate::Field = crate::Field::new(1, 13, EV_ENABLE); + pub const EV_ENABLE_SOURCE14: crate::Field = crate::Field::new(1, 14, EV_ENABLE); + pub const EV_ENABLE_SOURCE15: crate::Field = crate::Field::new(1, 15, EV_ENABLE); + pub const EV_ENABLE_SOURCE16: crate::Field = crate::Field::new(1, 16, EV_ENABLE); + pub const EV_ENABLE_SOURCE17: crate::Field = crate::Field::new(1, 17, EV_ENABLE); + pub const EV_ENABLE_SOURCE18: crate::Field = crate::Field::new(1, 18, EV_ENABLE); + pub const EV_ENABLE_SOURCE19: crate::Field = crate::Field::new(1, 19, EV_ENABLE); + + pub const IRQARRAY19_IRQ: usize = 19; + pub const HW_IRQARRAY19_BASE: usize = 0xe000f000; + } + + pub mod irqarray2 { + pub const IRQARRAY2_NUMREGS: usize = 4; + + pub const EV_SOFT: crate::Register = crate::Register::new(0, 0xfffff); + pub const EV_SOFT_TRIGGER: crate::Field = crate::Field::new(20, 0, EV_SOFT); + + pub const EV_STATUS: crate::Register = crate::Register::new(1, 0xfffff); + pub const EV_STATUS_SOURCE0: crate::Field = crate::Field::new(1, 0, EV_STATUS); + pub const EV_STATUS_SOURCE1: crate::Field = crate::Field::new(1, 1, EV_STATUS); + pub const EV_STATUS_SOURCE2: crate::Field = crate::Field::new(1, 2, EV_STATUS); + pub const EV_STATUS_SOURCE3: crate::Field = crate::Field::new(1, 3, EV_STATUS); + pub const EV_STATUS_SOURCE4: crate::Field = crate::Field::new(1, 4, EV_STATUS); + pub const EV_STATUS_SOURCE5: crate::Field = crate::Field::new(1, 5, EV_STATUS); + pub const EV_STATUS_SOURCE6: crate::Field = crate::Field::new(1, 6, EV_STATUS); + pub const EV_STATUS_SOURCE7: crate::Field = crate::Field::new(1, 7, EV_STATUS); + pub const EV_STATUS_SOURCE8: crate::Field = crate::Field::new(1, 8, EV_STATUS); + pub const EV_STATUS_SOURCE9: crate::Field = crate::Field::new(1, 9, EV_STATUS); + pub const EV_STATUS_SOURCE10: crate::Field = crate::Field::new(1, 10, EV_STATUS); + pub const EV_STATUS_SOURCE11: crate::Field = crate::Field::new(1, 11, EV_STATUS); + pub const EV_STATUS_SOURCE12: crate::Field = crate::Field::new(1, 12, EV_STATUS); + pub const EV_STATUS_SOURCE13: crate::Field = crate::Field::new(1, 13, EV_STATUS); + pub const EV_STATUS_SOURCE14: crate::Field = crate::Field::new(1, 14, EV_STATUS); + pub const EV_STATUS_SOURCE15: crate::Field = crate::Field::new(1, 15, EV_STATUS); + pub const EV_STATUS_SOURCE16: crate::Field = crate::Field::new(1, 16, EV_STATUS); + pub const EV_STATUS_SOURCE17: crate::Field = crate::Field::new(1, 17, EV_STATUS); + pub const EV_STATUS_SOURCE18: crate::Field = crate::Field::new(1, 18, EV_STATUS); + pub const EV_STATUS_SOURCE19: crate::Field = crate::Field::new(1, 19, EV_STATUS); + + pub const EV_PENDING: crate::Register = crate::Register::new(2, 0xfffff); + pub const EV_PENDING_SOURCE0: crate::Field = crate::Field::new(1, 0, EV_PENDING); + pub const EV_PENDING_SOURCE1: crate::Field = crate::Field::new(1, 1, EV_PENDING); + pub const EV_PENDING_SOURCE2: crate::Field = crate::Field::new(1, 2, EV_PENDING); + pub const EV_PENDING_SOURCE3: crate::Field = crate::Field::new(1, 3, EV_PENDING); + pub const EV_PENDING_SOURCE4: crate::Field = crate::Field::new(1, 4, EV_PENDING); + pub const EV_PENDING_SOURCE5: crate::Field = crate::Field::new(1, 5, EV_PENDING); + pub const EV_PENDING_SOURCE6: crate::Field = crate::Field::new(1, 6, EV_PENDING); + pub const EV_PENDING_SOURCE7: crate::Field = crate::Field::new(1, 7, EV_PENDING); + pub const EV_PENDING_SOURCE8: crate::Field = crate::Field::new(1, 8, EV_PENDING); + pub const EV_PENDING_SOURCE9: crate::Field = crate::Field::new(1, 9, EV_PENDING); + pub const EV_PENDING_SOURCE10: crate::Field = crate::Field::new(1, 10, EV_PENDING); + pub const EV_PENDING_SOURCE11: crate::Field = crate::Field::new(1, 11, EV_PENDING); + pub const EV_PENDING_SOURCE12: crate::Field = crate::Field::new(1, 12, EV_PENDING); + pub const EV_PENDING_SOURCE13: crate::Field = crate::Field::new(1, 13, EV_PENDING); + pub const EV_PENDING_SOURCE14: crate::Field = crate::Field::new(1, 14, EV_PENDING); + pub const EV_PENDING_SOURCE15: crate::Field = crate::Field::new(1, 15, EV_PENDING); + pub const EV_PENDING_SOURCE16: crate::Field = crate::Field::new(1, 16, EV_PENDING); + pub const EV_PENDING_SOURCE17: crate::Field = crate::Field::new(1, 17, EV_PENDING); + pub const EV_PENDING_SOURCE18: crate::Field = crate::Field::new(1, 18, EV_PENDING); + pub const EV_PENDING_SOURCE19: crate::Field = crate::Field::new(1, 19, EV_PENDING); + + pub const EV_ENABLE: crate::Register = crate::Register::new(3, 0xfffff); + pub const EV_ENABLE_SOURCE0: crate::Field = crate::Field::new(1, 0, EV_ENABLE); + pub const EV_ENABLE_SOURCE1: crate::Field = crate::Field::new(1, 1, EV_ENABLE); + pub const EV_ENABLE_SOURCE2: crate::Field = crate::Field::new(1, 2, EV_ENABLE); + pub const EV_ENABLE_SOURCE3: crate::Field = crate::Field::new(1, 3, EV_ENABLE); + pub const EV_ENABLE_SOURCE4: crate::Field = crate::Field::new(1, 4, EV_ENABLE); + pub const EV_ENABLE_SOURCE5: crate::Field = crate::Field::new(1, 5, EV_ENABLE); + pub const EV_ENABLE_SOURCE6: crate::Field = crate::Field::new(1, 6, EV_ENABLE); + pub const EV_ENABLE_SOURCE7: crate::Field = crate::Field::new(1, 7, EV_ENABLE); + pub const EV_ENABLE_SOURCE8: crate::Field = crate::Field::new(1, 8, EV_ENABLE); + pub const EV_ENABLE_SOURCE9: crate::Field = crate::Field::new(1, 9, EV_ENABLE); + pub const EV_ENABLE_SOURCE10: crate::Field = crate::Field::new(1, 10, EV_ENABLE); + pub const EV_ENABLE_SOURCE11: crate::Field = crate::Field::new(1, 11, EV_ENABLE); + pub const EV_ENABLE_SOURCE12: crate::Field = crate::Field::new(1, 12, EV_ENABLE); + pub const EV_ENABLE_SOURCE13: crate::Field = crate::Field::new(1, 13, EV_ENABLE); + pub const EV_ENABLE_SOURCE14: crate::Field = crate::Field::new(1, 14, EV_ENABLE); + pub const EV_ENABLE_SOURCE15: crate::Field = crate::Field::new(1, 15, EV_ENABLE); + pub const EV_ENABLE_SOURCE16: crate::Field = crate::Field::new(1, 16, EV_ENABLE); + pub const EV_ENABLE_SOURCE17: crate::Field = crate::Field::new(1, 17, EV_ENABLE); + pub const EV_ENABLE_SOURCE18: crate::Field = crate::Field::new(1, 18, EV_ENABLE); + pub const EV_ENABLE_SOURCE19: crate::Field = crate::Field::new(1, 19, EV_ENABLE); + + pub const IRQARRAY2_IRQ: usize = 2; + pub const HW_IRQARRAY2_BASE: usize = 0xe0010000; + } + + pub mod irqarray3 { + pub const IRQARRAY3_NUMREGS: usize = 4; + + pub const EV_SOFT: crate::Register = crate::Register::new(0, 0xfffff); + pub const EV_SOFT_TRIGGER: crate::Field = crate::Field::new(20, 0, EV_SOFT); + + pub const EV_STATUS: crate::Register = crate::Register::new(1, 0xfffff); + pub const EV_STATUS_SOURCE0: crate::Field = crate::Field::new(1, 0, EV_STATUS); + pub const EV_STATUS_SOURCE1: crate::Field = crate::Field::new(1, 1, EV_STATUS); + pub const EV_STATUS_SOURCE2: crate::Field = crate::Field::new(1, 2, EV_STATUS); + pub const EV_STATUS_SOURCE3: crate::Field = crate::Field::new(1, 3, EV_STATUS); + pub const EV_STATUS_SOURCE4: crate::Field = crate::Field::new(1, 4, EV_STATUS); + pub const EV_STATUS_SOURCE5: crate::Field = crate::Field::new(1, 5, EV_STATUS); + pub const EV_STATUS_SOURCE6: crate::Field = crate::Field::new(1, 6, EV_STATUS); + pub const EV_STATUS_SOURCE7: crate::Field = crate::Field::new(1, 7, EV_STATUS); + pub const EV_STATUS_SOURCE8: crate::Field = crate::Field::new(1, 8, EV_STATUS); + pub const EV_STATUS_SOURCE9: crate::Field = crate::Field::new(1, 9, EV_STATUS); + pub const EV_STATUS_SOURCE10: crate::Field = crate::Field::new(1, 10, EV_STATUS); + pub const EV_STATUS_SOURCE11: crate::Field = crate::Field::new(1, 11, EV_STATUS); + pub const EV_STATUS_SOURCE12: crate::Field = crate::Field::new(1, 12, EV_STATUS); + pub const EV_STATUS_SOURCE13: crate::Field = crate::Field::new(1, 13, EV_STATUS); + pub const EV_STATUS_SOURCE14: crate::Field = crate::Field::new(1, 14, EV_STATUS); + pub const EV_STATUS_SOURCE15: crate::Field = crate::Field::new(1, 15, EV_STATUS); + pub const EV_STATUS_SOURCE16: crate::Field = crate::Field::new(1, 16, EV_STATUS); + pub const EV_STATUS_SOURCE17: crate::Field = crate::Field::new(1, 17, EV_STATUS); + pub const EV_STATUS_SOURCE18: crate::Field = crate::Field::new(1, 18, EV_STATUS); + pub const EV_STATUS_SOURCE19: crate::Field = crate::Field::new(1, 19, EV_STATUS); + + pub const EV_PENDING: crate::Register = crate::Register::new(2, 0xfffff); + pub const EV_PENDING_SOURCE0: crate::Field = crate::Field::new(1, 0, EV_PENDING); + pub const EV_PENDING_SOURCE1: crate::Field = crate::Field::new(1, 1, EV_PENDING); + pub const EV_PENDING_SOURCE2: crate::Field = crate::Field::new(1, 2, EV_PENDING); + pub const EV_PENDING_SOURCE3: crate::Field = crate::Field::new(1, 3, EV_PENDING); + pub const EV_PENDING_SOURCE4: crate::Field = crate::Field::new(1, 4, EV_PENDING); + pub const EV_PENDING_SOURCE5: crate::Field = crate::Field::new(1, 5, EV_PENDING); + pub const EV_PENDING_SOURCE6: crate::Field = crate::Field::new(1, 6, EV_PENDING); + pub const EV_PENDING_SOURCE7: crate::Field = crate::Field::new(1, 7, EV_PENDING); + pub const EV_PENDING_SOURCE8: crate::Field = crate::Field::new(1, 8, EV_PENDING); + pub const EV_PENDING_SOURCE9: crate::Field = crate::Field::new(1, 9, EV_PENDING); + pub const EV_PENDING_SOURCE10: crate::Field = crate::Field::new(1, 10, EV_PENDING); + pub const EV_PENDING_SOURCE11: crate::Field = crate::Field::new(1, 11, EV_PENDING); + pub const EV_PENDING_SOURCE12: crate::Field = crate::Field::new(1, 12, EV_PENDING); + pub const EV_PENDING_SOURCE13: crate::Field = crate::Field::new(1, 13, EV_PENDING); + pub const EV_PENDING_SOURCE14: crate::Field = crate::Field::new(1, 14, EV_PENDING); + pub const EV_PENDING_SOURCE15: crate::Field = crate::Field::new(1, 15, EV_PENDING); + pub const EV_PENDING_SOURCE16: crate::Field = crate::Field::new(1, 16, EV_PENDING); + pub const EV_PENDING_SOURCE17: crate::Field = crate::Field::new(1, 17, EV_PENDING); + pub const EV_PENDING_SOURCE18: crate::Field = crate::Field::new(1, 18, EV_PENDING); + pub const EV_PENDING_SOURCE19: crate::Field = crate::Field::new(1, 19, EV_PENDING); + + pub const EV_ENABLE: crate::Register = crate::Register::new(3, 0xfffff); + pub const EV_ENABLE_SOURCE0: crate::Field = crate::Field::new(1, 0, EV_ENABLE); + pub const EV_ENABLE_SOURCE1: crate::Field = crate::Field::new(1, 1, EV_ENABLE); + pub const EV_ENABLE_SOURCE2: crate::Field = crate::Field::new(1, 2, EV_ENABLE); + pub const EV_ENABLE_SOURCE3: crate::Field = crate::Field::new(1, 3, EV_ENABLE); + pub const EV_ENABLE_SOURCE4: crate::Field = crate::Field::new(1, 4, EV_ENABLE); + pub const EV_ENABLE_SOURCE5: crate::Field = crate::Field::new(1, 5, EV_ENABLE); + pub const EV_ENABLE_SOURCE6: crate::Field = crate::Field::new(1, 6, EV_ENABLE); + pub const EV_ENABLE_SOURCE7: crate::Field = crate::Field::new(1, 7, EV_ENABLE); + pub const EV_ENABLE_SOURCE8: crate::Field = crate::Field::new(1, 8, EV_ENABLE); + pub const EV_ENABLE_SOURCE9: crate::Field = crate::Field::new(1, 9, EV_ENABLE); + pub const EV_ENABLE_SOURCE10: crate::Field = crate::Field::new(1, 10, EV_ENABLE); + pub const EV_ENABLE_SOURCE11: crate::Field = crate::Field::new(1, 11, EV_ENABLE); + pub const EV_ENABLE_SOURCE12: crate::Field = crate::Field::new(1, 12, EV_ENABLE); + pub const EV_ENABLE_SOURCE13: crate::Field = crate::Field::new(1, 13, EV_ENABLE); + pub const EV_ENABLE_SOURCE14: crate::Field = crate::Field::new(1, 14, EV_ENABLE); + pub const EV_ENABLE_SOURCE15: crate::Field = crate::Field::new(1, 15, EV_ENABLE); + pub const EV_ENABLE_SOURCE16: crate::Field = crate::Field::new(1, 16, EV_ENABLE); + pub const EV_ENABLE_SOURCE17: crate::Field = crate::Field::new(1, 17, EV_ENABLE); + pub const EV_ENABLE_SOURCE18: crate::Field = crate::Field::new(1, 18, EV_ENABLE); + pub const EV_ENABLE_SOURCE19: crate::Field = crate::Field::new(1, 19, EV_ENABLE); + + pub const IRQARRAY3_IRQ: usize = 3; + pub const HW_IRQARRAY3_BASE: usize = 0xe0011000; + } + + pub mod irqarray4 { + pub const IRQARRAY4_NUMREGS: usize = 4; + + pub const EV_SOFT: crate::Register = crate::Register::new(0, 0xfffff); + pub const EV_SOFT_TRIGGER: crate::Field = crate::Field::new(20, 0, EV_SOFT); + + pub const EV_STATUS: crate::Register = crate::Register::new(1, 0xfffff); + pub const EV_STATUS_SOURCE0: crate::Field = crate::Field::new(1, 0, EV_STATUS); + pub const EV_STATUS_SOURCE1: crate::Field = crate::Field::new(1, 1, EV_STATUS); + pub const EV_STATUS_SOURCE2: crate::Field = crate::Field::new(1, 2, EV_STATUS); + pub const EV_STATUS_SOURCE3: crate::Field = crate::Field::new(1, 3, EV_STATUS); + pub const EV_STATUS_SOURCE4: crate::Field = crate::Field::new(1, 4, EV_STATUS); + pub const EV_STATUS_SOURCE5: crate::Field = crate::Field::new(1, 5, EV_STATUS); + pub const EV_STATUS_SOURCE6: crate::Field = crate::Field::new(1, 6, EV_STATUS); + pub const EV_STATUS_SOURCE7: crate::Field = crate::Field::new(1, 7, EV_STATUS); + pub const EV_STATUS_SOURCE8: crate::Field = crate::Field::new(1, 8, EV_STATUS); + pub const EV_STATUS_SOURCE9: crate::Field = crate::Field::new(1, 9, EV_STATUS); + pub const EV_STATUS_SOURCE10: crate::Field = crate::Field::new(1, 10, EV_STATUS); + pub const EV_STATUS_SOURCE11: crate::Field = crate::Field::new(1, 11, EV_STATUS); + pub const EV_STATUS_SOURCE12: crate::Field = crate::Field::new(1, 12, EV_STATUS); + pub const EV_STATUS_SOURCE13: crate::Field = crate::Field::new(1, 13, EV_STATUS); + pub const EV_STATUS_SOURCE14: crate::Field = crate::Field::new(1, 14, EV_STATUS); + pub const EV_STATUS_SOURCE15: crate::Field = crate::Field::new(1, 15, EV_STATUS); + pub const EV_STATUS_SOURCE16: crate::Field = crate::Field::new(1, 16, EV_STATUS); + pub const EV_STATUS_SOURCE17: crate::Field = crate::Field::new(1, 17, EV_STATUS); + pub const EV_STATUS_SOURCE18: crate::Field = crate::Field::new(1, 18, EV_STATUS); + pub const EV_STATUS_SOURCE19: crate::Field = crate::Field::new(1, 19, EV_STATUS); + + pub const EV_PENDING: crate::Register = crate::Register::new(2, 0xfffff); + pub const EV_PENDING_SOURCE0: crate::Field = crate::Field::new(1, 0, EV_PENDING); + pub const EV_PENDING_SOURCE1: crate::Field = crate::Field::new(1, 1, EV_PENDING); + pub const EV_PENDING_SOURCE2: crate::Field = crate::Field::new(1, 2, EV_PENDING); + pub const EV_PENDING_SOURCE3: crate::Field = crate::Field::new(1, 3, EV_PENDING); + pub const EV_PENDING_SOURCE4: crate::Field = crate::Field::new(1, 4, EV_PENDING); + pub const EV_PENDING_SOURCE5: crate::Field = crate::Field::new(1, 5, EV_PENDING); + pub const EV_PENDING_SOURCE6: crate::Field = crate::Field::new(1, 6, EV_PENDING); + pub const EV_PENDING_SOURCE7: crate::Field = crate::Field::new(1, 7, EV_PENDING); + pub const EV_PENDING_SOURCE8: crate::Field = crate::Field::new(1, 8, EV_PENDING); + pub const EV_PENDING_SOURCE9: crate::Field = crate::Field::new(1, 9, EV_PENDING); + pub const EV_PENDING_SOURCE10: crate::Field = crate::Field::new(1, 10, EV_PENDING); + pub const EV_PENDING_SOURCE11: crate::Field = crate::Field::new(1, 11, EV_PENDING); + pub const EV_PENDING_SOURCE12: crate::Field = crate::Field::new(1, 12, EV_PENDING); + pub const EV_PENDING_SOURCE13: crate::Field = crate::Field::new(1, 13, EV_PENDING); + pub const EV_PENDING_SOURCE14: crate::Field = crate::Field::new(1, 14, EV_PENDING); + pub const EV_PENDING_SOURCE15: crate::Field = crate::Field::new(1, 15, EV_PENDING); + pub const EV_PENDING_SOURCE16: crate::Field = crate::Field::new(1, 16, EV_PENDING); + pub const EV_PENDING_SOURCE17: crate::Field = crate::Field::new(1, 17, EV_PENDING); + pub const EV_PENDING_SOURCE18: crate::Field = crate::Field::new(1, 18, EV_PENDING); + pub const EV_PENDING_SOURCE19: crate::Field = crate::Field::new(1, 19, EV_PENDING); + + pub const EV_ENABLE: crate::Register = crate::Register::new(3, 0xfffff); + pub const EV_ENABLE_SOURCE0: crate::Field = crate::Field::new(1, 0, EV_ENABLE); + pub const EV_ENABLE_SOURCE1: crate::Field = crate::Field::new(1, 1, EV_ENABLE); + pub const EV_ENABLE_SOURCE2: crate::Field = crate::Field::new(1, 2, EV_ENABLE); + pub const EV_ENABLE_SOURCE3: crate::Field = crate::Field::new(1, 3, EV_ENABLE); + pub const EV_ENABLE_SOURCE4: crate::Field = crate::Field::new(1, 4, EV_ENABLE); + pub const EV_ENABLE_SOURCE5: crate::Field = crate::Field::new(1, 5, EV_ENABLE); + pub const EV_ENABLE_SOURCE6: crate::Field = crate::Field::new(1, 6, EV_ENABLE); + pub const EV_ENABLE_SOURCE7: crate::Field = crate::Field::new(1, 7, EV_ENABLE); + pub const EV_ENABLE_SOURCE8: crate::Field = crate::Field::new(1, 8, EV_ENABLE); + pub const EV_ENABLE_SOURCE9: crate::Field = crate::Field::new(1, 9, EV_ENABLE); + pub const EV_ENABLE_SOURCE10: crate::Field = crate::Field::new(1, 10, EV_ENABLE); + pub const EV_ENABLE_SOURCE11: crate::Field = crate::Field::new(1, 11, EV_ENABLE); + pub const EV_ENABLE_SOURCE12: crate::Field = crate::Field::new(1, 12, EV_ENABLE); + pub const EV_ENABLE_SOURCE13: crate::Field = crate::Field::new(1, 13, EV_ENABLE); + pub const EV_ENABLE_SOURCE14: crate::Field = crate::Field::new(1, 14, EV_ENABLE); + pub const EV_ENABLE_SOURCE15: crate::Field = crate::Field::new(1, 15, EV_ENABLE); + pub const EV_ENABLE_SOURCE16: crate::Field = crate::Field::new(1, 16, EV_ENABLE); + pub const EV_ENABLE_SOURCE17: crate::Field = crate::Field::new(1, 17, EV_ENABLE); + pub const EV_ENABLE_SOURCE18: crate::Field = crate::Field::new(1, 18, EV_ENABLE); + pub const EV_ENABLE_SOURCE19: crate::Field = crate::Field::new(1, 19, EV_ENABLE); + + pub const IRQARRAY4_IRQ: usize = 4; + pub const HW_IRQARRAY4_BASE: usize = 0xe0012000; + } + + pub mod irqarray5 { + pub const IRQARRAY5_NUMREGS: usize = 4; + + pub const EV_SOFT: crate::Register = crate::Register::new(0, 0xfffff); + pub const EV_SOFT_TRIGGER: crate::Field = crate::Field::new(20, 0, EV_SOFT); + + pub const EV_STATUS: crate::Register = crate::Register::new(1, 0xfffff); + pub const EV_STATUS_SOURCE0: crate::Field = crate::Field::new(1, 0, EV_STATUS); + pub const EV_STATUS_SOURCE1: crate::Field = crate::Field::new(1, 1, EV_STATUS); + pub const EV_STATUS_SOURCE2: crate::Field = crate::Field::new(1, 2, EV_STATUS); + pub const EV_STATUS_SOURCE3: crate::Field = crate::Field::new(1, 3, EV_STATUS); + pub const EV_STATUS_SOURCE4: crate::Field = crate::Field::new(1, 4, EV_STATUS); + pub const EV_STATUS_SOURCE5: crate::Field = crate::Field::new(1, 5, EV_STATUS); + pub const EV_STATUS_SOURCE6: crate::Field = crate::Field::new(1, 6, EV_STATUS); + pub const EV_STATUS_SOURCE7: crate::Field = crate::Field::new(1, 7, EV_STATUS); + pub const EV_STATUS_SOURCE8: crate::Field = crate::Field::new(1, 8, EV_STATUS); + pub const EV_STATUS_SOURCE9: crate::Field = crate::Field::new(1, 9, EV_STATUS); + pub const EV_STATUS_SOURCE10: crate::Field = crate::Field::new(1, 10, EV_STATUS); + pub const EV_STATUS_SOURCE11: crate::Field = crate::Field::new(1, 11, EV_STATUS); + pub const EV_STATUS_SOURCE12: crate::Field = crate::Field::new(1, 12, EV_STATUS); + pub const EV_STATUS_SOURCE13: crate::Field = crate::Field::new(1, 13, EV_STATUS); + pub const EV_STATUS_SOURCE14: crate::Field = crate::Field::new(1, 14, EV_STATUS); + pub const EV_STATUS_SOURCE15: crate::Field = crate::Field::new(1, 15, EV_STATUS); + pub const EV_STATUS_SOURCE16: crate::Field = crate::Field::new(1, 16, EV_STATUS); + pub const EV_STATUS_SOURCE17: crate::Field = crate::Field::new(1, 17, EV_STATUS); + pub const EV_STATUS_SOURCE18: crate::Field = crate::Field::new(1, 18, EV_STATUS); + pub const EV_STATUS_SOURCE19: crate::Field = crate::Field::new(1, 19, EV_STATUS); + + pub const EV_PENDING: crate::Register = crate::Register::new(2, 0xfffff); + pub const EV_PENDING_SOURCE0: crate::Field = crate::Field::new(1, 0, EV_PENDING); + pub const EV_PENDING_SOURCE1: crate::Field = crate::Field::new(1, 1, EV_PENDING); + pub const EV_PENDING_SOURCE2: crate::Field = crate::Field::new(1, 2, EV_PENDING); + pub const EV_PENDING_SOURCE3: crate::Field = crate::Field::new(1, 3, EV_PENDING); + pub const EV_PENDING_SOURCE4: crate::Field = crate::Field::new(1, 4, EV_PENDING); + pub const EV_PENDING_SOURCE5: crate::Field = crate::Field::new(1, 5, EV_PENDING); + pub const EV_PENDING_SOURCE6: crate::Field = crate::Field::new(1, 6, EV_PENDING); + pub const EV_PENDING_SOURCE7: crate::Field = crate::Field::new(1, 7, EV_PENDING); + pub const EV_PENDING_SOURCE8: crate::Field = crate::Field::new(1, 8, EV_PENDING); + pub const EV_PENDING_SOURCE9: crate::Field = crate::Field::new(1, 9, EV_PENDING); + pub const EV_PENDING_SOURCE10: crate::Field = crate::Field::new(1, 10, EV_PENDING); + pub const EV_PENDING_SOURCE11: crate::Field = crate::Field::new(1, 11, EV_PENDING); + pub const EV_PENDING_SOURCE12: crate::Field = crate::Field::new(1, 12, EV_PENDING); + pub const EV_PENDING_SOURCE13: crate::Field = crate::Field::new(1, 13, EV_PENDING); + pub const EV_PENDING_SOURCE14: crate::Field = crate::Field::new(1, 14, EV_PENDING); + pub const EV_PENDING_SOURCE15: crate::Field = crate::Field::new(1, 15, EV_PENDING); + pub const EV_PENDING_SOURCE16: crate::Field = crate::Field::new(1, 16, EV_PENDING); + pub const EV_PENDING_SOURCE17: crate::Field = crate::Field::new(1, 17, EV_PENDING); + pub const EV_PENDING_SOURCE18: crate::Field = crate::Field::new(1, 18, EV_PENDING); + pub const EV_PENDING_SOURCE19: crate::Field = crate::Field::new(1, 19, EV_PENDING); + + pub const EV_ENABLE: crate::Register = crate::Register::new(3, 0xfffff); + pub const EV_ENABLE_SOURCE0: crate::Field = crate::Field::new(1, 0, EV_ENABLE); + pub const EV_ENABLE_SOURCE1: crate::Field = crate::Field::new(1, 1, EV_ENABLE); + pub const EV_ENABLE_SOURCE2: crate::Field = crate::Field::new(1, 2, EV_ENABLE); + pub const EV_ENABLE_SOURCE3: crate::Field = crate::Field::new(1, 3, EV_ENABLE); + pub const EV_ENABLE_SOURCE4: crate::Field = crate::Field::new(1, 4, EV_ENABLE); + pub const EV_ENABLE_SOURCE5: crate::Field = crate::Field::new(1, 5, EV_ENABLE); + pub const EV_ENABLE_SOURCE6: crate::Field = crate::Field::new(1, 6, EV_ENABLE); + pub const EV_ENABLE_SOURCE7: crate::Field = crate::Field::new(1, 7, EV_ENABLE); + pub const EV_ENABLE_SOURCE8: crate::Field = crate::Field::new(1, 8, EV_ENABLE); + pub const EV_ENABLE_SOURCE9: crate::Field = crate::Field::new(1, 9, EV_ENABLE); + pub const EV_ENABLE_SOURCE10: crate::Field = crate::Field::new(1, 10, EV_ENABLE); + pub const EV_ENABLE_SOURCE11: crate::Field = crate::Field::new(1, 11, EV_ENABLE); + pub const EV_ENABLE_SOURCE12: crate::Field = crate::Field::new(1, 12, EV_ENABLE); + pub const EV_ENABLE_SOURCE13: crate::Field = crate::Field::new(1, 13, EV_ENABLE); + pub const EV_ENABLE_SOURCE14: crate::Field = crate::Field::new(1, 14, EV_ENABLE); + pub const EV_ENABLE_SOURCE15: crate::Field = crate::Field::new(1, 15, EV_ENABLE); + pub const EV_ENABLE_SOURCE16: crate::Field = crate::Field::new(1, 16, EV_ENABLE); + pub const EV_ENABLE_SOURCE17: crate::Field = crate::Field::new(1, 17, EV_ENABLE); + pub const EV_ENABLE_SOURCE18: crate::Field = crate::Field::new(1, 18, EV_ENABLE); + pub const EV_ENABLE_SOURCE19: crate::Field = crate::Field::new(1, 19, EV_ENABLE); + + pub const IRQARRAY5_IRQ: usize = 5; + pub const HW_IRQARRAY5_BASE: usize = 0xe0013000; + } + + pub mod irqarray6 { + pub const IRQARRAY6_NUMREGS: usize = 4; + + pub const EV_SOFT: crate::Register = crate::Register::new(0, 0xfffff); + pub const EV_SOFT_TRIGGER: crate::Field = crate::Field::new(20, 0, EV_SOFT); + + pub const EV_STATUS: crate::Register = crate::Register::new(1, 0xfffff); + pub const EV_STATUS_SOURCE0: crate::Field = crate::Field::new(1, 0, EV_STATUS); + pub const EV_STATUS_SOURCE1: crate::Field = crate::Field::new(1, 1, EV_STATUS); + pub const EV_STATUS_SOURCE2: crate::Field = crate::Field::new(1, 2, EV_STATUS); + pub const EV_STATUS_SOURCE3: crate::Field = crate::Field::new(1, 3, EV_STATUS); + pub const EV_STATUS_SOURCE4: crate::Field = crate::Field::new(1, 4, EV_STATUS); + pub const EV_STATUS_SOURCE5: crate::Field = crate::Field::new(1, 5, EV_STATUS); + pub const EV_STATUS_SOURCE6: crate::Field = crate::Field::new(1, 6, EV_STATUS); + pub const EV_STATUS_SOURCE7: crate::Field = crate::Field::new(1, 7, EV_STATUS); + pub const EV_STATUS_SOURCE8: crate::Field = crate::Field::new(1, 8, EV_STATUS); + pub const EV_STATUS_SOURCE9: crate::Field = crate::Field::new(1, 9, EV_STATUS); + pub const EV_STATUS_SOURCE10: crate::Field = crate::Field::new(1, 10, EV_STATUS); + pub const EV_STATUS_SOURCE11: crate::Field = crate::Field::new(1, 11, EV_STATUS); + pub const EV_STATUS_SOURCE12: crate::Field = crate::Field::new(1, 12, EV_STATUS); + pub const EV_STATUS_SOURCE13: crate::Field = crate::Field::new(1, 13, EV_STATUS); + pub const EV_STATUS_SOURCE14: crate::Field = crate::Field::new(1, 14, EV_STATUS); + pub const EV_STATUS_SOURCE15: crate::Field = crate::Field::new(1, 15, EV_STATUS); + pub const EV_STATUS_SOURCE16: crate::Field = crate::Field::new(1, 16, EV_STATUS); + pub const EV_STATUS_SOURCE17: crate::Field = crate::Field::new(1, 17, EV_STATUS); + pub const EV_STATUS_SOURCE18: crate::Field = crate::Field::new(1, 18, EV_STATUS); + pub const EV_STATUS_SOURCE19: crate::Field = crate::Field::new(1, 19, EV_STATUS); + + pub const EV_PENDING: crate::Register = crate::Register::new(2, 0xfffff); + pub const EV_PENDING_SOURCE0: crate::Field = crate::Field::new(1, 0, EV_PENDING); + pub const EV_PENDING_SOURCE1: crate::Field = crate::Field::new(1, 1, EV_PENDING); + pub const EV_PENDING_SOURCE2: crate::Field = crate::Field::new(1, 2, EV_PENDING); + pub const EV_PENDING_SOURCE3: crate::Field = crate::Field::new(1, 3, EV_PENDING); + pub const EV_PENDING_SOURCE4: crate::Field = crate::Field::new(1, 4, EV_PENDING); + pub const EV_PENDING_SOURCE5: crate::Field = crate::Field::new(1, 5, EV_PENDING); + pub const EV_PENDING_SOURCE6: crate::Field = crate::Field::new(1, 6, EV_PENDING); + pub const EV_PENDING_SOURCE7: crate::Field = crate::Field::new(1, 7, EV_PENDING); + pub const EV_PENDING_SOURCE8: crate::Field = crate::Field::new(1, 8, EV_PENDING); + pub const EV_PENDING_SOURCE9: crate::Field = crate::Field::new(1, 9, EV_PENDING); + pub const EV_PENDING_SOURCE10: crate::Field = crate::Field::new(1, 10, EV_PENDING); + pub const EV_PENDING_SOURCE11: crate::Field = crate::Field::new(1, 11, EV_PENDING); + pub const EV_PENDING_SOURCE12: crate::Field = crate::Field::new(1, 12, EV_PENDING); + pub const EV_PENDING_SOURCE13: crate::Field = crate::Field::new(1, 13, EV_PENDING); + pub const EV_PENDING_SOURCE14: crate::Field = crate::Field::new(1, 14, EV_PENDING); + pub const EV_PENDING_SOURCE15: crate::Field = crate::Field::new(1, 15, EV_PENDING); + pub const EV_PENDING_SOURCE16: crate::Field = crate::Field::new(1, 16, EV_PENDING); + pub const EV_PENDING_SOURCE17: crate::Field = crate::Field::new(1, 17, EV_PENDING); + pub const EV_PENDING_SOURCE18: crate::Field = crate::Field::new(1, 18, EV_PENDING); + pub const EV_PENDING_SOURCE19: crate::Field = crate::Field::new(1, 19, EV_PENDING); + + pub const EV_ENABLE: crate::Register = crate::Register::new(3, 0xfffff); + pub const EV_ENABLE_SOURCE0: crate::Field = crate::Field::new(1, 0, EV_ENABLE); + pub const EV_ENABLE_SOURCE1: crate::Field = crate::Field::new(1, 1, EV_ENABLE); + pub const EV_ENABLE_SOURCE2: crate::Field = crate::Field::new(1, 2, EV_ENABLE); + pub const EV_ENABLE_SOURCE3: crate::Field = crate::Field::new(1, 3, EV_ENABLE); + pub const EV_ENABLE_SOURCE4: crate::Field = crate::Field::new(1, 4, EV_ENABLE); + pub const EV_ENABLE_SOURCE5: crate::Field = crate::Field::new(1, 5, EV_ENABLE); + pub const EV_ENABLE_SOURCE6: crate::Field = crate::Field::new(1, 6, EV_ENABLE); + pub const EV_ENABLE_SOURCE7: crate::Field = crate::Field::new(1, 7, EV_ENABLE); + pub const EV_ENABLE_SOURCE8: crate::Field = crate::Field::new(1, 8, EV_ENABLE); + pub const EV_ENABLE_SOURCE9: crate::Field = crate::Field::new(1, 9, EV_ENABLE); + pub const EV_ENABLE_SOURCE10: crate::Field = crate::Field::new(1, 10, EV_ENABLE); + pub const EV_ENABLE_SOURCE11: crate::Field = crate::Field::new(1, 11, EV_ENABLE); + pub const EV_ENABLE_SOURCE12: crate::Field = crate::Field::new(1, 12, EV_ENABLE); + pub const EV_ENABLE_SOURCE13: crate::Field = crate::Field::new(1, 13, EV_ENABLE); + pub const EV_ENABLE_SOURCE14: crate::Field = crate::Field::new(1, 14, EV_ENABLE); + pub const EV_ENABLE_SOURCE15: crate::Field = crate::Field::new(1, 15, EV_ENABLE); + pub const EV_ENABLE_SOURCE16: crate::Field = crate::Field::new(1, 16, EV_ENABLE); + pub const EV_ENABLE_SOURCE17: crate::Field = crate::Field::new(1, 17, EV_ENABLE); + pub const EV_ENABLE_SOURCE18: crate::Field = crate::Field::new(1, 18, EV_ENABLE); + pub const EV_ENABLE_SOURCE19: crate::Field = crate::Field::new(1, 19, EV_ENABLE); + + pub const IRQARRAY6_IRQ: usize = 6; + pub const HW_IRQARRAY6_BASE: usize = 0xe0014000; + } + + pub mod irqarray7 { + pub const IRQARRAY7_NUMREGS: usize = 4; + + pub const EV_SOFT: crate::Register = crate::Register::new(0, 0xfffff); + pub const EV_SOFT_TRIGGER: crate::Field = crate::Field::new(20, 0, EV_SOFT); + + pub const EV_STATUS: crate::Register = crate::Register::new(1, 0xfffff); + pub const EV_STATUS_SOURCE0: crate::Field = crate::Field::new(1, 0, EV_STATUS); + pub const EV_STATUS_SOURCE1: crate::Field = crate::Field::new(1, 1, EV_STATUS); + pub const EV_STATUS_SOURCE2: crate::Field = crate::Field::new(1, 2, EV_STATUS); + pub const EV_STATUS_SOURCE3: crate::Field = crate::Field::new(1, 3, EV_STATUS); + pub const EV_STATUS_SOURCE4: crate::Field = crate::Field::new(1, 4, EV_STATUS); + pub const EV_STATUS_SOURCE5: crate::Field = crate::Field::new(1, 5, EV_STATUS); + pub const EV_STATUS_SOURCE6: crate::Field = crate::Field::new(1, 6, EV_STATUS); + pub const EV_STATUS_SOURCE7: crate::Field = crate::Field::new(1, 7, EV_STATUS); + pub const EV_STATUS_SOURCE8: crate::Field = crate::Field::new(1, 8, EV_STATUS); + pub const EV_STATUS_SOURCE9: crate::Field = crate::Field::new(1, 9, EV_STATUS); + pub const EV_STATUS_SOURCE10: crate::Field = crate::Field::new(1, 10, EV_STATUS); + pub const EV_STATUS_SOURCE11: crate::Field = crate::Field::new(1, 11, EV_STATUS); + pub const EV_STATUS_SOURCE12: crate::Field = crate::Field::new(1, 12, EV_STATUS); + pub const EV_STATUS_SOURCE13: crate::Field = crate::Field::new(1, 13, EV_STATUS); + pub const EV_STATUS_SOURCE14: crate::Field = crate::Field::new(1, 14, EV_STATUS); + pub const EV_STATUS_SOURCE15: crate::Field = crate::Field::new(1, 15, EV_STATUS); + pub const EV_STATUS_SOURCE16: crate::Field = crate::Field::new(1, 16, EV_STATUS); + pub const EV_STATUS_SOURCE17: crate::Field = crate::Field::new(1, 17, EV_STATUS); + pub const EV_STATUS_SOURCE18: crate::Field = crate::Field::new(1, 18, EV_STATUS); + pub const EV_STATUS_SOURCE19: crate::Field = crate::Field::new(1, 19, EV_STATUS); + + pub const EV_PENDING: crate::Register = crate::Register::new(2, 0xfffff); + pub const EV_PENDING_SOURCE0: crate::Field = crate::Field::new(1, 0, EV_PENDING); + pub const EV_PENDING_SOURCE1: crate::Field = crate::Field::new(1, 1, EV_PENDING); + pub const EV_PENDING_SOURCE2: crate::Field = crate::Field::new(1, 2, EV_PENDING); + pub const EV_PENDING_SOURCE3: crate::Field = crate::Field::new(1, 3, EV_PENDING); + pub const EV_PENDING_SOURCE4: crate::Field = crate::Field::new(1, 4, EV_PENDING); + pub const EV_PENDING_SOURCE5: crate::Field = crate::Field::new(1, 5, EV_PENDING); + pub const EV_PENDING_SOURCE6: crate::Field = crate::Field::new(1, 6, EV_PENDING); + pub const EV_PENDING_SOURCE7: crate::Field = crate::Field::new(1, 7, EV_PENDING); + pub const EV_PENDING_SOURCE8: crate::Field = crate::Field::new(1, 8, EV_PENDING); + pub const EV_PENDING_SOURCE9: crate::Field = crate::Field::new(1, 9, EV_PENDING); + pub const EV_PENDING_SOURCE10: crate::Field = crate::Field::new(1, 10, EV_PENDING); + pub const EV_PENDING_SOURCE11: crate::Field = crate::Field::new(1, 11, EV_PENDING); + pub const EV_PENDING_SOURCE12: crate::Field = crate::Field::new(1, 12, EV_PENDING); + pub const EV_PENDING_SOURCE13: crate::Field = crate::Field::new(1, 13, EV_PENDING); + pub const EV_PENDING_SOURCE14: crate::Field = crate::Field::new(1, 14, EV_PENDING); + pub const EV_PENDING_SOURCE15: crate::Field = crate::Field::new(1, 15, EV_PENDING); + pub const EV_PENDING_SOURCE16: crate::Field = crate::Field::new(1, 16, EV_PENDING); + pub const EV_PENDING_SOURCE17: crate::Field = crate::Field::new(1, 17, EV_PENDING); + pub const EV_PENDING_SOURCE18: crate::Field = crate::Field::new(1, 18, EV_PENDING); + pub const EV_PENDING_SOURCE19: crate::Field = crate::Field::new(1, 19, EV_PENDING); + + pub const EV_ENABLE: crate::Register = crate::Register::new(3, 0xfffff); + pub const EV_ENABLE_SOURCE0: crate::Field = crate::Field::new(1, 0, EV_ENABLE); + pub const EV_ENABLE_SOURCE1: crate::Field = crate::Field::new(1, 1, EV_ENABLE); + pub const EV_ENABLE_SOURCE2: crate::Field = crate::Field::new(1, 2, EV_ENABLE); + pub const EV_ENABLE_SOURCE3: crate::Field = crate::Field::new(1, 3, EV_ENABLE); + pub const EV_ENABLE_SOURCE4: crate::Field = crate::Field::new(1, 4, EV_ENABLE); + pub const EV_ENABLE_SOURCE5: crate::Field = crate::Field::new(1, 5, EV_ENABLE); + pub const EV_ENABLE_SOURCE6: crate::Field = crate::Field::new(1, 6, EV_ENABLE); + pub const EV_ENABLE_SOURCE7: crate::Field = crate::Field::new(1, 7, EV_ENABLE); + pub const EV_ENABLE_SOURCE8: crate::Field = crate::Field::new(1, 8, EV_ENABLE); + pub const EV_ENABLE_SOURCE9: crate::Field = crate::Field::new(1, 9, EV_ENABLE); + pub const EV_ENABLE_SOURCE10: crate::Field = crate::Field::new(1, 10, EV_ENABLE); + pub const EV_ENABLE_SOURCE11: crate::Field = crate::Field::new(1, 11, EV_ENABLE); + pub const EV_ENABLE_SOURCE12: crate::Field = crate::Field::new(1, 12, EV_ENABLE); + pub const EV_ENABLE_SOURCE13: crate::Field = crate::Field::new(1, 13, EV_ENABLE); + pub const EV_ENABLE_SOURCE14: crate::Field = crate::Field::new(1, 14, EV_ENABLE); + pub const EV_ENABLE_SOURCE15: crate::Field = crate::Field::new(1, 15, EV_ENABLE); + pub const EV_ENABLE_SOURCE16: crate::Field = crate::Field::new(1, 16, EV_ENABLE); + pub const EV_ENABLE_SOURCE17: crate::Field = crate::Field::new(1, 17, EV_ENABLE); + pub const EV_ENABLE_SOURCE18: crate::Field = crate::Field::new(1, 18, EV_ENABLE); + pub const EV_ENABLE_SOURCE19: crate::Field = crate::Field::new(1, 19, EV_ENABLE); + + pub const IRQARRAY7_IRQ: usize = 7; + pub const HW_IRQARRAY7_BASE: usize = 0xe0015000; + } + + pub mod irqarray8 { + pub const IRQARRAY8_NUMREGS: usize = 4; + + pub const EV_SOFT: crate::Register = crate::Register::new(0, 0xfffff); + pub const EV_SOFT_TRIGGER: crate::Field = crate::Field::new(20, 0, EV_SOFT); + + pub const EV_STATUS: crate::Register = crate::Register::new(1, 0xfffff); + pub const EV_STATUS_SOURCE0: crate::Field = crate::Field::new(1, 0, EV_STATUS); + pub const EV_STATUS_SOURCE1: crate::Field = crate::Field::new(1, 1, EV_STATUS); + pub const EV_STATUS_SOURCE2: crate::Field = crate::Field::new(1, 2, EV_STATUS); + pub const EV_STATUS_SOURCE3: crate::Field = crate::Field::new(1, 3, EV_STATUS); + pub const EV_STATUS_SOURCE4: crate::Field = crate::Field::new(1, 4, EV_STATUS); + pub const EV_STATUS_SOURCE5: crate::Field = crate::Field::new(1, 5, EV_STATUS); + pub const EV_STATUS_SOURCE6: crate::Field = crate::Field::new(1, 6, EV_STATUS); + pub const EV_STATUS_SOURCE7: crate::Field = crate::Field::new(1, 7, EV_STATUS); + pub const EV_STATUS_SOURCE8: crate::Field = crate::Field::new(1, 8, EV_STATUS); + pub const EV_STATUS_SOURCE9: crate::Field = crate::Field::new(1, 9, EV_STATUS); + pub const EV_STATUS_SOURCE10: crate::Field = crate::Field::new(1, 10, EV_STATUS); + pub const EV_STATUS_SOURCE11: crate::Field = crate::Field::new(1, 11, EV_STATUS); + pub const EV_STATUS_SOURCE12: crate::Field = crate::Field::new(1, 12, EV_STATUS); + pub const EV_STATUS_SOURCE13: crate::Field = crate::Field::new(1, 13, EV_STATUS); + pub const EV_STATUS_SOURCE14: crate::Field = crate::Field::new(1, 14, EV_STATUS); + pub const EV_STATUS_SOURCE15: crate::Field = crate::Field::new(1, 15, EV_STATUS); + pub const EV_STATUS_SOURCE16: crate::Field = crate::Field::new(1, 16, EV_STATUS); + pub const EV_STATUS_SOURCE17: crate::Field = crate::Field::new(1, 17, EV_STATUS); + pub const EV_STATUS_SOURCE18: crate::Field = crate::Field::new(1, 18, EV_STATUS); + pub const EV_STATUS_SOURCE19: crate::Field = crate::Field::new(1, 19, EV_STATUS); + + pub const EV_PENDING: crate::Register = crate::Register::new(2, 0xfffff); + pub const EV_PENDING_SOURCE0: crate::Field = crate::Field::new(1, 0, EV_PENDING); + pub const EV_PENDING_SOURCE1: crate::Field = crate::Field::new(1, 1, EV_PENDING); + pub const EV_PENDING_SOURCE2: crate::Field = crate::Field::new(1, 2, EV_PENDING); + pub const EV_PENDING_SOURCE3: crate::Field = crate::Field::new(1, 3, EV_PENDING); + pub const EV_PENDING_SOURCE4: crate::Field = crate::Field::new(1, 4, EV_PENDING); + pub const EV_PENDING_SOURCE5: crate::Field = crate::Field::new(1, 5, EV_PENDING); + pub const EV_PENDING_SOURCE6: crate::Field = crate::Field::new(1, 6, EV_PENDING); + pub const EV_PENDING_SOURCE7: crate::Field = crate::Field::new(1, 7, EV_PENDING); + pub const EV_PENDING_SOURCE8: crate::Field = crate::Field::new(1, 8, EV_PENDING); + pub const EV_PENDING_SOURCE9: crate::Field = crate::Field::new(1, 9, EV_PENDING); + pub const EV_PENDING_SOURCE10: crate::Field = crate::Field::new(1, 10, EV_PENDING); + pub const EV_PENDING_SOURCE11: crate::Field = crate::Field::new(1, 11, EV_PENDING); + pub const EV_PENDING_SOURCE12: crate::Field = crate::Field::new(1, 12, EV_PENDING); + pub const EV_PENDING_SOURCE13: crate::Field = crate::Field::new(1, 13, EV_PENDING); + pub const EV_PENDING_SOURCE14: crate::Field = crate::Field::new(1, 14, EV_PENDING); + pub const EV_PENDING_SOURCE15: crate::Field = crate::Field::new(1, 15, EV_PENDING); + pub const EV_PENDING_SOURCE16: crate::Field = crate::Field::new(1, 16, EV_PENDING); + pub const EV_PENDING_SOURCE17: crate::Field = crate::Field::new(1, 17, EV_PENDING); + pub const EV_PENDING_SOURCE18: crate::Field = crate::Field::new(1, 18, EV_PENDING); + pub const EV_PENDING_SOURCE19: crate::Field = crate::Field::new(1, 19, EV_PENDING); + + pub const EV_ENABLE: crate::Register = crate::Register::new(3, 0xfffff); + pub const EV_ENABLE_SOURCE0: crate::Field = crate::Field::new(1, 0, EV_ENABLE); + pub const EV_ENABLE_SOURCE1: crate::Field = crate::Field::new(1, 1, EV_ENABLE); + pub const EV_ENABLE_SOURCE2: crate::Field = crate::Field::new(1, 2, EV_ENABLE); + pub const EV_ENABLE_SOURCE3: crate::Field = crate::Field::new(1, 3, EV_ENABLE); + pub const EV_ENABLE_SOURCE4: crate::Field = crate::Field::new(1, 4, EV_ENABLE); + pub const EV_ENABLE_SOURCE5: crate::Field = crate::Field::new(1, 5, EV_ENABLE); + pub const EV_ENABLE_SOURCE6: crate::Field = crate::Field::new(1, 6, EV_ENABLE); + pub const EV_ENABLE_SOURCE7: crate::Field = crate::Field::new(1, 7, EV_ENABLE); + pub const EV_ENABLE_SOURCE8: crate::Field = crate::Field::new(1, 8, EV_ENABLE); + pub const EV_ENABLE_SOURCE9: crate::Field = crate::Field::new(1, 9, EV_ENABLE); + pub const EV_ENABLE_SOURCE10: crate::Field = crate::Field::new(1, 10, EV_ENABLE); + pub const EV_ENABLE_SOURCE11: crate::Field = crate::Field::new(1, 11, EV_ENABLE); + pub const EV_ENABLE_SOURCE12: crate::Field = crate::Field::new(1, 12, EV_ENABLE); + pub const EV_ENABLE_SOURCE13: crate::Field = crate::Field::new(1, 13, EV_ENABLE); + pub const EV_ENABLE_SOURCE14: crate::Field = crate::Field::new(1, 14, EV_ENABLE); + pub const EV_ENABLE_SOURCE15: crate::Field = crate::Field::new(1, 15, EV_ENABLE); + pub const EV_ENABLE_SOURCE16: crate::Field = crate::Field::new(1, 16, EV_ENABLE); + pub const EV_ENABLE_SOURCE17: crate::Field = crate::Field::new(1, 17, EV_ENABLE); + pub const EV_ENABLE_SOURCE18: crate::Field = crate::Field::new(1, 18, EV_ENABLE); + pub const EV_ENABLE_SOURCE19: crate::Field = crate::Field::new(1, 19, EV_ENABLE); + + pub const IRQARRAY8_IRQ: usize = 8; + pub const HW_IRQARRAY8_BASE: usize = 0xe0016000; + } + + pub mod irqarray9 { + pub const IRQARRAY9_NUMREGS: usize = 4; + + pub const EV_SOFT: crate::Register = crate::Register::new(0, 0xfffff); + pub const EV_SOFT_TRIGGER: crate::Field = crate::Field::new(20, 0, EV_SOFT); + + pub const EV_STATUS: crate::Register = crate::Register::new(1, 0xfffff); + pub const EV_STATUS_SOURCE0: crate::Field = crate::Field::new(1, 0, EV_STATUS); + pub const EV_STATUS_SOURCE1: crate::Field = crate::Field::new(1, 1, EV_STATUS); + pub const EV_STATUS_SOURCE2: crate::Field = crate::Field::new(1, 2, EV_STATUS); + pub const EV_STATUS_SOURCE3: crate::Field = crate::Field::new(1, 3, EV_STATUS); + pub const EV_STATUS_SOURCE4: crate::Field = crate::Field::new(1, 4, EV_STATUS); + pub const EV_STATUS_SOURCE5: crate::Field = crate::Field::new(1, 5, EV_STATUS); + pub const EV_STATUS_SOURCE6: crate::Field = crate::Field::new(1, 6, EV_STATUS); + pub const EV_STATUS_SOURCE7: crate::Field = crate::Field::new(1, 7, EV_STATUS); + pub const EV_STATUS_SOURCE8: crate::Field = crate::Field::new(1, 8, EV_STATUS); + pub const EV_STATUS_SOURCE9: crate::Field = crate::Field::new(1, 9, EV_STATUS); + pub const EV_STATUS_SOURCE10: crate::Field = crate::Field::new(1, 10, EV_STATUS); + pub const EV_STATUS_SOURCE11: crate::Field = crate::Field::new(1, 11, EV_STATUS); + pub const EV_STATUS_SOURCE12: crate::Field = crate::Field::new(1, 12, EV_STATUS); + pub const EV_STATUS_SOURCE13: crate::Field = crate::Field::new(1, 13, EV_STATUS); + pub const EV_STATUS_SOURCE14: crate::Field = crate::Field::new(1, 14, EV_STATUS); + pub const EV_STATUS_SOURCE15: crate::Field = crate::Field::new(1, 15, EV_STATUS); + pub const EV_STATUS_SOURCE16: crate::Field = crate::Field::new(1, 16, EV_STATUS); + pub const EV_STATUS_SOURCE17: crate::Field = crate::Field::new(1, 17, EV_STATUS); + pub const EV_STATUS_SOURCE18: crate::Field = crate::Field::new(1, 18, EV_STATUS); + pub const EV_STATUS_SOURCE19: crate::Field = crate::Field::new(1, 19, EV_STATUS); + + pub const EV_PENDING: crate::Register = crate::Register::new(2, 0xfffff); + pub const EV_PENDING_SOURCE0: crate::Field = crate::Field::new(1, 0, EV_PENDING); + pub const EV_PENDING_SOURCE1: crate::Field = crate::Field::new(1, 1, EV_PENDING); + pub const EV_PENDING_SOURCE2: crate::Field = crate::Field::new(1, 2, EV_PENDING); + pub const EV_PENDING_SOURCE3: crate::Field = crate::Field::new(1, 3, EV_PENDING); + pub const EV_PENDING_SOURCE4: crate::Field = crate::Field::new(1, 4, EV_PENDING); + pub const EV_PENDING_SOURCE5: crate::Field = crate::Field::new(1, 5, EV_PENDING); + pub const EV_PENDING_SOURCE6: crate::Field = crate::Field::new(1, 6, EV_PENDING); + pub const EV_PENDING_SOURCE7: crate::Field = crate::Field::new(1, 7, EV_PENDING); + pub const EV_PENDING_SOURCE8: crate::Field = crate::Field::new(1, 8, EV_PENDING); + pub const EV_PENDING_SOURCE9: crate::Field = crate::Field::new(1, 9, EV_PENDING); + pub const EV_PENDING_SOURCE10: crate::Field = crate::Field::new(1, 10, EV_PENDING); + pub const EV_PENDING_SOURCE11: crate::Field = crate::Field::new(1, 11, EV_PENDING); + pub const EV_PENDING_SOURCE12: crate::Field = crate::Field::new(1, 12, EV_PENDING); + pub const EV_PENDING_SOURCE13: crate::Field = crate::Field::new(1, 13, EV_PENDING); + pub const EV_PENDING_SOURCE14: crate::Field = crate::Field::new(1, 14, EV_PENDING); + pub const EV_PENDING_SOURCE15: crate::Field = crate::Field::new(1, 15, EV_PENDING); + pub const EV_PENDING_SOURCE16: crate::Field = crate::Field::new(1, 16, EV_PENDING); + pub const EV_PENDING_SOURCE17: crate::Field = crate::Field::new(1, 17, EV_PENDING); + pub const EV_PENDING_SOURCE18: crate::Field = crate::Field::new(1, 18, EV_PENDING); + pub const EV_PENDING_SOURCE19: crate::Field = crate::Field::new(1, 19, EV_PENDING); + + pub const EV_ENABLE: crate::Register = crate::Register::new(3, 0xfffff); + pub const EV_ENABLE_SOURCE0: crate::Field = crate::Field::new(1, 0, EV_ENABLE); + pub const EV_ENABLE_SOURCE1: crate::Field = crate::Field::new(1, 1, EV_ENABLE); + pub const EV_ENABLE_SOURCE2: crate::Field = crate::Field::new(1, 2, EV_ENABLE); + pub const EV_ENABLE_SOURCE3: crate::Field = crate::Field::new(1, 3, EV_ENABLE); + pub const EV_ENABLE_SOURCE4: crate::Field = crate::Field::new(1, 4, EV_ENABLE); + pub const EV_ENABLE_SOURCE5: crate::Field = crate::Field::new(1, 5, EV_ENABLE); + pub const EV_ENABLE_SOURCE6: crate::Field = crate::Field::new(1, 6, EV_ENABLE); + pub const EV_ENABLE_SOURCE7: crate::Field = crate::Field::new(1, 7, EV_ENABLE); + pub const EV_ENABLE_SOURCE8: crate::Field = crate::Field::new(1, 8, EV_ENABLE); + pub const EV_ENABLE_SOURCE9: crate::Field = crate::Field::new(1, 9, EV_ENABLE); + pub const EV_ENABLE_SOURCE10: crate::Field = crate::Field::new(1, 10, EV_ENABLE); + pub const EV_ENABLE_SOURCE11: crate::Field = crate::Field::new(1, 11, EV_ENABLE); + pub const EV_ENABLE_SOURCE12: crate::Field = crate::Field::new(1, 12, EV_ENABLE); + pub const EV_ENABLE_SOURCE13: crate::Field = crate::Field::new(1, 13, EV_ENABLE); + pub const EV_ENABLE_SOURCE14: crate::Field = crate::Field::new(1, 14, EV_ENABLE); + pub const EV_ENABLE_SOURCE15: crate::Field = crate::Field::new(1, 15, EV_ENABLE); + pub const EV_ENABLE_SOURCE16: crate::Field = crate::Field::new(1, 16, EV_ENABLE); + pub const EV_ENABLE_SOURCE17: crate::Field = crate::Field::new(1, 17, EV_ENABLE); + pub const EV_ENABLE_SOURCE18: crate::Field = crate::Field::new(1, 18, EV_ENABLE); + pub const EV_ENABLE_SOURCE19: crate::Field = crate::Field::new(1, 19, EV_ENABLE); + + pub const IRQARRAY9_IRQ: usize = 9; + pub const HW_IRQARRAY9_BASE: usize = 0xe0017000; + } + + pub mod mailbox { + pub const MAILBOX_NUMREGS: usize = 8; + + pub const WDATA: crate::Register = crate::Register::new(0, 0xffffffff); + pub const WDATA_WDATA: crate::Field = crate::Field::new(32, 0, WDATA); + + pub const RDATA: crate::Register = crate::Register::new(1, 0xffffffff); + pub const RDATA_RDATA: crate::Field = crate::Field::new(32, 0, RDATA); + + pub const EV_STATUS: crate::Register = crate::Register::new(2, 0xf); + pub const EV_STATUS_AVAILABLE: crate::Field = crate::Field::new(1, 0, EV_STATUS); + pub const EV_STATUS_ABORT_INIT: crate::Field = crate::Field::new(1, 1, EV_STATUS); + pub const EV_STATUS_ABORT_DONE: crate::Field = crate::Field::new(1, 2, EV_STATUS); + pub const EV_STATUS_ERROR: crate::Field = crate::Field::new(1, 3, EV_STATUS); + + pub const EV_PENDING: crate::Register = crate::Register::new(3, 0xf); + pub const EV_PENDING_AVAILABLE: crate::Field = crate::Field::new(1, 0, EV_PENDING); + pub const EV_PENDING_ABORT_INIT: crate::Field = crate::Field::new(1, 1, EV_PENDING); + pub const EV_PENDING_ABORT_DONE: crate::Field = crate::Field::new(1, 2, EV_PENDING); + pub const EV_PENDING_ERROR: crate::Field = crate::Field::new(1, 3, EV_PENDING); + + pub const EV_ENABLE: crate::Register = crate::Register::new(4, 0xf); + pub const EV_ENABLE_AVAILABLE: crate::Field = crate::Field::new(1, 0, EV_ENABLE); + pub const EV_ENABLE_ABORT_INIT: crate::Field = crate::Field::new(1, 1, EV_ENABLE); + pub const EV_ENABLE_ABORT_DONE: crate::Field = crate::Field::new(1, 2, EV_ENABLE); + pub const EV_ENABLE_ERROR: crate::Field = crate::Field::new(1, 3, EV_ENABLE); + + pub const STATUS: crate::Register = crate::Register::new(5, 0x3ffffff); + pub const STATUS_RX_WORDS: crate::Field = crate::Field::new(11, 0, STATUS); + pub const STATUS_TX_WORDS: crate::Field = crate::Field::new(11, 11, STATUS); + pub const STATUS_ABORT_IN_PROGRESS: crate::Field = crate::Field::new(1, 22, STATUS); + pub const STATUS_ABORT_ACK: crate::Field = crate::Field::new(1, 23, STATUS); + pub const STATUS_TX_ERR: crate::Field = crate::Field::new(1, 24, STATUS); + pub const STATUS_RX_ERR: crate::Field = crate::Field::new(1, 25, STATUS); + + pub const CONTROL: crate::Register = crate::Register::new(6, 0x1); + pub const CONTROL_ABORT: crate::Field = crate::Field::new(1, 0, CONTROL); + + pub const DONE: crate::Register = crate::Register::new(7, 0x1); + pub const DONE_DONE: crate::Field = crate::Field::new(1, 0, DONE); + + pub const MAILBOX_IRQ: usize = 22; + pub const HW_MAILBOX_BASE: usize = 0xe0018000; + } + + pub mod mb_client { + pub const MB_CLIENT_NUMREGS: usize = 8; + + pub const WDATA: crate::Register = crate::Register::new(0, 0xffffffff); + pub const WDATA_WDATA: crate::Field = crate::Field::new(32, 0, WDATA); + + pub const RDATA: crate::Register = crate::Register::new(1, 0xffffffff); + pub const RDATA_RDATA: crate::Field = crate::Field::new(32, 0, RDATA); + + pub const EV_STATUS: crate::Register = crate::Register::new(2, 0xf); + pub const EV_STATUS_AVAILABLE: crate::Field = crate::Field::new(1, 0, EV_STATUS); + pub const EV_STATUS_ABORT_INIT: crate::Field = crate::Field::new(1, 1, EV_STATUS); + pub const EV_STATUS_ABORT_DONE: crate::Field = crate::Field::new(1, 2, EV_STATUS); + pub const EV_STATUS_ERROR: crate::Field = crate::Field::new(1, 3, EV_STATUS); + + pub const EV_PENDING: crate::Register = crate::Register::new(3, 0xf); + pub const EV_PENDING_AVAILABLE: crate::Field = crate::Field::new(1, 0, EV_PENDING); + pub const EV_PENDING_ABORT_INIT: crate::Field = crate::Field::new(1, 1, EV_PENDING); + pub const EV_PENDING_ABORT_DONE: crate::Field = crate::Field::new(1, 2, EV_PENDING); + pub const EV_PENDING_ERROR: crate::Field = crate::Field::new(1, 3, EV_PENDING); + + pub const EV_ENABLE: crate::Register = crate::Register::new(4, 0xf); + pub const EV_ENABLE_AVAILABLE: crate::Field = crate::Field::new(1, 0, EV_ENABLE); + pub const EV_ENABLE_ABORT_INIT: crate::Field = crate::Field::new(1, 1, EV_ENABLE); + pub const EV_ENABLE_ABORT_DONE: crate::Field = crate::Field::new(1, 2, EV_ENABLE); + pub const EV_ENABLE_ERROR: crate::Field = crate::Field::new(1, 3, EV_ENABLE); + + pub const STATUS: crate::Register = crate::Register::new(5, 0x3f); + pub const STATUS_RX_AVAIL: crate::Field = crate::Field::new(1, 0, STATUS); + pub const STATUS_TX_FREE: crate::Field = crate::Field::new(1, 1, STATUS); + pub const STATUS_ABORT_IN_PROGRESS: crate::Field = crate::Field::new(1, 2, STATUS); + pub const STATUS_ABORT_ACK: crate::Field = crate::Field::new(1, 3, STATUS); + pub const STATUS_TX_ERR: crate::Field = crate::Field::new(1, 4, STATUS); + pub const STATUS_RX_ERR: crate::Field = crate::Field::new(1, 5, STATUS); + + pub const CONTROL: crate::Register = crate::Register::new(6, 0x1); + pub const CONTROL_ABORT: crate::Field = crate::Field::new(1, 0, CONTROL); + + pub const DONE: crate::Register = crate::Register::new(7, 0x1); + pub const DONE_DONE: crate::Field = crate::Field::new(1, 0, DONE); + + pub const MB_CLIENT_IRQ: usize = 23; + pub const HW_MB_CLIENT_BASE: usize = 0xe0019000; + } + + pub mod resetvalue { + pub const RESETVALUE_NUMREGS: usize = 1; + + pub const PC: crate::Register = crate::Register::new(0, 0xffffffff); + pub const PC_PC: crate::Field = crate::Field::new(32, 0, PC); + + pub const HW_RESETVALUE_BASE: usize = 0xe001a000; + } + + pub mod ticktimer { + pub const TICKTIMER_NUMREGS: usize = 9; + + pub const CONTROL: crate::Register = crate::Register::new(0, 0x1); + pub const CONTROL_RESET: crate::Field = crate::Field::new(1, 0, CONTROL); + + pub const TIME1: crate::Register = crate::Register::new(1, 0xffffffff); + pub const TIME1_TIME: crate::Field = crate::Field::new(32, 0, TIME1); + + pub const TIME0: crate::Register = crate::Register::new(2, 0xffffffff); + pub const TIME0_TIME: crate::Field = crate::Field::new(32, 0, TIME0); + + pub const MSLEEP_TARGET1: crate::Register = crate::Register::new(3, 0xffffffff); + pub const MSLEEP_TARGET1_MSLEEP_TARGET: crate::Field = crate::Field::new(32, 0, MSLEEP_TARGET1); + + pub const MSLEEP_TARGET0: crate::Register = crate::Register::new(4, 0xffffffff); + pub const MSLEEP_TARGET0_MSLEEP_TARGET: crate::Field = crate::Field::new(32, 0, MSLEEP_TARGET0); + + pub const EV_STATUS: crate::Register = crate::Register::new(5, 0x1); + pub const EV_STATUS_ALARM: crate::Field = crate::Field::new(1, 0, EV_STATUS); + + pub const EV_PENDING: crate::Register = crate::Register::new(6, 0x1); + pub const EV_PENDING_ALARM: crate::Field = crate::Field::new(1, 0, EV_PENDING); + + pub const EV_ENABLE: crate::Register = crate::Register::new(7, 0x1); + pub const EV_ENABLE_ALARM: crate::Field = crate::Field::new(1, 0, EV_ENABLE); + + pub const CLOCKS_PER_TICK: crate::Register = crate::Register::new(8, 0xffffffff); + pub const CLOCKS_PER_TICK_CLOCKS_PER_TICK: crate::Field = crate::Field::new(32, 0, CLOCKS_PER_TICK); + + pub const TICKTIMER_IRQ: usize = 20; + pub const HW_TICKTIMER_BASE: usize = 0xe001b000; + } + + pub mod pl230 { + pub const PL230_NUMREGS: usize = 20; + + pub const STATUS: crate::Register = crate::Register::new(0, 0xf01f00f1); + pub const STATUS_TEST_STATUS: crate::Field = crate::Field::new(4, 28, STATUS); + pub const STATUS_CHNLS_MINUS1: crate::Field = crate::Field::new(5, 16, STATUS); + pub const STATUS_STATE: crate::Field = crate::Field::new(4, 4, STATUS); + pub const STATUS_MASTER_ENABLE: crate::Field = crate::Field::new(1, 0, STATUS); + + pub const CFG: crate::Register = crate::Register::new(1, 0xe1); + pub const CFG_CHNL_PROT_CTRL: crate::Field = crate::Field::new(3, 5, CFG); + pub const CFG_MASTER_ENABLE: crate::Field = crate::Field::new(1, 0, CFG); + + pub const CTRLBASEPTR: crate::Register = crate::Register::new(2, 0xffffff00); + pub const CTRLBASEPTR_CTRL_BASE_PTR: crate::Field = crate::Field::new(24, 8, CTRLBASEPTR); + + pub const ALTCTRLBASEPTR: crate::Register = crate::Register::new(3, 0xffffffff); + pub const ALTCTRLBASEPTR_ALT_CTRL_BASE_PTR: crate::Field = crate::Field::new(32, 0, ALTCTRLBASEPTR); + + pub const DMA_WAITONREQ_STATUS: crate::Register = crate::Register::new(4, 0xff); + pub const DMA_WAITONREQ_STATUS_DMA_WAITONREQ_STATUS: crate::Field = crate::Field::new(8, 0, DMA_WAITONREQ_STATUS); + + pub const CHNLSWREQUEST: crate::Register = crate::Register::new(5, 0xff); + pub const CHNLSWREQUEST_CHNL_SW_REQUEST: crate::Field = crate::Field::new(8, 0, CHNLSWREQUEST); + + pub const CHNLUSEBURSTSET: crate::Register = crate::Register::new(6, 0xff); + pub const CHNLUSEBURSTSET_CHNL_USEBURST_SET: crate::Field = crate::Field::new(8, 0, CHNLUSEBURSTSET); + + pub const CHNLUSEBURSTCLR: crate::Register = crate::Register::new(7, 0xff); + pub const CHNLUSEBURSTCLR_CHNL_USEBURST_CLR: crate::Field = crate::Field::new(8, 0, CHNLUSEBURSTCLR); + + pub const CHNLREQMASKSET: crate::Register = crate::Register::new(8, 0xff); + pub const CHNLREQMASKSET_CHNL_REQ_MASK_SET: crate::Field = crate::Field::new(8, 0, CHNLREQMASKSET); + + pub const CHNLREQMASKCLR: crate::Register = crate::Register::new(9, 0xff); + pub const CHNLREQMASKCLR_CHNL_REQ_MASK_CLR: crate::Field = crate::Field::new(8, 0, CHNLREQMASKCLR); + + pub const CHNLENABLESET: crate::Register = crate::Register::new(10, 0xff); + pub const CHNLENABLESET_CHNL_ENABLE_SET: crate::Field = crate::Field::new(8, 0, CHNLENABLESET); + + pub const CHNLENABLECLR: crate::Register = crate::Register::new(11, 0xff); + pub const CHNLENABLECLR_CHNL_ENABLE_CLR: crate::Field = crate::Field::new(8, 0, CHNLENABLECLR); + + pub const CHNLPRIALTSET: crate::Register = crate::Register::new(12, 0xff); + pub const CHNLPRIALTSET_CHNL_PRI_ALT_SET: crate::Field = crate::Field::new(8, 0, CHNLPRIALTSET); + + pub const CHNLPRIALTCLR: crate::Register = crate::Register::new(13, 0xff); + pub const CHNLPRIALTCLR_CHNL_PRI_ALT_CLR: crate::Field = crate::Field::new(8, 0, CHNLPRIALTCLR); + + pub const CHNLPRIORITYSET: crate::Register = crate::Register::new(14, 0xff); + pub const CHNLPRIORITYSET_CHNL_PRIORITY_SET: crate::Field = crate::Field::new(8, 0, CHNLPRIORITYSET); + + pub const CHNLPRIORITYCLR: crate::Register = crate::Register::new(15, 0xff); + pub const CHNLPRIORITYCLR_CHNL_PRIORITY_CLR: crate::Field = crate::Field::new(8, 0, CHNLPRIORITYCLR); + + pub const ERRCLR: crate::Register = crate::Register::new(19, 0x1); + pub const ERRCLR_ERR_CLR: crate::Field = crate::Field::new(1, 0, ERRCLR); + + pub const PERIPH_ID_0: crate::Register = crate::Register::new(1016, 0xff); + pub const PERIPH_ID_0_PART_NUMBER_LSB: crate::Field = crate::Field::new(8, 0, PERIPH_ID_0); + + pub const PERIPH_ID_1: crate::Register = crate::Register::new(1017, 0x7f); + pub const PERIPH_ID_1_PART_NUMBER_MSB: crate::Field = crate::Field::new(4, 0, PERIPH_ID_1); + pub const PERIPH_ID_1_JEP106_LSB: crate::Field = crate::Field::new(3, 4, PERIPH_ID_1); + + pub const PERIPH_ID_2: crate::Register = crate::Register::new(1018, 0xff); + pub const PERIPH_ID_2_JEP106_MSB: crate::Field = crate::Field::new(3, 0, PERIPH_ID_2); + pub const PERIPH_ID_2_JEDEC_USED: crate::Field = crate::Field::new(1, 3, PERIPH_ID_2); + pub const PERIPH_ID_2_REVISION: crate::Field = crate::Field::new(4, 4, PERIPH_ID_2); + + pub const HW_PL230_BASE: usize = 0x40011000; + } + + pub mod aes { + pub const AES_NUMREGS: usize = 10; + + pub const SFR_CRFUNC: crate::Register = crate::Register::new(0, 0xff); + pub const SFR_CRFUNC_SFR_CRFUNC: crate::Field = crate::Field::new(8, 0, SFR_CRFUNC); + + pub const SFR_AR: crate::Register = crate::Register::new(1, 0xffffffff); + pub const SFR_AR_SFR_AR: crate::Field = crate::Field::new(32, 0, SFR_AR); + + pub const SFR_SRMFSM: crate::Register = crate::Register::new(2, 0xff); + pub const SFR_SRMFSM_SFR_SRMFSM: crate::Field = crate::Field::new(8, 0, SFR_SRMFSM); + + pub const SFR_FR: crate::Register = crate::Register::new(3, 0xf); + pub const SFR_FR_MFSM_DONE: crate::Field = crate::Field::new(1, 0, SFR_FR); + pub const SFR_FR_ACORE_DONE: crate::Field = crate::Field::new(1, 1, SFR_FR); + pub const SFR_FR_CHNLO_DONE: crate::Field = crate::Field::new(1, 2, SFR_FR); + pub const SFR_FR_CHNLI_DONE: crate::Field = crate::Field::new(1, 3, SFR_FR); + + pub const SFR_OPT: crate::Register = crate::Register::new(4, 0x1ff); + pub const SFR_OPT_OPT_KLEN0: crate::Field = crate::Field::new(4, 0, SFR_OPT); + pub const SFR_OPT_OPT_MODE0: crate::Field = crate::Field::new(4, 4, SFR_OPT); + pub const SFR_OPT_OPT_IFSTART0: crate::Field = crate::Field::new(1, 8, SFR_OPT); + + pub const SFR_OPT1: crate::Register = crate::Register::new(5, 0xffff); + pub const SFR_OPT1_SFR_OPT1: crate::Field = crate::Field::new(16, 0, SFR_OPT1); + + pub const SFR_SEGPTR_PTRID_IV: crate::Register = crate::Register::new(12, 0xfff); + pub const SFR_SEGPTR_PTRID_IV_PTRID_IV: crate::Field = crate::Field::new(12, 0, SFR_SEGPTR_PTRID_IV); + + pub const SFR_SEGPTR_PTRID_AKEY: crate::Register = crate::Register::new(13, 0xfff); + pub const SFR_SEGPTR_PTRID_AKEY_PTRID_AKEY: crate::Field = crate::Field::new(12, 0, SFR_SEGPTR_PTRID_AKEY); + + pub const SFR_SEGPTR_PTRID_AIB: crate::Register = crate::Register::new(14, 0xfff); + pub const SFR_SEGPTR_PTRID_AIB_PTRID_AIB: crate::Field = crate::Field::new(12, 0, SFR_SEGPTR_PTRID_AIB); + + pub const SFR_SEGPTR_PTRID_AOB: crate::Register = crate::Register::new(15, 0xfff); + pub const SFR_SEGPTR_PTRID_AOB_PTRID_AOB: crate::Field = crate::Field::new(12, 0, SFR_SEGPTR_PTRID_AOB); + + pub const HW_AES_BASE: usize = 0x4002d000; + } + + pub mod combohash { + pub const COMBOHASH_NUMREGS: usize = 12; + + pub const SFR_CRFUNC: crate::Register = crate::Register::new(0, 0xff); + pub const SFR_CRFUNC_CR_FUNC: crate::Field = crate::Field::new(8, 0, SFR_CRFUNC); + + pub const SFR_AR: crate::Register = crate::Register::new(1, 0xffffffff); + pub const SFR_AR_SFR_AR: crate::Field = crate::Field::new(32, 0, SFR_AR); + + pub const SFR_SRMFSM: crate::Register = crate::Register::new(2, 0xff); + pub const SFR_SRMFSM_MFSM: crate::Field = crate::Field::new(8, 0, SFR_SRMFSM); + + pub const SFR_FR: crate::Register = crate::Register::new(3, 0xf); + pub const SFR_FR_MFSM_DONE: crate::Field = crate::Field::new(1, 0, SFR_FR); + pub const SFR_FR_HASH_DONE: crate::Field = crate::Field::new(1, 1, SFR_FR); + pub const SFR_FR_CHNLO_DONE: crate::Field = crate::Field::new(1, 2, SFR_FR); + pub const SFR_FR_CHNLI_DONE: crate::Field = crate::Field::new(1, 3, SFR_FR); + + pub const SFR_OPT1: crate::Register = crate::Register::new(4, 0xffff); + pub const SFR_OPT1_CR_OPT_HASHCNT: crate::Field = crate::Field::new(16, 0, SFR_OPT1); + + pub const SFR_OPT2: crate::Register = crate::Register::new(5, 0x7); + pub const SFR_OPT2_CR_OPT_SCRTCHK: crate::Field = crate::Field::new(1, 0, SFR_OPT2); + pub const SFR_OPT2_CR_OPT_IFSOB: crate::Field = crate::Field::new(1, 1, SFR_OPT2); + pub const SFR_OPT2_CR_OPT_IFSTART: crate::Field = crate::Field::new(1, 2, SFR_OPT2); + + pub const SFR_SEGPTR_SEGID_LKEY: crate::Register = crate::Register::new(8, 0xfff); + pub const SFR_SEGPTR_SEGID_LKEY_SEGID_LKEY: crate::Field = crate::Field::new(12, 0, SFR_SEGPTR_SEGID_LKEY); + + pub const SFR_SEGPTR_SEGID_KEY: crate::Register = crate::Register::new(9, 0xfff); + pub const SFR_SEGPTR_SEGID_KEY_SEGID_KEY: crate::Field = crate::Field::new(12, 0, SFR_SEGPTR_SEGID_KEY); + + pub const SFR_SEGPTR_SEGID_SCRT: crate::Register = crate::Register::new(11, 0xfff); + pub const SFR_SEGPTR_SEGID_SCRT_SEGID_SCRT: crate::Field = crate::Field::new(12, 0, SFR_SEGPTR_SEGID_SCRT); + + pub const SFR_SEGPTR_SEGID_MSG: crate::Register = crate::Register::new(12, 0xfff); + pub const SFR_SEGPTR_SEGID_MSG_SEGID_MSG: crate::Field = crate::Field::new(12, 0, SFR_SEGPTR_SEGID_MSG); + + pub const SFR_SEGPTR_SEGID_HOUT: crate::Register = crate::Register::new(13, 0xfff); + pub const SFR_SEGPTR_SEGID_HOUT_SEGID_HOUT: crate::Field = crate::Field::new(12, 0, SFR_SEGPTR_SEGID_HOUT); + + pub const SFR_SEGPTR_SEGID_SOB: crate::Register = crate::Register::new(14, 0xfff); + pub const SFR_SEGPTR_SEGID_SOB_SEGID_SOB: crate::Field = crate::Field::new(12, 0, SFR_SEGPTR_SEGID_SOB); + + pub const HW_COMBOHASH_BASE: usize = 0x4002b000; + } + + pub mod pke { + pub const PKE_NUMREGS: usize = 12; + + pub const SFR_CRFUNC: crate::Register = crate::Register::new(0, 0xff); + pub const SFR_CRFUNC_SFR_CRFUNC: crate::Field = crate::Field::new(8, 0, SFR_CRFUNC); + + pub const SFR_AR: crate::Register = crate::Register::new(1, 0xffffffff); + pub const SFR_AR_SFR_AR: crate::Field = crate::Field::new(32, 0, SFR_AR); + + pub const SFR_SRMFSM: crate::Register = crate::Register::new(2, 0x1ff); + pub const SFR_SRMFSM_MFSM: crate::Field = crate::Field::new(8, 0, SFR_SRMFSM); + pub const SFR_SRMFSM_MODINVREADY: crate::Field = crate::Field::new(1, 8, SFR_SRMFSM); + + pub const SFR_FR: crate::Register = crate::Register::new(3, 0x1f); + pub const SFR_FR_MFSM_DONE: crate::Field = crate::Field::new(1, 0, SFR_FR); + pub const SFR_FR_PCORE_DONE: crate::Field = crate::Field::new(1, 1, SFR_FR); + pub const SFR_FR_CHNLO_DONE: crate::Field = crate::Field::new(1, 2, SFR_FR); + pub const SFR_FR_CHNLI_DONE: crate::Field = crate::Field::new(1, 3, SFR_FR); + pub const SFR_FR_CHNLX_DONE: crate::Field = crate::Field::new(1, 4, SFR_FR); + + pub const SFR_OPTNW: crate::Register = crate::Register::new(4, 0x1fff); + pub const SFR_OPTNW_SFR_OPTNW: crate::Field = crate::Field::new(13, 0, SFR_OPTNW); + + pub const SFR_OPTEW: crate::Register = crate::Register::new(5, 0x1fff); + pub const SFR_OPTEW_SFR_OPTEW: crate::Field = crate::Field::new(13, 0, SFR_OPTEW); + + pub const SFR_OPTMASK: crate::Register = crate::Register::new(8, 0xffff); + pub const SFR_OPTMASK_SFR_OPTMASK: crate::Field = crate::Field::new(16, 0, SFR_OPTMASK); + + pub const SFR_SEGPTR_PTRID_PCON: crate::Register = crate::Register::new(12, 0xfff); + pub const SFR_SEGPTR_PTRID_PCON_PTRID_PCON: crate::Field = crate::Field::new(12, 0, SFR_SEGPTR_PTRID_PCON); + + pub const SFR_SEGPTR_PTRID_PIB0: crate::Register = crate::Register::new(13, 0xfff); + pub const SFR_SEGPTR_PTRID_PIB0_PTRID_PIB0: crate::Field = crate::Field::new(12, 0, SFR_SEGPTR_PTRID_PIB0); + + pub const SFR_SEGPTR_PTRID_PIB1: crate::Register = crate::Register::new(14, 0xfff); + pub const SFR_SEGPTR_PTRID_PIB1_PTRID_PIB1: crate::Field = crate::Field::new(12, 0, SFR_SEGPTR_PTRID_PIB1); + + pub const SFR_SEGPTR_PTRID_PKB: crate::Register = crate::Register::new(15, 0xfff); + pub const SFR_SEGPTR_PTRID_PKB_PTRID_PKB: crate::Field = crate::Field::new(12, 0, SFR_SEGPTR_PTRID_PKB); + + pub const SFR_SEGPTR_PTRID_POB: crate::Register = crate::Register::new(16, 0xfff); + pub const SFR_SEGPTR_PTRID_POB_PTRID_POB: crate::Field = crate::Field::new(12, 0, SFR_SEGPTR_PTRID_POB); + + pub const HW_PKE_BASE: usize = 0x4002c000; + } + + pub mod scedma { + pub const SCEDMA_NUMREGS: usize = 18; + + pub const SFR_SCHSTART_AR: crate::Register = crate::Register::new(0, 0xffffffff); + pub const SFR_SCHSTART_AR_SFR_SCHSTART_AR: crate::Field = crate::Field::new(32, 0, SFR_SCHSTART_AR); + + pub const SFR_XCH_FUNC: crate::Register = crate::Register::new(4, 0x1); + pub const SFR_XCH_FUNC_SFR_XCH_FUNC: crate::Field = crate::Field::new(1, 0, SFR_XCH_FUNC); + + pub const SFR_XCH_OPT: crate::Register = crate::Register::new(5, 0xff); + pub const SFR_XCH_OPT_SFR_XCH_OPT: crate::Field = crate::Field::new(8, 0, SFR_XCH_OPT); + + pub const SFR_XCH_AXSTART: crate::Register = crate::Register::new(6, 0xffffffff); + pub const SFR_XCH_AXSTART_SFR_XCH_AXSTART: crate::Field = crate::Field::new(32, 0, SFR_XCH_AXSTART); + + pub const SFR_XCH_SEGID: crate::Register = crate::Register::new(7, 0xff); + pub const SFR_XCH_SEGID_SFR_XCH_SEGID: crate::Field = crate::Field::new(8, 0, SFR_XCH_SEGID); + + pub const SFR_XCH_SEGSTART: crate::Register = crate::Register::new(8, 0xfff); + pub const SFR_XCH_SEGSTART_XCHCR_SEGSTART: crate::Field = crate::Field::new(12, 0, SFR_XCH_SEGSTART); + + pub const SFR_XCH_TRANSIZE: crate::Register = crate::Register::new(9, 0x3fffffff); + pub const SFR_XCH_TRANSIZE_XCHCR_TRANSIZE: crate::Field = crate::Field::new(30, 0, SFR_XCH_TRANSIZE); + + pub const SFR_SCH_FUNC: crate::Register = crate::Register::new(12, 0x1); + pub const SFR_SCH_FUNC_SFR_SCH_FUNC: crate::Field = crate::Field::new(1, 0, SFR_SCH_FUNC); + + pub const SFR_SCH_OPT: crate::Register = crate::Register::new(13, 0xff); + pub const SFR_SCH_OPT_SFR_SCH_OPT: crate::Field = crate::Field::new(8, 0, SFR_SCH_OPT); + + pub const SFR_SCH_AXSTART: crate::Register = crate::Register::new(14, 0xffffffff); + pub const SFR_SCH_AXSTART_SFR_SCH_AXSTART: crate::Field = crate::Field::new(32, 0, SFR_SCH_AXSTART); + + pub const SFR_SCH_SEGID: crate::Register = crate::Register::new(15, 0xff); + pub const SFR_SCH_SEGID_SFR_SCH_SEGID: crate::Field = crate::Field::new(8, 0, SFR_SCH_SEGID); + + pub const SFR_SCH_SEGSTART: crate::Register = crate::Register::new(16, 0xfff); + pub const SFR_SCH_SEGSTART_SCHCR_SEGSTART: crate::Field = crate::Field::new(12, 0, SFR_SCH_SEGSTART); + + pub const SFR_SCH_TRANSIZE: crate::Register = crate::Register::new(17, 0x3fffffff); + pub const SFR_SCH_TRANSIZE_SCHCR_TRANSIZE: crate::Field = crate::Field::new(30, 0, SFR_SCH_TRANSIZE); + + pub const SFR_ICH_OPT: crate::Register = crate::Register::new(20, 0xf); + pub const SFR_ICH_OPT_SFR_ICH_OPT: crate::Field = crate::Field::new(4, 0, SFR_ICH_OPT); + + pub const SFR_ICH_SEGID: crate::Register = crate::Register::new(21, 0xffff); + pub const SFR_ICH_SEGID_SFR_ICH_SEGID: crate::Field = crate::Field::new(16, 0, SFR_ICH_SEGID); + + pub const SFR_ICH_RPSTART: crate::Register = crate::Register::new(22, 0xfff); + pub const SFR_ICH_RPSTART_ICHCR_RPSTART: crate::Field = crate::Field::new(12, 0, SFR_ICH_RPSTART); + + pub const SFR_ICH_WPSTART: crate::Register = crate::Register::new(23, 0xfff); + pub const SFR_ICH_WPSTART_ICHCR_WPSTART: crate::Field = crate::Field::new(12, 0, SFR_ICH_WPSTART); + + pub const SFR_ICH_TRANSIZE: crate::Register = crate::Register::new(24, 0xfff); + pub const SFR_ICH_TRANSIZE_ICHCR_TRANSIZE: crate::Field = crate::Field::new(12, 0, SFR_ICH_TRANSIZE); + + pub const HW_SCEDMA_BASE: usize = 0x40029000; + } + + pub mod sce_glbsfr { + pub const SCE_GLBSFR_NUMREGS: usize = 17; + + pub const SFR_SCEMODE: crate::Register = crate::Register::new(0, 0x3); + pub const SFR_SCEMODE_CR_SCEMODE: crate::Field = crate::Field::new(2, 0, SFR_SCEMODE); + + pub const SFR_SUBEN: crate::Register = crate::Register::new(1, 0xffff); + pub const SFR_SUBEN_CR_SUBEN: crate::Field = crate::Field::new(16, 0, SFR_SUBEN); + + pub const SFR_AHBS: crate::Register = crate::Register::new(2, 0x1f); + pub const SFR_AHBS_CR_AHBSOPT: crate::Field = crate::Field::new(5, 0, SFR_AHBS); + + pub const SFR_SRBUSY: crate::Register = crate::Register::new(4, 0xffff); + pub const SFR_SRBUSY_SR_BUSY: crate::Field = crate::Field::new(16, 0, SFR_SRBUSY); + + pub const SFR_FRDONE: crate::Register = crate::Register::new(5, 0xffff); + pub const SFR_FRDONE_FR_DONE: crate::Field = crate::Field::new(16, 0, SFR_FRDONE); + + pub const SFR_FRERR: crate::Register = crate::Register::new(6, 0xffff); + pub const SFR_FRERR_FR_ERR: crate::Field = crate::Field::new(16, 0, SFR_FRERR); + + pub const SFR_ARCLR: crate::Register = crate::Register::new(7, 0xffffffff); + pub const SFR_ARCLR_AR_CLRRAM: crate::Field = crate::Field::new(32, 0, SFR_ARCLR); + + pub const SFR_TICKCYC: crate::Register = crate::Register::new(8, 0xff); + pub const SFR_TICKCYC_SFR_TICKCYC: crate::Field = crate::Field::new(8, 0, SFR_TICKCYC); + + pub const SFR_TICKCNT: crate::Register = crate::Register::new(9, 0xffffffff); + pub const SFR_TICKCNT_SFR_TICKCNT: crate::Field = crate::Field::new(32, 0, SFR_TICKCNT); + + pub const SFR_FFEN: crate::Register = crate::Register::new(12, 0x3f); + pub const SFR_FFEN_CR_FFEN: crate::Field = crate::Field::new(6, 0, SFR_FFEN); + + pub const SFR_FFCLR: crate::Register = crate::Register::new(13, 0xffffffff); + pub const SFR_FFCLR_AR_FFCLR: crate::Field = crate::Field::new(32, 0, SFR_FFCLR); + + pub const SFR_FFCNT_SR_FF0: crate::Register = crate::Register::new(16, 0xffff); + pub const SFR_FFCNT_SR_FF0_SR_FF0: crate::Field = crate::Field::new(16, 0, SFR_FFCNT_SR_FF0); + + pub const SFR_FFCNT_SR_FF1: crate::Register = crate::Register::new(17, 0xffff); + pub const SFR_FFCNT_SR_FF1_SR_FF1: crate::Field = crate::Field::new(16, 0, SFR_FFCNT_SR_FF1); + + pub const SFR_FFCNT_SR_FF2: crate::Register = crate::Register::new(18, 0xffff); + pub const SFR_FFCNT_SR_FF2_SR_FF2: crate::Field = crate::Field::new(16, 0, SFR_FFCNT_SR_FF2); + + pub const SFR_FFCNT_SR_FF3: crate::Register = crate::Register::new(19, 0xffff); + pub const SFR_FFCNT_SR_FF3_SR_FF3: crate::Field = crate::Field::new(16, 0, SFR_FFCNT_SR_FF3); + + pub const SFR_FFCNT_SR_FF4: crate::Register = crate::Register::new(20, 0xffff); + pub const SFR_FFCNT_SR_FF4_SR_FF4: crate::Field = crate::Field::new(16, 0, SFR_FFCNT_SR_FF4); + + pub const SFR_FFCNT_SR_FF5: crate::Register = crate::Register::new(21, 0xffff); + pub const SFR_FFCNT_SR_FF5_SR_FF5: crate::Field = crate::Field::new(16, 0, SFR_FFCNT_SR_FF5); + + pub const HW_SCE_GLBSFR_BASE: usize = 0x40028000; + } + + pub mod trng { + pub const TRNG_NUMREGS: usize = 12; + + pub const SFR_CRFUNC: crate::Register = crate::Register::new(0, 0xff); + pub const SFR_CRFUNC_CR_FUNC: crate::Field = crate::Field::new(8, 0, SFR_CRFUNC); + + pub const SFR_AR: crate::Register = crate::Register::new(1, 0xffffffff); + pub const SFR_AR_START: crate::Field = crate::Field::new(32, 0, SFR_AR); + + pub const SFR_SRMFSM: crate::Register = crate::Register::new(2, 0x3); + pub const SFR_SRMFSM_MFSM: crate::Field = crate::Field::new(1, 0, SFR_SRMFSM); + pub const SFR_SRMFSM_MODINVREADY: crate::Field = crate::Field::new(1, 1, SFR_SRMFSM); + + pub const SFR_FR: crate::Register = crate::Register::new(3, 0x1f); + pub const SFR_FR_MFSM_DONE: crate::Field = crate::Field::new(1, 0, SFR_FR); + pub const SFR_FR_PCORE_DONE: crate::Field = crate::Field::new(1, 1, SFR_FR); + pub const SFR_FR_CHNLO_DONE: crate::Field = crate::Field::new(1, 2, SFR_FR); + pub const SFR_FR_CHNLI_DONE: crate::Field = crate::Field::new(1, 3, SFR_FR); + pub const SFR_FR_CHNLX_DONE: crate::Field = crate::Field::new(1, 4, SFR_FR); + + pub const SFR_OPTNW: crate::Register = crate::Register::new(4, 0x1fff); + pub const SFR_OPTNW_OPT_NW: crate::Field = crate::Field::new(13, 0, SFR_OPTNW); + + pub const SFR_OPTEW: crate::Register = crate::Register::new(5, 0x1fff); + pub const SFR_OPTEW_OPT_EW: crate::Field = crate::Field::new(13, 0, SFR_OPTEW); + + pub const SFR_OPTMASK: crate::Register = crate::Register::new(8, 0xffff); + pub const SFR_OPTMASK_OPT_MASK: crate::Field = crate::Field::new(16, 0, SFR_OPTMASK); + + pub const SFR_SEGPTR_CR_SEGPTRSTART0: crate::Register = crate::Register::new(12, 0xfff); + pub const SFR_SEGPTR_CR_SEGPTRSTART0_CR_SEGPTRSTART0: crate::Field = crate::Field::new(12, 0, SFR_SEGPTR_CR_SEGPTRSTART0); + + pub const SFR_SEGPTR_CR_SEGPTRSTART1: crate::Register = crate::Register::new(13, 0xfff); + pub const SFR_SEGPTR_CR_SEGPTRSTART1_CR_SEGPTRSTART1: crate::Field = crate::Field::new(12, 0, SFR_SEGPTR_CR_SEGPTRSTART1); + + pub const SFR_SEGPTR_CR_SEGPTRSTART2: crate::Register = crate::Register::new(14, 0xfff); + pub const SFR_SEGPTR_CR_SEGPTRSTART2_CR_SEGPTRSTART2: crate::Field = crate::Field::new(12, 0, SFR_SEGPTR_CR_SEGPTRSTART2); + + pub const SFR_SEGPTR_CR_SEGPTRSTART3: crate::Register = crate::Register::new(15, 0xfff); + pub const SFR_SEGPTR_CR_SEGPTRSTART3_CR_SEGPTRSTART3: crate::Field = crate::Field::new(12, 0, SFR_SEGPTR_CR_SEGPTRSTART3); + + pub const SFR_SEGPTR_CR_SEGPTRSTART4: crate::Register = crate::Register::new(16, 0xfff); + pub const SFR_SEGPTR_CR_SEGPTRSTART4_CR_SEGPTRSTART4: crate::Field = crate::Field::new(12, 0, SFR_SEGPTR_CR_SEGPTRSTART4); + + pub const HW_TRNG_BASE: usize = 0x4002e000; + } + + pub mod alu { + pub const ALU_NUMREGS: usize = 0; + + pub const HW_ALU_BASE: usize = 0x4002f000; + } + + pub mod duart { + pub const DUART_NUMREGS: usize = 4; + + pub const SFR_TXD: crate::Register = crate::Register::new(0, 0xff); + pub const SFR_TXD_SFR_TXD: crate::Field = crate::Field::new(8, 0, SFR_TXD); + + pub const SFR_CR: crate::Register = crate::Register::new(1, 0x1); + pub const SFR_CR_SFR_CR: crate::Field = crate::Field::new(1, 0, SFR_CR); + + pub const SFR_SR: crate::Register = crate::Register::new(2, 0x1); + pub const SFR_SR_SFR_SR: crate::Field = crate::Field::new(1, 0, SFR_SR); + + pub const SFR_ETUC: crate::Register = crate::Register::new(3, 0xffff); + pub const SFR_ETUC_SFR_ETUC: crate::Field = crate::Field::new(16, 0, SFR_ETUC); + + pub const HW_DUART_BASE: usize = 0x40042000; + } + + pub mod wdg_intf { + pub const WDG_INTF_NUMREGS: usize = 0; + + pub const HW_WDG_INTF_BASE: usize = 0x40041000; + } + + pub mod timer_intf { + pub const TIMER_INTF_NUMREGS: usize = 0; + + pub const HW_TIMER_INTF_BASE: usize = 0x40043000; + } + + pub mod evc { + pub const EVC_NUMREGS: usize = 22; + + pub const SFR_CM7EVSEL_CM7EVSEL0: crate::Register = crate::Register::new(0, 0xff); + pub const SFR_CM7EVSEL_CM7EVSEL0_CM7EVSEL0: crate::Field = crate::Field::new(8, 0, SFR_CM7EVSEL_CM7EVSEL0); + + pub const SFR_CM7EVSEL_CM7EVSEL1: crate::Register = crate::Register::new(1, 0xff); + pub const SFR_CM7EVSEL_CM7EVSEL1_CM7EVSEL1: crate::Field = crate::Field::new(8, 0, SFR_CM7EVSEL_CM7EVSEL1); + + pub const SFR_CM7EVSEL_CM7EVSEL2: crate::Register = crate::Register::new(2, 0xff); + pub const SFR_CM7EVSEL_CM7EVSEL2_CM7EVSEL2: crate::Field = crate::Field::new(8, 0, SFR_CM7EVSEL_CM7EVSEL2); + + pub const SFR_CM7EVSEL_CM7EVSEL3: crate::Register = crate::Register::new(3, 0xff); + pub const SFR_CM7EVSEL_CM7EVSEL3_CM7EVSEL3: crate::Field = crate::Field::new(8, 0, SFR_CM7EVSEL_CM7EVSEL3); + + pub const SFR_CM7EVSEL_CM7EVSEL4: crate::Register = crate::Register::new(4, 0xff); + pub const SFR_CM7EVSEL_CM7EVSEL4_CM7EVSEL4: crate::Field = crate::Field::new(8, 0, SFR_CM7EVSEL_CM7EVSEL4); + + pub const SFR_CM7EVSEL_CM7EVSEL5: crate::Register = crate::Register::new(5, 0xff); + pub const SFR_CM7EVSEL_CM7EVSEL5_CM7EVSEL5: crate::Field = crate::Field::new(8, 0, SFR_CM7EVSEL_CM7EVSEL5); + + pub const SFR_CM7EVSEL_CM7EVSEL6: crate::Register = crate::Register::new(6, 0xff); + pub const SFR_CM7EVSEL_CM7EVSEL6_CM7EVSEL6: crate::Field = crate::Field::new(8, 0, SFR_CM7EVSEL_CM7EVSEL6); + + pub const SFR_CM7EVSEL_CM7EVSEL7: crate::Register = crate::Register::new(7, 0xff); + pub const SFR_CM7EVSEL_CM7EVSEL7_CM7EVSEL7: crate::Field = crate::Field::new(8, 0, SFR_CM7EVSEL_CM7EVSEL7); + + pub const SFR_CM7EVEN: crate::Register = crate::Register::new(8, 0xff); + pub const SFR_CM7EVEN_CM7EVEN: crate::Field = crate::Field::new(8, 0, SFR_CM7EVEN); + + pub const SFR_CM7EVFR: crate::Register = crate::Register::new(9, 0xff); + pub const SFR_CM7EVFR_CM7EVS: crate::Field = crate::Field::new(8, 0, SFR_CM7EVFR); + + pub const SFR_TMREVSEL: crate::Register = crate::Register::new(12, 0xffff); + pub const SFR_TMREVSEL_TMR_EVSEL: crate::Field = crate::Field::new(16, 0, SFR_TMREVSEL); + + pub const SFR_PWMEVSEL: crate::Register = crate::Register::new(13, 0xffffffff); + pub const SFR_PWMEVSEL_PWM_EVSEL: crate::Field = crate::Field::new(32, 0, SFR_PWMEVSEL); + + pub const SFR_IFEVEN_IFEVEN0: crate::Register = crate::Register::new(16, 0xffffffff); + pub const SFR_IFEVEN_IFEVEN0_IFEVEN0: crate::Field = crate::Field::new(32, 0, SFR_IFEVEN_IFEVEN0); + + pub const SFR_IFEVEN_IFEVEN1: crate::Register = crate::Register::new(17, 0xffffffff); + pub const SFR_IFEVEN_IFEVEN1_IFEVEN1: crate::Field = crate::Field::new(32, 0, SFR_IFEVEN_IFEVEN1); + + pub const SFR_IFEVEN_IFEVEN2: crate::Register = crate::Register::new(18, 0xffffffff); + pub const SFR_IFEVEN_IFEVEN2_IFEVEN2: crate::Field = crate::Field::new(32, 0, SFR_IFEVEN_IFEVEN2); + + pub const SFR_IFEVEN_IFEVEN3: crate::Register = crate::Register::new(19, 0xffffffff); + pub const SFR_IFEVEN_IFEVEN3_IFEVEN3: crate::Field = crate::Field::new(32, 0, SFR_IFEVEN_IFEVEN3); + + pub const SFR_IFEVEN_IFEVEN4: crate::Register = crate::Register::new(20, 0xffffffff); + pub const SFR_IFEVEN_IFEVEN4_IFEVEN4: crate::Field = crate::Field::new(32, 0, SFR_IFEVEN_IFEVEN4); + + pub const SFR_IFEVEN_IFEVEN5: crate::Register = crate::Register::new(21, 0xffffffff); + pub const SFR_IFEVEN_IFEVEN5_IFEVEN5: crate::Field = crate::Field::new(32, 0, SFR_IFEVEN_IFEVEN5); + + pub const SFR_IFEVEN_IFEVEN6: crate::Register = crate::Register::new(22, 0xffffffff); + pub const SFR_IFEVEN_IFEVEN6_IFEVEN6: crate::Field = crate::Field::new(32, 0, SFR_IFEVEN_IFEVEN6); + + pub const SFR_IFEVEN_IFEVEN7: crate::Register = crate::Register::new(23, 0xffffffff); + pub const SFR_IFEVEN_IFEVEN7_IFEVEN7: crate::Field = crate::Field::new(32, 0, SFR_IFEVEN_IFEVEN7); + + pub const SFR_IFEVERRFR: crate::Register = crate::Register::new(24, 0xffffffff); + pub const SFR_IFEVERRFR_IFEV_ERRS: crate::Field = crate::Field::new(32, 0, SFR_IFEVERRFR); + + pub const SFR_CM7ERRFR: crate::Register = crate::Register::new(32, 0xffffffff); + pub const SFR_CM7ERRFR_ERRIN: crate::Field = crate::Field::new(32, 0, SFR_CM7ERRFR); + + pub const HW_EVC_BASE: usize = 0x40044000; + } + + pub mod sysctrl { + pub const SYSCTRL_NUMREGS: usize = 31; + + pub const SFR_CGUSEC: crate::Register = crate::Register::new(0, 0xffff); + pub const SFR_CGUSEC_SFR_CGUSEC: crate::Field = crate::Field::new(16, 0, SFR_CGUSEC); + + pub const SFR_CGULP: crate::Register = crate::Register::new(1, 0xffff); + pub const SFR_CGULP_SFR_CGULP: crate::Field = crate::Field::new(16, 0, SFR_CGULP); + + pub const SFR_CGUSEL0: crate::Register = crate::Register::new(4, 0x3); + pub const SFR_CGUSEL0_SFR_CGUSEL0: crate::Field = crate::Field::new(2, 0, SFR_CGUSEL0); + + pub const SFR_CGUFD_CFGFDCR0: crate::Register = crate::Register::new(5, 0xffff); + pub const SFR_CGUFD_CFGFDCR0_CFGFDCR0: crate::Field = crate::Field::new(16, 0, SFR_CGUFD_CFGFDCR0); + + pub const SFR_CGUFD_CFGFDCR1: crate::Register = crate::Register::new(6, 0xffff); + pub const SFR_CGUFD_CFGFDCR1_CFGFDCR1: crate::Field = crate::Field::new(16, 0, SFR_CGUFD_CFGFDCR1); + + pub const SFR_CGUFD_CFGFDCR2: crate::Register = crate::Register::new(7, 0xffff); + pub const SFR_CGUFD_CFGFDCR2_CFGFDCR2: crate::Field = crate::Field::new(16, 0, SFR_CGUFD_CFGFDCR2); + + pub const SFR_CGUFD_CFGFDCR3: crate::Register = crate::Register::new(8, 0xffff); + pub const SFR_CGUFD_CFGFDCR3_CFGFDCR3: crate::Field = crate::Field::new(16, 0, SFR_CGUFD_CFGFDCR3); + + pub const SFR_CGUFD_CFGFDCR4: crate::Register = crate::Register::new(9, 0xffff); + pub const SFR_CGUFD_CFGFDCR4_CFGFDCR4: crate::Field = crate::Field::new(16, 0, SFR_CGUFD_CFGFDCR4); + + pub const SFR_CGUSET: crate::Register = crate::Register::new(11, 0xffffffff); + pub const SFR_CGUSET_SFR_CGUSET: crate::Field = crate::Field::new(32, 0, SFR_CGUSET); + + pub const SFR_CGUSEL1: crate::Register = crate::Register::new(12, 0x1); + pub const SFR_CGUSEL1_SFR_CGUSEL1: crate::Field = crate::Field::new(1, 0, SFR_CGUSEL1); + + pub const SFR_CGUFSSR_FSFREQ0: crate::Register = crate::Register::new(16, 0xffff); + pub const SFR_CGUFSSR_FSFREQ0_FSFREQ0: crate::Field = crate::Field::new(16, 0, SFR_CGUFSSR_FSFREQ0); + + pub const SFR_CGUFSSR_FSFREQ1: crate::Register = crate::Register::new(17, 0xffff); + pub const SFR_CGUFSSR_FSFREQ1_FSFREQ1: crate::Field = crate::Field::new(16, 0, SFR_CGUFSSR_FSFREQ1); + + pub const SFR_CGUFSSR_FSFREQ2: crate::Register = crate::Register::new(18, 0xffff); + pub const SFR_CGUFSSR_FSFREQ2_FSFREQ2: crate::Field = crate::Field::new(16, 0, SFR_CGUFSSR_FSFREQ2); + + pub const SFR_CGUFSSR_FSFREQ3: crate::Register = crate::Register::new(19, 0xffff); + pub const SFR_CGUFSSR_FSFREQ3_FSFREQ3: crate::Field = crate::Field::new(16, 0, SFR_CGUFSSR_FSFREQ3); + + pub const SFR_CGUFSVLD: crate::Register = crate::Register::new(20, 0xf); + pub const SFR_CGUFSVLD_SFR_CGUFSVLD: crate::Field = crate::Field::new(4, 0, SFR_CGUFSVLD); + + pub const SFR_CGUFSCR: crate::Register = crate::Register::new(21, 0xffff); + pub const SFR_CGUFSCR_SFR_CGUFSCR: crate::Field = crate::Field::new(16, 0, SFR_CGUFSCR); + + pub const SFR_ACLKGR: crate::Register = crate::Register::new(24, 0xff); + pub const SFR_ACLKGR_SFR_ACLKGR: crate::Field = crate::Field::new(8, 0, SFR_ACLKGR); + + pub const SFR_HCLKGR: crate::Register = crate::Register::new(25, 0xff); + pub const SFR_HCLKGR_SFR_HCLKGR: crate::Field = crate::Field::new(8, 0, SFR_HCLKGR); + + pub const SFR_ICLKGR: crate::Register = crate::Register::new(26, 0xff); + pub const SFR_ICLKGR_SFR_ICLKGR: crate::Field = crate::Field::new(8, 0, SFR_ICLKGR); + + pub const SFR_PCLKGR: crate::Register = crate::Register::new(27, 0xff); + pub const SFR_PCLKGR_SFR_PCLKGR: crate::Field = crate::Field::new(8, 0, SFR_PCLKGR); + + pub const SFR_RCURST0: crate::Register = crate::Register::new(32, 0xffffffff); + pub const SFR_RCURST0_SFR_RCURST0: crate::Field = crate::Field::new(32, 0, SFR_RCURST0); + + pub const SFR_RCURST1: crate::Register = crate::Register::new(33, 0xffffffff); + pub const SFR_RCURST1_SFR_RCURST1: crate::Field = crate::Field::new(32, 0, SFR_RCURST1); + + pub const SFR_RCUSRCFR: crate::Register = crate::Register::new(34, 0xffff); + pub const SFR_RCUSRCFR_SFR_RCUSRCFR: crate::Field = crate::Field::new(16, 0, SFR_RCUSRCFR); + + pub const SFR_IPCARIPFLOW: crate::Register = crate::Register::new(36, 0xffffffff); + pub const SFR_IPCARIPFLOW_SFR_IPCARIPFLOW: crate::Field = crate::Field::new(32, 0, SFR_IPCARIPFLOW); + + pub const SFR_IPCEN: crate::Register = crate::Register::new(37, 0xffff); + pub const SFR_IPCEN_SFR_IPCEN: crate::Field = crate::Field::new(16, 0, SFR_IPCEN); + + pub const SFR_IPCLPEN: crate::Register = crate::Register::new(38, 0xffff); + pub const SFR_IPCLPEN_SFR_IPCLPEN: crate::Field = crate::Field::new(16, 0, SFR_IPCLPEN); + + pub const SFR_IPCOSC: crate::Register = crate::Register::new(39, 0x7f); + pub const SFR_IPCOSC_SFR_IPCOSC: crate::Field = crate::Field::new(7, 0, SFR_IPCOSC); + + pub const SFR_IPCPLLMN: crate::Register = crate::Register::new(40, 0x1ffff); + pub const SFR_IPCPLLMN_SFR_IPCPLLMN: crate::Field = crate::Field::new(17, 0, SFR_IPCPLLMN); + + pub const SFR_IPCPLLF: crate::Register = crate::Register::new(41, 0x1ffffff); + pub const SFR_IPCPLLF_SFR_IPCPLLF: crate::Field = crate::Field::new(25, 0, SFR_IPCPLLF); + + pub const SFR_IPCPLLQ: crate::Register = crate::Register::new(42, 0x7fff); + pub const SFR_IPCPLLQ_SFR_IPCPLLQ: crate::Field = crate::Field::new(15, 0, SFR_IPCPLLQ); + + pub const SFR_IPCCR: crate::Register = crate::Register::new(43, 0xffff); + pub const SFR_IPCCR_SFR_IPCCR: crate::Field = crate::Field::new(16, 0, SFR_IPCCR); + + pub const HW_SYSCTRL_BASE: usize = 0x40040000; + } + + pub mod apb_thru { + pub const APB_THRU_NUMREGS: usize = 0; + + pub const HW_APB_THRU_BASE: usize = 0x50122000; + } + + pub mod iox { + pub const IOX_NUMREGS: usize = 46; + + pub const SFR_AFSEL_CRAFSEL0: crate::Register = crate::Register::new(0, 0xffff); + pub const SFR_AFSEL_CRAFSEL0_CRAFSEL0: crate::Field = crate::Field::new(16, 0, SFR_AFSEL_CRAFSEL0); + + pub const SFR_AFSEL_CRAFSEL1: crate::Register = crate::Register::new(1, 0xffff); + pub const SFR_AFSEL_CRAFSEL1_CRAFSEL1: crate::Field = crate::Field::new(16, 0, SFR_AFSEL_CRAFSEL1); + + pub const SFR_AFSEL_CRAFSEL2: crate::Register = crate::Register::new(2, 0xffff); + pub const SFR_AFSEL_CRAFSEL2_CRAFSEL2: crate::Field = crate::Field::new(16, 0, SFR_AFSEL_CRAFSEL2); + + pub const SFR_AFSEL_CRAFSEL3: crate::Register = crate::Register::new(3, 0xffff); + pub const SFR_AFSEL_CRAFSEL3_CRAFSEL3: crate::Field = crate::Field::new(16, 0, SFR_AFSEL_CRAFSEL3); + + pub const SFR_AFSEL_CRAFSEL4: crate::Register = crate::Register::new(4, 0xffff); + pub const SFR_AFSEL_CRAFSEL4_CRAFSEL4: crate::Field = crate::Field::new(16, 0, SFR_AFSEL_CRAFSEL4); + + pub const SFR_AFSEL_CRAFSEL5: crate::Register = crate::Register::new(5, 0xffff); + pub const SFR_AFSEL_CRAFSEL5_CRAFSEL5: crate::Field = crate::Field::new(16, 0, SFR_AFSEL_CRAFSEL5); + + pub const SFR_AFSEL_CRAFSEL6: crate::Register = crate::Register::new(6, 0xffff); + pub const SFR_AFSEL_CRAFSEL6_CRAFSEL6: crate::Field = crate::Field::new(16, 0, SFR_AFSEL_CRAFSEL6); + + pub const SFR_AFSEL_CRAFSEL7: crate::Register = crate::Register::new(7, 0xffff); + pub const SFR_AFSEL_CRAFSEL7_CRAFSEL7: crate::Field = crate::Field::new(16, 0, SFR_AFSEL_CRAFSEL7); + + pub const SFR_INTCR_CRINT0: crate::Register = crate::Register::new(64, 0x3ff); + pub const SFR_INTCR_CRINT0_CRINT0: crate::Field = crate::Field::new(10, 0, SFR_INTCR_CRINT0); + + pub const SFR_INTCR_CRINT1: crate::Register = crate::Register::new(65, 0x3ff); + pub const SFR_INTCR_CRINT1_CRINT1: crate::Field = crate::Field::new(10, 0, SFR_INTCR_CRINT1); + + pub const SFR_INTCR_CRINT2: crate::Register = crate::Register::new(66, 0x3ff); + pub const SFR_INTCR_CRINT2_CRINT2: crate::Field = crate::Field::new(10, 0, SFR_INTCR_CRINT2); + + pub const SFR_INTCR_CRINT3: crate::Register = crate::Register::new(67, 0x3ff); + pub const SFR_INTCR_CRINT3_CRINT3: crate::Field = crate::Field::new(10, 0, SFR_INTCR_CRINT3); + + pub const SFR_INTCR_CRINT4: crate::Register = crate::Register::new(68, 0x3ff); + pub const SFR_INTCR_CRINT4_CRINT4: crate::Field = crate::Field::new(10, 0, SFR_INTCR_CRINT4); + + pub const SFR_INTCR_CRINT5: crate::Register = crate::Register::new(69, 0x3ff); + pub const SFR_INTCR_CRINT5_CRINT5: crate::Field = crate::Field::new(10, 0, SFR_INTCR_CRINT5); + + pub const SFR_INTCR_CRINT6: crate::Register = crate::Register::new(70, 0x3ff); + pub const SFR_INTCR_CRINT6_CRINT6: crate::Field = crate::Field::new(10, 0, SFR_INTCR_CRINT6); + + pub const SFR_INTCR_CRINT7: crate::Register = crate::Register::new(71, 0x3ff); + pub const SFR_INTCR_CRINT7_CRINT7: crate::Field = crate::Field::new(10, 0, SFR_INTCR_CRINT7); + + pub const SFR_INTFR: crate::Register = crate::Register::new(72, 0xff); + pub const SFR_INTFR_FRINT: crate::Field = crate::Field::new(8, 0, SFR_INTFR); + + pub const SFR_GPIOOUT_CRGO0: crate::Register = crate::Register::new(76, 0xffff); + pub const SFR_GPIOOUT_CRGO0_CRGO0: crate::Field = crate::Field::new(16, 0, SFR_GPIOOUT_CRGO0); + + pub const SFR_GPIOOUT_CRGO1: crate::Register = crate::Register::new(77, 0xffff); + pub const SFR_GPIOOUT_CRGO1_CRGO1: crate::Field = crate::Field::new(16, 0, SFR_GPIOOUT_CRGO1); + + pub const SFR_GPIOOUT_CRGO2: crate::Register = crate::Register::new(78, 0xffff); + pub const SFR_GPIOOUT_CRGO2_CRGO2: crate::Field = crate::Field::new(16, 0, SFR_GPIOOUT_CRGO2); + + pub const SFR_GPIOOUT_CRGO3: crate::Register = crate::Register::new(79, 0xffff); + pub const SFR_GPIOOUT_CRGO3_CRGO3: crate::Field = crate::Field::new(16, 0, SFR_GPIOOUT_CRGO3); + + pub const SFR_GPIOOE_CRGOE0: crate::Register = crate::Register::new(80, 0xffff); + pub const SFR_GPIOOE_CRGOE0_CRGOE0: crate::Field = crate::Field::new(16, 0, SFR_GPIOOE_CRGOE0); + + pub const SFR_GPIOOE_CRGOE1: crate::Register = crate::Register::new(81, 0xffff); + pub const SFR_GPIOOE_CRGOE1_CRGOE1: crate::Field = crate::Field::new(16, 0, SFR_GPIOOE_CRGOE1); + + pub const SFR_GPIOOE_CRGOE2: crate::Register = crate::Register::new(82, 0xffff); + pub const SFR_GPIOOE_CRGOE2_CRGOE2: crate::Field = crate::Field::new(16, 0, SFR_GPIOOE_CRGOE2); + + pub const SFR_GPIOOE_CRGOE3: crate::Register = crate::Register::new(83, 0xffff); + pub const SFR_GPIOOE_CRGOE3_CRGOE3: crate::Field = crate::Field::new(16, 0, SFR_GPIOOE_CRGOE3); + + pub const SFR_GPIOPU_CRGPU0: crate::Register = crate::Register::new(84, 0xffff); + pub const SFR_GPIOPU_CRGPU0_CRGPU0: crate::Field = crate::Field::new(16, 0, SFR_GPIOPU_CRGPU0); + + pub const SFR_GPIOPU_CRGPU1: crate::Register = crate::Register::new(85, 0xffff); + pub const SFR_GPIOPU_CRGPU1_CRGPU1: crate::Field = crate::Field::new(16, 0, SFR_GPIOPU_CRGPU1); + + pub const SFR_GPIOPU_CRGPU2: crate::Register = crate::Register::new(86, 0xffff); + pub const SFR_GPIOPU_CRGPU2_CRGPU2: crate::Field = crate::Field::new(16, 0, SFR_GPIOPU_CRGPU2); + + pub const SFR_GPIOPU_CRGPU3: crate::Register = crate::Register::new(87, 0xffff); + pub const SFR_GPIOPU_CRGPU3_CRGPU3: crate::Field = crate::Field::new(16, 0, SFR_GPIOPU_CRGPU3); + + pub const SFR_GPIOIN_SRGI0: crate::Register = crate::Register::new(88, 0xffff); + pub const SFR_GPIOIN_SRGI0_SRGI0: crate::Field = crate::Field::new(16, 0, SFR_GPIOIN_SRGI0); + + pub const SFR_GPIOIN_SRGI1: crate::Register = crate::Register::new(89, 0xffff); + pub const SFR_GPIOIN_SRGI1_SRGI1: crate::Field = crate::Field::new(16, 0, SFR_GPIOIN_SRGI1); + + pub const SFR_GPIOIN_SRGI2: crate::Register = crate::Register::new(90, 0xffff); + pub const SFR_GPIOIN_SRGI2_SRGI2: crate::Field = crate::Field::new(16, 0, SFR_GPIOIN_SRGI2); + + pub const SFR_GPIOIN_SRGI3: crate::Register = crate::Register::new(91, 0xffff); + pub const SFR_GPIOIN_SRGI3_SRGI3: crate::Field = crate::Field::new(16, 0, SFR_GPIOIN_SRGI3); + + pub const SFR_PIOSEL: crate::Register = crate::Register::new(128, 0xffffffff); + pub const SFR_PIOSEL_PIOSEL: crate::Field = crate::Field::new(32, 0, SFR_PIOSEL); + + pub const SFR_CFG_SCHM_CR_CFG_SCHMSEL0: crate::Register = crate::Register::new(140, 0xffff); + pub const SFR_CFG_SCHM_CR_CFG_SCHMSEL0_CR_CFG_SCHMSEL0: crate::Field = crate::Field::new(16, 0, SFR_CFG_SCHM_CR_CFG_SCHMSEL0); + + pub const SFR_CFG_SCHM_CR_CFG_SCHMSEL1: crate::Register = crate::Register::new(141, 0xffff); + pub const SFR_CFG_SCHM_CR_CFG_SCHMSEL1_CR_CFG_SCHMSEL1: crate::Field = crate::Field::new(16, 0, SFR_CFG_SCHM_CR_CFG_SCHMSEL1); + + pub const SFR_CFG_SCHM_CR_CFG_SCHMSEL2: crate::Register = crate::Register::new(142, 0xffff); + pub const SFR_CFG_SCHM_CR_CFG_SCHMSEL2_CR_CFG_SCHMSEL2: crate::Field = crate::Field::new(16, 0, SFR_CFG_SCHM_CR_CFG_SCHMSEL2); + + pub const SFR_CFG_SCHM_CR_CFG_SCHMSEL3: crate::Register = crate::Register::new(143, 0xffff); + pub const SFR_CFG_SCHM_CR_CFG_SCHMSEL3_CR_CFG_SCHMSEL3: crate::Field = crate::Field::new(16, 0, SFR_CFG_SCHM_CR_CFG_SCHMSEL3); + + pub const SFR_CFG_SLEW_CR_CFG_SLEWSLOW0: crate::Register = crate::Register::new(144, 0xffff); + pub const SFR_CFG_SLEW_CR_CFG_SLEWSLOW0_CR_CFG_SLEWSLOW0: crate::Field = crate::Field::new(16, 0, SFR_CFG_SLEW_CR_CFG_SLEWSLOW0); + + pub const SFR_CFG_SLEW_CR_CFG_SLEWSLOW1: crate::Register = crate::Register::new(145, 0xffff); + pub const SFR_CFG_SLEW_CR_CFG_SLEWSLOW1_CR_CFG_SLEWSLOW1: crate::Field = crate::Field::new(16, 0, SFR_CFG_SLEW_CR_CFG_SLEWSLOW1); + + pub const SFR_CFG_SLEW_CR_CFG_SLEWSLOW2: crate::Register = crate::Register::new(146, 0xffff); + pub const SFR_CFG_SLEW_CR_CFG_SLEWSLOW2_CR_CFG_SLEWSLOW2: crate::Field = crate::Field::new(16, 0, SFR_CFG_SLEW_CR_CFG_SLEWSLOW2); + + pub const SFR_CFG_SLEW_CR_CFG_SLEWSLOW3: crate::Register = crate::Register::new(147, 0xffff); + pub const SFR_CFG_SLEW_CR_CFG_SLEWSLOW3_CR_CFG_SLEWSLOW3: crate::Field = crate::Field::new(16, 0, SFR_CFG_SLEW_CR_CFG_SLEWSLOW3); + + pub const SFR_CFG_DRVSEL_CR_CFG_DRVSEL0: crate::Register = crate::Register::new(148, 0xffffffff); + pub const SFR_CFG_DRVSEL_CR_CFG_DRVSEL0_CR_CFG_DRVSEL0: crate::Field = crate::Field::new(32, 0, SFR_CFG_DRVSEL_CR_CFG_DRVSEL0); + + pub const SFR_CFG_DRVSEL_CR_CFG_DRVSEL1: crate::Register = crate::Register::new(149, 0xffffffff); + pub const SFR_CFG_DRVSEL_CR_CFG_DRVSEL1_CR_CFG_DRVSEL1: crate::Field = crate::Field::new(32, 0, SFR_CFG_DRVSEL_CR_CFG_DRVSEL1); + + pub const SFR_CFG_DRVSEL_CR_CFG_DRVSEL2: crate::Register = crate::Register::new(150, 0xffffffff); + pub const SFR_CFG_DRVSEL_CR_CFG_DRVSEL2_CR_CFG_DRVSEL2: crate::Field = crate::Field::new(32, 0, SFR_CFG_DRVSEL_CR_CFG_DRVSEL2); + + pub const SFR_CFG_DRVSEL_CR_CFG_DRVSEL3: crate::Register = crate::Register::new(151, 0xffffffff); + pub const SFR_CFG_DRVSEL_CR_CFG_DRVSEL3_CR_CFG_DRVSEL3: crate::Field = crate::Field::new(32, 0, SFR_CFG_DRVSEL_CR_CFG_DRVSEL3); + + pub const HW_IOX_BASE: usize = 0x5012f000; + } + + pub mod pwm { + pub const PWM_NUMREGS: usize = 0; + + pub const HW_PWM_BASE: usize = 0x50120000; + } + + pub mod sddc { + pub const SDDC_NUMREGS: usize = 112; + + pub const SFR_IO: crate::Register = crate::Register::new(0, 0x3); + pub const SFR_IO_SFR_IO: crate::Field = crate::Field::new(2, 0, SFR_IO); + + pub const SFR_AR: crate::Register = crate::Register::new(1, 0xffffffff); + pub const SFR_AR_SFR_AR: crate::Field = crate::Field::new(32, 0, SFR_AR); + + pub const CR_OCR: crate::Register = crate::Register::new(4, 0xffffff); + pub const CR_OCR_CR_OCR: crate::Field = crate::Field::new(24, 0, CR_OCR); + + pub const CR_RDFFTHRES: crate::Register = crate::Register::new(5, 0xff); + pub const CR_RDFFTHRES_CR_RDFFTHRES: crate::Field = crate::Field::new(8, 0, CR_RDFFTHRES); + + pub const CR_REV: crate::Register = crate::Register::new(6, 0xffff); + pub const CR_REV_CFG_REG_SD_SPEC_REVISION: crate::Field = crate::Field::new(8, 0, CR_REV); + pub const CR_REV_CFG_REG_CCCR_SDIO_REVISION: crate::Field = crate::Field::new(8, 8, CR_REV); + + pub const CR_BACSA: crate::Register = crate::Register::new(7, 0x3ffff); + pub const CR_BACSA_CFG_BASE_ADDR_CSA: crate::Field = crate::Field::new(18, 0, CR_BACSA); + + pub const CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC0: crate::Register = crate::Register::new(8, 0x3ffff); + pub const CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC0_CFG_BASE_ADDR_IO_FUNC0: crate::Field = crate::Field::new(18, 0, CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC0); + + pub const CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC1: crate::Register = crate::Register::new(9, 0x3ffff); + pub const CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC1_CFG_BASE_ADDR_IO_FUNC1: crate::Field = crate::Field::new(18, 0, CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC1); + + pub const CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC2: crate::Register = crate::Register::new(10, 0x3ffff); + pub const CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC2_CFG_BASE_ADDR_IO_FUNC2: crate::Field = crate::Field::new(18, 0, CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC2); + + pub const CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC3: crate::Register = crate::Register::new(11, 0x3ffff); + pub const CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC3_CFG_BASE_ADDR_IO_FUNC3: crate::Field = crate::Field::new(18, 0, CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC3); + + pub const CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC4: crate::Register = crate::Register::new(12, 0x3ffff); + pub const CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC4_CFG_BASE_ADDR_IO_FUNC4: crate::Field = crate::Field::new(18, 0, CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC4); + + pub const CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC5: crate::Register = crate::Register::new(13, 0x3ffff); + pub const CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC5_CFG_BASE_ADDR_IO_FUNC5: crate::Field = crate::Field::new(18, 0, CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC5); + + pub const CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC6: crate::Register = crate::Register::new(14, 0x3ffff); + pub const CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC6_CFG_BASE_ADDR_IO_FUNC6: crate::Field = crate::Field::new(18, 0, CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC6); + + pub const CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC7: crate::Register = crate::Register::new(15, 0x3ffff); + pub const CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC7_CFG_BASE_ADDR_IO_FUNC7: crate::Field = crate::Field::new(18, 0, CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC7); + + pub const CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR0: crate::Register = crate::Register::new(16, 0x1ffff); + pub const CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR0_CFG_REG_FUNC_CIS_PTR0: crate::Field = crate::Field::new(17, 0, CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR0); + + pub const CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR1: crate::Register = crate::Register::new(17, 0x1ffff); + pub const CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR1_CFG_REG_FUNC_CIS_PTR1: crate::Field = crate::Field::new(17, 0, CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR1); + + pub const CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR2: crate::Register = crate::Register::new(18, 0x1ffff); + pub const CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR2_CFG_REG_FUNC_CIS_PTR2: crate::Field = crate::Field::new(17, 0, CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR2); + + pub const CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR3: crate::Register = crate::Register::new(19, 0x1ffff); + pub const CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR3_CFG_REG_FUNC_CIS_PTR3: crate::Field = crate::Field::new(17, 0, CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR3); + + pub const CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR4: crate::Register = crate::Register::new(20, 0x1ffff); + pub const CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR4_CFG_REG_FUNC_CIS_PTR4: crate::Field = crate::Field::new(17, 0, CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR4); + + pub const CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR5: crate::Register = crate::Register::new(21, 0x1ffff); + pub const CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR5_CFG_REG_FUNC_CIS_PTR5: crate::Field = crate::Field::new(17, 0, CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR5); + + pub const CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR6: crate::Register = crate::Register::new(22, 0x1ffff); + pub const CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR6_CFG_REG_FUNC_CIS_PTR6: crate::Field = crate::Field::new(17, 0, CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR6); + + pub const CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR7: crate::Register = crate::Register::new(23, 0x1ffff); + pub const CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR7_CFG_REG_FUNC_CIS_PTR7: crate::Field = crate::Field::new(17, 0, CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR7); + + pub const CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE0: crate::Register = crate::Register::new(24, 0xff); + pub const CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE0_CFG_REG_FUNC_EXT_STD_CODE0: crate::Field = crate::Field::new(8, 0, CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE0); + + pub const CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE1: crate::Register = crate::Register::new(25, 0xff); + pub const CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE1_CFG_REG_FUNC_EXT_STD_CODE1: crate::Field = crate::Field::new(8, 0, CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE1); + + pub const CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE2: crate::Register = crate::Register::new(26, 0xff); + pub const CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE2_CFG_REG_FUNC_EXT_STD_CODE2: crate::Field = crate::Field::new(8, 0, CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE2); + + pub const CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE3: crate::Register = crate::Register::new(27, 0xff); + pub const CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE3_CFG_REG_FUNC_EXT_STD_CODE3: crate::Field = crate::Field::new(8, 0, CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE3); + + pub const CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE4: crate::Register = crate::Register::new(28, 0xff); + pub const CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE4_CFG_REG_FUNC_EXT_STD_CODE4: crate::Field = crate::Field::new(8, 0, CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE4); + + pub const CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE5: crate::Register = crate::Register::new(29, 0xff); + pub const CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE5_CFG_REG_FUNC_EXT_STD_CODE5: crate::Field = crate::Field::new(8, 0, CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE5); + + pub const CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE6: crate::Register = crate::Register::new(30, 0xff); + pub const CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE6_CFG_REG_FUNC_EXT_STD_CODE6: crate::Field = crate::Field::new(8, 0, CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE6); + + pub const CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE7: crate::Register = crate::Register::new(31, 0xff); + pub const CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE7_CFG_REG_FUNC_EXT_STD_CODE7: crate::Field = crate::Field::new(8, 0, CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE7); + + pub const CR_WRITE_PROTECT: crate::Register = crate::Register::new(32, 0x1); + pub const CR_WRITE_PROTECT_CR_WRITE_PROTECT: crate::Field = crate::Field::new(1, 0, CR_WRITE_PROTECT); + + pub const CR_REG_DSR: crate::Register = crate::Register::new(33, 0xffff); + pub const CR_REG_DSR_CR_REG_DSR: crate::Field = crate::Field::new(16, 0, CR_REG_DSR); + + pub const CR_REG_CID_CFG_REG_CID0: crate::Register = crate::Register::new(34, 0xffffffff); + pub const CR_REG_CID_CFG_REG_CID0_CFG_REG_CID0: crate::Field = crate::Field::new(32, 0, CR_REG_CID_CFG_REG_CID0); + + pub const CR_REG_CID_CFG_REG_CID1: crate::Register = crate::Register::new(35, 0xffffffff); + pub const CR_REG_CID_CFG_REG_CID1_CFG_REG_CID1: crate::Field = crate::Field::new(32, 0, CR_REG_CID_CFG_REG_CID1); + + pub const CR_REG_CID_CFG_REG_CID2: crate::Register = crate::Register::new(36, 0xffffffff); + pub const CR_REG_CID_CFG_REG_CID2_CFG_REG_CID2: crate::Field = crate::Field::new(32, 0, CR_REG_CID_CFG_REG_CID2); + + pub const CR_REG_CID_CFG_REG_CID3: crate::Register = crate::Register::new(37, 0xffffffff); + pub const CR_REG_CID_CFG_REG_CID3_CFG_REG_CID3: crate::Field = crate::Field::new(32, 0, CR_REG_CID_CFG_REG_CID3); + + pub const CR_REG_CSD_CFG_REG_CSD0: crate::Register = crate::Register::new(38, 0xffffffff); + pub const CR_REG_CSD_CFG_REG_CSD0_CFG_REG_CSD0: crate::Field = crate::Field::new(32, 0, CR_REG_CSD_CFG_REG_CSD0); + + pub const CR_REG_CSD_CFG_REG_CSD1: crate::Register = crate::Register::new(39, 0xffffffff); + pub const CR_REG_CSD_CFG_REG_CSD1_CFG_REG_CSD1: crate::Field = crate::Field::new(32, 0, CR_REG_CSD_CFG_REG_CSD1); + + pub const CR_REG_CSD_CFG_REG_CSD2: crate::Register = crate::Register::new(40, 0xffffffff); + pub const CR_REG_CSD_CFG_REG_CSD2_CFG_REG_CSD2: crate::Field = crate::Field::new(32, 0, CR_REG_CSD_CFG_REG_CSD2); + + pub const CR_REG_CSD_CFG_REG_CSD3: crate::Register = crate::Register::new(41, 0xffffffff); + pub const CR_REG_CSD_CFG_REG_CSD3_CFG_REG_CSD3: crate::Field = crate::Field::new(32, 0, CR_REG_CSD_CFG_REG_CSD3); + + pub const CR_REG_SCR_CFG_REG_SCR0: crate::Register = crate::Register::new(42, 0xffffffff); + pub const CR_REG_SCR_CFG_REG_SCR0_CFG_REG_SCR0: crate::Field = crate::Field::new(32, 0, CR_REG_SCR_CFG_REG_SCR0); + + pub const CR_REG_SCR_CFG_REG_SCR1: crate::Register = crate::Register::new(43, 0xffffffff); + pub const CR_REG_SCR_CFG_REG_SCR1_CFG_REG_SCR1: crate::Field = crate::Field::new(32, 0, CR_REG_SCR_CFG_REG_SCR1); + + pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS0: crate::Register = crate::Register::new(44, 0xffffffff); + pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS0_CFG_REG_SD_STATUS0: crate::Field = crate::Field::new(32, 0, CR_REG_SD_STATUS_CFG_REG_SD_STATUS0); + + pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS1: crate::Register = crate::Register::new(45, 0xffffffff); + pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS1_CFG_REG_SD_STATUS1: crate::Field = crate::Field::new(32, 0, CR_REG_SD_STATUS_CFG_REG_SD_STATUS1); + + pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS2: crate::Register = crate::Register::new(46, 0xffffffff); + pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS2_CFG_REG_SD_STATUS2: crate::Field = crate::Field::new(32, 0, CR_REG_SD_STATUS_CFG_REG_SD_STATUS2); + + pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS3: crate::Register = crate::Register::new(47, 0xffffffff); + pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS3_CFG_REG_SD_STATUS3: crate::Field = crate::Field::new(32, 0, CR_REG_SD_STATUS_CFG_REG_SD_STATUS3); + + pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS4: crate::Register = crate::Register::new(48, 0xffffffff); + pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS4_CFG_REG_SD_STATUS4: crate::Field = crate::Field::new(32, 0, CR_REG_SD_STATUS_CFG_REG_SD_STATUS4); + + pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS5: crate::Register = crate::Register::new(49, 0xffffffff); + pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS5_CFG_REG_SD_STATUS5: crate::Field = crate::Field::new(32, 0, CR_REG_SD_STATUS_CFG_REG_SD_STATUS5); + + pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS6: crate::Register = crate::Register::new(50, 0xffffffff); + pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS6_CFG_REG_SD_STATUS6: crate::Field = crate::Field::new(32, 0, CR_REG_SD_STATUS_CFG_REG_SD_STATUS6); + + pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS7: crate::Register = crate::Register::new(51, 0xffffffff); + pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS7_CFG_REG_SD_STATUS7: crate::Field = crate::Field::new(32, 0, CR_REG_SD_STATUS_CFG_REG_SD_STATUS7); + + pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS8: crate::Register = crate::Register::new(52, 0xffffffff); + pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS8_CFG_REG_SD_STATUS8: crate::Field = crate::Field::new(32, 0, CR_REG_SD_STATUS_CFG_REG_SD_STATUS8); + + pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS9: crate::Register = crate::Register::new(53, 0xffffffff); + pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS9_CFG_REG_SD_STATUS9: crate::Field = crate::Field::new(32, 0, CR_REG_SD_STATUS_CFG_REG_SD_STATUS9); + + pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS10: crate::Register = crate::Register::new(54, 0xffffffff); + pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS10_CFG_REG_SD_STATUS10: crate::Field = crate::Field::new(32, 0, CR_REG_SD_STATUS_CFG_REG_SD_STATUS10); + + pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS11: crate::Register = crate::Register::new(55, 0xffffffff); + pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS11_CFG_REG_SD_STATUS11: crate::Field = crate::Field::new(32, 0, CR_REG_SD_STATUS_CFG_REG_SD_STATUS11); + + pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS12: crate::Register = crate::Register::new(56, 0xffffffff); + pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS12_CFG_REG_SD_STATUS12: crate::Field = crate::Field::new(32, 0, CR_REG_SD_STATUS_CFG_REG_SD_STATUS12); + + pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS13: crate::Register = crate::Register::new(57, 0xffffffff); + pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS13_CFG_REG_SD_STATUS13: crate::Field = crate::Field::new(32, 0, CR_REG_SD_STATUS_CFG_REG_SD_STATUS13); + + pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS14: crate::Register = crate::Register::new(58, 0xffffffff); + pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS14_CFG_REG_SD_STATUS14: crate::Field = crate::Field::new(32, 0, CR_REG_SD_STATUS_CFG_REG_SD_STATUS14); + + pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS15: crate::Register = crate::Register::new(59, 0xffffffff); + pub const CR_REG_SD_STATUS_CFG_REG_SD_STATUS15_CFG_REG_SD_STATUS15: crate::Field = crate::Field::new(32, 0, CR_REG_SD_STATUS_CFG_REG_SD_STATUS15); + + pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC0: crate::Register = crate::Register::new(64, 0x3ffff); + pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC0_CFG_BASE_ADDR_MEM_FUNC0: crate::Field = crate::Field::new(18, 0, CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC0); + + pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC1: crate::Register = crate::Register::new(65, 0x3ffff); + pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC1_CFG_BASE_ADDR_MEM_FUNC1: crate::Field = crate::Field::new(18, 0, CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC1); + + pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC2: crate::Register = crate::Register::new(66, 0x3ffff); + pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC2_CFG_BASE_ADDR_MEM_FUNC2: crate::Field = crate::Field::new(18, 0, CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC2); + + pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC3: crate::Register = crate::Register::new(67, 0x3ffff); + pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC3_CFG_BASE_ADDR_MEM_FUNC3: crate::Field = crate::Field::new(18, 0, CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC3); + + pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC4: crate::Register = crate::Register::new(68, 0x3ffff); + pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC4_CFG_BASE_ADDR_MEM_FUNC4: crate::Field = crate::Field::new(18, 0, CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC4); + + pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC5: crate::Register = crate::Register::new(69, 0x3ffff); + pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC5_CFG_BASE_ADDR_MEM_FUNC5: crate::Field = crate::Field::new(18, 0, CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC5); + + pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC6: crate::Register = crate::Register::new(70, 0x3ffff); + pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC6_CFG_BASE_ADDR_MEM_FUNC6: crate::Field = crate::Field::new(18, 0, CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC6); + + pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC7: crate::Register = crate::Register::new(71, 0x3ffff); + pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC7_CFG_BASE_ADDR_MEM_FUNC7: crate::Field = crate::Field::new(18, 0, CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC7); + + pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC8: crate::Register = crate::Register::new(72, 0x3ffff); + pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC8_CFG_BASE_ADDR_MEM_FUNC8: crate::Field = crate::Field::new(18, 0, CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC8); + + pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC9: crate::Register = crate::Register::new(73, 0x3ffff); + pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC9_CFG_BASE_ADDR_MEM_FUNC9: crate::Field = crate::Field::new(18, 0, CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC9); + + pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC10: crate::Register = crate::Register::new(74, 0x3ffff); + pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC10_CFG_BASE_ADDR_MEM_FUNC10: crate::Field = crate::Field::new(18, 0, CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC10); + + pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC11: crate::Register = crate::Register::new(75, 0x3ffff); + pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC11_CFG_BASE_ADDR_MEM_FUNC11: crate::Field = crate::Field::new(18, 0, CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC11); + + pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC12: crate::Register = crate::Register::new(76, 0x3ffff); + pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC12_CFG_BASE_ADDR_MEM_FUNC12: crate::Field = crate::Field::new(18, 0, CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC12); + + pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC13: crate::Register = crate::Register::new(77, 0x3ffff); + pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC13_CFG_BASE_ADDR_MEM_FUNC13: crate::Field = crate::Field::new(18, 0, CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC13); + + pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC14: crate::Register = crate::Register::new(78, 0x3ffff); + pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC14_CFG_BASE_ADDR_MEM_FUNC14: crate::Field = crate::Field::new(18, 0, CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC14); + + pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC15: crate::Register = crate::Register::new(79, 0x3ffff); + pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC15_CFG_BASE_ADDR_MEM_FUNC15: crate::Field = crate::Field::new(18, 0, CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC15); + + pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC16: crate::Register = crate::Register::new(80, 0x3ffff); + pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC16_CFG_BASE_ADDR_MEM_FUNC16: crate::Field = crate::Field::new(18, 0, CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC16); + + pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC17: crate::Register = crate::Register::new(81, 0x3ffff); + pub const CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC17_CFG_BASE_ADDR_MEM_FUNC17: crate::Field = crate::Field::new(18, 0, CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC17); + + pub const CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE0: crate::Register = crate::Register::new(82, 0xff); + pub const CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE0_CFG_REG_FUNC_ISDIO_INTERFACE_CODE0: crate::Field = crate::Field::new(8, 0, CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE0); + + pub const CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE1: crate::Register = crate::Register::new(83, 0xff); + pub const CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE1_CFG_REG_FUNC_ISDIO_INTERFACE_CODE1: crate::Field = crate::Field::new(8, 0, CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE1); + + pub const CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE2: crate::Register = crate::Register::new(84, 0xff); + pub const CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE2_CFG_REG_FUNC_ISDIO_INTERFACE_CODE2: crate::Field = crate::Field::new(8, 0, CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE2); + + pub const CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE3: crate::Register = crate::Register::new(85, 0xff); + pub const CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE3_CFG_REG_FUNC_ISDIO_INTERFACE_CODE3: crate::Field = crate::Field::new(8, 0, CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE3); + + pub const CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE4: crate::Register = crate::Register::new(86, 0xff); + pub const CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE4_CFG_REG_FUNC_ISDIO_INTERFACE_CODE4: crate::Field = crate::Field::new(8, 0, CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE4); + + pub const CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE5: crate::Register = crate::Register::new(87, 0xff); + pub const CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE5_CFG_REG_FUNC_ISDIO_INTERFACE_CODE5: crate::Field = crate::Field::new(8, 0, CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE5); + + pub const CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE6: crate::Register = crate::Register::new(88, 0xff); + pub const CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE6_CFG_REG_FUNC_ISDIO_INTERFACE_CODE6: crate::Field = crate::Field::new(8, 0, CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE6); + + pub const CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE0: crate::Register = crate::Register::new(90, 0xffff); + pub const CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE0_CFG_REG_FUNC_MANUFACT_CODE0: crate::Field = crate::Field::new(16, 0, CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE0); + + pub const CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE1: crate::Register = crate::Register::new(91, 0xffff); + pub const CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE1_CFG_REG_FUNC_MANUFACT_CODE1: crate::Field = crate::Field::new(16, 0, CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE1); + + pub const CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE2: crate::Register = crate::Register::new(92, 0xffff); + pub const CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE2_CFG_REG_FUNC_MANUFACT_CODE2: crate::Field = crate::Field::new(16, 0, CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE2); + + pub const CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE3: crate::Register = crate::Register::new(93, 0xffff); + pub const CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE3_CFG_REG_FUNC_MANUFACT_CODE3: crate::Field = crate::Field::new(16, 0, CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE3); + + pub const CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE4: crate::Register = crate::Register::new(94, 0xffff); + pub const CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE4_CFG_REG_FUNC_MANUFACT_CODE4: crate::Field = crate::Field::new(16, 0, CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE4); + + pub const CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE5: crate::Register = crate::Register::new(95, 0xffff); + pub const CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE5_CFG_REG_FUNC_MANUFACT_CODE5: crate::Field = crate::Field::new(16, 0, CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE5); + + pub const CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE6: crate::Register = crate::Register::new(96, 0xffff); + pub const CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE6_CFG_REG_FUNC_MANUFACT_CODE6: crate::Field = crate::Field::new(16, 0, CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE6); + + pub const CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO0: crate::Register = crate::Register::new(98, 0xffff); + pub const CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO0_CFG_REG_FUNC_MANUFACT_INFO0: crate::Field = crate::Field::new(16, 0, CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO0); + + pub const CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO1: crate::Register = crate::Register::new(99, 0xffff); + pub const CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO1_CFG_REG_FUNC_MANUFACT_INFO1: crate::Field = crate::Field::new(16, 0, CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO1); + + pub const CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO2: crate::Register = crate::Register::new(100, 0xffff); + pub const CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO2_CFG_REG_FUNC_MANUFACT_INFO2: crate::Field = crate::Field::new(16, 0, CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO2); + + pub const CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO3: crate::Register = crate::Register::new(101, 0xffff); + pub const CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO3_CFG_REG_FUNC_MANUFACT_INFO3: crate::Field = crate::Field::new(16, 0, CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO3); + + pub const CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO4: crate::Register = crate::Register::new(102, 0xffff); + pub const CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO4_CFG_REG_FUNC_MANUFACT_INFO4: crate::Field = crate::Field::new(16, 0, CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO4); + + pub const CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO5: crate::Register = crate::Register::new(103, 0xffff); + pub const CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO5_CFG_REG_FUNC_MANUFACT_INFO5: crate::Field = crate::Field::new(16, 0, CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO5); + + pub const CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO6: crate::Register = crate::Register::new(104, 0xffff); + pub const CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO6_CFG_REG_FUNC_MANUFACT_INFO6: crate::Field = crate::Field::new(16, 0, CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO6); + + pub const CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE0: crate::Register = crate::Register::new(106, 0xff); + pub const CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE0_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE0: crate::Field = crate::Field::new(8, 0, CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE0); + + pub const CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE1: crate::Register = crate::Register::new(107, 0xff); + pub const CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE1_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE1: crate::Field = crate::Field::new(8, 0, CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE1); + + pub const CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE2: crate::Register = crate::Register::new(108, 0xff); + pub const CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE2_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE2: crate::Field = crate::Field::new(8, 0, CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE2); + + pub const CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE3: crate::Register = crate::Register::new(109, 0xff); + pub const CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE3_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE3: crate::Field = crate::Field::new(8, 0, CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE3); + + pub const CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE4: crate::Register = crate::Register::new(110, 0xff); + pub const CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE4_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE4: crate::Field = crate::Field::new(8, 0, CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE4); + + pub const CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE5: crate::Register = crate::Register::new(111, 0xff); + pub const CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE5_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE5: crate::Field = crate::Field::new(8, 0, CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE5); + + pub const CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE6: crate::Register = crate::Register::new(112, 0xff); + pub const CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE6_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE6: crate::Field = crate::Field::new(8, 0, CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE6); + + pub const CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO0: crate::Register = crate::Register::new(114, 0xffff); + pub const CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO0_CFG_REG_FUNC_INFO0: crate::Field = crate::Field::new(16, 0, CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO0); + + pub const CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO1: crate::Register = crate::Register::new(115, 0xffff); + pub const CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO1_CFG_REG_FUNC_INFO1: crate::Field = crate::Field::new(16, 0, CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO1); + + pub const CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO2: crate::Register = crate::Register::new(116, 0xffff); + pub const CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO2_CFG_REG_FUNC_INFO2: crate::Field = crate::Field::new(16, 0, CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO2); + + pub const CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO3: crate::Register = crate::Register::new(117, 0xffff); + pub const CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO3_CFG_REG_FUNC_INFO3: crate::Field = crate::Field::new(16, 0, CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO3); + + pub const CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO4: crate::Register = crate::Register::new(118, 0xffff); + pub const CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO4_CFG_REG_FUNC_INFO4: crate::Field = crate::Field::new(16, 0, CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO4); + + pub const CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO5: crate::Register = crate::Register::new(119, 0xffff); + pub const CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO5_CFG_REG_FUNC_INFO5: crate::Field = crate::Field::new(16, 0, CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO5); + + pub const CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO6: crate::Register = crate::Register::new(120, 0xffff); + pub const CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO6_CFG_REG_FUNC_INFO6: crate::Field = crate::Field::new(16, 0, CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO6); + + pub const CR_REG_UHS_1_SUPPORT: crate::Register = crate::Register::new(124, 0xffffffff); + pub const CR_REG_UHS_1_SUPPORT_CFG_REG_MAX_CURRENT: crate::Field = crate::Field::new(16, 0, CR_REG_UHS_1_SUPPORT); + pub const CR_REG_UHS_1_SUPPORT_CFG_REG_DATA_STRC_VERSION: crate::Field = crate::Field::new(8, 16, CR_REG_UHS_1_SUPPORT); + pub const CR_REG_UHS_1_SUPPORT_CFG_REG_UHS_1_SUPPORT: crate::Field = crate::Field::new(8, 24, CR_REG_UHS_1_SUPPORT); + + pub const HW_SDDC_BASE: usize = 0x50121000; + } + + pub mod rp_pio { + pub const RP_PIO_NUMREGS: usize = 89; + + pub const SFR_CTRL: crate::Register = crate::Register::new(0, 0xfff); + pub const SFR_CTRL_EN: crate::Field = crate::Field::new(4, 0, SFR_CTRL); + pub const SFR_CTRL_RESTART: crate::Field = crate::Field::new(4, 4, SFR_CTRL); + pub const SFR_CTRL_CLKDIV_RESTART: crate::Field = crate::Field::new(4, 8, SFR_CTRL); + + pub const SFR_FSTAT: crate::Register = crate::Register::new(1, 0xffffffff); + pub const SFR_FSTAT_RX_FULL: crate::Field = crate::Field::new(4, 0, SFR_FSTAT); + pub const SFR_FSTAT_CONSTANT0: crate::Field = crate::Field::new(4, 4, SFR_FSTAT); + pub const SFR_FSTAT_RX_EMPTY: crate::Field = crate::Field::new(4, 8, SFR_FSTAT); + pub const SFR_FSTAT_CONSTANT1: crate::Field = crate::Field::new(4, 12, SFR_FSTAT); + pub const SFR_FSTAT_TX_FULL: crate::Field = crate::Field::new(4, 16, SFR_FSTAT); + pub const SFR_FSTAT_CONSTANT2: crate::Field = crate::Field::new(4, 20, SFR_FSTAT); + pub const SFR_FSTAT_TX_EMPTY: crate::Field = crate::Field::new(4, 24, SFR_FSTAT); + pub const SFR_FSTAT_CONSTANT3: crate::Field = crate::Field::new(4, 28, SFR_FSTAT); + + pub const SFR_FDEBUG: crate::Register = crate::Register::new(2, 0xffffffff); + pub const SFR_FDEBUG_RXSTALL: crate::Field = crate::Field::new(4, 0, SFR_FDEBUG); + pub const SFR_FDEBUG_NC_DBG3: crate::Field = crate::Field::new(4, 4, SFR_FDEBUG); + pub const SFR_FDEBUG_RXUNDER: crate::Field = crate::Field::new(4, 8, SFR_FDEBUG); + pub const SFR_FDEBUG_NC_DBG2: crate::Field = crate::Field::new(4, 12, SFR_FDEBUG); + pub const SFR_FDEBUG_TXOVER: crate::Field = crate::Field::new(4, 16, SFR_FDEBUG); + pub const SFR_FDEBUG_NC_DBG1: crate::Field = crate::Field::new(4, 20, SFR_FDEBUG); + pub const SFR_FDEBUG_TXSTALL: crate::Field = crate::Field::new(4, 24, SFR_FDEBUG); + pub const SFR_FDEBUG_NC_DBG0: crate::Field = crate::Field::new(4, 28, SFR_FDEBUG); + + pub const SFR_FLEVEL: crate::Register = crate::Register::new(3, 0xffffffff); + pub const SFR_FLEVEL_TX_LEVEL0: crate::Field = crate::Field::new(3, 0, SFR_FLEVEL); + pub const SFR_FLEVEL_CONSTANT0: crate::Field = crate::Field::new(1, 3, SFR_FLEVEL); + pub const SFR_FLEVEL_RX_LEVEL0: crate::Field = crate::Field::new(3, 4, SFR_FLEVEL); + pub const SFR_FLEVEL_CONSTANT1: crate::Field = crate::Field::new(1, 7, SFR_FLEVEL); + pub const SFR_FLEVEL_TX_LEVEL1: crate::Field = crate::Field::new(3, 8, SFR_FLEVEL); + pub const SFR_FLEVEL_CONSTANT2: crate::Field = crate::Field::new(1, 11, SFR_FLEVEL); + pub const SFR_FLEVEL_RX_LEVEL1: crate::Field = crate::Field::new(3, 12, SFR_FLEVEL); + pub const SFR_FLEVEL_CONSTANT3: crate::Field = crate::Field::new(1, 15, SFR_FLEVEL); + pub const SFR_FLEVEL_TX_LEVEL2: crate::Field = crate::Field::new(3, 16, SFR_FLEVEL); + pub const SFR_FLEVEL_CONSTANT4: crate::Field = crate::Field::new(1, 19, SFR_FLEVEL); + pub const SFR_FLEVEL_RX_LEVEL2: crate::Field = crate::Field::new(3, 20, SFR_FLEVEL); + pub const SFR_FLEVEL_CONSTANT5: crate::Field = crate::Field::new(1, 23, SFR_FLEVEL); + pub const SFR_FLEVEL_TX_LEVEL3: crate::Field = crate::Field::new(3, 24, SFR_FLEVEL); + pub const SFR_FLEVEL_CONSTANT6: crate::Field = crate::Field::new(1, 27, SFR_FLEVEL); + pub const SFR_FLEVEL_RX_LEVEL3: crate::Field = crate::Field::new(3, 28, SFR_FLEVEL); + pub const SFR_FLEVEL_CONSTANT7: crate::Field = crate::Field::new(1, 31, SFR_FLEVEL); + + pub const SFR_TXF0: crate::Register = crate::Register::new(4, 0xffffffff); + pub const SFR_TXF0_FDIN: crate::Field = crate::Field::new(32, 0, SFR_TXF0); + + pub const SFR_TXF1: crate::Register = crate::Register::new(5, 0xffffffff); + pub const SFR_TXF1_FDIN: crate::Field = crate::Field::new(32, 0, SFR_TXF1); + + pub const SFR_TXF2: crate::Register = crate::Register::new(6, 0xffffffff); + pub const SFR_TXF2_FDIN: crate::Field = crate::Field::new(32, 0, SFR_TXF2); + + pub const SFR_TXF3: crate::Register = crate::Register::new(7, 0xffffffff); + pub const SFR_TXF3_FDIN: crate::Field = crate::Field::new(32, 0, SFR_TXF3); + + pub const SFR_RXF0: crate::Register = crate::Register::new(8, 0xffffffff); + pub const SFR_RXF0_PDOUT: crate::Field = crate::Field::new(32, 0, SFR_RXF0); + + pub const SFR_RXF1: crate::Register = crate::Register::new(9, 0xffffffff); + pub const SFR_RXF1_PDOUT: crate::Field = crate::Field::new(32, 0, SFR_RXF1); + + pub const SFR_RXF2: crate::Register = crate::Register::new(10, 0xffffffff); + pub const SFR_RXF2_PDOUT: crate::Field = crate::Field::new(32, 0, SFR_RXF2); + + pub const SFR_RXF3: crate::Register = crate::Register::new(11, 0xffffffff); + pub const SFR_RXF3_PDOUT: crate::Field = crate::Field::new(32, 0, SFR_RXF3); + + pub const SFR_IRQ: crate::Register = crate::Register::new(12, 0xff); + pub const SFR_IRQ_SFR_IRQ: crate::Field = crate::Field::new(8, 0, SFR_IRQ); + + pub const SFR_IRQ_FORCE: crate::Register = crate::Register::new(13, 0xff); + pub const SFR_IRQ_FORCE_SFR_IRQ_FORCE: crate::Field = crate::Field::new(8, 0, SFR_IRQ_FORCE); + + pub const SFR_SYNC_BYPASS: crate::Register = crate::Register::new(14, 0xffffffff); + pub const SFR_SYNC_BYPASS_SFR_SYNC_BYPASS: crate::Field = crate::Field::new(32, 0, SFR_SYNC_BYPASS); + + pub const SFR_DBG_PADOUT: crate::Register = crate::Register::new(15, 0xffffffff); + pub const SFR_DBG_PADOUT_SFR_DBG_PADOUT: crate::Field = crate::Field::new(32, 0, SFR_DBG_PADOUT); + + pub const SFR_DBG_PADOE: crate::Register = crate::Register::new(16, 0xffffffff); + pub const SFR_DBG_PADOE_SFR_DBG_PADOE: crate::Field = crate::Field::new(32, 0, SFR_DBG_PADOE); + + pub const SFR_DBG_CFGINFO: crate::Register = crate::Register::new(17, 0xffffffff); + pub const SFR_DBG_CFGINFO_CONSTANT0: crate::Field = crate::Field::new(8, 0, SFR_DBG_CFGINFO); + pub const SFR_DBG_CFGINFO_CONSTANT1: crate::Field = crate::Field::new(8, 8, SFR_DBG_CFGINFO); + pub const SFR_DBG_CFGINFO_CONSTANT2: crate::Field = crate::Field::new(16, 16, SFR_DBG_CFGINFO); + + pub const SFR_INSTR_MEM0: crate::Register = crate::Register::new(18, 0xffff); + pub const SFR_INSTR_MEM0_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM0); + + pub const SFR_INSTR_MEM1: crate::Register = crate::Register::new(19, 0xffff); + pub const SFR_INSTR_MEM1_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM1); + + pub const SFR_INSTR_MEM2: crate::Register = crate::Register::new(20, 0xffff); + pub const SFR_INSTR_MEM2_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM2); + + pub const SFR_INSTR_MEM3: crate::Register = crate::Register::new(21, 0xffff); + pub const SFR_INSTR_MEM3_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM3); + + pub const SFR_INSTR_MEM4: crate::Register = crate::Register::new(22, 0xffff); + pub const SFR_INSTR_MEM4_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM4); + + pub const SFR_INSTR_MEM5: crate::Register = crate::Register::new(23, 0xffff); + pub const SFR_INSTR_MEM5_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM5); + + pub const SFR_INSTR_MEM6: crate::Register = crate::Register::new(24, 0xffff); + pub const SFR_INSTR_MEM6_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM6); + + pub const SFR_INSTR_MEM7: crate::Register = crate::Register::new(25, 0xffff); + pub const SFR_INSTR_MEM7_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM7); + + pub const SFR_INSTR_MEM8: crate::Register = crate::Register::new(26, 0xffff); + pub const SFR_INSTR_MEM8_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM8); + + pub const SFR_INSTR_MEM9: crate::Register = crate::Register::new(27, 0xffff); + pub const SFR_INSTR_MEM9_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM9); + + pub const SFR_INSTR_MEM10: crate::Register = crate::Register::new(28, 0xffff); + pub const SFR_INSTR_MEM10_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM10); + + pub const SFR_INSTR_MEM11: crate::Register = crate::Register::new(29, 0xffff); + pub const SFR_INSTR_MEM11_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM11); + + pub const SFR_INSTR_MEM12: crate::Register = crate::Register::new(30, 0xffff); + pub const SFR_INSTR_MEM12_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM12); + + pub const SFR_INSTR_MEM13: crate::Register = crate::Register::new(31, 0xffff); + pub const SFR_INSTR_MEM13_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM13); + + pub const SFR_INSTR_MEM14: crate::Register = crate::Register::new(32, 0xffff); + pub const SFR_INSTR_MEM14_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM14); + + pub const SFR_INSTR_MEM15: crate::Register = crate::Register::new(33, 0xffff); + pub const SFR_INSTR_MEM15_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM15); + + pub const SFR_INSTR_MEM16: crate::Register = crate::Register::new(34, 0xffff); + pub const SFR_INSTR_MEM16_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM16); + + pub const SFR_INSTR_MEM17: crate::Register = crate::Register::new(35, 0xffff); + pub const SFR_INSTR_MEM17_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM17); + + pub const SFR_INSTR_MEM18: crate::Register = crate::Register::new(36, 0xffff); + pub const SFR_INSTR_MEM18_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM18); + + pub const SFR_INSTR_MEM19: crate::Register = crate::Register::new(37, 0xffff); + pub const SFR_INSTR_MEM19_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM19); + + pub const SFR_INSTR_MEM20: crate::Register = crate::Register::new(38, 0xffff); + pub const SFR_INSTR_MEM20_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM20); + + pub const SFR_INSTR_MEM21: crate::Register = crate::Register::new(39, 0xffff); + pub const SFR_INSTR_MEM21_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM21); + + pub const SFR_INSTR_MEM22: crate::Register = crate::Register::new(40, 0xffff); + pub const SFR_INSTR_MEM22_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM22); + + pub const SFR_INSTR_MEM23: crate::Register = crate::Register::new(41, 0xffff); + pub const SFR_INSTR_MEM23_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM23); + + pub const SFR_INSTR_MEM24: crate::Register = crate::Register::new(42, 0xffff); + pub const SFR_INSTR_MEM24_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM24); + + pub const SFR_INSTR_MEM25: crate::Register = crate::Register::new(43, 0xffff); + pub const SFR_INSTR_MEM25_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM25); + + pub const SFR_INSTR_MEM26: crate::Register = crate::Register::new(44, 0xffff); + pub const SFR_INSTR_MEM26_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM26); + + pub const SFR_INSTR_MEM27: crate::Register = crate::Register::new(45, 0xffff); + pub const SFR_INSTR_MEM27_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM27); + + pub const SFR_INSTR_MEM28: crate::Register = crate::Register::new(46, 0xffff); + pub const SFR_INSTR_MEM28_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM28); + + pub const SFR_INSTR_MEM29: crate::Register = crate::Register::new(47, 0xffff); + pub const SFR_INSTR_MEM29_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM29); + + pub const SFR_INSTR_MEM30: crate::Register = crate::Register::new(48, 0xffff); + pub const SFR_INSTR_MEM30_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM30); + + pub const SFR_INSTR_MEM31: crate::Register = crate::Register::new(49, 0xffff); + pub const SFR_INSTR_MEM31_INSTR: crate::Field = crate::Field::new(16, 0, SFR_INSTR_MEM31); + + pub const SFR_SM0_CLKDIV: crate::Register = crate::Register::new(50, 0xffffffff); + pub const SFR_SM0_CLKDIV_UNUSED_DIV: crate::Field = crate::Field::new(8, 0, SFR_SM0_CLKDIV); + pub const SFR_SM0_CLKDIV_DIV_FRAC: crate::Field = crate::Field::new(8, 8, SFR_SM0_CLKDIV); + pub const SFR_SM0_CLKDIV_DIV_INT: crate::Field = crate::Field::new(16, 16, SFR_SM0_CLKDIV); + + pub const SFR_SM0_EXECCTRL: crate::Register = crate::Register::new(51, 0xffffffff); + pub const SFR_SM0_EXECCTRL_STATUS_N: crate::Field = crate::Field::new(4, 0, SFR_SM0_EXECCTRL); + pub const SFR_SM0_EXECCTRL_STATUS_SEL: crate::Field = crate::Field::new(1, 4, SFR_SM0_EXECCTRL); + pub const SFR_SM0_EXECCTRL_RESVD_EXEC: crate::Field = crate::Field::new(2, 5, SFR_SM0_EXECCTRL); + pub const SFR_SM0_EXECCTRL_WRAP_TARGET: crate::Field = crate::Field::new(5, 7, SFR_SM0_EXECCTRL); + pub const SFR_SM0_EXECCTRL_PEND: crate::Field = crate::Field::new(5, 12, SFR_SM0_EXECCTRL); + pub const SFR_SM0_EXECCTRL_OUT_STICKY: crate::Field = crate::Field::new(1, 17, SFR_SM0_EXECCTRL); + pub const SFR_SM0_EXECCTRL_INLINE_OUT_EN: crate::Field = crate::Field::new(1, 18, SFR_SM0_EXECCTRL); + pub const SFR_SM0_EXECCTRL_OUT_EN_SEL: crate::Field = crate::Field::new(5, 19, SFR_SM0_EXECCTRL); + pub const SFR_SM0_EXECCTRL_JMP_PIN: crate::Field = crate::Field::new(5, 24, SFR_SM0_EXECCTRL); + pub const SFR_SM0_EXECCTRL_SIDE_PINDIR: crate::Field = crate::Field::new(1, 29, SFR_SM0_EXECCTRL); + pub const SFR_SM0_EXECCTRL_SIDESET_ENABLE_BIT: crate::Field = crate::Field::new(1, 30, SFR_SM0_EXECCTRL); + pub const SFR_SM0_EXECCTRL_EXEC_STALLED_RO0: crate::Field = crate::Field::new(1, 31, SFR_SM0_EXECCTRL); + + pub const SFR_SM0_SHIFTCTRL: crate::Register = crate::Register::new(52, 0xffffffff); + pub const SFR_SM0_SHIFTCTRL_RESVD_SHIFT: crate::Field = crate::Field::new(16, 0, SFR_SM0_SHIFTCTRL); + pub const SFR_SM0_SHIFTCTRL_AUTO_PUSH: crate::Field = crate::Field::new(1, 16, SFR_SM0_SHIFTCTRL); + pub const SFR_SM0_SHIFTCTRL_AUTO_PULL: crate::Field = crate::Field::new(1, 17, SFR_SM0_SHIFTCTRL); + pub const SFR_SM0_SHIFTCTRL_IN_SHIFT_DIR: crate::Field = crate::Field::new(1, 18, SFR_SM0_SHIFTCTRL); + pub const SFR_SM0_SHIFTCTRL_OUT_SHIFT_DIR: crate::Field = crate::Field::new(1, 19, SFR_SM0_SHIFTCTRL); + pub const SFR_SM0_SHIFTCTRL_ISR_THRESHOLD: crate::Field = crate::Field::new(5, 20, SFR_SM0_SHIFTCTRL); + pub const SFR_SM0_SHIFTCTRL_OSR_THRESHOLD: crate::Field = crate::Field::new(5, 25, SFR_SM0_SHIFTCTRL); + pub const SFR_SM0_SHIFTCTRL_JOIN_TX: crate::Field = crate::Field::new(1, 30, SFR_SM0_SHIFTCTRL); + pub const SFR_SM0_SHIFTCTRL_JOIN_RX: crate::Field = crate::Field::new(1, 31, SFR_SM0_SHIFTCTRL); + + pub const SFR_SM0_ADDR: crate::Register = crate::Register::new(53, 0x1f); + pub const SFR_SM0_ADDR_PC: crate::Field = crate::Field::new(5, 0, SFR_SM0_ADDR); + + pub const SFR_SM0_INSTR: crate::Register = crate::Register::new(54, 0xffff); + pub const SFR_SM0_INSTR_IMM_INSTR: crate::Field = crate::Field::new(16, 0, SFR_SM0_INSTR); + + pub const SFR_SM0_PINCTRL: crate::Register = crate::Register::new(55, 0xffffffff); + pub const SFR_SM0_PINCTRL_PINS_OUT_BASE: crate::Field = crate::Field::new(5, 0, SFR_SM0_PINCTRL); + pub const SFR_SM0_PINCTRL_PINS_SET_BASE: crate::Field = crate::Field::new(5, 5, SFR_SM0_PINCTRL); + pub const SFR_SM0_PINCTRL_PINS_SIDE_BASE: crate::Field = crate::Field::new(5, 10, SFR_SM0_PINCTRL); + pub const SFR_SM0_PINCTRL_PINS_IN_BASE: crate::Field = crate::Field::new(5, 15, SFR_SM0_PINCTRL); + pub const SFR_SM0_PINCTRL_PINS_OUT_COUNT: crate::Field = crate::Field::new(6, 20, SFR_SM0_PINCTRL); + pub const SFR_SM0_PINCTRL_PINS_SET_COUNT: crate::Field = crate::Field::new(3, 26, SFR_SM0_PINCTRL); + pub const SFR_SM0_PINCTRL_PINS_SIDE_COUNT: crate::Field = crate::Field::new(3, 29, SFR_SM0_PINCTRL); + + pub const SFR_SM1_CLKDIV: crate::Register = crate::Register::new(56, 0xffffffff); + pub const SFR_SM1_CLKDIV_UNUSED_DIV: crate::Field = crate::Field::new(8, 0, SFR_SM1_CLKDIV); + pub const SFR_SM1_CLKDIV_DIV_FRAC: crate::Field = crate::Field::new(8, 8, SFR_SM1_CLKDIV); + pub const SFR_SM1_CLKDIV_DIV_INT: crate::Field = crate::Field::new(16, 16, SFR_SM1_CLKDIV); + + pub const SFR_SM1_EXECCTRL: crate::Register = crate::Register::new(57, 0xffffffff); + pub const SFR_SM1_EXECCTRL_STATUS_N: crate::Field = crate::Field::new(4, 0, SFR_SM1_EXECCTRL); + pub const SFR_SM1_EXECCTRL_STATUS_SEL: crate::Field = crate::Field::new(1, 4, SFR_SM1_EXECCTRL); + pub const SFR_SM1_EXECCTRL_RESVD_EXEC: crate::Field = crate::Field::new(2, 5, SFR_SM1_EXECCTRL); + pub const SFR_SM1_EXECCTRL_WRAP_TARGET: crate::Field = crate::Field::new(5, 7, SFR_SM1_EXECCTRL); + pub const SFR_SM1_EXECCTRL_PEND: crate::Field = crate::Field::new(5, 12, SFR_SM1_EXECCTRL); + pub const SFR_SM1_EXECCTRL_OUT_STICKY: crate::Field = crate::Field::new(1, 17, SFR_SM1_EXECCTRL); + pub const SFR_SM1_EXECCTRL_INLINE_OUT_EN: crate::Field = crate::Field::new(1, 18, SFR_SM1_EXECCTRL); + pub const SFR_SM1_EXECCTRL_OUT_EN_SEL: crate::Field = crate::Field::new(5, 19, SFR_SM1_EXECCTRL); + pub const SFR_SM1_EXECCTRL_JMP_PIN: crate::Field = crate::Field::new(5, 24, SFR_SM1_EXECCTRL); + pub const SFR_SM1_EXECCTRL_SIDE_PINDIR: crate::Field = crate::Field::new(1, 29, SFR_SM1_EXECCTRL); + pub const SFR_SM1_EXECCTRL_SIDESET_ENABLE_BIT: crate::Field = crate::Field::new(1, 30, SFR_SM1_EXECCTRL); + pub const SFR_SM1_EXECCTRL_EXEC_STALLED_RO1: crate::Field = crate::Field::new(1, 31, SFR_SM1_EXECCTRL); + + pub const SFR_SM1_SHIFTCTRL: crate::Register = crate::Register::new(58, 0xffffffff); + pub const SFR_SM1_SHIFTCTRL_RESVD_SHIFT: crate::Field = crate::Field::new(16, 0, SFR_SM1_SHIFTCTRL); + pub const SFR_SM1_SHIFTCTRL_AUTO_PUSH: crate::Field = crate::Field::new(1, 16, SFR_SM1_SHIFTCTRL); + pub const SFR_SM1_SHIFTCTRL_AUTO_PULL: crate::Field = crate::Field::new(1, 17, SFR_SM1_SHIFTCTRL); + pub const SFR_SM1_SHIFTCTRL_IN_SHIFT_DIR: crate::Field = crate::Field::new(1, 18, SFR_SM1_SHIFTCTRL); + pub const SFR_SM1_SHIFTCTRL_OUT_SHIFT_DIR: crate::Field = crate::Field::new(1, 19, SFR_SM1_SHIFTCTRL); + pub const SFR_SM1_SHIFTCTRL_ISR_THRESHOLD: crate::Field = crate::Field::new(5, 20, SFR_SM1_SHIFTCTRL); + pub const SFR_SM1_SHIFTCTRL_OSR_THRESHOLD: crate::Field = crate::Field::new(5, 25, SFR_SM1_SHIFTCTRL); + pub const SFR_SM1_SHIFTCTRL_JOIN_TX: crate::Field = crate::Field::new(1, 30, SFR_SM1_SHIFTCTRL); + pub const SFR_SM1_SHIFTCTRL_JOIN_RX: crate::Field = crate::Field::new(1, 31, SFR_SM1_SHIFTCTRL); + + pub const SFR_SM1_ADDR: crate::Register = crate::Register::new(59, 0x1f); + pub const SFR_SM1_ADDR_PC: crate::Field = crate::Field::new(5, 0, SFR_SM1_ADDR); + + pub const SFR_SM1_INSTR: crate::Register = crate::Register::new(60, 0xffff); + pub const SFR_SM1_INSTR_IMM_INSTR: crate::Field = crate::Field::new(16, 0, SFR_SM1_INSTR); + + pub const SFR_SM1_PINCTRL: crate::Register = crate::Register::new(61, 0xffffffff); + pub const SFR_SM1_PINCTRL_PINS_OUT_BASE: crate::Field = crate::Field::new(5, 0, SFR_SM1_PINCTRL); + pub const SFR_SM1_PINCTRL_PINS_SET_BASE: crate::Field = crate::Field::new(5, 5, SFR_SM1_PINCTRL); + pub const SFR_SM1_PINCTRL_PINS_SIDE_BASE: crate::Field = crate::Field::new(5, 10, SFR_SM1_PINCTRL); + pub const SFR_SM1_PINCTRL_PINS_IN_BASE: crate::Field = crate::Field::new(5, 15, SFR_SM1_PINCTRL); + pub const SFR_SM1_PINCTRL_PINS_OUT_COUNT: crate::Field = crate::Field::new(6, 20, SFR_SM1_PINCTRL); + pub const SFR_SM1_PINCTRL_PINS_SET_COUNT: crate::Field = crate::Field::new(3, 26, SFR_SM1_PINCTRL); + pub const SFR_SM1_PINCTRL_PINS_SIDE_COUNT: crate::Field = crate::Field::new(3, 29, SFR_SM1_PINCTRL); + + pub const SFR_SM2_CLKDIV: crate::Register = crate::Register::new(62, 0xffffffff); + pub const SFR_SM2_CLKDIV_UNUSED_DIV: crate::Field = crate::Field::new(8, 0, SFR_SM2_CLKDIV); + pub const SFR_SM2_CLKDIV_DIV_FRAC: crate::Field = crate::Field::new(8, 8, SFR_SM2_CLKDIV); + pub const SFR_SM2_CLKDIV_DIV_INT: crate::Field = crate::Field::new(16, 16, SFR_SM2_CLKDIV); + + pub const SFR_SM2_EXECCTRL: crate::Register = crate::Register::new(63, 0xffffffff); + pub const SFR_SM2_EXECCTRL_STATUS_N: crate::Field = crate::Field::new(4, 0, SFR_SM2_EXECCTRL); + pub const SFR_SM2_EXECCTRL_STATUS_SEL: crate::Field = crate::Field::new(1, 4, SFR_SM2_EXECCTRL); + pub const SFR_SM2_EXECCTRL_RESVD_EXEC: crate::Field = crate::Field::new(2, 5, SFR_SM2_EXECCTRL); + pub const SFR_SM2_EXECCTRL_WRAP_TARGET: crate::Field = crate::Field::new(5, 7, SFR_SM2_EXECCTRL); + pub const SFR_SM2_EXECCTRL_PEND: crate::Field = crate::Field::new(5, 12, SFR_SM2_EXECCTRL); + pub const SFR_SM2_EXECCTRL_OUT_STICKY: crate::Field = crate::Field::new(1, 17, SFR_SM2_EXECCTRL); + pub const SFR_SM2_EXECCTRL_INLINE_OUT_EN: crate::Field = crate::Field::new(1, 18, SFR_SM2_EXECCTRL); + pub const SFR_SM2_EXECCTRL_OUT_EN_SEL: crate::Field = crate::Field::new(5, 19, SFR_SM2_EXECCTRL); + pub const SFR_SM2_EXECCTRL_JMP_PIN: crate::Field = crate::Field::new(5, 24, SFR_SM2_EXECCTRL); + pub const SFR_SM2_EXECCTRL_SIDE_PINDIR: crate::Field = crate::Field::new(1, 29, SFR_SM2_EXECCTRL); + pub const SFR_SM2_EXECCTRL_SIDESET_ENABLE_BIT: crate::Field = crate::Field::new(1, 30, SFR_SM2_EXECCTRL); + pub const SFR_SM2_EXECCTRL_EXEC_STALLED_RO2: crate::Field = crate::Field::new(1, 31, SFR_SM2_EXECCTRL); + + pub const SFR_SM2_SHIFTCTRL: crate::Register = crate::Register::new(64, 0xffffffff); + pub const SFR_SM2_SHIFTCTRL_RESVD_SHIFT: crate::Field = crate::Field::new(16, 0, SFR_SM2_SHIFTCTRL); + pub const SFR_SM2_SHIFTCTRL_AUTO_PUSH: crate::Field = crate::Field::new(1, 16, SFR_SM2_SHIFTCTRL); + pub const SFR_SM2_SHIFTCTRL_AUTO_PULL: crate::Field = crate::Field::new(1, 17, SFR_SM2_SHIFTCTRL); + pub const SFR_SM2_SHIFTCTRL_IN_SHIFT_DIR: crate::Field = crate::Field::new(1, 18, SFR_SM2_SHIFTCTRL); + pub const SFR_SM2_SHIFTCTRL_OUT_SHIFT_DIR: crate::Field = crate::Field::new(1, 19, SFR_SM2_SHIFTCTRL); + pub const SFR_SM2_SHIFTCTRL_ISR_THRESHOLD: crate::Field = crate::Field::new(5, 20, SFR_SM2_SHIFTCTRL); + pub const SFR_SM2_SHIFTCTRL_OSR_THRESHOLD: crate::Field = crate::Field::new(5, 25, SFR_SM2_SHIFTCTRL); + pub const SFR_SM2_SHIFTCTRL_JOIN_TX: crate::Field = crate::Field::new(1, 30, SFR_SM2_SHIFTCTRL); + pub const SFR_SM2_SHIFTCTRL_JOIN_RX: crate::Field = crate::Field::new(1, 31, SFR_SM2_SHIFTCTRL); + + pub const SFR_SM2_ADDR: crate::Register = crate::Register::new(65, 0x1f); + pub const SFR_SM2_ADDR_PC: crate::Field = crate::Field::new(5, 0, SFR_SM2_ADDR); + + pub const SFR_SM2_INSTR: crate::Register = crate::Register::new(66, 0xffff); + pub const SFR_SM2_INSTR_IMM_INSTR: crate::Field = crate::Field::new(16, 0, SFR_SM2_INSTR); + + pub const SFR_SM2_PINCTRL: crate::Register = crate::Register::new(67, 0xffffffff); + pub const SFR_SM2_PINCTRL_PINS_OUT_BASE: crate::Field = crate::Field::new(5, 0, SFR_SM2_PINCTRL); + pub const SFR_SM2_PINCTRL_PINS_SET_BASE: crate::Field = crate::Field::new(5, 5, SFR_SM2_PINCTRL); + pub const SFR_SM2_PINCTRL_PINS_SIDE_BASE: crate::Field = crate::Field::new(5, 10, SFR_SM2_PINCTRL); + pub const SFR_SM2_PINCTRL_PINS_IN_BASE: crate::Field = crate::Field::new(5, 15, SFR_SM2_PINCTRL); + pub const SFR_SM2_PINCTRL_PINS_OUT_COUNT: crate::Field = crate::Field::new(6, 20, SFR_SM2_PINCTRL); + pub const SFR_SM2_PINCTRL_PINS_SET_COUNT: crate::Field = crate::Field::new(3, 26, SFR_SM2_PINCTRL); + pub const SFR_SM2_PINCTRL_PINS_SIDE_COUNT: crate::Field = crate::Field::new(3, 29, SFR_SM2_PINCTRL); + + pub const SFR_SM3_CLKDIV: crate::Register = crate::Register::new(68, 0xffffffff); + pub const SFR_SM3_CLKDIV_UNUSED_DIV: crate::Field = crate::Field::new(8, 0, SFR_SM3_CLKDIV); + pub const SFR_SM3_CLKDIV_DIV_FRAC: crate::Field = crate::Field::new(8, 8, SFR_SM3_CLKDIV); + pub const SFR_SM3_CLKDIV_DIV_INT: crate::Field = crate::Field::new(16, 16, SFR_SM3_CLKDIV); + + pub const SFR_SM3_EXECCTRL: crate::Register = crate::Register::new(69, 0xffffffff); + pub const SFR_SM3_EXECCTRL_STATUS_N: crate::Field = crate::Field::new(4, 0, SFR_SM3_EXECCTRL); + pub const SFR_SM3_EXECCTRL_STATUS_SEL: crate::Field = crate::Field::new(1, 4, SFR_SM3_EXECCTRL); + pub const SFR_SM3_EXECCTRL_RESVD_EXEC: crate::Field = crate::Field::new(2, 5, SFR_SM3_EXECCTRL); + pub const SFR_SM3_EXECCTRL_WRAP_TARGET: crate::Field = crate::Field::new(5, 7, SFR_SM3_EXECCTRL); + pub const SFR_SM3_EXECCTRL_PEND: crate::Field = crate::Field::new(5, 12, SFR_SM3_EXECCTRL); + pub const SFR_SM3_EXECCTRL_OUT_STICKY: crate::Field = crate::Field::new(1, 17, SFR_SM3_EXECCTRL); + pub const SFR_SM3_EXECCTRL_INLINE_OUT_EN: crate::Field = crate::Field::new(1, 18, SFR_SM3_EXECCTRL); + pub const SFR_SM3_EXECCTRL_OUT_EN_SEL: crate::Field = crate::Field::new(5, 19, SFR_SM3_EXECCTRL); + pub const SFR_SM3_EXECCTRL_JMP_PIN: crate::Field = crate::Field::new(5, 24, SFR_SM3_EXECCTRL); + pub const SFR_SM3_EXECCTRL_SIDE_PINDIR: crate::Field = crate::Field::new(1, 29, SFR_SM3_EXECCTRL); + pub const SFR_SM3_EXECCTRL_SIDESET_ENABLE_BIT: crate::Field = crate::Field::new(1, 30, SFR_SM3_EXECCTRL); + pub const SFR_SM3_EXECCTRL_EXEC_STALLED_RO3: crate::Field = crate::Field::new(1, 31, SFR_SM3_EXECCTRL); + + pub const SFR_SM3_SHIFTCTRL: crate::Register = crate::Register::new(70, 0xffffffff); + pub const SFR_SM3_SHIFTCTRL_RESVD_SHIFT: crate::Field = crate::Field::new(16, 0, SFR_SM3_SHIFTCTRL); + pub const SFR_SM3_SHIFTCTRL_AUTO_PUSH: crate::Field = crate::Field::new(1, 16, SFR_SM3_SHIFTCTRL); + pub const SFR_SM3_SHIFTCTRL_AUTO_PULL: crate::Field = crate::Field::new(1, 17, SFR_SM3_SHIFTCTRL); + pub const SFR_SM3_SHIFTCTRL_IN_SHIFT_DIR: crate::Field = crate::Field::new(1, 18, SFR_SM3_SHIFTCTRL); + pub const SFR_SM3_SHIFTCTRL_OUT_SHIFT_DIR: crate::Field = crate::Field::new(1, 19, SFR_SM3_SHIFTCTRL); + pub const SFR_SM3_SHIFTCTRL_ISR_THRESHOLD: crate::Field = crate::Field::new(5, 20, SFR_SM3_SHIFTCTRL); + pub const SFR_SM3_SHIFTCTRL_OSR_THRESHOLD: crate::Field = crate::Field::new(5, 25, SFR_SM3_SHIFTCTRL); + pub const SFR_SM3_SHIFTCTRL_JOIN_TX: crate::Field = crate::Field::new(1, 30, SFR_SM3_SHIFTCTRL); + pub const SFR_SM3_SHIFTCTRL_JOIN_RX: crate::Field = crate::Field::new(1, 31, SFR_SM3_SHIFTCTRL); + + pub const SFR_SM3_ADDR: crate::Register = crate::Register::new(71, 0x1f); + pub const SFR_SM3_ADDR_PC: crate::Field = crate::Field::new(5, 0, SFR_SM3_ADDR); + + pub const SFR_SM3_INSTR: crate::Register = crate::Register::new(72, 0xffff); + pub const SFR_SM3_INSTR_IMM_INSTR: crate::Field = crate::Field::new(16, 0, SFR_SM3_INSTR); + + pub const SFR_SM3_PINCTRL: crate::Register = crate::Register::new(73, 0xffffffff); + pub const SFR_SM3_PINCTRL_PINS_OUT_BASE: crate::Field = crate::Field::new(5, 0, SFR_SM3_PINCTRL); + pub const SFR_SM3_PINCTRL_PINS_SET_BASE: crate::Field = crate::Field::new(5, 5, SFR_SM3_PINCTRL); + pub const SFR_SM3_PINCTRL_PINS_SIDE_BASE: crate::Field = crate::Field::new(5, 10, SFR_SM3_PINCTRL); + pub const SFR_SM3_PINCTRL_PINS_IN_BASE: crate::Field = crate::Field::new(5, 15, SFR_SM3_PINCTRL); + pub const SFR_SM3_PINCTRL_PINS_OUT_COUNT: crate::Field = crate::Field::new(6, 20, SFR_SM3_PINCTRL); + pub const SFR_SM3_PINCTRL_PINS_SET_COUNT: crate::Field = crate::Field::new(3, 26, SFR_SM3_PINCTRL); + pub const SFR_SM3_PINCTRL_PINS_SIDE_COUNT: crate::Field = crate::Field::new(3, 29, SFR_SM3_PINCTRL); + + pub const SFR_INTR: crate::Register = crate::Register::new(74, 0xfff); + pub const SFR_INTR_INTR_RXNEMPTY: crate::Field = crate::Field::new(4, 0, SFR_INTR); + pub const SFR_INTR_INTR_TXNFULL: crate::Field = crate::Field::new(4, 4, SFR_INTR); + pub const SFR_INTR_INTR_SM: crate::Field = crate::Field::new(4, 8, SFR_INTR); + + pub const SFR_IRQ0_INTE: crate::Register = crate::Register::new(75, 0xfff); + pub const SFR_IRQ0_INTE_IRQ0_INTE_RXNEMPTY: crate::Field = crate::Field::new(4, 0, SFR_IRQ0_INTE); + pub const SFR_IRQ0_INTE_IRQ0_INTE_TXNFULL: crate::Field = crate::Field::new(4, 4, SFR_IRQ0_INTE); + pub const SFR_IRQ0_INTE_IRQ0_INTE_SM: crate::Field = crate::Field::new(4, 8, SFR_IRQ0_INTE); + + pub const SFR_IRQ0_INTF: crate::Register = crate::Register::new(76, 0xfff); + pub const SFR_IRQ0_INTF_IRQ0_INTF_RXNEMPTY: crate::Field = crate::Field::new(4, 0, SFR_IRQ0_INTF); + pub const SFR_IRQ0_INTF_IRQ0_INTF_TXNFULL: crate::Field = crate::Field::new(4, 4, SFR_IRQ0_INTF); + pub const SFR_IRQ0_INTF_IRQ0_INTF_SM: crate::Field = crate::Field::new(4, 8, SFR_IRQ0_INTF); + + pub const SFR_IRQ0_INTS: crate::Register = crate::Register::new(77, 0xfff); + pub const SFR_IRQ0_INTS_IRQ0_INTS_RXNEMPTY: crate::Field = crate::Field::new(4, 0, SFR_IRQ0_INTS); + pub const SFR_IRQ0_INTS_IRQ0_INTS_TXNFULL: crate::Field = crate::Field::new(4, 4, SFR_IRQ0_INTS); + pub const SFR_IRQ0_INTS_IRQ0_INTS_SM: crate::Field = crate::Field::new(4, 8, SFR_IRQ0_INTS); + + pub const SFR_IRQ1_INTE: crate::Register = crate::Register::new(78, 0xfff); + pub const SFR_IRQ1_INTE_IRQ1_INTE_RXNEMPTY: crate::Field = crate::Field::new(4, 0, SFR_IRQ1_INTE); + pub const SFR_IRQ1_INTE_IRQ1_INTE_TXNFULL: crate::Field = crate::Field::new(4, 4, SFR_IRQ1_INTE); + pub const SFR_IRQ1_INTE_IRQ1_INTE_SM: crate::Field = crate::Field::new(4, 8, SFR_IRQ1_INTE); + + pub const SFR_IRQ1_INTF: crate::Register = crate::Register::new(79, 0xfff); + pub const SFR_IRQ1_INTF_IRQ1_INTF_RXNEMPTY: crate::Field = crate::Field::new(4, 0, SFR_IRQ1_INTF); + pub const SFR_IRQ1_INTF_IRQ1_INTF_TXNFULL: crate::Field = crate::Field::new(4, 4, SFR_IRQ1_INTF); + pub const SFR_IRQ1_INTF_IRQ1_INTF_SM: crate::Field = crate::Field::new(4, 8, SFR_IRQ1_INTF); + + pub const SFR_IRQ1_INTS: crate::Register = crate::Register::new(80, 0xfff); + pub const SFR_IRQ1_INTS_IRQ1_INTS_RXNEMPTY: crate::Field = crate::Field::new(4, 0, SFR_IRQ1_INTS); + pub const SFR_IRQ1_INTS_IRQ1_INTS_TXNFULL: crate::Field = crate::Field::new(4, 4, SFR_IRQ1_INTS); + pub const SFR_IRQ1_INTS_IRQ1_INTS_SM: crate::Field = crate::Field::new(4, 8, SFR_IRQ1_INTS); + + pub const SFR_IO_OE_INV: crate::Register = crate::Register::new(96, 0xffffffff); + pub const SFR_IO_OE_INV_SFR_IO_OE_INV: crate::Field = crate::Field::new(32, 0, SFR_IO_OE_INV); + + pub const SFR_IO_O_INV: crate::Register = crate::Register::new(97, 0xffffffff); + pub const SFR_IO_O_INV_SFR_IO_O_INV: crate::Field = crate::Field::new(32, 0, SFR_IO_O_INV); + + pub const SFR_IO_I_INV: crate::Register = crate::Register::new(98, 0xffffffff); + pub const SFR_IO_I_INV_SFR_IO_I_INV: crate::Field = crate::Field::new(32, 0, SFR_IO_I_INV); + + pub const SFR_FIFO_MARGIN: crate::Register = crate::Register::new(99, 0xffff); + pub const SFR_FIFO_MARGIN_FIFO_TX_MARGIN0: crate::Field = crate::Field::new(2, 0, SFR_FIFO_MARGIN); + pub const SFR_FIFO_MARGIN_FIFO_RX_MARGIN0: crate::Field = crate::Field::new(2, 2, SFR_FIFO_MARGIN); + pub const SFR_FIFO_MARGIN_FIFO_TX_MARGIN1: crate::Field = crate::Field::new(2, 4, SFR_FIFO_MARGIN); + pub const SFR_FIFO_MARGIN_FIFO_RX_MARGIN1: crate::Field = crate::Field::new(2, 6, SFR_FIFO_MARGIN); + pub const SFR_FIFO_MARGIN_FIFO_TX_MARGIN2: crate::Field = crate::Field::new(2, 8, SFR_FIFO_MARGIN); + pub const SFR_FIFO_MARGIN_FIFO_RX_MARGIN2: crate::Field = crate::Field::new(2, 10, SFR_FIFO_MARGIN); + pub const SFR_FIFO_MARGIN_FIFO_TX_MARGIN3: crate::Field = crate::Field::new(2, 12, SFR_FIFO_MARGIN); + pub const SFR_FIFO_MARGIN_FIFO_RX_MARGIN3: crate::Field = crate::Field::new(2, 14, SFR_FIFO_MARGIN); + + pub const SFR_ZERO0: crate::Register = crate::Register::new(100, 0xffffffff); + pub const SFR_ZERO0_SFR_ZERO0: crate::Field = crate::Field::new(32, 0, SFR_ZERO0); + + pub const SFR_ZERO1: crate::Register = crate::Register::new(101, 0xffffffff); + pub const SFR_ZERO1_SFR_ZERO1: crate::Field = crate::Field::new(32, 0, SFR_ZERO1); + + pub const SFR_ZERO2: crate::Register = crate::Register::new(102, 0xffffffff); + pub const SFR_ZERO2_SFR_ZERO2: crate::Field = crate::Field::new(32, 0, SFR_ZERO2); + + pub const SFR_ZERO3: crate::Register = crate::Register::new(103, 0xffffffff); + pub const SFR_ZERO3_SFR_ZERO3: crate::Field = crate::Field::new(32, 0, SFR_ZERO3); + + pub const HW_RP_PIO_BASE: usize = 0x50123000; + } + + pub mod mdma { + pub const MDMA_NUMREGS: usize = 24; + + pub const SFR_EVSEL_CR_EVSEL0: crate::Register = crate::Register::new(0, 0xff); + pub const SFR_EVSEL_CR_EVSEL0_CR_EVSEL0: crate::Field = crate::Field::new(8, 0, SFR_EVSEL_CR_EVSEL0); + + pub const SFR_EVSEL_CR_EVSEL1: crate::Register = crate::Register::new(1, 0xff); + pub const SFR_EVSEL_CR_EVSEL1_CR_EVSEL1: crate::Field = crate::Field::new(8, 0, SFR_EVSEL_CR_EVSEL1); + + pub const SFR_EVSEL_CR_EVSEL2: crate::Register = crate::Register::new(2, 0xff); + pub const SFR_EVSEL_CR_EVSEL2_CR_EVSEL2: crate::Field = crate::Field::new(8, 0, SFR_EVSEL_CR_EVSEL2); + + pub const SFR_EVSEL_CR_EVSEL3: crate::Register = crate::Register::new(3, 0xff); + pub const SFR_EVSEL_CR_EVSEL3_CR_EVSEL3: crate::Field = crate::Field::new(8, 0, SFR_EVSEL_CR_EVSEL3); + + pub const SFR_EVSEL_CR_EVSEL4: crate::Register = crate::Register::new(4, 0xff); + pub const SFR_EVSEL_CR_EVSEL4_CR_EVSEL4: crate::Field = crate::Field::new(8, 0, SFR_EVSEL_CR_EVSEL4); + + pub const SFR_EVSEL_CR_EVSEL5: crate::Register = crate::Register::new(5, 0xff); + pub const SFR_EVSEL_CR_EVSEL5_CR_EVSEL5: crate::Field = crate::Field::new(8, 0, SFR_EVSEL_CR_EVSEL5); + + pub const SFR_EVSEL_CR_EVSEL6: crate::Register = crate::Register::new(6, 0xff); + pub const SFR_EVSEL_CR_EVSEL6_CR_EVSEL6: crate::Field = crate::Field::new(8, 0, SFR_EVSEL_CR_EVSEL6); + + pub const SFR_EVSEL_CR_EVSEL7: crate::Register = crate::Register::new(7, 0xff); + pub const SFR_EVSEL_CR_EVSEL7_CR_EVSEL7: crate::Field = crate::Field::new(8, 0, SFR_EVSEL_CR_EVSEL7); + + pub const SFR_CR_CR_MDMAREQ0: crate::Register = crate::Register::new(8, 0x1f); + pub const SFR_CR_CR_MDMAREQ0_CR_MDMAREQ0: crate::Field = crate::Field::new(5, 0, SFR_CR_CR_MDMAREQ0); + + pub const SFR_CR_CR_MDMAREQ1: crate::Register = crate::Register::new(9, 0x1f); + pub const SFR_CR_CR_MDMAREQ1_CR_MDMAREQ1: crate::Field = crate::Field::new(5, 0, SFR_CR_CR_MDMAREQ1); + + pub const SFR_CR_CR_MDMAREQ2: crate::Register = crate::Register::new(10, 0x1f); + pub const SFR_CR_CR_MDMAREQ2_CR_MDMAREQ2: crate::Field = crate::Field::new(5, 0, SFR_CR_CR_MDMAREQ2); + + pub const SFR_CR_CR_MDMAREQ3: crate::Register = crate::Register::new(11, 0x1f); + pub const SFR_CR_CR_MDMAREQ3_CR_MDMAREQ3: crate::Field = crate::Field::new(5, 0, SFR_CR_CR_MDMAREQ3); + + pub const SFR_CR_CR_MDMAREQ4: crate::Register = crate::Register::new(12, 0x1f); + pub const SFR_CR_CR_MDMAREQ4_CR_MDMAREQ4: crate::Field = crate::Field::new(5, 0, SFR_CR_CR_MDMAREQ4); + + pub const SFR_CR_CR_MDMAREQ5: crate::Register = crate::Register::new(13, 0x1f); + pub const SFR_CR_CR_MDMAREQ5_CR_MDMAREQ5: crate::Field = crate::Field::new(5, 0, SFR_CR_CR_MDMAREQ5); + + pub const SFR_CR_CR_MDMAREQ6: crate::Register = crate::Register::new(14, 0x1f); + pub const SFR_CR_CR_MDMAREQ6_CR_MDMAREQ6: crate::Field = crate::Field::new(5, 0, SFR_CR_CR_MDMAREQ6); + + pub const SFR_CR_CR_MDMAREQ7: crate::Register = crate::Register::new(15, 0x1f); + pub const SFR_CR_CR_MDMAREQ7_CR_MDMAREQ7: crate::Field = crate::Field::new(5, 0, SFR_CR_CR_MDMAREQ7); + + pub const SFR_SR_SR_MDMAREQ0: crate::Register = crate::Register::new(16, 0x1f); + pub const SFR_SR_SR_MDMAREQ0_SR_MDMAREQ0: crate::Field = crate::Field::new(5, 0, SFR_SR_SR_MDMAREQ0); + + pub const SFR_SR_SR_MDMAREQ1: crate::Register = crate::Register::new(17, 0x1f); + pub const SFR_SR_SR_MDMAREQ1_SR_MDMAREQ1: crate::Field = crate::Field::new(5, 0, SFR_SR_SR_MDMAREQ1); + + pub const SFR_SR_SR_MDMAREQ2: crate::Register = crate::Register::new(18, 0x1f); + pub const SFR_SR_SR_MDMAREQ2_SR_MDMAREQ2: crate::Field = crate::Field::new(5, 0, SFR_SR_SR_MDMAREQ2); + + pub const SFR_SR_SR_MDMAREQ3: crate::Register = crate::Register::new(19, 0x1f); + pub const SFR_SR_SR_MDMAREQ3_SR_MDMAREQ3: crate::Field = crate::Field::new(5, 0, SFR_SR_SR_MDMAREQ3); + + pub const SFR_SR_SR_MDMAREQ4: crate::Register = crate::Register::new(20, 0x1f); + pub const SFR_SR_SR_MDMAREQ4_SR_MDMAREQ4: crate::Field = crate::Field::new(5, 0, SFR_SR_SR_MDMAREQ4); + + pub const SFR_SR_SR_MDMAREQ5: crate::Register = crate::Register::new(21, 0x1f); + pub const SFR_SR_SR_MDMAREQ5_SR_MDMAREQ5: crate::Field = crate::Field::new(5, 0, SFR_SR_SR_MDMAREQ5); + + pub const SFR_SR_SR_MDMAREQ6: crate::Register = crate::Register::new(22, 0x1f); + pub const SFR_SR_SR_MDMAREQ6_SR_MDMAREQ6: crate::Field = crate::Field::new(5, 0, SFR_SR_SR_MDMAREQ6); + + pub const SFR_SR_SR_MDMAREQ7: crate::Register = crate::Register::new(23, 0x1f); + pub const SFR_SR_SR_MDMAREQ7_SR_MDMAREQ7: crate::Field = crate::Field::new(5, 0, SFR_SR_SR_MDMAREQ7); + + pub const HW_MDMA_BASE: usize = 0x40002000; + } + + pub mod qfc { + pub const QFC_NUMREGS: usize = 14; + + pub const SFR_IO: crate::Register = crate::Register::new(0, 0xff); + pub const SFR_IO_SFR_IO: crate::Field = crate::Field::new(8, 0, SFR_IO); + + pub const SFR_AR: crate::Register = crate::Register::new(1, 0xffffffff); + pub const SFR_AR_SFR_AR: crate::Field = crate::Field::new(32, 0, SFR_AR); + + pub const SFR_IODRV: crate::Register = crate::Register::new(2, 0xfff); + pub const SFR_IODRV_PADDRVSEL: crate::Field = crate::Field::new(12, 0, SFR_IODRV); + + pub const CR_XIP_ADDRMODE: crate::Register = crate::Register::new(4, 0x3); + pub const CR_XIP_ADDRMODE_CR_XIP_ADDRMODE: crate::Field = crate::Field::new(2, 0, CR_XIP_ADDRMODE); + + pub const CR_XIP_OPCODE: crate::Register = crate::Register::new(5, 0xffffffff); + pub const CR_XIP_OPCODE_CR_XIP_OPCODE: crate::Field = crate::Field::new(32, 0, CR_XIP_OPCODE); + + pub const CR_XIP_WIDTH: crate::Register = crate::Register::new(6, 0x3f); + pub const CR_XIP_WIDTH_CR_XIP_WIDTH: crate::Field = crate::Field::new(6, 0, CR_XIP_WIDTH); + + pub const CR_XIP_SSEL: crate::Register = crate::Register::new(7, 0x7f); + pub const CR_XIP_SSEL_CR_XIP_SSEL: crate::Field = crate::Field::new(7, 0, CR_XIP_SSEL); + + pub const CR_XIP_DUMCYC: crate::Register = crate::Register::new(8, 0xffff); + pub const CR_XIP_DUMCYC_CR_XIP_DUMCYC: crate::Field = crate::Field::new(16, 0, CR_XIP_DUMCYC); + + pub const CR_XIP_CFG: crate::Register = crate::Register::new(9, 0x3fff); + pub const CR_XIP_CFG_CR_XIP_CFG: crate::Field = crate::Field::new(14, 0, CR_XIP_CFG); + + pub const CR_AESKEY_AESKEYIN0: crate::Register = crate::Register::new(16, 0xffffffff); + pub const CR_AESKEY_AESKEYIN0_AESKEYIN0: crate::Field = crate::Field::new(32, 0, CR_AESKEY_AESKEYIN0); + + pub const CR_AESKEY_AESKEYIN1: crate::Register = crate::Register::new(17, 0xffffffff); + pub const CR_AESKEY_AESKEYIN1_AESKEYIN1: crate::Field = crate::Field::new(32, 0, CR_AESKEY_AESKEYIN1); + + pub const CR_AESKEY_AESKEYIN2: crate::Register = crate::Register::new(18, 0xffffffff); + pub const CR_AESKEY_AESKEYIN2_AESKEYIN2: crate::Field = crate::Field::new(32, 0, CR_AESKEY_AESKEYIN2); + + pub const CR_AESKEY_AESKEYIN3: crate::Register = crate::Register::new(19, 0xffffffff); + pub const CR_AESKEY_AESKEYIN3_AESKEYIN3: crate::Field = crate::Field::new(32, 0, CR_AESKEY_AESKEYIN3); + + pub const CR_AESENA: crate::Register = crate::Register::new(20, 0x1); + pub const CR_AESENA_CR_AESENA: crate::Field = crate::Field::new(1, 0, CR_AESENA); + + pub const HW_QFC_BASE: usize = 0x40000000; + } + + pub mod pl230_placeholder { + pub const PL230_PLACEHOLDER_NUMREGS: usize = 0; + + pub const HW_PL230_PLACEHOLDER_BASE: usize = 0x40011000; + } + + pub mod gluechain { + pub const GLUECHAIN_NUMREGS: usize = 4; + + pub const SFR_GCMASK: crate::Register = crate::Register::new(0, 0xffffffff); + pub const SFR_GCMASK_CR_GCMASK: crate::Field = crate::Field::new(32, 0, SFR_GCMASK); + + pub const SFR_GCSR: crate::Register = crate::Register::new(1, 0xffffffff); + pub const SFR_GCSR_GLUEREG: crate::Field = crate::Field::new(32, 0, SFR_GCSR); + + pub const SFR_GCRST: crate::Register = crate::Register::new(2, 0xffffffff); + pub const SFR_GCRST_GLUERST: crate::Field = crate::Field::new(32, 0, SFR_GCRST); + + pub const SFR_GCTEST: crate::Register = crate::Register::new(3, 0xffffffff); + pub const SFR_GCTEST_GLUETEST: crate::Field = crate::Field::new(32, 0, SFR_GCTEST); + + pub const HW_GLUECHAIN_BASE: usize = 0x40054000; + } + + pub mod mesh { + pub const MESH_NUMREGS: usize = 10; + + pub const SFR_MLDRV_CR_MLDRV0: crate::Register = crate::Register::new(0, 0xffffffff); + pub const SFR_MLDRV_CR_MLDRV0_CR_MLDRV0: crate::Field = crate::Field::new(32, 0, SFR_MLDRV_CR_MLDRV0); + + pub const SFR_MLIE_CR_MLIE0: crate::Register = crate::Register::new(1, 0xffffffff); + pub const SFR_MLIE_CR_MLIE0_CR_MLIE0: crate::Field = crate::Field::new(32, 0, SFR_MLIE_CR_MLIE0); + + pub const SFR_MLSR_SR_MLSR0: crate::Register = crate::Register::new(2, 0xffffffff); + pub const SFR_MLSR_SR_MLSR0_SR_MLSR0: crate::Field = crate::Field::new(32, 0, SFR_MLSR_SR_MLSR0); + + pub const SFR_MLSR_SR_MLSR1: crate::Register = crate::Register::new(3, 0xffffffff); + pub const SFR_MLSR_SR_MLSR1_SR_MLSR1: crate::Field = crate::Field::new(32, 0, SFR_MLSR_SR_MLSR1); + + pub const SFR_MLSR_SR_MLSR2: crate::Register = crate::Register::new(4, 0xffffffff); + pub const SFR_MLSR_SR_MLSR2_SR_MLSR2: crate::Field = crate::Field::new(32, 0, SFR_MLSR_SR_MLSR2); + + pub const SFR_MLSR_SR_MLSR3: crate::Register = crate::Register::new(5, 0xffffffff); + pub const SFR_MLSR_SR_MLSR3_SR_MLSR3: crate::Field = crate::Field::new(32, 0, SFR_MLSR_SR_MLSR3); + + pub const SFR_MLSR_SR_MLSR4: crate::Register = crate::Register::new(6, 0xffffffff); + pub const SFR_MLSR_SR_MLSR4_SR_MLSR4: crate::Field = crate::Field::new(32, 0, SFR_MLSR_SR_MLSR4); + + pub const SFR_MLSR_SR_MLSR5: crate::Register = crate::Register::new(7, 0xffffffff); + pub const SFR_MLSR_SR_MLSR5_SR_MLSR5: crate::Field = crate::Field::new(32, 0, SFR_MLSR_SR_MLSR5); + + pub const SFR_MLSR_SR_MLSR6: crate::Register = crate::Register::new(8, 0xffffffff); + pub const SFR_MLSR_SR_MLSR6_SR_MLSR6: crate::Field = crate::Field::new(32, 0, SFR_MLSR_SR_MLSR6); + + pub const SFR_MLSR_SR_MLSR7: crate::Register = crate::Register::new(9, 0xffffffff); + pub const SFR_MLSR_SR_MLSR7_SR_MLSR7: crate::Field = crate::Field::new(32, 0, SFR_MLSR_SR_MLSR7); + + pub const HW_MESH_BASE: usize = 0x40052000; + } + + pub mod sensorc { + pub const SENSORC_NUMREGS: usize = 14; + + pub const SFR_VDMASK0: crate::Register = crate::Register::new(0, 0xff); + pub const SFR_VDMASK0_CR_VDMASK0: crate::Field = crate::Field::new(8, 0, SFR_VDMASK0); + + pub const SFR_VDMASK1: crate::Register = crate::Register::new(1, 0xff); + pub const SFR_VDMASK1_CR_VDMASK1: crate::Field = crate::Field::new(8, 0, SFR_VDMASK1); + + pub const SFR_VDSR: crate::Register = crate::Register::new(2, 0xff); + pub const SFR_VDSR_SR_VDSR: crate::Field = crate::Field::new(8, 0, SFR_VDSR); + + pub const SFR_LDMASK: crate::Register = crate::Register::new(4, 0xf); + pub const SFR_LDMASK_CR_LDMASK: crate::Field = crate::Field::new(4, 0, SFR_LDMASK); + + pub const SFR_LDSR: crate::Register = crate::Register::new(5, 0xf); + pub const SFR_LDSR_SR_LDSR: crate::Field = crate::Field::new(4, 0, SFR_LDSR); + + pub const SFR_LDCFG: crate::Register = crate::Register::new(6, 0xf); + pub const SFR_LDCFG_SFR_LDCFG: crate::Field = crate::Field::new(4, 0, SFR_LDCFG); + + pub const SFR_VDCFG_CR_VDCFG0: crate::Register = crate::Register::new(8, 0xf); + pub const SFR_VDCFG_CR_VDCFG0_CR_VDCFG0: crate::Field = crate::Field::new(4, 0, SFR_VDCFG_CR_VDCFG0); + + pub const SFR_VDCFG_CR_VDCFG1: crate::Register = crate::Register::new(9, 0xf); + pub const SFR_VDCFG_CR_VDCFG1_CR_VDCFG1: crate::Field = crate::Field::new(4, 0, SFR_VDCFG_CR_VDCFG1); + + pub const SFR_VDCFG_CR_VDCFG2: crate::Register = crate::Register::new(10, 0xf); + pub const SFR_VDCFG_CR_VDCFG2_CR_VDCFG2: crate::Field = crate::Field::new(4, 0, SFR_VDCFG_CR_VDCFG2); + + pub const SFR_VDCFG_CR_VDCFG3: crate::Register = crate::Register::new(11, 0xf); + pub const SFR_VDCFG_CR_VDCFG3_CR_VDCFG3: crate::Field = crate::Field::new(4, 0, SFR_VDCFG_CR_VDCFG3); + + pub const SFR_VDCFG_CR_VDCFG4: crate::Register = crate::Register::new(12, 0xf); + pub const SFR_VDCFG_CR_VDCFG4_CR_VDCFG4: crate::Field = crate::Field::new(4, 0, SFR_VDCFG_CR_VDCFG4); + + pub const SFR_VDCFG_CR_VDCFG5: crate::Register = crate::Register::new(13, 0xf); + pub const SFR_VDCFG_CR_VDCFG5_CR_VDCFG5: crate::Field = crate::Field::new(4, 0, SFR_VDCFG_CR_VDCFG5); + + pub const SFR_VDCFG_CR_VDCFG6: crate::Register = crate::Register::new(14, 0xf); + pub const SFR_VDCFG_CR_VDCFG6_CR_VDCFG6: crate::Field = crate::Field::new(4, 0, SFR_VDCFG_CR_VDCFG6); + + pub const SFR_VDCFG_CR_VDCFG7: crate::Register = crate::Register::new(15, 0xf); + pub const SFR_VDCFG_CR_VDCFG7_CR_VDCFG7: crate::Field = crate::Field::new(4, 0, SFR_VDCFG_CR_VDCFG7); + + pub const HW_SENSORC_BASE: usize = 0x40053000; + } +} + +// Litex auto-generated constants +pub const LITEX_CONFIG_CLOCK_FREQUENCY: usize = 800000000; +pub const LITEX_CONFIG_CPU_TYPE_NONE: &str = "None"; +pub const LITEX_CONFIG_CPU_VARIANT_STANDARD: &str = "None"; +pub const LITEX_CONFIG_CPU_HUMAN_NAME: &str = "Unknown"; +pub const LITEX_CONFIG_BIOS_NO_BUILD_TIME: &str = "None"; +pub const LITEX_CONFIG_CSR_DATA_WIDTH: usize = 32; +pub const LITEX_CONFIG_CSR_ALIGNMENT: usize = 32; +pub const LITEX_CONFIG_BUS_STANDARD: &str = "AXI-LITE"; +pub const LITEX_CONFIG_BUS_DATA_WIDTH: usize = 32; +pub const LITEX_CONFIG_BUS_ADDRESS_WIDTH: usize = 32; +pub const LITEX_CONFIG_BUS_BURSTING: usize = 0; +pub const LITEX_APP_UART_INTERRUPT: usize = 2; +pub const LITEX_CONSOLE_INTERRUPT: usize = 1; +pub const LITEX_UART_INTERRUPT: usize = 0; +pub const LITEX_CONFIG_CLOCK_FREQUENCY_: usize = 800000000; +pub const LITEX_CONFIG_CPU_HAS_INTERRUPT: &str = "None"; +pub const LITEX_CONFIG_CPU_RESET_ADDR: usize = 1610612736; +pub const LITEX_CONFIG_CPU_HAS_DCACHE: &str = "None"; +pub const LITEX_CONFIG_CPU_HAS_ICACHE: &str = "None"; +pub const LITEX_CONFIG_CPU_TYPE_VEXRISCV_AXI: &str = "None"; +pub const LITEX_CONFIG_CPU_VARIANT_STANDARD_: &str = "None"; +pub const LITEX_CONFIG_CPU_HUMAN_NAME_: &str = "VexRiscvAxi4"; +pub const LITEX_CONFIG_CPU_NOP: &str = "nop"; +pub const LITEX_CONFIG_CSR_DATA_WIDTH_: usize = 32; +pub const LITEX_CONFIG_CSR_ALIGNMENT_: usize = 32; +pub const LITEX_CONFIG_BUS_STANDARD_: &str = "AXI-LITE"; +pub const LITEX_CONFIG_BUS_DATA_WIDTH_: usize = 32; +pub const LITEX_CONFIG_BUS_ADDRESS_WIDTH_: usize = 32; +pub const LITEX_CONFIG_BUS_BURSTING_: usize = 0; +pub const LITEX_IRQARRAY0_INTERRUPT: usize = 0; +pub const LITEX_IRQARRAY1_INTERRUPT: usize = 1; +pub const LITEX_IRQARRAY10_INTERRUPT: usize = 10; +pub const LITEX_IRQARRAY11_INTERRUPT: usize = 11; +pub const LITEX_IRQARRAY12_INTERRUPT: usize = 12; +pub const LITEX_IRQARRAY13_INTERRUPT: usize = 13; +pub const LITEX_IRQARRAY14_INTERRUPT: usize = 14; +pub const LITEX_IRQARRAY15_INTERRUPT: usize = 15; +pub const LITEX_IRQARRAY16_INTERRUPT: usize = 16; +pub const LITEX_IRQARRAY17_INTERRUPT: usize = 17; +pub const LITEX_IRQARRAY18_INTERRUPT: usize = 18; +pub const LITEX_IRQARRAY19_INTERRUPT: usize = 19; +pub const LITEX_IRQARRAY2_INTERRUPT: usize = 2; +pub const LITEX_IRQARRAY3_INTERRUPT: usize = 3; +pub const LITEX_IRQARRAY4_INTERRUPT: usize = 4; +pub const LITEX_IRQARRAY5_INTERRUPT: usize = 5; +pub const LITEX_IRQARRAY6_INTERRUPT: usize = 6; +pub const LITEX_IRQARRAY7_INTERRUPT: usize = 7; +pub const LITEX_IRQARRAY8_INTERRUPT: usize = 8; +pub const LITEX_IRQARRAY9_INTERRUPT: usize = 9; +pub const LITEX_MAILBOX_INTERRUPT: usize = 22; +pub const LITEX_MB_CLIENT_INTERRUPT: usize = 23; +pub const LITEX_SUSRES_INTERRUPT: usize = 21; +pub const LITEX_TICKTIMER_INTERRUPT: usize = 20; + + +#[cfg(test)] +mod tests { + + #[test] + #[ignore] + fn compile_check_gpio_csr() { + use super::*; + let mut gpio_csr = CSR::new(HW_GPIO_BASE as *mut u32); + + let foo = gpio_csr.r(utra::gpio::UARTSEL); + gpio_csr.wo(utra::gpio::UARTSEL, foo); + let bar = gpio_csr.rf(utra::gpio::UARTSEL_UARTSEL); + gpio_csr.rmwf(utra::gpio::UARTSEL_UARTSEL, bar); + let mut baz = gpio_csr.zf(utra::gpio::UARTSEL_UARTSEL, bar); + baz |= gpio_csr.ms(utra::gpio::UARTSEL_UARTSEL, 1); + gpio_csr.wfo(utra::gpio::UARTSEL_UARTSEL, baz); + } + + #[test] + #[ignore] + fn compile_check_uart_csr() { + use super::*; + let mut uart_csr = CSR::new(HW_UART_BASE as *mut u32); + + let foo = uart_csr.r(utra::uart::RXTX); + uart_csr.wo(utra::uart::RXTX, foo); + let bar = uart_csr.rf(utra::uart::RXTX_RXTX); + uart_csr.rmwf(utra::uart::RXTX_RXTX, bar); + let mut baz = uart_csr.zf(utra::uart::RXTX_RXTX, bar); + baz |= uart_csr.ms(utra::uart::RXTX_RXTX, 1); + uart_csr.wfo(utra::uart::RXTX_RXTX, baz); + + let foo = uart_csr.r(utra::uart::TXFULL); + uart_csr.wo(utra::uart::TXFULL, foo); + let bar = uart_csr.rf(utra::uart::TXFULL_TXFULL); + uart_csr.rmwf(utra::uart::TXFULL_TXFULL, bar); + let mut baz = uart_csr.zf(utra::uart::TXFULL_TXFULL, bar); + baz |= uart_csr.ms(utra::uart::TXFULL_TXFULL, 1); + uart_csr.wfo(utra::uart::TXFULL_TXFULL, baz); + + let foo = uart_csr.r(utra::uart::RXEMPTY); + uart_csr.wo(utra::uart::RXEMPTY, foo); + let bar = uart_csr.rf(utra::uart::RXEMPTY_RXEMPTY); + uart_csr.rmwf(utra::uart::RXEMPTY_RXEMPTY, bar); + let mut baz = uart_csr.zf(utra::uart::RXEMPTY_RXEMPTY, bar); + baz |= uart_csr.ms(utra::uart::RXEMPTY_RXEMPTY, 1); + uart_csr.wfo(utra::uart::RXEMPTY_RXEMPTY, baz); + + let foo = uart_csr.r(utra::uart::EV_STATUS); + uart_csr.wo(utra::uart::EV_STATUS, foo); + let bar = uart_csr.rf(utra::uart::EV_STATUS_TX); + uart_csr.rmwf(utra::uart::EV_STATUS_TX, bar); + let mut baz = uart_csr.zf(utra::uart::EV_STATUS_TX, bar); + baz |= uart_csr.ms(utra::uart::EV_STATUS_TX, 1); + uart_csr.wfo(utra::uart::EV_STATUS_TX, baz); + let bar = uart_csr.rf(utra::uart::EV_STATUS_RX); + uart_csr.rmwf(utra::uart::EV_STATUS_RX, bar); + let mut baz = uart_csr.zf(utra::uart::EV_STATUS_RX, bar); + baz |= uart_csr.ms(utra::uart::EV_STATUS_RX, 1); + uart_csr.wfo(utra::uart::EV_STATUS_RX, baz); + + let foo = uart_csr.r(utra::uart::EV_PENDING); + uart_csr.wo(utra::uart::EV_PENDING, foo); + let bar = uart_csr.rf(utra::uart::EV_PENDING_TX); + uart_csr.rmwf(utra::uart::EV_PENDING_TX, bar); + let mut baz = uart_csr.zf(utra::uart::EV_PENDING_TX, bar); + baz |= uart_csr.ms(utra::uart::EV_PENDING_TX, 1); + uart_csr.wfo(utra::uart::EV_PENDING_TX, baz); + let bar = uart_csr.rf(utra::uart::EV_PENDING_RX); + uart_csr.rmwf(utra::uart::EV_PENDING_RX, bar); + let mut baz = uart_csr.zf(utra::uart::EV_PENDING_RX, bar); + baz |= uart_csr.ms(utra::uart::EV_PENDING_RX, 1); + uart_csr.wfo(utra::uart::EV_PENDING_RX, baz); + + let foo = uart_csr.r(utra::uart::EV_ENABLE); + uart_csr.wo(utra::uart::EV_ENABLE, foo); + let bar = uart_csr.rf(utra::uart::EV_ENABLE_TX); + uart_csr.rmwf(utra::uart::EV_ENABLE_TX, bar); + let mut baz = uart_csr.zf(utra::uart::EV_ENABLE_TX, bar); + baz |= uart_csr.ms(utra::uart::EV_ENABLE_TX, 1); + uart_csr.wfo(utra::uart::EV_ENABLE_TX, baz); + let bar = uart_csr.rf(utra::uart::EV_ENABLE_RX); + uart_csr.rmwf(utra::uart::EV_ENABLE_RX, bar); + let mut baz = uart_csr.zf(utra::uart::EV_ENABLE_RX, bar); + baz |= uart_csr.ms(utra::uart::EV_ENABLE_RX, 1); + uart_csr.wfo(utra::uart::EV_ENABLE_RX, baz); + + let foo = uart_csr.r(utra::uart::TXEMPTY); + uart_csr.wo(utra::uart::TXEMPTY, foo); + let bar = uart_csr.rf(utra::uart::TXEMPTY_TXEMPTY); + uart_csr.rmwf(utra::uart::TXEMPTY_TXEMPTY, bar); + let mut baz = uart_csr.zf(utra::uart::TXEMPTY_TXEMPTY, bar); + baz |= uart_csr.ms(utra::uart::TXEMPTY_TXEMPTY, 1); + uart_csr.wfo(utra::uart::TXEMPTY_TXEMPTY, baz); + + let foo = uart_csr.r(utra::uart::RXFULL); + uart_csr.wo(utra::uart::RXFULL, foo); + let bar = uart_csr.rf(utra::uart::RXFULL_RXFULL); + uart_csr.rmwf(utra::uart::RXFULL_RXFULL, bar); + let mut baz = uart_csr.zf(utra::uart::RXFULL_RXFULL, bar); + baz |= uart_csr.ms(utra::uart::RXFULL_RXFULL, 1); + uart_csr.wfo(utra::uart::RXFULL_RXFULL, baz); + } + + #[test] + #[ignore] + fn compile_check_console_csr() { + use super::*; + let mut console_csr = CSR::new(HW_CONSOLE_BASE as *mut u32); + + let foo = console_csr.r(utra::console::RXTX); + console_csr.wo(utra::console::RXTX, foo); + let bar = console_csr.rf(utra::console::RXTX_RXTX); + console_csr.rmwf(utra::console::RXTX_RXTX, bar); + let mut baz = console_csr.zf(utra::console::RXTX_RXTX, bar); + baz |= console_csr.ms(utra::console::RXTX_RXTX, 1); + console_csr.wfo(utra::console::RXTX_RXTX, baz); + + let foo = console_csr.r(utra::console::TXFULL); + console_csr.wo(utra::console::TXFULL, foo); + let bar = console_csr.rf(utra::console::TXFULL_TXFULL); + console_csr.rmwf(utra::console::TXFULL_TXFULL, bar); + let mut baz = console_csr.zf(utra::console::TXFULL_TXFULL, bar); + baz |= console_csr.ms(utra::console::TXFULL_TXFULL, 1); + console_csr.wfo(utra::console::TXFULL_TXFULL, baz); + + let foo = console_csr.r(utra::console::RXEMPTY); + console_csr.wo(utra::console::RXEMPTY, foo); + let bar = console_csr.rf(utra::console::RXEMPTY_RXEMPTY); + console_csr.rmwf(utra::console::RXEMPTY_RXEMPTY, bar); + let mut baz = console_csr.zf(utra::console::RXEMPTY_RXEMPTY, bar); + baz |= console_csr.ms(utra::console::RXEMPTY_RXEMPTY, 1); + console_csr.wfo(utra::console::RXEMPTY_RXEMPTY, baz); + + let foo = console_csr.r(utra::console::EV_STATUS); + console_csr.wo(utra::console::EV_STATUS, foo); + let bar = console_csr.rf(utra::console::EV_STATUS_TX); + console_csr.rmwf(utra::console::EV_STATUS_TX, bar); + let mut baz = console_csr.zf(utra::console::EV_STATUS_TX, bar); + baz |= console_csr.ms(utra::console::EV_STATUS_TX, 1); + console_csr.wfo(utra::console::EV_STATUS_TX, baz); + let bar = console_csr.rf(utra::console::EV_STATUS_RX); + console_csr.rmwf(utra::console::EV_STATUS_RX, bar); + let mut baz = console_csr.zf(utra::console::EV_STATUS_RX, bar); + baz |= console_csr.ms(utra::console::EV_STATUS_RX, 1); + console_csr.wfo(utra::console::EV_STATUS_RX, baz); + + let foo = console_csr.r(utra::console::EV_PENDING); + console_csr.wo(utra::console::EV_PENDING, foo); + let bar = console_csr.rf(utra::console::EV_PENDING_TX); + console_csr.rmwf(utra::console::EV_PENDING_TX, bar); + let mut baz = console_csr.zf(utra::console::EV_PENDING_TX, bar); + baz |= console_csr.ms(utra::console::EV_PENDING_TX, 1); + console_csr.wfo(utra::console::EV_PENDING_TX, baz); + let bar = console_csr.rf(utra::console::EV_PENDING_RX); + console_csr.rmwf(utra::console::EV_PENDING_RX, bar); + let mut baz = console_csr.zf(utra::console::EV_PENDING_RX, bar); + baz |= console_csr.ms(utra::console::EV_PENDING_RX, 1); + console_csr.wfo(utra::console::EV_PENDING_RX, baz); + + let foo = console_csr.r(utra::console::EV_ENABLE); + console_csr.wo(utra::console::EV_ENABLE, foo); + let bar = console_csr.rf(utra::console::EV_ENABLE_TX); + console_csr.rmwf(utra::console::EV_ENABLE_TX, bar); + let mut baz = console_csr.zf(utra::console::EV_ENABLE_TX, bar); + baz |= console_csr.ms(utra::console::EV_ENABLE_TX, 1); + console_csr.wfo(utra::console::EV_ENABLE_TX, baz); + let bar = console_csr.rf(utra::console::EV_ENABLE_RX); + console_csr.rmwf(utra::console::EV_ENABLE_RX, bar); + let mut baz = console_csr.zf(utra::console::EV_ENABLE_RX, bar); + baz |= console_csr.ms(utra::console::EV_ENABLE_RX, 1); + console_csr.wfo(utra::console::EV_ENABLE_RX, baz); + + let foo = console_csr.r(utra::console::TXEMPTY); + console_csr.wo(utra::console::TXEMPTY, foo); + let bar = console_csr.rf(utra::console::TXEMPTY_TXEMPTY); + console_csr.rmwf(utra::console::TXEMPTY_TXEMPTY, bar); + let mut baz = console_csr.zf(utra::console::TXEMPTY_TXEMPTY, bar); + baz |= console_csr.ms(utra::console::TXEMPTY_TXEMPTY, 1); + console_csr.wfo(utra::console::TXEMPTY_TXEMPTY, baz); + + let foo = console_csr.r(utra::console::RXFULL); + console_csr.wo(utra::console::RXFULL, foo); + let bar = console_csr.rf(utra::console::RXFULL_RXFULL); + console_csr.rmwf(utra::console::RXFULL_RXFULL, bar); + let mut baz = console_csr.zf(utra::console::RXFULL_RXFULL, bar); + baz |= console_csr.ms(utra::console::RXFULL_RXFULL, 1); + console_csr.wfo(utra::console::RXFULL_RXFULL, baz); + } + + #[test] + #[ignore] + fn compile_check_app_uart_csr() { + use super::*; + let mut app_uart_csr = CSR::new(HW_APP_UART_BASE as *mut u32); + + let foo = app_uart_csr.r(utra::app_uart::RXTX); + app_uart_csr.wo(utra::app_uart::RXTX, foo); + let bar = app_uart_csr.rf(utra::app_uart::RXTX_RXTX); + app_uart_csr.rmwf(utra::app_uart::RXTX_RXTX, bar); + let mut baz = app_uart_csr.zf(utra::app_uart::RXTX_RXTX, bar); + baz |= app_uart_csr.ms(utra::app_uart::RXTX_RXTX, 1); + app_uart_csr.wfo(utra::app_uart::RXTX_RXTX, baz); + + let foo = app_uart_csr.r(utra::app_uart::TXFULL); + app_uart_csr.wo(utra::app_uart::TXFULL, foo); + let bar = app_uart_csr.rf(utra::app_uart::TXFULL_TXFULL); + app_uart_csr.rmwf(utra::app_uart::TXFULL_TXFULL, bar); + let mut baz = app_uart_csr.zf(utra::app_uart::TXFULL_TXFULL, bar); + baz |= app_uart_csr.ms(utra::app_uart::TXFULL_TXFULL, 1); + app_uart_csr.wfo(utra::app_uart::TXFULL_TXFULL, baz); + + let foo = app_uart_csr.r(utra::app_uart::RXEMPTY); + app_uart_csr.wo(utra::app_uart::RXEMPTY, foo); + let bar = app_uart_csr.rf(utra::app_uart::RXEMPTY_RXEMPTY); + app_uart_csr.rmwf(utra::app_uart::RXEMPTY_RXEMPTY, bar); + let mut baz = app_uart_csr.zf(utra::app_uart::RXEMPTY_RXEMPTY, bar); + baz |= app_uart_csr.ms(utra::app_uart::RXEMPTY_RXEMPTY, 1); + app_uart_csr.wfo(utra::app_uart::RXEMPTY_RXEMPTY, baz); + + let foo = app_uart_csr.r(utra::app_uart::EV_STATUS); + app_uart_csr.wo(utra::app_uart::EV_STATUS, foo); + let bar = app_uart_csr.rf(utra::app_uart::EV_STATUS_TX); + app_uart_csr.rmwf(utra::app_uart::EV_STATUS_TX, bar); + let mut baz = app_uart_csr.zf(utra::app_uart::EV_STATUS_TX, bar); + baz |= app_uart_csr.ms(utra::app_uart::EV_STATUS_TX, 1); + app_uart_csr.wfo(utra::app_uart::EV_STATUS_TX, baz); + let bar = app_uart_csr.rf(utra::app_uart::EV_STATUS_RX); + app_uart_csr.rmwf(utra::app_uart::EV_STATUS_RX, bar); + let mut baz = app_uart_csr.zf(utra::app_uart::EV_STATUS_RX, bar); + baz |= app_uart_csr.ms(utra::app_uart::EV_STATUS_RX, 1); + app_uart_csr.wfo(utra::app_uart::EV_STATUS_RX, baz); + + let foo = app_uart_csr.r(utra::app_uart::EV_PENDING); + app_uart_csr.wo(utra::app_uart::EV_PENDING, foo); + let bar = app_uart_csr.rf(utra::app_uart::EV_PENDING_TX); + app_uart_csr.rmwf(utra::app_uart::EV_PENDING_TX, bar); + let mut baz = app_uart_csr.zf(utra::app_uart::EV_PENDING_TX, bar); + baz |= app_uart_csr.ms(utra::app_uart::EV_PENDING_TX, 1); + app_uart_csr.wfo(utra::app_uart::EV_PENDING_TX, baz); + let bar = app_uart_csr.rf(utra::app_uart::EV_PENDING_RX); + app_uart_csr.rmwf(utra::app_uart::EV_PENDING_RX, bar); + let mut baz = app_uart_csr.zf(utra::app_uart::EV_PENDING_RX, bar); + baz |= app_uart_csr.ms(utra::app_uart::EV_PENDING_RX, 1); + app_uart_csr.wfo(utra::app_uart::EV_PENDING_RX, baz); + + let foo = app_uart_csr.r(utra::app_uart::EV_ENABLE); + app_uart_csr.wo(utra::app_uart::EV_ENABLE, foo); + let bar = app_uart_csr.rf(utra::app_uart::EV_ENABLE_TX); + app_uart_csr.rmwf(utra::app_uart::EV_ENABLE_TX, bar); + let mut baz = app_uart_csr.zf(utra::app_uart::EV_ENABLE_TX, bar); + baz |= app_uart_csr.ms(utra::app_uart::EV_ENABLE_TX, 1); + app_uart_csr.wfo(utra::app_uart::EV_ENABLE_TX, baz); + let bar = app_uart_csr.rf(utra::app_uart::EV_ENABLE_RX); + app_uart_csr.rmwf(utra::app_uart::EV_ENABLE_RX, bar); + let mut baz = app_uart_csr.zf(utra::app_uart::EV_ENABLE_RX, bar); + baz |= app_uart_csr.ms(utra::app_uart::EV_ENABLE_RX, 1); + app_uart_csr.wfo(utra::app_uart::EV_ENABLE_RX, baz); + + let foo = app_uart_csr.r(utra::app_uart::TXEMPTY); + app_uart_csr.wo(utra::app_uart::TXEMPTY, foo); + let bar = app_uart_csr.rf(utra::app_uart::TXEMPTY_TXEMPTY); + app_uart_csr.rmwf(utra::app_uart::TXEMPTY_TXEMPTY, bar); + let mut baz = app_uart_csr.zf(utra::app_uart::TXEMPTY_TXEMPTY, bar); + baz |= app_uart_csr.ms(utra::app_uart::TXEMPTY_TXEMPTY, 1); + app_uart_csr.wfo(utra::app_uart::TXEMPTY_TXEMPTY, baz); + + let foo = app_uart_csr.r(utra::app_uart::RXFULL); + app_uart_csr.wo(utra::app_uart::RXFULL, foo); + let bar = app_uart_csr.rf(utra::app_uart::RXFULL_RXFULL); + app_uart_csr.rmwf(utra::app_uart::RXFULL_RXFULL, bar); + let mut baz = app_uart_csr.zf(utra::app_uart::RXFULL_RXFULL, bar); + baz |= app_uart_csr.ms(utra::app_uart::RXFULL_RXFULL, 1); + app_uart_csr.wfo(utra::app_uart::RXFULL_RXFULL, baz); + } + + #[test] + #[ignore] + fn compile_check_identifier_mem_csr() { + use super::*; + let mut identifier_mem_csr = CSR::new(HW_IDENTIFIER_MEM_BASE as *mut u32); + + let foo = identifier_mem_csr.r(utra::identifier_mem::IDENTIFIER_MEM); + identifier_mem_csr.wo(utra::identifier_mem::IDENTIFIER_MEM, foo); + let bar = identifier_mem_csr.rf(utra::identifier_mem::IDENTIFIER_MEM_IDENTIFIER_MEM); + identifier_mem_csr.rmwf(utra::identifier_mem::IDENTIFIER_MEM_IDENTIFIER_MEM, bar); + let mut baz = identifier_mem_csr.zf(utra::identifier_mem::IDENTIFIER_MEM_IDENTIFIER_MEM, bar); + baz |= identifier_mem_csr.ms(utra::identifier_mem::IDENTIFIER_MEM_IDENTIFIER_MEM, 1); + identifier_mem_csr.wfo(utra::identifier_mem::IDENTIFIER_MEM_IDENTIFIER_MEM, baz); + } + + #[test] + #[ignore] + fn compile_check_main_csr() { + use super::*; + let mut main_csr = CSR::new(HW_MAIN_BASE as *mut u32); + + let foo = main_csr.r(utra::main::REPORT); + main_csr.wo(utra::main::REPORT, foo); + let bar = main_csr.rf(utra::main::REPORT_REPORT); + main_csr.rmwf(utra::main::REPORT_REPORT, bar); + let mut baz = main_csr.zf(utra::main::REPORT_REPORT, bar); + baz |= main_csr.ms(utra::main::REPORT_REPORT, 1); + main_csr.wfo(utra::main::REPORT_REPORT, baz); + + let foo = main_csr.r(utra::main::SUCCESS); + main_csr.wo(utra::main::SUCCESS, foo); + let bar = main_csr.rf(utra::main::SUCCESS_SUCCESS); + main_csr.rmwf(utra::main::SUCCESS_SUCCESS, bar); + let mut baz = main_csr.zf(utra::main::SUCCESS_SUCCESS, bar); + baz |= main_csr.ms(utra::main::SUCCESS_SUCCESS, 1); + main_csr.wfo(utra::main::SUCCESS_SUCCESS, baz); + + let foo = main_csr.r(utra::main::DONE); + main_csr.wo(utra::main::DONE, foo); + let bar = main_csr.rf(utra::main::DONE_DONE); + main_csr.rmwf(utra::main::DONE_DONE, bar); + let mut baz = main_csr.zf(utra::main::DONE_DONE, bar); + baz |= main_csr.ms(utra::main::DONE_DONE, 1); + main_csr.wfo(utra::main::DONE_DONE, baz); + + let foo = main_csr.r(utra::main::WDATA); + main_csr.wo(utra::main::WDATA, foo); + let bar = main_csr.rf(utra::main::WDATA_WDATA); + main_csr.rmwf(utra::main::WDATA_WDATA, bar); + let mut baz = main_csr.zf(utra::main::WDATA_WDATA, bar); + baz |= main_csr.ms(utra::main::WDATA_WDATA, 1); + main_csr.wfo(utra::main::WDATA_WDATA, baz); + + let foo = main_csr.r(utra::main::RDATA); + main_csr.wo(utra::main::RDATA, foo); + let bar = main_csr.rf(utra::main::RDATA_RDATA); + main_csr.rmwf(utra::main::RDATA_RDATA, bar); + let mut baz = main_csr.zf(utra::main::RDATA_RDATA, bar); + baz |= main_csr.ms(utra::main::RDATA_RDATA, 1); + main_csr.wfo(utra::main::RDATA_RDATA, baz); + + let foo = main_csr.r(utra::main::RINC); + main_csr.wo(utra::main::RINC, foo); + let bar = main_csr.rf(utra::main::RINC_RINC); + main_csr.rmwf(utra::main::RINC_RINC, bar); + let mut baz = main_csr.zf(utra::main::RINC_RINC, bar); + baz |= main_csr.ms(utra::main::RINC_RINC, 1); + main_csr.wfo(utra::main::RINC_RINC, baz); + + let foo = main_csr.r(utra::main::IRQTEST0); + main_csr.wo(utra::main::IRQTEST0, foo); + let bar = main_csr.rf(utra::main::IRQTEST0_TRIGGER); + main_csr.rmwf(utra::main::IRQTEST0_TRIGGER, bar); + let mut baz = main_csr.zf(utra::main::IRQTEST0_TRIGGER, bar); + baz |= main_csr.ms(utra::main::IRQTEST0_TRIGGER, 1); + main_csr.wfo(utra::main::IRQTEST0_TRIGGER, baz); + + let foo = main_csr.r(utra::main::IRQTEST1); + main_csr.wo(utra::main::IRQTEST1, foo); + let bar = main_csr.rf(utra::main::IRQTEST1_TRIGGER); + main_csr.rmwf(utra::main::IRQTEST1_TRIGGER, bar); + let mut baz = main_csr.zf(utra::main::IRQTEST1_TRIGGER, bar); + baz |= main_csr.ms(utra::main::IRQTEST1_TRIGGER, 1); + main_csr.wfo(utra::main::IRQTEST1_TRIGGER, baz); + } + + #[test] + #[ignore] + fn compile_check_d11ctime_csr() { + use super::*; + let mut d11ctime_csr = CSR::new(HW_D11CTIME_BASE as *mut u32); + + let foo = d11ctime_csr.r(utra::d11ctime::CONTROL); + d11ctime_csr.wo(utra::d11ctime::CONTROL, foo); + let bar = d11ctime_csr.rf(utra::d11ctime::CONTROL_COUNT); + d11ctime_csr.rmwf(utra::d11ctime::CONTROL_COUNT, bar); + let mut baz = d11ctime_csr.zf(utra::d11ctime::CONTROL_COUNT, bar); + baz |= d11ctime_csr.ms(utra::d11ctime::CONTROL_COUNT, 1); + d11ctime_csr.wfo(utra::d11ctime::CONTROL_COUNT, baz); + + let foo = d11ctime_csr.r(utra::d11ctime::HEARTBEAT); + d11ctime_csr.wo(utra::d11ctime::HEARTBEAT, foo); + let bar = d11ctime_csr.rf(utra::d11ctime::HEARTBEAT_BEAT); + d11ctime_csr.rmwf(utra::d11ctime::HEARTBEAT_BEAT, bar); + let mut baz = d11ctime_csr.zf(utra::d11ctime::HEARTBEAT_BEAT, bar); + baz |= d11ctime_csr.ms(utra::d11ctime::HEARTBEAT_BEAT, 1); + d11ctime_csr.wfo(utra::d11ctime::HEARTBEAT_BEAT, baz); + } + + #[test] + #[ignore] + fn compile_check_susres_csr() { + use super::*; + let mut susres_csr = CSR::new(HW_SUSRES_BASE as *mut u32); + + let foo = susres_csr.r(utra::susres::CONTROL); + susres_csr.wo(utra::susres::CONTROL, foo); + let bar = susres_csr.rf(utra::susres::CONTROL_PAUSE); + susres_csr.rmwf(utra::susres::CONTROL_PAUSE, bar); + let mut baz = susres_csr.zf(utra::susres::CONTROL_PAUSE, bar); + baz |= susres_csr.ms(utra::susres::CONTROL_PAUSE, 1); + susres_csr.wfo(utra::susres::CONTROL_PAUSE, baz); + let bar = susres_csr.rf(utra::susres::CONTROL_LOAD); + susres_csr.rmwf(utra::susres::CONTROL_LOAD, bar); + let mut baz = susres_csr.zf(utra::susres::CONTROL_LOAD, bar); + baz |= susres_csr.ms(utra::susres::CONTROL_LOAD, 1); + susres_csr.wfo(utra::susres::CONTROL_LOAD, baz); + + let foo = susres_csr.r(utra::susres::RESUME_TIME1); + susres_csr.wo(utra::susres::RESUME_TIME1, foo); + let bar = susres_csr.rf(utra::susres::RESUME_TIME1_RESUME_TIME); + susres_csr.rmwf(utra::susres::RESUME_TIME1_RESUME_TIME, bar); + let mut baz = susres_csr.zf(utra::susres::RESUME_TIME1_RESUME_TIME, bar); + baz |= susres_csr.ms(utra::susres::RESUME_TIME1_RESUME_TIME, 1); + susres_csr.wfo(utra::susres::RESUME_TIME1_RESUME_TIME, baz); + + let foo = susres_csr.r(utra::susres::RESUME_TIME0); + susres_csr.wo(utra::susres::RESUME_TIME0, foo); + let bar = susres_csr.rf(utra::susres::RESUME_TIME0_RESUME_TIME); + susres_csr.rmwf(utra::susres::RESUME_TIME0_RESUME_TIME, bar); + let mut baz = susres_csr.zf(utra::susres::RESUME_TIME0_RESUME_TIME, bar); + baz |= susres_csr.ms(utra::susres::RESUME_TIME0_RESUME_TIME, 1); + susres_csr.wfo(utra::susres::RESUME_TIME0_RESUME_TIME, baz); + + let foo = susres_csr.r(utra::susres::TIME1); + susres_csr.wo(utra::susres::TIME1, foo); + let bar = susres_csr.rf(utra::susres::TIME1_TIME); + susres_csr.rmwf(utra::susres::TIME1_TIME, bar); + let mut baz = susres_csr.zf(utra::susres::TIME1_TIME, bar); + baz |= susres_csr.ms(utra::susres::TIME1_TIME, 1); + susres_csr.wfo(utra::susres::TIME1_TIME, baz); + + let foo = susres_csr.r(utra::susres::TIME0); + susres_csr.wo(utra::susres::TIME0, foo); + let bar = susres_csr.rf(utra::susres::TIME0_TIME); + susres_csr.rmwf(utra::susres::TIME0_TIME, bar); + let mut baz = susres_csr.zf(utra::susres::TIME0_TIME, bar); + baz |= susres_csr.ms(utra::susres::TIME0_TIME, 1); + susres_csr.wfo(utra::susres::TIME0_TIME, baz); + + let foo = susres_csr.r(utra::susres::STATUS); + susres_csr.wo(utra::susres::STATUS, foo); + let bar = susres_csr.rf(utra::susres::STATUS_PAUSED); + susres_csr.rmwf(utra::susres::STATUS_PAUSED, bar); + let mut baz = susres_csr.zf(utra::susres::STATUS_PAUSED, bar); + baz |= susres_csr.ms(utra::susres::STATUS_PAUSED, 1); + susres_csr.wfo(utra::susres::STATUS_PAUSED, baz); + + let foo = susres_csr.r(utra::susres::STATE); + susres_csr.wo(utra::susres::STATE, foo); + let bar = susres_csr.rf(utra::susres::STATE_RESUME); + susres_csr.rmwf(utra::susres::STATE_RESUME, bar); + let mut baz = susres_csr.zf(utra::susres::STATE_RESUME, bar); + baz |= susres_csr.ms(utra::susres::STATE_RESUME, 1); + susres_csr.wfo(utra::susres::STATE_RESUME, baz); + let bar = susres_csr.rf(utra::susres::STATE_WAS_FORCED); + susres_csr.rmwf(utra::susres::STATE_WAS_FORCED, bar); + let mut baz = susres_csr.zf(utra::susres::STATE_WAS_FORCED, bar); + baz |= susres_csr.ms(utra::susres::STATE_WAS_FORCED, 1); + susres_csr.wfo(utra::susres::STATE_WAS_FORCED, baz); + + let foo = susres_csr.r(utra::susres::INTERRUPT); + susres_csr.wo(utra::susres::INTERRUPT, foo); + let bar = susres_csr.rf(utra::susres::INTERRUPT_INTERRUPT); + susres_csr.rmwf(utra::susres::INTERRUPT_INTERRUPT, bar); + let mut baz = susres_csr.zf(utra::susres::INTERRUPT_INTERRUPT, bar); + baz |= susres_csr.ms(utra::susres::INTERRUPT_INTERRUPT, 1); + susres_csr.wfo(utra::susres::INTERRUPT_INTERRUPT, baz); + + let foo = susres_csr.r(utra::susres::EV_STATUS); + susres_csr.wo(utra::susres::EV_STATUS, foo); + let bar = susres_csr.rf(utra::susres::EV_STATUS_SOFT_INT); + susres_csr.rmwf(utra::susres::EV_STATUS_SOFT_INT, bar); + let mut baz = susres_csr.zf(utra::susres::EV_STATUS_SOFT_INT, bar); + baz |= susres_csr.ms(utra::susres::EV_STATUS_SOFT_INT, 1); + susres_csr.wfo(utra::susres::EV_STATUS_SOFT_INT, baz); + + let foo = susres_csr.r(utra::susres::EV_PENDING); + susres_csr.wo(utra::susres::EV_PENDING, foo); + let bar = susres_csr.rf(utra::susres::EV_PENDING_SOFT_INT); + susres_csr.rmwf(utra::susres::EV_PENDING_SOFT_INT, bar); + let mut baz = susres_csr.zf(utra::susres::EV_PENDING_SOFT_INT, bar); + baz |= susres_csr.ms(utra::susres::EV_PENDING_SOFT_INT, 1); + susres_csr.wfo(utra::susres::EV_PENDING_SOFT_INT, baz); + + let foo = susres_csr.r(utra::susres::EV_ENABLE); + susres_csr.wo(utra::susres::EV_ENABLE, foo); + let bar = susres_csr.rf(utra::susres::EV_ENABLE_SOFT_INT); + susres_csr.rmwf(utra::susres::EV_ENABLE_SOFT_INT, bar); + let mut baz = susres_csr.zf(utra::susres::EV_ENABLE_SOFT_INT, bar); + baz |= susres_csr.ms(utra::susres::EV_ENABLE_SOFT_INT, 1); + susres_csr.wfo(utra::susres::EV_ENABLE_SOFT_INT, baz); + } + + #[test] + #[ignore] + fn compile_check_coreuser_csr() { + use super::*; + let mut coreuser_csr = CSR::new(HW_COREUSER_BASE as *mut u32); + + let foo = coreuser_csr.r(utra::coreuser::SET_ASID); + coreuser_csr.wo(utra::coreuser::SET_ASID, foo); + let bar = coreuser_csr.rf(utra::coreuser::SET_ASID_ASID); + coreuser_csr.rmwf(utra::coreuser::SET_ASID_ASID, bar); + let mut baz = coreuser_csr.zf(utra::coreuser::SET_ASID_ASID, bar); + baz |= coreuser_csr.ms(utra::coreuser::SET_ASID_ASID, 1); + coreuser_csr.wfo(utra::coreuser::SET_ASID_ASID, baz); + let bar = coreuser_csr.rf(utra::coreuser::SET_ASID_TRUSTED); + coreuser_csr.rmwf(utra::coreuser::SET_ASID_TRUSTED, bar); + let mut baz = coreuser_csr.zf(utra::coreuser::SET_ASID_TRUSTED, bar); + baz |= coreuser_csr.ms(utra::coreuser::SET_ASID_TRUSTED, 1); + coreuser_csr.wfo(utra::coreuser::SET_ASID_TRUSTED, baz); + + let foo = coreuser_csr.r(utra::coreuser::GET_ASID_ADDR); + coreuser_csr.wo(utra::coreuser::GET_ASID_ADDR, foo); + let bar = coreuser_csr.rf(utra::coreuser::GET_ASID_ADDR_ASID); + coreuser_csr.rmwf(utra::coreuser::GET_ASID_ADDR_ASID, bar); + let mut baz = coreuser_csr.zf(utra::coreuser::GET_ASID_ADDR_ASID, bar); + baz |= coreuser_csr.ms(utra::coreuser::GET_ASID_ADDR_ASID, 1); + coreuser_csr.wfo(utra::coreuser::GET_ASID_ADDR_ASID, baz); + + let foo = coreuser_csr.r(utra::coreuser::GET_ASID_VALUE); + coreuser_csr.wo(utra::coreuser::GET_ASID_VALUE, foo); + let bar = coreuser_csr.rf(utra::coreuser::GET_ASID_VALUE_VALUE); + coreuser_csr.rmwf(utra::coreuser::GET_ASID_VALUE_VALUE, bar); + let mut baz = coreuser_csr.zf(utra::coreuser::GET_ASID_VALUE_VALUE, bar); + baz |= coreuser_csr.ms(utra::coreuser::GET_ASID_VALUE_VALUE, 1); + coreuser_csr.wfo(utra::coreuser::GET_ASID_VALUE_VALUE, baz); + + let foo = coreuser_csr.r(utra::coreuser::SET_PRIVILEGE); + coreuser_csr.wo(utra::coreuser::SET_PRIVILEGE, foo); + let bar = coreuser_csr.rf(utra::coreuser::SET_PRIVILEGE_MPP); + coreuser_csr.rmwf(utra::coreuser::SET_PRIVILEGE_MPP, bar); + let mut baz = coreuser_csr.zf(utra::coreuser::SET_PRIVILEGE_MPP, bar); + baz |= coreuser_csr.ms(utra::coreuser::SET_PRIVILEGE_MPP, 1); + coreuser_csr.wfo(utra::coreuser::SET_PRIVILEGE_MPP, baz); + + let foo = coreuser_csr.r(utra::coreuser::CONTROL); + coreuser_csr.wo(utra::coreuser::CONTROL, foo); + let bar = coreuser_csr.rf(utra::coreuser::CONTROL_ENABLE); + coreuser_csr.rmwf(utra::coreuser::CONTROL_ENABLE, bar); + let mut baz = coreuser_csr.zf(utra::coreuser::CONTROL_ENABLE, bar); + baz |= coreuser_csr.ms(utra::coreuser::CONTROL_ENABLE, 1); + coreuser_csr.wfo(utra::coreuser::CONTROL_ENABLE, baz); + let bar = coreuser_csr.rf(utra::coreuser::CONTROL_ASID); + coreuser_csr.rmwf(utra::coreuser::CONTROL_ASID, bar); + let mut baz = coreuser_csr.zf(utra::coreuser::CONTROL_ASID, bar); + baz |= coreuser_csr.ms(utra::coreuser::CONTROL_ASID, 1); + coreuser_csr.wfo(utra::coreuser::CONTROL_ASID, baz); + let bar = coreuser_csr.rf(utra::coreuser::CONTROL_PPN_A); + coreuser_csr.rmwf(utra::coreuser::CONTROL_PPN_A, bar); + let mut baz = coreuser_csr.zf(utra::coreuser::CONTROL_PPN_A, bar); + baz |= coreuser_csr.ms(utra::coreuser::CONTROL_PPN_A, 1); + coreuser_csr.wfo(utra::coreuser::CONTROL_PPN_A, baz); + let bar = coreuser_csr.rf(utra::coreuser::CONTROL_PPN_B); + coreuser_csr.rmwf(utra::coreuser::CONTROL_PPN_B, bar); + let mut baz = coreuser_csr.zf(utra::coreuser::CONTROL_PPN_B, bar); + baz |= coreuser_csr.ms(utra::coreuser::CONTROL_PPN_B, 1); + coreuser_csr.wfo(utra::coreuser::CONTROL_PPN_B, baz); + let bar = coreuser_csr.rf(utra::coreuser::CONTROL_PRIVILEGE); + coreuser_csr.rmwf(utra::coreuser::CONTROL_PRIVILEGE, bar); + let mut baz = coreuser_csr.zf(utra::coreuser::CONTROL_PRIVILEGE, bar); + baz |= coreuser_csr.ms(utra::coreuser::CONTROL_PRIVILEGE, 1); + coreuser_csr.wfo(utra::coreuser::CONTROL_PRIVILEGE, baz); + + let foo = coreuser_csr.r(utra::coreuser::PROTECT); + coreuser_csr.wo(utra::coreuser::PROTECT, foo); + let bar = coreuser_csr.rf(utra::coreuser::PROTECT_PROTECT); + coreuser_csr.rmwf(utra::coreuser::PROTECT_PROTECT, bar); + let mut baz = coreuser_csr.zf(utra::coreuser::PROTECT_PROTECT, bar); + baz |= coreuser_csr.ms(utra::coreuser::PROTECT_PROTECT, 1); + coreuser_csr.wfo(utra::coreuser::PROTECT_PROTECT, baz); + + let foo = coreuser_csr.r(utra::coreuser::WINDOW_AL); + coreuser_csr.wo(utra::coreuser::WINDOW_AL, foo); + let bar = coreuser_csr.rf(utra::coreuser::WINDOW_AL_PPN); + coreuser_csr.rmwf(utra::coreuser::WINDOW_AL_PPN, bar); + let mut baz = coreuser_csr.zf(utra::coreuser::WINDOW_AL_PPN, bar); + baz |= coreuser_csr.ms(utra::coreuser::WINDOW_AL_PPN, 1); + coreuser_csr.wfo(utra::coreuser::WINDOW_AL_PPN, baz); + + let foo = coreuser_csr.r(utra::coreuser::WINDOW_AH); + coreuser_csr.wo(utra::coreuser::WINDOW_AH, foo); + let bar = coreuser_csr.rf(utra::coreuser::WINDOW_AH_PPN); + coreuser_csr.rmwf(utra::coreuser::WINDOW_AH_PPN, bar); + let mut baz = coreuser_csr.zf(utra::coreuser::WINDOW_AH_PPN, bar); + baz |= coreuser_csr.ms(utra::coreuser::WINDOW_AH_PPN, 1); + coreuser_csr.wfo(utra::coreuser::WINDOW_AH_PPN, baz); + + let foo = coreuser_csr.r(utra::coreuser::WINDOW_BL); + coreuser_csr.wo(utra::coreuser::WINDOW_BL, foo); + let bar = coreuser_csr.rf(utra::coreuser::WINDOW_BL_PPN); + coreuser_csr.rmwf(utra::coreuser::WINDOW_BL_PPN, bar); + let mut baz = coreuser_csr.zf(utra::coreuser::WINDOW_BL_PPN, bar); + baz |= coreuser_csr.ms(utra::coreuser::WINDOW_BL_PPN, 1); + coreuser_csr.wfo(utra::coreuser::WINDOW_BL_PPN, baz); + + let foo = coreuser_csr.r(utra::coreuser::WINDOW_BH); + coreuser_csr.wo(utra::coreuser::WINDOW_BH, foo); + let bar = coreuser_csr.rf(utra::coreuser::WINDOW_BH_PPN); + coreuser_csr.rmwf(utra::coreuser::WINDOW_BH_PPN, bar); + let mut baz = coreuser_csr.zf(utra::coreuser::WINDOW_BH_PPN, bar); + baz |= coreuser_csr.ms(utra::coreuser::WINDOW_BH_PPN, 1); + coreuser_csr.wfo(utra::coreuser::WINDOW_BH_PPN, baz); + } + + #[test] + #[ignore] + fn compile_check_csrtest_csr() { + use super::*; + let mut csrtest_csr = CSR::new(HW_CSRTEST_BASE as *mut u32); + + let foo = csrtest_csr.r(utra::csrtest::WTEST); + csrtest_csr.wo(utra::csrtest::WTEST, foo); + let bar = csrtest_csr.rf(utra::csrtest::WTEST_WTEST); + csrtest_csr.rmwf(utra::csrtest::WTEST_WTEST, bar); + let mut baz = csrtest_csr.zf(utra::csrtest::WTEST_WTEST, bar); + baz |= csrtest_csr.ms(utra::csrtest::WTEST_WTEST, 1); + csrtest_csr.wfo(utra::csrtest::WTEST_WTEST, baz); + + let foo = csrtest_csr.r(utra::csrtest::RTEST); + csrtest_csr.wo(utra::csrtest::RTEST, foo); + let bar = csrtest_csr.rf(utra::csrtest::RTEST_RTEST); + csrtest_csr.rmwf(utra::csrtest::RTEST_RTEST, bar); + let mut baz = csrtest_csr.zf(utra::csrtest::RTEST_RTEST, bar); + baz |= csrtest_csr.ms(utra::csrtest::RTEST_RTEST, 1); + csrtest_csr.wfo(utra::csrtest::RTEST_RTEST, baz); + } + + #[test] + #[ignore] + fn compile_check_irqarray0_csr() { + use super::*; + let mut irqarray0_csr = CSR::new(HW_IRQARRAY0_BASE as *mut u32); + + let foo = irqarray0_csr.r(utra::irqarray0::EV_SOFT); + irqarray0_csr.wo(utra::irqarray0::EV_SOFT, foo); + let bar = irqarray0_csr.rf(utra::irqarray0::EV_SOFT_TRIGGER); + irqarray0_csr.rmwf(utra::irqarray0::EV_SOFT_TRIGGER, bar); + let mut baz = irqarray0_csr.zf(utra::irqarray0::EV_SOFT_TRIGGER, bar); + baz |= irqarray0_csr.ms(utra::irqarray0::EV_SOFT_TRIGGER, 1); + irqarray0_csr.wfo(utra::irqarray0::EV_SOFT_TRIGGER, baz); + + let foo = irqarray0_csr.r(utra::irqarray0::EV_STATUS); + irqarray0_csr.wo(utra::irqarray0::EV_STATUS, foo); + let bar = irqarray0_csr.rf(utra::irqarray0::EV_STATUS_SOURCE0); + irqarray0_csr.rmwf(utra::irqarray0::EV_STATUS_SOURCE0, bar); + let mut baz = irqarray0_csr.zf(utra::irqarray0::EV_STATUS_SOURCE0, bar); + baz |= irqarray0_csr.ms(utra::irqarray0::EV_STATUS_SOURCE0, 1); + irqarray0_csr.wfo(utra::irqarray0::EV_STATUS_SOURCE0, baz); + let bar = irqarray0_csr.rf(utra::irqarray0::EV_STATUS_SOURCE1); + irqarray0_csr.rmwf(utra::irqarray0::EV_STATUS_SOURCE1, bar); + let mut baz = irqarray0_csr.zf(utra::irqarray0::EV_STATUS_SOURCE1, bar); + baz |= irqarray0_csr.ms(utra::irqarray0::EV_STATUS_SOURCE1, 1); + irqarray0_csr.wfo(utra::irqarray0::EV_STATUS_SOURCE1, baz); + let bar = irqarray0_csr.rf(utra::irqarray0::EV_STATUS_SOURCE2); + irqarray0_csr.rmwf(utra::irqarray0::EV_STATUS_SOURCE2, bar); + let mut baz = irqarray0_csr.zf(utra::irqarray0::EV_STATUS_SOURCE2, bar); + baz |= irqarray0_csr.ms(utra::irqarray0::EV_STATUS_SOURCE2, 1); + irqarray0_csr.wfo(utra::irqarray0::EV_STATUS_SOURCE2, baz); + let bar = irqarray0_csr.rf(utra::irqarray0::EV_STATUS_SOURCE3); + irqarray0_csr.rmwf(utra::irqarray0::EV_STATUS_SOURCE3, bar); + let mut baz = irqarray0_csr.zf(utra::irqarray0::EV_STATUS_SOURCE3, bar); + baz |= irqarray0_csr.ms(utra::irqarray0::EV_STATUS_SOURCE3, 1); + irqarray0_csr.wfo(utra::irqarray0::EV_STATUS_SOURCE3, baz); + let bar = irqarray0_csr.rf(utra::irqarray0::EV_STATUS_SOURCE4); + irqarray0_csr.rmwf(utra::irqarray0::EV_STATUS_SOURCE4, bar); + let mut baz = irqarray0_csr.zf(utra::irqarray0::EV_STATUS_SOURCE4, bar); + baz |= irqarray0_csr.ms(utra::irqarray0::EV_STATUS_SOURCE4, 1); + irqarray0_csr.wfo(utra::irqarray0::EV_STATUS_SOURCE4, baz); + let bar = irqarray0_csr.rf(utra::irqarray0::EV_STATUS_SOURCE5); + irqarray0_csr.rmwf(utra::irqarray0::EV_STATUS_SOURCE5, bar); + let mut baz = irqarray0_csr.zf(utra::irqarray0::EV_STATUS_SOURCE5, bar); + baz |= irqarray0_csr.ms(utra::irqarray0::EV_STATUS_SOURCE5, 1); + irqarray0_csr.wfo(utra::irqarray0::EV_STATUS_SOURCE5, baz); + let bar = irqarray0_csr.rf(utra::irqarray0::EV_STATUS_SOURCE6); + irqarray0_csr.rmwf(utra::irqarray0::EV_STATUS_SOURCE6, bar); + let mut baz = irqarray0_csr.zf(utra::irqarray0::EV_STATUS_SOURCE6, bar); + baz |= irqarray0_csr.ms(utra::irqarray0::EV_STATUS_SOURCE6, 1); + irqarray0_csr.wfo(utra::irqarray0::EV_STATUS_SOURCE6, baz); + let bar = irqarray0_csr.rf(utra::irqarray0::EV_STATUS_SOURCE7); + irqarray0_csr.rmwf(utra::irqarray0::EV_STATUS_SOURCE7, bar); + let mut baz = irqarray0_csr.zf(utra::irqarray0::EV_STATUS_SOURCE7, bar); + baz |= irqarray0_csr.ms(utra::irqarray0::EV_STATUS_SOURCE7, 1); + irqarray0_csr.wfo(utra::irqarray0::EV_STATUS_SOURCE7, baz); + let bar = irqarray0_csr.rf(utra::irqarray0::EV_STATUS_SOURCE8); + irqarray0_csr.rmwf(utra::irqarray0::EV_STATUS_SOURCE8, bar); + let mut baz = irqarray0_csr.zf(utra::irqarray0::EV_STATUS_SOURCE8, bar); + baz |= irqarray0_csr.ms(utra::irqarray0::EV_STATUS_SOURCE8, 1); + irqarray0_csr.wfo(utra::irqarray0::EV_STATUS_SOURCE8, baz); + let bar = irqarray0_csr.rf(utra::irqarray0::EV_STATUS_SOURCE9); + irqarray0_csr.rmwf(utra::irqarray0::EV_STATUS_SOURCE9, bar); + let mut baz = irqarray0_csr.zf(utra::irqarray0::EV_STATUS_SOURCE9, bar); + baz |= irqarray0_csr.ms(utra::irqarray0::EV_STATUS_SOURCE9, 1); + irqarray0_csr.wfo(utra::irqarray0::EV_STATUS_SOURCE9, baz); + let bar = irqarray0_csr.rf(utra::irqarray0::EV_STATUS_SOURCE10); + irqarray0_csr.rmwf(utra::irqarray0::EV_STATUS_SOURCE10, bar); + let mut baz = irqarray0_csr.zf(utra::irqarray0::EV_STATUS_SOURCE10, bar); + baz |= irqarray0_csr.ms(utra::irqarray0::EV_STATUS_SOURCE10, 1); + irqarray0_csr.wfo(utra::irqarray0::EV_STATUS_SOURCE10, baz); + let bar = irqarray0_csr.rf(utra::irqarray0::EV_STATUS_SOURCE11); + irqarray0_csr.rmwf(utra::irqarray0::EV_STATUS_SOURCE11, bar); + let mut baz = irqarray0_csr.zf(utra::irqarray0::EV_STATUS_SOURCE11, bar); + baz |= irqarray0_csr.ms(utra::irqarray0::EV_STATUS_SOURCE11, 1); + irqarray0_csr.wfo(utra::irqarray0::EV_STATUS_SOURCE11, baz); + let bar = irqarray0_csr.rf(utra::irqarray0::EV_STATUS_SOURCE12); + irqarray0_csr.rmwf(utra::irqarray0::EV_STATUS_SOURCE12, bar); + let mut baz = irqarray0_csr.zf(utra::irqarray0::EV_STATUS_SOURCE12, bar); + baz |= irqarray0_csr.ms(utra::irqarray0::EV_STATUS_SOURCE12, 1); + irqarray0_csr.wfo(utra::irqarray0::EV_STATUS_SOURCE12, baz); + let bar = irqarray0_csr.rf(utra::irqarray0::EV_STATUS_SOURCE13); + irqarray0_csr.rmwf(utra::irqarray0::EV_STATUS_SOURCE13, bar); + let mut baz = irqarray0_csr.zf(utra::irqarray0::EV_STATUS_SOURCE13, bar); + baz |= irqarray0_csr.ms(utra::irqarray0::EV_STATUS_SOURCE13, 1); + irqarray0_csr.wfo(utra::irqarray0::EV_STATUS_SOURCE13, baz); + let bar = irqarray0_csr.rf(utra::irqarray0::EV_STATUS_SOURCE14); + irqarray0_csr.rmwf(utra::irqarray0::EV_STATUS_SOURCE14, bar); + let mut baz = irqarray0_csr.zf(utra::irqarray0::EV_STATUS_SOURCE14, bar); + baz |= irqarray0_csr.ms(utra::irqarray0::EV_STATUS_SOURCE14, 1); + irqarray0_csr.wfo(utra::irqarray0::EV_STATUS_SOURCE14, baz); + let bar = irqarray0_csr.rf(utra::irqarray0::EV_STATUS_SOURCE15); + irqarray0_csr.rmwf(utra::irqarray0::EV_STATUS_SOURCE15, bar); + let mut baz = irqarray0_csr.zf(utra::irqarray0::EV_STATUS_SOURCE15, bar); + baz |= irqarray0_csr.ms(utra::irqarray0::EV_STATUS_SOURCE15, 1); + irqarray0_csr.wfo(utra::irqarray0::EV_STATUS_SOURCE15, baz); + let bar = irqarray0_csr.rf(utra::irqarray0::EV_STATUS_SOURCE16); + irqarray0_csr.rmwf(utra::irqarray0::EV_STATUS_SOURCE16, bar); + let mut baz = irqarray0_csr.zf(utra::irqarray0::EV_STATUS_SOURCE16, bar); + baz |= irqarray0_csr.ms(utra::irqarray0::EV_STATUS_SOURCE16, 1); + irqarray0_csr.wfo(utra::irqarray0::EV_STATUS_SOURCE16, baz); + let bar = irqarray0_csr.rf(utra::irqarray0::EV_STATUS_SOURCE17); + irqarray0_csr.rmwf(utra::irqarray0::EV_STATUS_SOURCE17, bar); + let mut baz = irqarray0_csr.zf(utra::irqarray0::EV_STATUS_SOURCE17, bar); + baz |= irqarray0_csr.ms(utra::irqarray0::EV_STATUS_SOURCE17, 1); + irqarray0_csr.wfo(utra::irqarray0::EV_STATUS_SOURCE17, baz); + let bar = irqarray0_csr.rf(utra::irqarray0::EV_STATUS_SOURCE18); + irqarray0_csr.rmwf(utra::irqarray0::EV_STATUS_SOURCE18, bar); + let mut baz = irqarray0_csr.zf(utra::irqarray0::EV_STATUS_SOURCE18, bar); + baz |= irqarray0_csr.ms(utra::irqarray0::EV_STATUS_SOURCE18, 1); + irqarray0_csr.wfo(utra::irqarray0::EV_STATUS_SOURCE18, baz); + let bar = irqarray0_csr.rf(utra::irqarray0::EV_STATUS_SOURCE19); + irqarray0_csr.rmwf(utra::irqarray0::EV_STATUS_SOURCE19, bar); + let mut baz = irqarray0_csr.zf(utra::irqarray0::EV_STATUS_SOURCE19, bar); + baz |= irqarray0_csr.ms(utra::irqarray0::EV_STATUS_SOURCE19, 1); + irqarray0_csr.wfo(utra::irqarray0::EV_STATUS_SOURCE19, baz); + + let foo = irqarray0_csr.r(utra::irqarray0::EV_PENDING); + irqarray0_csr.wo(utra::irqarray0::EV_PENDING, foo); + let bar = irqarray0_csr.rf(utra::irqarray0::EV_PENDING_SOURCE0); + irqarray0_csr.rmwf(utra::irqarray0::EV_PENDING_SOURCE0, bar); + let mut baz = irqarray0_csr.zf(utra::irqarray0::EV_PENDING_SOURCE0, bar); + baz |= irqarray0_csr.ms(utra::irqarray0::EV_PENDING_SOURCE0, 1); + irqarray0_csr.wfo(utra::irqarray0::EV_PENDING_SOURCE0, baz); + let bar = irqarray0_csr.rf(utra::irqarray0::EV_PENDING_SOURCE1); + irqarray0_csr.rmwf(utra::irqarray0::EV_PENDING_SOURCE1, bar); + let mut baz = irqarray0_csr.zf(utra::irqarray0::EV_PENDING_SOURCE1, bar); + baz |= irqarray0_csr.ms(utra::irqarray0::EV_PENDING_SOURCE1, 1); + irqarray0_csr.wfo(utra::irqarray0::EV_PENDING_SOURCE1, baz); + let bar = irqarray0_csr.rf(utra::irqarray0::EV_PENDING_SOURCE2); + irqarray0_csr.rmwf(utra::irqarray0::EV_PENDING_SOURCE2, bar); + let mut baz = irqarray0_csr.zf(utra::irqarray0::EV_PENDING_SOURCE2, bar); + baz |= irqarray0_csr.ms(utra::irqarray0::EV_PENDING_SOURCE2, 1); + irqarray0_csr.wfo(utra::irqarray0::EV_PENDING_SOURCE2, baz); + let bar = irqarray0_csr.rf(utra::irqarray0::EV_PENDING_SOURCE3); + irqarray0_csr.rmwf(utra::irqarray0::EV_PENDING_SOURCE3, bar); + let mut baz = irqarray0_csr.zf(utra::irqarray0::EV_PENDING_SOURCE3, bar); + baz |= irqarray0_csr.ms(utra::irqarray0::EV_PENDING_SOURCE3, 1); + irqarray0_csr.wfo(utra::irqarray0::EV_PENDING_SOURCE3, baz); + let bar = irqarray0_csr.rf(utra::irqarray0::EV_PENDING_SOURCE4); + irqarray0_csr.rmwf(utra::irqarray0::EV_PENDING_SOURCE4, bar); + let mut baz = irqarray0_csr.zf(utra::irqarray0::EV_PENDING_SOURCE4, bar); + baz |= irqarray0_csr.ms(utra::irqarray0::EV_PENDING_SOURCE4, 1); + irqarray0_csr.wfo(utra::irqarray0::EV_PENDING_SOURCE4, baz); + let bar = irqarray0_csr.rf(utra::irqarray0::EV_PENDING_SOURCE5); + irqarray0_csr.rmwf(utra::irqarray0::EV_PENDING_SOURCE5, bar); + let mut baz = irqarray0_csr.zf(utra::irqarray0::EV_PENDING_SOURCE5, bar); + baz |= irqarray0_csr.ms(utra::irqarray0::EV_PENDING_SOURCE5, 1); + irqarray0_csr.wfo(utra::irqarray0::EV_PENDING_SOURCE5, baz); + let bar = irqarray0_csr.rf(utra::irqarray0::EV_PENDING_SOURCE6); + irqarray0_csr.rmwf(utra::irqarray0::EV_PENDING_SOURCE6, bar); + let mut baz = irqarray0_csr.zf(utra::irqarray0::EV_PENDING_SOURCE6, bar); + baz |= irqarray0_csr.ms(utra::irqarray0::EV_PENDING_SOURCE6, 1); + irqarray0_csr.wfo(utra::irqarray0::EV_PENDING_SOURCE6, baz); + let bar = irqarray0_csr.rf(utra::irqarray0::EV_PENDING_SOURCE7); + irqarray0_csr.rmwf(utra::irqarray0::EV_PENDING_SOURCE7, bar); + let mut baz = irqarray0_csr.zf(utra::irqarray0::EV_PENDING_SOURCE7, bar); + baz |= irqarray0_csr.ms(utra::irqarray0::EV_PENDING_SOURCE7, 1); + irqarray0_csr.wfo(utra::irqarray0::EV_PENDING_SOURCE7, baz); + let bar = irqarray0_csr.rf(utra::irqarray0::EV_PENDING_SOURCE8); + irqarray0_csr.rmwf(utra::irqarray0::EV_PENDING_SOURCE8, bar); + let mut baz = irqarray0_csr.zf(utra::irqarray0::EV_PENDING_SOURCE8, bar); + baz |= irqarray0_csr.ms(utra::irqarray0::EV_PENDING_SOURCE8, 1); + irqarray0_csr.wfo(utra::irqarray0::EV_PENDING_SOURCE8, baz); + let bar = irqarray0_csr.rf(utra::irqarray0::EV_PENDING_SOURCE9); + irqarray0_csr.rmwf(utra::irqarray0::EV_PENDING_SOURCE9, bar); + let mut baz = irqarray0_csr.zf(utra::irqarray0::EV_PENDING_SOURCE9, bar); + baz |= irqarray0_csr.ms(utra::irqarray0::EV_PENDING_SOURCE9, 1); + irqarray0_csr.wfo(utra::irqarray0::EV_PENDING_SOURCE9, baz); + let bar = irqarray0_csr.rf(utra::irqarray0::EV_PENDING_SOURCE10); + irqarray0_csr.rmwf(utra::irqarray0::EV_PENDING_SOURCE10, bar); + let mut baz = irqarray0_csr.zf(utra::irqarray0::EV_PENDING_SOURCE10, bar); + baz |= irqarray0_csr.ms(utra::irqarray0::EV_PENDING_SOURCE10, 1); + irqarray0_csr.wfo(utra::irqarray0::EV_PENDING_SOURCE10, baz); + let bar = irqarray0_csr.rf(utra::irqarray0::EV_PENDING_SOURCE11); + irqarray0_csr.rmwf(utra::irqarray0::EV_PENDING_SOURCE11, bar); + let mut baz = irqarray0_csr.zf(utra::irqarray0::EV_PENDING_SOURCE11, bar); + baz |= irqarray0_csr.ms(utra::irqarray0::EV_PENDING_SOURCE11, 1); + irqarray0_csr.wfo(utra::irqarray0::EV_PENDING_SOURCE11, baz); + let bar = irqarray0_csr.rf(utra::irqarray0::EV_PENDING_SOURCE12); + irqarray0_csr.rmwf(utra::irqarray0::EV_PENDING_SOURCE12, bar); + let mut baz = irqarray0_csr.zf(utra::irqarray0::EV_PENDING_SOURCE12, bar); + baz |= irqarray0_csr.ms(utra::irqarray0::EV_PENDING_SOURCE12, 1); + irqarray0_csr.wfo(utra::irqarray0::EV_PENDING_SOURCE12, baz); + let bar = irqarray0_csr.rf(utra::irqarray0::EV_PENDING_SOURCE13); + irqarray0_csr.rmwf(utra::irqarray0::EV_PENDING_SOURCE13, bar); + let mut baz = irqarray0_csr.zf(utra::irqarray0::EV_PENDING_SOURCE13, bar); + baz |= irqarray0_csr.ms(utra::irqarray0::EV_PENDING_SOURCE13, 1); + irqarray0_csr.wfo(utra::irqarray0::EV_PENDING_SOURCE13, baz); + let bar = irqarray0_csr.rf(utra::irqarray0::EV_PENDING_SOURCE14); + irqarray0_csr.rmwf(utra::irqarray0::EV_PENDING_SOURCE14, bar); + let mut baz = irqarray0_csr.zf(utra::irqarray0::EV_PENDING_SOURCE14, bar); + baz |= irqarray0_csr.ms(utra::irqarray0::EV_PENDING_SOURCE14, 1); + irqarray0_csr.wfo(utra::irqarray0::EV_PENDING_SOURCE14, baz); + let bar = irqarray0_csr.rf(utra::irqarray0::EV_PENDING_SOURCE15); + irqarray0_csr.rmwf(utra::irqarray0::EV_PENDING_SOURCE15, bar); + let mut baz = irqarray0_csr.zf(utra::irqarray0::EV_PENDING_SOURCE15, bar); + baz |= irqarray0_csr.ms(utra::irqarray0::EV_PENDING_SOURCE15, 1); + irqarray0_csr.wfo(utra::irqarray0::EV_PENDING_SOURCE15, baz); + let bar = irqarray0_csr.rf(utra::irqarray0::EV_PENDING_SOURCE16); + irqarray0_csr.rmwf(utra::irqarray0::EV_PENDING_SOURCE16, bar); + let mut baz = irqarray0_csr.zf(utra::irqarray0::EV_PENDING_SOURCE16, bar); + baz |= irqarray0_csr.ms(utra::irqarray0::EV_PENDING_SOURCE16, 1); + irqarray0_csr.wfo(utra::irqarray0::EV_PENDING_SOURCE16, baz); + let bar = irqarray0_csr.rf(utra::irqarray0::EV_PENDING_SOURCE17); + irqarray0_csr.rmwf(utra::irqarray0::EV_PENDING_SOURCE17, bar); + let mut baz = irqarray0_csr.zf(utra::irqarray0::EV_PENDING_SOURCE17, bar); + baz |= irqarray0_csr.ms(utra::irqarray0::EV_PENDING_SOURCE17, 1); + irqarray0_csr.wfo(utra::irqarray0::EV_PENDING_SOURCE17, baz); + let bar = irqarray0_csr.rf(utra::irqarray0::EV_PENDING_SOURCE18); + irqarray0_csr.rmwf(utra::irqarray0::EV_PENDING_SOURCE18, bar); + let mut baz = irqarray0_csr.zf(utra::irqarray0::EV_PENDING_SOURCE18, bar); + baz |= irqarray0_csr.ms(utra::irqarray0::EV_PENDING_SOURCE18, 1); + irqarray0_csr.wfo(utra::irqarray0::EV_PENDING_SOURCE18, baz); + let bar = irqarray0_csr.rf(utra::irqarray0::EV_PENDING_SOURCE19); + irqarray0_csr.rmwf(utra::irqarray0::EV_PENDING_SOURCE19, bar); + let mut baz = irqarray0_csr.zf(utra::irqarray0::EV_PENDING_SOURCE19, bar); + baz |= irqarray0_csr.ms(utra::irqarray0::EV_PENDING_SOURCE19, 1); + irqarray0_csr.wfo(utra::irqarray0::EV_PENDING_SOURCE19, baz); + + let foo = irqarray0_csr.r(utra::irqarray0::EV_ENABLE); + irqarray0_csr.wo(utra::irqarray0::EV_ENABLE, foo); + let bar = irqarray0_csr.rf(utra::irqarray0::EV_ENABLE_SOURCE0); + irqarray0_csr.rmwf(utra::irqarray0::EV_ENABLE_SOURCE0, bar); + let mut baz = irqarray0_csr.zf(utra::irqarray0::EV_ENABLE_SOURCE0, bar); + baz |= irqarray0_csr.ms(utra::irqarray0::EV_ENABLE_SOURCE0, 1); + irqarray0_csr.wfo(utra::irqarray0::EV_ENABLE_SOURCE0, baz); + let bar = irqarray0_csr.rf(utra::irqarray0::EV_ENABLE_SOURCE1); + irqarray0_csr.rmwf(utra::irqarray0::EV_ENABLE_SOURCE1, bar); + let mut baz = irqarray0_csr.zf(utra::irqarray0::EV_ENABLE_SOURCE1, bar); + baz |= irqarray0_csr.ms(utra::irqarray0::EV_ENABLE_SOURCE1, 1); + irqarray0_csr.wfo(utra::irqarray0::EV_ENABLE_SOURCE1, baz); + let bar = irqarray0_csr.rf(utra::irqarray0::EV_ENABLE_SOURCE2); + irqarray0_csr.rmwf(utra::irqarray0::EV_ENABLE_SOURCE2, bar); + let mut baz = irqarray0_csr.zf(utra::irqarray0::EV_ENABLE_SOURCE2, bar); + baz |= irqarray0_csr.ms(utra::irqarray0::EV_ENABLE_SOURCE2, 1); + irqarray0_csr.wfo(utra::irqarray0::EV_ENABLE_SOURCE2, baz); + let bar = irqarray0_csr.rf(utra::irqarray0::EV_ENABLE_SOURCE3); + irqarray0_csr.rmwf(utra::irqarray0::EV_ENABLE_SOURCE3, bar); + let mut baz = irqarray0_csr.zf(utra::irqarray0::EV_ENABLE_SOURCE3, bar); + baz |= irqarray0_csr.ms(utra::irqarray0::EV_ENABLE_SOURCE3, 1); + irqarray0_csr.wfo(utra::irqarray0::EV_ENABLE_SOURCE3, baz); + let bar = irqarray0_csr.rf(utra::irqarray0::EV_ENABLE_SOURCE4); + irqarray0_csr.rmwf(utra::irqarray0::EV_ENABLE_SOURCE4, bar); + let mut baz = irqarray0_csr.zf(utra::irqarray0::EV_ENABLE_SOURCE4, bar); + baz |= irqarray0_csr.ms(utra::irqarray0::EV_ENABLE_SOURCE4, 1); + irqarray0_csr.wfo(utra::irqarray0::EV_ENABLE_SOURCE4, baz); + let bar = irqarray0_csr.rf(utra::irqarray0::EV_ENABLE_SOURCE5); + irqarray0_csr.rmwf(utra::irqarray0::EV_ENABLE_SOURCE5, bar); + let mut baz = irqarray0_csr.zf(utra::irqarray0::EV_ENABLE_SOURCE5, bar); + baz |= irqarray0_csr.ms(utra::irqarray0::EV_ENABLE_SOURCE5, 1); + irqarray0_csr.wfo(utra::irqarray0::EV_ENABLE_SOURCE5, baz); + let bar = irqarray0_csr.rf(utra::irqarray0::EV_ENABLE_SOURCE6); + irqarray0_csr.rmwf(utra::irqarray0::EV_ENABLE_SOURCE6, bar); + let mut baz = irqarray0_csr.zf(utra::irqarray0::EV_ENABLE_SOURCE6, bar); + baz |= irqarray0_csr.ms(utra::irqarray0::EV_ENABLE_SOURCE6, 1); + irqarray0_csr.wfo(utra::irqarray0::EV_ENABLE_SOURCE6, baz); + let bar = irqarray0_csr.rf(utra::irqarray0::EV_ENABLE_SOURCE7); + irqarray0_csr.rmwf(utra::irqarray0::EV_ENABLE_SOURCE7, bar); + let mut baz = irqarray0_csr.zf(utra::irqarray0::EV_ENABLE_SOURCE7, bar); + baz |= irqarray0_csr.ms(utra::irqarray0::EV_ENABLE_SOURCE7, 1); + irqarray0_csr.wfo(utra::irqarray0::EV_ENABLE_SOURCE7, baz); + let bar = irqarray0_csr.rf(utra::irqarray0::EV_ENABLE_SOURCE8); + irqarray0_csr.rmwf(utra::irqarray0::EV_ENABLE_SOURCE8, bar); + let mut baz = irqarray0_csr.zf(utra::irqarray0::EV_ENABLE_SOURCE8, bar); + baz |= irqarray0_csr.ms(utra::irqarray0::EV_ENABLE_SOURCE8, 1); + irqarray0_csr.wfo(utra::irqarray0::EV_ENABLE_SOURCE8, baz); + let bar = irqarray0_csr.rf(utra::irqarray0::EV_ENABLE_SOURCE9); + irqarray0_csr.rmwf(utra::irqarray0::EV_ENABLE_SOURCE9, bar); + let mut baz = irqarray0_csr.zf(utra::irqarray0::EV_ENABLE_SOURCE9, bar); + baz |= irqarray0_csr.ms(utra::irqarray0::EV_ENABLE_SOURCE9, 1); + irqarray0_csr.wfo(utra::irqarray0::EV_ENABLE_SOURCE9, baz); + let bar = irqarray0_csr.rf(utra::irqarray0::EV_ENABLE_SOURCE10); + irqarray0_csr.rmwf(utra::irqarray0::EV_ENABLE_SOURCE10, bar); + let mut baz = irqarray0_csr.zf(utra::irqarray0::EV_ENABLE_SOURCE10, bar); + baz |= irqarray0_csr.ms(utra::irqarray0::EV_ENABLE_SOURCE10, 1); + irqarray0_csr.wfo(utra::irqarray0::EV_ENABLE_SOURCE10, baz); + let bar = irqarray0_csr.rf(utra::irqarray0::EV_ENABLE_SOURCE11); + irqarray0_csr.rmwf(utra::irqarray0::EV_ENABLE_SOURCE11, bar); + let mut baz = irqarray0_csr.zf(utra::irqarray0::EV_ENABLE_SOURCE11, bar); + baz |= irqarray0_csr.ms(utra::irqarray0::EV_ENABLE_SOURCE11, 1); + irqarray0_csr.wfo(utra::irqarray0::EV_ENABLE_SOURCE11, baz); + let bar = irqarray0_csr.rf(utra::irqarray0::EV_ENABLE_SOURCE12); + irqarray0_csr.rmwf(utra::irqarray0::EV_ENABLE_SOURCE12, bar); + let mut baz = irqarray0_csr.zf(utra::irqarray0::EV_ENABLE_SOURCE12, bar); + baz |= irqarray0_csr.ms(utra::irqarray0::EV_ENABLE_SOURCE12, 1); + irqarray0_csr.wfo(utra::irqarray0::EV_ENABLE_SOURCE12, baz); + let bar = irqarray0_csr.rf(utra::irqarray0::EV_ENABLE_SOURCE13); + irqarray0_csr.rmwf(utra::irqarray0::EV_ENABLE_SOURCE13, bar); + let mut baz = irqarray0_csr.zf(utra::irqarray0::EV_ENABLE_SOURCE13, bar); + baz |= irqarray0_csr.ms(utra::irqarray0::EV_ENABLE_SOURCE13, 1); + irqarray0_csr.wfo(utra::irqarray0::EV_ENABLE_SOURCE13, baz); + let bar = irqarray0_csr.rf(utra::irqarray0::EV_ENABLE_SOURCE14); + irqarray0_csr.rmwf(utra::irqarray0::EV_ENABLE_SOURCE14, bar); + let mut baz = irqarray0_csr.zf(utra::irqarray0::EV_ENABLE_SOURCE14, bar); + baz |= irqarray0_csr.ms(utra::irqarray0::EV_ENABLE_SOURCE14, 1); + irqarray0_csr.wfo(utra::irqarray0::EV_ENABLE_SOURCE14, baz); + let bar = irqarray0_csr.rf(utra::irqarray0::EV_ENABLE_SOURCE15); + irqarray0_csr.rmwf(utra::irqarray0::EV_ENABLE_SOURCE15, bar); + let mut baz = irqarray0_csr.zf(utra::irqarray0::EV_ENABLE_SOURCE15, bar); + baz |= irqarray0_csr.ms(utra::irqarray0::EV_ENABLE_SOURCE15, 1); + irqarray0_csr.wfo(utra::irqarray0::EV_ENABLE_SOURCE15, baz); + let bar = irqarray0_csr.rf(utra::irqarray0::EV_ENABLE_SOURCE16); + irqarray0_csr.rmwf(utra::irqarray0::EV_ENABLE_SOURCE16, bar); + let mut baz = irqarray0_csr.zf(utra::irqarray0::EV_ENABLE_SOURCE16, bar); + baz |= irqarray0_csr.ms(utra::irqarray0::EV_ENABLE_SOURCE16, 1); + irqarray0_csr.wfo(utra::irqarray0::EV_ENABLE_SOURCE16, baz); + let bar = irqarray0_csr.rf(utra::irqarray0::EV_ENABLE_SOURCE17); + irqarray0_csr.rmwf(utra::irqarray0::EV_ENABLE_SOURCE17, bar); + let mut baz = irqarray0_csr.zf(utra::irqarray0::EV_ENABLE_SOURCE17, bar); + baz |= irqarray0_csr.ms(utra::irqarray0::EV_ENABLE_SOURCE17, 1); + irqarray0_csr.wfo(utra::irqarray0::EV_ENABLE_SOURCE17, baz); + let bar = irqarray0_csr.rf(utra::irqarray0::EV_ENABLE_SOURCE18); + irqarray0_csr.rmwf(utra::irqarray0::EV_ENABLE_SOURCE18, bar); + let mut baz = irqarray0_csr.zf(utra::irqarray0::EV_ENABLE_SOURCE18, bar); + baz |= irqarray0_csr.ms(utra::irqarray0::EV_ENABLE_SOURCE18, 1); + irqarray0_csr.wfo(utra::irqarray0::EV_ENABLE_SOURCE18, baz); + let bar = irqarray0_csr.rf(utra::irqarray0::EV_ENABLE_SOURCE19); + irqarray0_csr.rmwf(utra::irqarray0::EV_ENABLE_SOURCE19, bar); + let mut baz = irqarray0_csr.zf(utra::irqarray0::EV_ENABLE_SOURCE19, bar); + baz |= irqarray0_csr.ms(utra::irqarray0::EV_ENABLE_SOURCE19, 1); + irqarray0_csr.wfo(utra::irqarray0::EV_ENABLE_SOURCE19, baz); + } + + #[test] + #[ignore] + fn compile_check_irqarray1_csr() { + use super::*; + let mut irqarray1_csr = CSR::new(HW_IRQARRAY1_BASE as *mut u32); + + let foo = irqarray1_csr.r(utra::irqarray1::EV_SOFT); + irqarray1_csr.wo(utra::irqarray1::EV_SOFT, foo); + let bar = irqarray1_csr.rf(utra::irqarray1::EV_SOFT_TRIGGER); + irqarray1_csr.rmwf(utra::irqarray1::EV_SOFT_TRIGGER, bar); + let mut baz = irqarray1_csr.zf(utra::irqarray1::EV_SOFT_TRIGGER, bar); + baz |= irqarray1_csr.ms(utra::irqarray1::EV_SOFT_TRIGGER, 1); + irqarray1_csr.wfo(utra::irqarray1::EV_SOFT_TRIGGER, baz); + + let foo = irqarray1_csr.r(utra::irqarray1::EV_STATUS); + irqarray1_csr.wo(utra::irqarray1::EV_STATUS, foo); + let bar = irqarray1_csr.rf(utra::irqarray1::EV_STATUS_SOURCE0); + irqarray1_csr.rmwf(utra::irqarray1::EV_STATUS_SOURCE0, bar); + let mut baz = irqarray1_csr.zf(utra::irqarray1::EV_STATUS_SOURCE0, bar); + baz |= irqarray1_csr.ms(utra::irqarray1::EV_STATUS_SOURCE0, 1); + irqarray1_csr.wfo(utra::irqarray1::EV_STATUS_SOURCE0, baz); + let bar = irqarray1_csr.rf(utra::irqarray1::EV_STATUS_SOURCE1); + irqarray1_csr.rmwf(utra::irqarray1::EV_STATUS_SOURCE1, bar); + let mut baz = irqarray1_csr.zf(utra::irqarray1::EV_STATUS_SOURCE1, bar); + baz |= irqarray1_csr.ms(utra::irqarray1::EV_STATUS_SOURCE1, 1); + irqarray1_csr.wfo(utra::irqarray1::EV_STATUS_SOURCE1, baz); + let bar = irqarray1_csr.rf(utra::irqarray1::EV_STATUS_SOURCE2); + irqarray1_csr.rmwf(utra::irqarray1::EV_STATUS_SOURCE2, bar); + let mut baz = irqarray1_csr.zf(utra::irqarray1::EV_STATUS_SOURCE2, bar); + baz |= irqarray1_csr.ms(utra::irqarray1::EV_STATUS_SOURCE2, 1); + irqarray1_csr.wfo(utra::irqarray1::EV_STATUS_SOURCE2, baz); + let bar = irqarray1_csr.rf(utra::irqarray1::EV_STATUS_SOURCE3); + irqarray1_csr.rmwf(utra::irqarray1::EV_STATUS_SOURCE3, bar); + let mut baz = irqarray1_csr.zf(utra::irqarray1::EV_STATUS_SOURCE3, bar); + baz |= irqarray1_csr.ms(utra::irqarray1::EV_STATUS_SOURCE3, 1); + irqarray1_csr.wfo(utra::irqarray1::EV_STATUS_SOURCE3, baz); + let bar = irqarray1_csr.rf(utra::irqarray1::EV_STATUS_SOURCE4); + irqarray1_csr.rmwf(utra::irqarray1::EV_STATUS_SOURCE4, bar); + let mut baz = irqarray1_csr.zf(utra::irqarray1::EV_STATUS_SOURCE4, bar); + baz |= irqarray1_csr.ms(utra::irqarray1::EV_STATUS_SOURCE4, 1); + irqarray1_csr.wfo(utra::irqarray1::EV_STATUS_SOURCE4, baz); + let bar = irqarray1_csr.rf(utra::irqarray1::EV_STATUS_SOURCE5); + irqarray1_csr.rmwf(utra::irqarray1::EV_STATUS_SOURCE5, bar); + let mut baz = irqarray1_csr.zf(utra::irqarray1::EV_STATUS_SOURCE5, bar); + baz |= irqarray1_csr.ms(utra::irqarray1::EV_STATUS_SOURCE5, 1); + irqarray1_csr.wfo(utra::irqarray1::EV_STATUS_SOURCE5, baz); + let bar = irqarray1_csr.rf(utra::irqarray1::EV_STATUS_SOURCE6); + irqarray1_csr.rmwf(utra::irqarray1::EV_STATUS_SOURCE6, bar); + let mut baz = irqarray1_csr.zf(utra::irqarray1::EV_STATUS_SOURCE6, bar); + baz |= irqarray1_csr.ms(utra::irqarray1::EV_STATUS_SOURCE6, 1); + irqarray1_csr.wfo(utra::irqarray1::EV_STATUS_SOURCE6, baz); + let bar = irqarray1_csr.rf(utra::irqarray1::EV_STATUS_SOURCE7); + irqarray1_csr.rmwf(utra::irqarray1::EV_STATUS_SOURCE7, bar); + let mut baz = irqarray1_csr.zf(utra::irqarray1::EV_STATUS_SOURCE7, bar); + baz |= irqarray1_csr.ms(utra::irqarray1::EV_STATUS_SOURCE7, 1); + irqarray1_csr.wfo(utra::irqarray1::EV_STATUS_SOURCE7, baz); + let bar = irqarray1_csr.rf(utra::irqarray1::EV_STATUS_SOURCE8); + irqarray1_csr.rmwf(utra::irqarray1::EV_STATUS_SOURCE8, bar); + let mut baz = irqarray1_csr.zf(utra::irqarray1::EV_STATUS_SOURCE8, bar); + baz |= irqarray1_csr.ms(utra::irqarray1::EV_STATUS_SOURCE8, 1); + irqarray1_csr.wfo(utra::irqarray1::EV_STATUS_SOURCE8, baz); + let bar = irqarray1_csr.rf(utra::irqarray1::EV_STATUS_SOURCE9); + irqarray1_csr.rmwf(utra::irqarray1::EV_STATUS_SOURCE9, bar); + let mut baz = irqarray1_csr.zf(utra::irqarray1::EV_STATUS_SOURCE9, bar); + baz |= irqarray1_csr.ms(utra::irqarray1::EV_STATUS_SOURCE9, 1); + irqarray1_csr.wfo(utra::irqarray1::EV_STATUS_SOURCE9, baz); + let bar = irqarray1_csr.rf(utra::irqarray1::EV_STATUS_SOURCE10); + irqarray1_csr.rmwf(utra::irqarray1::EV_STATUS_SOURCE10, bar); + let mut baz = irqarray1_csr.zf(utra::irqarray1::EV_STATUS_SOURCE10, bar); + baz |= irqarray1_csr.ms(utra::irqarray1::EV_STATUS_SOURCE10, 1); + irqarray1_csr.wfo(utra::irqarray1::EV_STATUS_SOURCE10, baz); + let bar = irqarray1_csr.rf(utra::irqarray1::EV_STATUS_SOURCE11); + irqarray1_csr.rmwf(utra::irqarray1::EV_STATUS_SOURCE11, bar); + let mut baz = irqarray1_csr.zf(utra::irqarray1::EV_STATUS_SOURCE11, bar); + baz |= irqarray1_csr.ms(utra::irqarray1::EV_STATUS_SOURCE11, 1); + irqarray1_csr.wfo(utra::irqarray1::EV_STATUS_SOURCE11, baz); + let bar = irqarray1_csr.rf(utra::irqarray1::EV_STATUS_SOURCE12); + irqarray1_csr.rmwf(utra::irqarray1::EV_STATUS_SOURCE12, bar); + let mut baz = irqarray1_csr.zf(utra::irqarray1::EV_STATUS_SOURCE12, bar); + baz |= irqarray1_csr.ms(utra::irqarray1::EV_STATUS_SOURCE12, 1); + irqarray1_csr.wfo(utra::irqarray1::EV_STATUS_SOURCE12, baz); + let bar = irqarray1_csr.rf(utra::irqarray1::EV_STATUS_SOURCE13); + irqarray1_csr.rmwf(utra::irqarray1::EV_STATUS_SOURCE13, bar); + let mut baz = irqarray1_csr.zf(utra::irqarray1::EV_STATUS_SOURCE13, bar); + baz |= irqarray1_csr.ms(utra::irqarray1::EV_STATUS_SOURCE13, 1); + irqarray1_csr.wfo(utra::irqarray1::EV_STATUS_SOURCE13, baz); + let bar = irqarray1_csr.rf(utra::irqarray1::EV_STATUS_SOURCE14); + irqarray1_csr.rmwf(utra::irqarray1::EV_STATUS_SOURCE14, bar); + let mut baz = irqarray1_csr.zf(utra::irqarray1::EV_STATUS_SOURCE14, bar); + baz |= irqarray1_csr.ms(utra::irqarray1::EV_STATUS_SOURCE14, 1); + irqarray1_csr.wfo(utra::irqarray1::EV_STATUS_SOURCE14, baz); + let bar = irqarray1_csr.rf(utra::irqarray1::EV_STATUS_SOURCE15); + irqarray1_csr.rmwf(utra::irqarray1::EV_STATUS_SOURCE15, bar); + let mut baz = irqarray1_csr.zf(utra::irqarray1::EV_STATUS_SOURCE15, bar); + baz |= irqarray1_csr.ms(utra::irqarray1::EV_STATUS_SOURCE15, 1); + irqarray1_csr.wfo(utra::irqarray1::EV_STATUS_SOURCE15, baz); + let bar = irqarray1_csr.rf(utra::irqarray1::EV_STATUS_SOURCE16); + irqarray1_csr.rmwf(utra::irqarray1::EV_STATUS_SOURCE16, bar); + let mut baz = irqarray1_csr.zf(utra::irqarray1::EV_STATUS_SOURCE16, bar); + baz |= irqarray1_csr.ms(utra::irqarray1::EV_STATUS_SOURCE16, 1); + irqarray1_csr.wfo(utra::irqarray1::EV_STATUS_SOURCE16, baz); + let bar = irqarray1_csr.rf(utra::irqarray1::EV_STATUS_SOURCE17); + irqarray1_csr.rmwf(utra::irqarray1::EV_STATUS_SOURCE17, bar); + let mut baz = irqarray1_csr.zf(utra::irqarray1::EV_STATUS_SOURCE17, bar); + baz |= irqarray1_csr.ms(utra::irqarray1::EV_STATUS_SOURCE17, 1); + irqarray1_csr.wfo(utra::irqarray1::EV_STATUS_SOURCE17, baz); + let bar = irqarray1_csr.rf(utra::irqarray1::EV_STATUS_SOURCE18); + irqarray1_csr.rmwf(utra::irqarray1::EV_STATUS_SOURCE18, bar); + let mut baz = irqarray1_csr.zf(utra::irqarray1::EV_STATUS_SOURCE18, bar); + baz |= irqarray1_csr.ms(utra::irqarray1::EV_STATUS_SOURCE18, 1); + irqarray1_csr.wfo(utra::irqarray1::EV_STATUS_SOURCE18, baz); + let bar = irqarray1_csr.rf(utra::irqarray1::EV_STATUS_SOURCE19); + irqarray1_csr.rmwf(utra::irqarray1::EV_STATUS_SOURCE19, bar); + let mut baz = irqarray1_csr.zf(utra::irqarray1::EV_STATUS_SOURCE19, bar); + baz |= irqarray1_csr.ms(utra::irqarray1::EV_STATUS_SOURCE19, 1); + irqarray1_csr.wfo(utra::irqarray1::EV_STATUS_SOURCE19, baz); + + let foo = irqarray1_csr.r(utra::irqarray1::EV_PENDING); + irqarray1_csr.wo(utra::irqarray1::EV_PENDING, foo); + let bar = irqarray1_csr.rf(utra::irqarray1::EV_PENDING_SOURCE0); + irqarray1_csr.rmwf(utra::irqarray1::EV_PENDING_SOURCE0, bar); + let mut baz = irqarray1_csr.zf(utra::irqarray1::EV_PENDING_SOURCE0, bar); + baz |= irqarray1_csr.ms(utra::irqarray1::EV_PENDING_SOURCE0, 1); + irqarray1_csr.wfo(utra::irqarray1::EV_PENDING_SOURCE0, baz); + let bar = irqarray1_csr.rf(utra::irqarray1::EV_PENDING_SOURCE1); + irqarray1_csr.rmwf(utra::irqarray1::EV_PENDING_SOURCE1, bar); + let mut baz = irqarray1_csr.zf(utra::irqarray1::EV_PENDING_SOURCE1, bar); + baz |= irqarray1_csr.ms(utra::irqarray1::EV_PENDING_SOURCE1, 1); + irqarray1_csr.wfo(utra::irqarray1::EV_PENDING_SOURCE1, baz); + let bar = irqarray1_csr.rf(utra::irqarray1::EV_PENDING_SOURCE2); + irqarray1_csr.rmwf(utra::irqarray1::EV_PENDING_SOURCE2, bar); + let mut baz = irqarray1_csr.zf(utra::irqarray1::EV_PENDING_SOURCE2, bar); + baz |= irqarray1_csr.ms(utra::irqarray1::EV_PENDING_SOURCE2, 1); + irqarray1_csr.wfo(utra::irqarray1::EV_PENDING_SOURCE2, baz); + let bar = irqarray1_csr.rf(utra::irqarray1::EV_PENDING_SOURCE3); + irqarray1_csr.rmwf(utra::irqarray1::EV_PENDING_SOURCE3, bar); + let mut baz = irqarray1_csr.zf(utra::irqarray1::EV_PENDING_SOURCE3, bar); + baz |= irqarray1_csr.ms(utra::irqarray1::EV_PENDING_SOURCE3, 1); + irqarray1_csr.wfo(utra::irqarray1::EV_PENDING_SOURCE3, baz); + let bar = irqarray1_csr.rf(utra::irqarray1::EV_PENDING_SOURCE4); + irqarray1_csr.rmwf(utra::irqarray1::EV_PENDING_SOURCE4, bar); + let mut baz = irqarray1_csr.zf(utra::irqarray1::EV_PENDING_SOURCE4, bar); + baz |= irqarray1_csr.ms(utra::irqarray1::EV_PENDING_SOURCE4, 1); + irqarray1_csr.wfo(utra::irqarray1::EV_PENDING_SOURCE4, baz); + let bar = irqarray1_csr.rf(utra::irqarray1::EV_PENDING_SOURCE5); + irqarray1_csr.rmwf(utra::irqarray1::EV_PENDING_SOURCE5, bar); + let mut baz = irqarray1_csr.zf(utra::irqarray1::EV_PENDING_SOURCE5, bar); + baz |= irqarray1_csr.ms(utra::irqarray1::EV_PENDING_SOURCE5, 1); + irqarray1_csr.wfo(utra::irqarray1::EV_PENDING_SOURCE5, baz); + let bar = irqarray1_csr.rf(utra::irqarray1::EV_PENDING_SOURCE6); + irqarray1_csr.rmwf(utra::irqarray1::EV_PENDING_SOURCE6, bar); + let mut baz = irqarray1_csr.zf(utra::irqarray1::EV_PENDING_SOURCE6, bar); + baz |= irqarray1_csr.ms(utra::irqarray1::EV_PENDING_SOURCE6, 1); + irqarray1_csr.wfo(utra::irqarray1::EV_PENDING_SOURCE6, baz); + let bar = irqarray1_csr.rf(utra::irqarray1::EV_PENDING_SOURCE7); + irqarray1_csr.rmwf(utra::irqarray1::EV_PENDING_SOURCE7, bar); + let mut baz = irqarray1_csr.zf(utra::irqarray1::EV_PENDING_SOURCE7, bar); + baz |= irqarray1_csr.ms(utra::irqarray1::EV_PENDING_SOURCE7, 1); + irqarray1_csr.wfo(utra::irqarray1::EV_PENDING_SOURCE7, baz); + let bar = irqarray1_csr.rf(utra::irqarray1::EV_PENDING_SOURCE8); + irqarray1_csr.rmwf(utra::irqarray1::EV_PENDING_SOURCE8, bar); + let mut baz = irqarray1_csr.zf(utra::irqarray1::EV_PENDING_SOURCE8, bar); + baz |= irqarray1_csr.ms(utra::irqarray1::EV_PENDING_SOURCE8, 1); + irqarray1_csr.wfo(utra::irqarray1::EV_PENDING_SOURCE8, baz); + let bar = irqarray1_csr.rf(utra::irqarray1::EV_PENDING_SOURCE9); + irqarray1_csr.rmwf(utra::irqarray1::EV_PENDING_SOURCE9, bar); + let mut baz = irqarray1_csr.zf(utra::irqarray1::EV_PENDING_SOURCE9, bar); + baz |= irqarray1_csr.ms(utra::irqarray1::EV_PENDING_SOURCE9, 1); + irqarray1_csr.wfo(utra::irqarray1::EV_PENDING_SOURCE9, baz); + let bar = irqarray1_csr.rf(utra::irqarray1::EV_PENDING_SOURCE10); + irqarray1_csr.rmwf(utra::irqarray1::EV_PENDING_SOURCE10, bar); + let mut baz = irqarray1_csr.zf(utra::irqarray1::EV_PENDING_SOURCE10, bar); + baz |= irqarray1_csr.ms(utra::irqarray1::EV_PENDING_SOURCE10, 1); + irqarray1_csr.wfo(utra::irqarray1::EV_PENDING_SOURCE10, baz); + let bar = irqarray1_csr.rf(utra::irqarray1::EV_PENDING_SOURCE11); + irqarray1_csr.rmwf(utra::irqarray1::EV_PENDING_SOURCE11, bar); + let mut baz = irqarray1_csr.zf(utra::irqarray1::EV_PENDING_SOURCE11, bar); + baz |= irqarray1_csr.ms(utra::irqarray1::EV_PENDING_SOURCE11, 1); + irqarray1_csr.wfo(utra::irqarray1::EV_PENDING_SOURCE11, baz); + let bar = irqarray1_csr.rf(utra::irqarray1::EV_PENDING_SOURCE12); + irqarray1_csr.rmwf(utra::irqarray1::EV_PENDING_SOURCE12, bar); + let mut baz = irqarray1_csr.zf(utra::irqarray1::EV_PENDING_SOURCE12, bar); + baz |= irqarray1_csr.ms(utra::irqarray1::EV_PENDING_SOURCE12, 1); + irqarray1_csr.wfo(utra::irqarray1::EV_PENDING_SOURCE12, baz); + let bar = irqarray1_csr.rf(utra::irqarray1::EV_PENDING_SOURCE13); + irqarray1_csr.rmwf(utra::irqarray1::EV_PENDING_SOURCE13, bar); + let mut baz = irqarray1_csr.zf(utra::irqarray1::EV_PENDING_SOURCE13, bar); + baz |= irqarray1_csr.ms(utra::irqarray1::EV_PENDING_SOURCE13, 1); + irqarray1_csr.wfo(utra::irqarray1::EV_PENDING_SOURCE13, baz); + let bar = irqarray1_csr.rf(utra::irqarray1::EV_PENDING_SOURCE14); + irqarray1_csr.rmwf(utra::irqarray1::EV_PENDING_SOURCE14, bar); + let mut baz = irqarray1_csr.zf(utra::irqarray1::EV_PENDING_SOURCE14, bar); + baz |= irqarray1_csr.ms(utra::irqarray1::EV_PENDING_SOURCE14, 1); + irqarray1_csr.wfo(utra::irqarray1::EV_PENDING_SOURCE14, baz); + let bar = irqarray1_csr.rf(utra::irqarray1::EV_PENDING_SOURCE15); + irqarray1_csr.rmwf(utra::irqarray1::EV_PENDING_SOURCE15, bar); + let mut baz = irqarray1_csr.zf(utra::irqarray1::EV_PENDING_SOURCE15, bar); + baz |= irqarray1_csr.ms(utra::irqarray1::EV_PENDING_SOURCE15, 1); + irqarray1_csr.wfo(utra::irqarray1::EV_PENDING_SOURCE15, baz); + let bar = irqarray1_csr.rf(utra::irqarray1::EV_PENDING_SOURCE16); + irqarray1_csr.rmwf(utra::irqarray1::EV_PENDING_SOURCE16, bar); + let mut baz = irqarray1_csr.zf(utra::irqarray1::EV_PENDING_SOURCE16, bar); + baz |= irqarray1_csr.ms(utra::irqarray1::EV_PENDING_SOURCE16, 1); + irqarray1_csr.wfo(utra::irqarray1::EV_PENDING_SOURCE16, baz); + let bar = irqarray1_csr.rf(utra::irqarray1::EV_PENDING_SOURCE17); + irqarray1_csr.rmwf(utra::irqarray1::EV_PENDING_SOURCE17, bar); + let mut baz = irqarray1_csr.zf(utra::irqarray1::EV_PENDING_SOURCE17, bar); + baz |= irqarray1_csr.ms(utra::irqarray1::EV_PENDING_SOURCE17, 1); + irqarray1_csr.wfo(utra::irqarray1::EV_PENDING_SOURCE17, baz); + let bar = irqarray1_csr.rf(utra::irqarray1::EV_PENDING_SOURCE18); + irqarray1_csr.rmwf(utra::irqarray1::EV_PENDING_SOURCE18, bar); + let mut baz = irqarray1_csr.zf(utra::irqarray1::EV_PENDING_SOURCE18, bar); + baz |= irqarray1_csr.ms(utra::irqarray1::EV_PENDING_SOURCE18, 1); + irqarray1_csr.wfo(utra::irqarray1::EV_PENDING_SOURCE18, baz); + let bar = irqarray1_csr.rf(utra::irqarray1::EV_PENDING_SOURCE19); + irqarray1_csr.rmwf(utra::irqarray1::EV_PENDING_SOURCE19, bar); + let mut baz = irqarray1_csr.zf(utra::irqarray1::EV_PENDING_SOURCE19, bar); + baz |= irqarray1_csr.ms(utra::irqarray1::EV_PENDING_SOURCE19, 1); + irqarray1_csr.wfo(utra::irqarray1::EV_PENDING_SOURCE19, baz); + + let foo = irqarray1_csr.r(utra::irqarray1::EV_ENABLE); + irqarray1_csr.wo(utra::irqarray1::EV_ENABLE, foo); + let bar = irqarray1_csr.rf(utra::irqarray1::EV_ENABLE_SOURCE0); + irqarray1_csr.rmwf(utra::irqarray1::EV_ENABLE_SOURCE0, bar); + let mut baz = irqarray1_csr.zf(utra::irqarray1::EV_ENABLE_SOURCE0, bar); + baz |= irqarray1_csr.ms(utra::irqarray1::EV_ENABLE_SOURCE0, 1); + irqarray1_csr.wfo(utra::irqarray1::EV_ENABLE_SOURCE0, baz); + let bar = irqarray1_csr.rf(utra::irqarray1::EV_ENABLE_SOURCE1); + irqarray1_csr.rmwf(utra::irqarray1::EV_ENABLE_SOURCE1, bar); + let mut baz = irqarray1_csr.zf(utra::irqarray1::EV_ENABLE_SOURCE1, bar); + baz |= irqarray1_csr.ms(utra::irqarray1::EV_ENABLE_SOURCE1, 1); + irqarray1_csr.wfo(utra::irqarray1::EV_ENABLE_SOURCE1, baz); + let bar = irqarray1_csr.rf(utra::irqarray1::EV_ENABLE_SOURCE2); + irqarray1_csr.rmwf(utra::irqarray1::EV_ENABLE_SOURCE2, bar); + let mut baz = irqarray1_csr.zf(utra::irqarray1::EV_ENABLE_SOURCE2, bar); + baz |= irqarray1_csr.ms(utra::irqarray1::EV_ENABLE_SOURCE2, 1); + irqarray1_csr.wfo(utra::irqarray1::EV_ENABLE_SOURCE2, baz); + let bar = irqarray1_csr.rf(utra::irqarray1::EV_ENABLE_SOURCE3); + irqarray1_csr.rmwf(utra::irqarray1::EV_ENABLE_SOURCE3, bar); + let mut baz = irqarray1_csr.zf(utra::irqarray1::EV_ENABLE_SOURCE3, bar); + baz |= irqarray1_csr.ms(utra::irqarray1::EV_ENABLE_SOURCE3, 1); + irqarray1_csr.wfo(utra::irqarray1::EV_ENABLE_SOURCE3, baz); + let bar = irqarray1_csr.rf(utra::irqarray1::EV_ENABLE_SOURCE4); + irqarray1_csr.rmwf(utra::irqarray1::EV_ENABLE_SOURCE4, bar); + let mut baz = irqarray1_csr.zf(utra::irqarray1::EV_ENABLE_SOURCE4, bar); + baz |= irqarray1_csr.ms(utra::irqarray1::EV_ENABLE_SOURCE4, 1); + irqarray1_csr.wfo(utra::irqarray1::EV_ENABLE_SOURCE4, baz); + let bar = irqarray1_csr.rf(utra::irqarray1::EV_ENABLE_SOURCE5); + irqarray1_csr.rmwf(utra::irqarray1::EV_ENABLE_SOURCE5, bar); + let mut baz = irqarray1_csr.zf(utra::irqarray1::EV_ENABLE_SOURCE5, bar); + baz |= irqarray1_csr.ms(utra::irqarray1::EV_ENABLE_SOURCE5, 1); + irqarray1_csr.wfo(utra::irqarray1::EV_ENABLE_SOURCE5, baz); + let bar = irqarray1_csr.rf(utra::irqarray1::EV_ENABLE_SOURCE6); + irqarray1_csr.rmwf(utra::irqarray1::EV_ENABLE_SOURCE6, bar); + let mut baz = irqarray1_csr.zf(utra::irqarray1::EV_ENABLE_SOURCE6, bar); + baz |= irqarray1_csr.ms(utra::irqarray1::EV_ENABLE_SOURCE6, 1); + irqarray1_csr.wfo(utra::irqarray1::EV_ENABLE_SOURCE6, baz); + let bar = irqarray1_csr.rf(utra::irqarray1::EV_ENABLE_SOURCE7); + irqarray1_csr.rmwf(utra::irqarray1::EV_ENABLE_SOURCE7, bar); + let mut baz = irqarray1_csr.zf(utra::irqarray1::EV_ENABLE_SOURCE7, bar); + baz |= irqarray1_csr.ms(utra::irqarray1::EV_ENABLE_SOURCE7, 1); + irqarray1_csr.wfo(utra::irqarray1::EV_ENABLE_SOURCE7, baz); + let bar = irqarray1_csr.rf(utra::irqarray1::EV_ENABLE_SOURCE8); + irqarray1_csr.rmwf(utra::irqarray1::EV_ENABLE_SOURCE8, bar); + let mut baz = irqarray1_csr.zf(utra::irqarray1::EV_ENABLE_SOURCE8, bar); + baz |= irqarray1_csr.ms(utra::irqarray1::EV_ENABLE_SOURCE8, 1); + irqarray1_csr.wfo(utra::irqarray1::EV_ENABLE_SOURCE8, baz); + let bar = irqarray1_csr.rf(utra::irqarray1::EV_ENABLE_SOURCE9); + irqarray1_csr.rmwf(utra::irqarray1::EV_ENABLE_SOURCE9, bar); + let mut baz = irqarray1_csr.zf(utra::irqarray1::EV_ENABLE_SOURCE9, bar); + baz |= irqarray1_csr.ms(utra::irqarray1::EV_ENABLE_SOURCE9, 1); + irqarray1_csr.wfo(utra::irqarray1::EV_ENABLE_SOURCE9, baz); + let bar = irqarray1_csr.rf(utra::irqarray1::EV_ENABLE_SOURCE10); + irqarray1_csr.rmwf(utra::irqarray1::EV_ENABLE_SOURCE10, bar); + let mut baz = irqarray1_csr.zf(utra::irqarray1::EV_ENABLE_SOURCE10, bar); + baz |= irqarray1_csr.ms(utra::irqarray1::EV_ENABLE_SOURCE10, 1); + irqarray1_csr.wfo(utra::irqarray1::EV_ENABLE_SOURCE10, baz); + let bar = irqarray1_csr.rf(utra::irqarray1::EV_ENABLE_SOURCE11); + irqarray1_csr.rmwf(utra::irqarray1::EV_ENABLE_SOURCE11, bar); + let mut baz = irqarray1_csr.zf(utra::irqarray1::EV_ENABLE_SOURCE11, bar); + baz |= irqarray1_csr.ms(utra::irqarray1::EV_ENABLE_SOURCE11, 1); + irqarray1_csr.wfo(utra::irqarray1::EV_ENABLE_SOURCE11, baz); + let bar = irqarray1_csr.rf(utra::irqarray1::EV_ENABLE_SOURCE12); + irqarray1_csr.rmwf(utra::irqarray1::EV_ENABLE_SOURCE12, bar); + let mut baz = irqarray1_csr.zf(utra::irqarray1::EV_ENABLE_SOURCE12, bar); + baz |= irqarray1_csr.ms(utra::irqarray1::EV_ENABLE_SOURCE12, 1); + irqarray1_csr.wfo(utra::irqarray1::EV_ENABLE_SOURCE12, baz); + let bar = irqarray1_csr.rf(utra::irqarray1::EV_ENABLE_SOURCE13); + irqarray1_csr.rmwf(utra::irqarray1::EV_ENABLE_SOURCE13, bar); + let mut baz = irqarray1_csr.zf(utra::irqarray1::EV_ENABLE_SOURCE13, bar); + baz |= irqarray1_csr.ms(utra::irqarray1::EV_ENABLE_SOURCE13, 1); + irqarray1_csr.wfo(utra::irqarray1::EV_ENABLE_SOURCE13, baz); + let bar = irqarray1_csr.rf(utra::irqarray1::EV_ENABLE_SOURCE14); + irqarray1_csr.rmwf(utra::irqarray1::EV_ENABLE_SOURCE14, bar); + let mut baz = irqarray1_csr.zf(utra::irqarray1::EV_ENABLE_SOURCE14, bar); + baz |= irqarray1_csr.ms(utra::irqarray1::EV_ENABLE_SOURCE14, 1); + irqarray1_csr.wfo(utra::irqarray1::EV_ENABLE_SOURCE14, baz); + let bar = irqarray1_csr.rf(utra::irqarray1::EV_ENABLE_SOURCE15); + irqarray1_csr.rmwf(utra::irqarray1::EV_ENABLE_SOURCE15, bar); + let mut baz = irqarray1_csr.zf(utra::irqarray1::EV_ENABLE_SOURCE15, bar); + baz |= irqarray1_csr.ms(utra::irqarray1::EV_ENABLE_SOURCE15, 1); + irqarray1_csr.wfo(utra::irqarray1::EV_ENABLE_SOURCE15, baz); + let bar = irqarray1_csr.rf(utra::irqarray1::EV_ENABLE_SOURCE16); + irqarray1_csr.rmwf(utra::irqarray1::EV_ENABLE_SOURCE16, bar); + let mut baz = irqarray1_csr.zf(utra::irqarray1::EV_ENABLE_SOURCE16, bar); + baz |= irqarray1_csr.ms(utra::irqarray1::EV_ENABLE_SOURCE16, 1); + irqarray1_csr.wfo(utra::irqarray1::EV_ENABLE_SOURCE16, baz); + let bar = irqarray1_csr.rf(utra::irqarray1::EV_ENABLE_SOURCE17); + irqarray1_csr.rmwf(utra::irqarray1::EV_ENABLE_SOURCE17, bar); + let mut baz = irqarray1_csr.zf(utra::irqarray1::EV_ENABLE_SOURCE17, bar); + baz |= irqarray1_csr.ms(utra::irqarray1::EV_ENABLE_SOURCE17, 1); + irqarray1_csr.wfo(utra::irqarray1::EV_ENABLE_SOURCE17, baz); + let bar = irqarray1_csr.rf(utra::irqarray1::EV_ENABLE_SOURCE18); + irqarray1_csr.rmwf(utra::irqarray1::EV_ENABLE_SOURCE18, bar); + let mut baz = irqarray1_csr.zf(utra::irqarray1::EV_ENABLE_SOURCE18, bar); + baz |= irqarray1_csr.ms(utra::irqarray1::EV_ENABLE_SOURCE18, 1); + irqarray1_csr.wfo(utra::irqarray1::EV_ENABLE_SOURCE18, baz); + let bar = irqarray1_csr.rf(utra::irqarray1::EV_ENABLE_SOURCE19); + irqarray1_csr.rmwf(utra::irqarray1::EV_ENABLE_SOURCE19, bar); + let mut baz = irqarray1_csr.zf(utra::irqarray1::EV_ENABLE_SOURCE19, bar); + baz |= irqarray1_csr.ms(utra::irqarray1::EV_ENABLE_SOURCE19, 1); + irqarray1_csr.wfo(utra::irqarray1::EV_ENABLE_SOURCE19, baz); + } + + #[test] + #[ignore] + fn compile_check_irqarray10_csr() { + use super::*; + let mut irqarray10_csr = CSR::new(HW_IRQARRAY10_BASE as *mut u32); + + let foo = irqarray10_csr.r(utra::irqarray10::EV_SOFT); + irqarray10_csr.wo(utra::irqarray10::EV_SOFT, foo); + let bar = irqarray10_csr.rf(utra::irqarray10::EV_SOFT_TRIGGER); + irqarray10_csr.rmwf(utra::irqarray10::EV_SOFT_TRIGGER, bar); + let mut baz = irqarray10_csr.zf(utra::irqarray10::EV_SOFT_TRIGGER, bar); + baz |= irqarray10_csr.ms(utra::irqarray10::EV_SOFT_TRIGGER, 1); + irqarray10_csr.wfo(utra::irqarray10::EV_SOFT_TRIGGER, baz); + + let foo = irqarray10_csr.r(utra::irqarray10::EV_STATUS); + irqarray10_csr.wo(utra::irqarray10::EV_STATUS, foo); + let bar = irqarray10_csr.rf(utra::irqarray10::EV_STATUS_SOURCE0); + irqarray10_csr.rmwf(utra::irqarray10::EV_STATUS_SOURCE0, bar); + let mut baz = irqarray10_csr.zf(utra::irqarray10::EV_STATUS_SOURCE0, bar); + baz |= irqarray10_csr.ms(utra::irqarray10::EV_STATUS_SOURCE0, 1); + irqarray10_csr.wfo(utra::irqarray10::EV_STATUS_SOURCE0, baz); + let bar = irqarray10_csr.rf(utra::irqarray10::EV_STATUS_SOURCE1); + irqarray10_csr.rmwf(utra::irqarray10::EV_STATUS_SOURCE1, bar); + let mut baz = irqarray10_csr.zf(utra::irqarray10::EV_STATUS_SOURCE1, bar); + baz |= irqarray10_csr.ms(utra::irqarray10::EV_STATUS_SOURCE1, 1); + irqarray10_csr.wfo(utra::irqarray10::EV_STATUS_SOURCE1, baz); + let bar = irqarray10_csr.rf(utra::irqarray10::EV_STATUS_SOURCE2); + irqarray10_csr.rmwf(utra::irqarray10::EV_STATUS_SOURCE2, bar); + let mut baz = irqarray10_csr.zf(utra::irqarray10::EV_STATUS_SOURCE2, bar); + baz |= irqarray10_csr.ms(utra::irqarray10::EV_STATUS_SOURCE2, 1); + irqarray10_csr.wfo(utra::irqarray10::EV_STATUS_SOURCE2, baz); + let bar = irqarray10_csr.rf(utra::irqarray10::EV_STATUS_SOURCE3); + irqarray10_csr.rmwf(utra::irqarray10::EV_STATUS_SOURCE3, bar); + let mut baz = irqarray10_csr.zf(utra::irqarray10::EV_STATUS_SOURCE3, bar); + baz |= irqarray10_csr.ms(utra::irqarray10::EV_STATUS_SOURCE3, 1); + irqarray10_csr.wfo(utra::irqarray10::EV_STATUS_SOURCE3, baz); + let bar = irqarray10_csr.rf(utra::irqarray10::EV_STATUS_SOURCE4); + irqarray10_csr.rmwf(utra::irqarray10::EV_STATUS_SOURCE4, bar); + let mut baz = irqarray10_csr.zf(utra::irqarray10::EV_STATUS_SOURCE4, bar); + baz |= irqarray10_csr.ms(utra::irqarray10::EV_STATUS_SOURCE4, 1); + irqarray10_csr.wfo(utra::irqarray10::EV_STATUS_SOURCE4, baz); + let bar = irqarray10_csr.rf(utra::irqarray10::EV_STATUS_SOURCE5); + irqarray10_csr.rmwf(utra::irqarray10::EV_STATUS_SOURCE5, bar); + let mut baz = irqarray10_csr.zf(utra::irqarray10::EV_STATUS_SOURCE5, bar); + baz |= irqarray10_csr.ms(utra::irqarray10::EV_STATUS_SOURCE5, 1); + irqarray10_csr.wfo(utra::irqarray10::EV_STATUS_SOURCE5, baz); + let bar = irqarray10_csr.rf(utra::irqarray10::EV_STATUS_SOURCE6); + irqarray10_csr.rmwf(utra::irqarray10::EV_STATUS_SOURCE6, bar); + let mut baz = irqarray10_csr.zf(utra::irqarray10::EV_STATUS_SOURCE6, bar); + baz |= irqarray10_csr.ms(utra::irqarray10::EV_STATUS_SOURCE6, 1); + irqarray10_csr.wfo(utra::irqarray10::EV_STATUS_SOURCE6, baz); + let bar = irqarray10_csr.rf(utra::irqarray10::EV_STATUS_SOURCE7); + irqarray10_csr.rmwf(utra::irqarray10::EV_STATUS_SOURCE7, bar); + let mut baz = irqarray10_csr.zf(utra::irqarray10::EV_STATUS_SOURCE7, bar); + baz |= irqarray10_csr.ms(utra::irqarray10::EV_STATUS_SOURCE7, 1); + irqarray10_csr.wfo(utra::irqarray10::EV_STATUS_SOURCE7, baz); + let bar = irqarray10_csr.rf(utra::irqarray10::EV_STATUS_SOURCE8); + irqarray10_csr.rmwf(utra::irqarray10::EV_STATUS_SOURCE8, bar); + let mut baz = irqarray10_csr.zf(utra::irqarray10::EV_STATUS_SOURCE8, bar); + baz |= irqarray10_csr.ms(utra::irqarray10::EV_STATUS_SOURCE8, 1); + irqarray10_csr.wfo(utra::irqarray10::EV_STATUS_SOURCE8, baz); + let bar = irqarray10_csr.rf(utra::irqarray10::EV_STATUS_SOURCE9); + irqarray10_csr.rmwf(utra::irqarray10::EV_STATUS_SOURCE9, bar); + let mut baz = irqarray10_csr.zf(utra::irqarray10::EV_STATUS_SOURCE9, bar); + baz |= irqarray10_csr.ms(utra::irqarray10::EV_STATUS_SOURCE9, 1); + irqarray10_csr.wfo(utra::irqarray10::EV_STATUS_SOURCE9, baz); + let bar = irqarray10_csr.rf(utra::irqarray10::EV_STATUS_SOURCE10); + irqarray10_csr.rmwf(utra::irqarray10::EV_STATUS_SOURCE10, bar); + let mut baz = irqarray10_csr.zf(utra::irqarray10::EV_STATUS_SOURCE10, bar); + baz |= irqarray10_csr.ms(utra::irqarray10::EV_STATUS_SOURCE10, 1); + irqarray10_csr.wfo(utra::irqarray10::EV_STATUS_SOURCE10, baz); + let bar = irqarray10_csr.rf(utra::irqarray10::EV_STATUS_SOURCE11); + irqarray10_csr.rmwf(utra::irqarray10::EV_STATUS_SOURCE11, bar); + let mut baz = irqarray10_csr.zf(utra::irqarray10::EV_STATUS_SOURCE11, bar); + baz |= irqarray10_csr.ms(utra::irqarray10::EV_STATUS_SOURCE11, 1); + irqarray10_csr.wfo(utra::irqarray10::EV_STATUS_SOURCE11, baz); + let bar = irqarray10_csr.rf(utra::irqarray10::EV_STATUS_SOURCE12); + irqarray10_csr.rmwf(utra::irqarray10::EV_STATUS_SOURCE12, bar); + let mut baz = irqarray10_csr.zf(utra::irqarray10::EV_STATUS_SOURCE12, bar); + baz |= irqarray10_csr.ms(utra::irqarray10::EV_STATUS_SOURCE12, 1); + irqarray10_csr.wfo(utra::irqarray10::EV_STATUS_SOURCE12, baz); + let bar = irqarray10_csr.rf(utra::irqarray10::EV_STATUS_SOURCE13); + irqarray10_csr.rmwf(utra::irqarray10::EV_STATUS_SOURCE13, bar); + let mut baz = irqarray10_csr.zf(utra::irqarray10::EV_STATUS_SOURCE13, bar); + baz |= irqarray10_csr.ms(utra::irqarray10::EV_STATUS_SOURCE13, 1); + irqarray10_csr.wfo(utra::irqarray10::EV_STATUS_SOURCE13, baz); + let bar = irqarray10_csr.rf(utra::irqarray10::EV_STATUS_SOURCE14); + irqarray10_csr.rmwf(utra::irqarray10::EV_STATUS_SOURCE14, bar); + let mut baz = irqarray10_csr.zf(utra::irqarray10::EV_STATUS_SOURCE14, bar); + baz |= irqarray10_csr.ms(utra::irqarray10::EV_STATUS_SOURCE14, 1); + irqarray10_csr.wfo(utra::irqarray10::EV_STATUS_SOURCE14, baz); + let bar = irqarray10_csr.rf(utra::irqarray10::EV_STATUS_SOURCE15); + irqarray10_csr.rmwf(utra::irqarray10::EV_STATUS_SOURCE15, bar); + let mut baz = irqarray10_csr.zf(utra::irqarray10::EV_STATUS_SOURCE15, bar); + baz |= irqarray10_csr.ms(utra::irqarray10::EV_STATUS_SOURCE15, 1); + irqarray10_csr.wfo(utra::irqarray10::EV_STATUS_SOURCE15, baz); + let bar = irqarray10_csr.rf(utra::irqarray10::EV_STATUS_SOURCE16); + irqarray10_csr.rmwf(utra::irqarray10::EV_STATUS_SOURCE16, bar); + let mut baz = irqarray10_csr.zf(utra::irqarray10::EV_STATUS_SOURCE16, bar); + baz |= irqarray10_csr.ms(utra::irqarray10::EV_STATUS_SOURCE16, 1); + irqarray10_csr.wfo(utra::irqarray10::EV_STATUS_SOURCE16, baz); + let bar = irqarray10_csr.rf(utra::irqarray10::EV_STATUS_SOURCE17); + irqarray10_csr.rmwf(utra::irqarray10::EV_STATUS_SOURCE17, bar); + let mut baz = irqarray10_csr.zf(utra::irqarray10::EV_STATUS_SOURCE17, bar); + baz |= irqarray10_csr.ms(utra::irqarray10::EV_STATUS_SOURCE17, 1); + irqarray10_csr.wfo(utra::irqarray10::EV_STATUS_SOURCE17, baz); + let bar = irqarray10_csr.rf(utra::irqarray10::EV_STATUS_SOURCE18); + irqarray10_csr.rmwf(utra::irqarray10::EV_STATUS_SOURCE18, bar); + let mut baz = irqarray10_csr.zf(utra::irqarray10::EV_STATUS_SOURCE18, bar); + baz |= irqarray10_csr.ms(utra::irqarray10::EV_STATUS_SOURCE18, 1); + irqarray10_csr.wfo(utra::irqarray10::EV_STATUS_SOURCE18, baz); + let bar = irqarray10_csr.rf(utra::irqarray10::EV_STATUS_SOURCE19); + irqarray10_csr.rmwf(utra::irqarray10::EV_STATUS_SOURCE19, bar); + let mut baz = irqarray10_csr.zf(utra::irqarray10::EV_STATUS_SOURCE19, bar); + baz |= irqarray10_csr.ms(utra::irqarray10::EV_STATUS_SOURCE19, 1); + irqarray10_csr.wfo(utra::irqarray10::EV_STATUS_SOURCE19, baz); + + let foo = irqarray10_csr.r(utra::irqarray10::EV_PENDING); + irqarray10_csr.wo(utra::irqarray10::EV_PENDING, foo); + let bar = irqarray10_csr.rf(utra::irqarray10::EV_PENDING_SOURCE0); + irqarray10_csr.rmwf(utra::irqarray10::EV_PENDING_SOURCE0, bar); + let mut baz = irqarray10_csr.zf(utra::irqarray10::EV_PENDING_SOURCE0, bar); + baz |= irqarray10_csr.ms(utra::irqarray10::EV_PENDING_SOURCE0, 1); + irqarray10_csr.wfo(utra::irqarray10::EV_PENDING_SOURCE0, baz); + let bar = irqarray10_csr.rf(utra::irqarray10::EV_PENDING_SOURCE1); + irqarray10_csr.rmwf(utra::irqarray10::EV_PENDING_SOURCE1, bar); + let mut baz = irqarray10_csr.zf(utra::irqarray10::EV_PENDING_SOURCE1, bar); + baz |= irqarray10_csr.ms(utra::irqarray10::EV_PENDING_SOURCE1, 1); + irqarray10_csr.wfo(utra::irqarray10::EV_PENDING_SOURCE1, baz); + let bar = irqarray10_csr.rf(utra::irqarray10::EV_PENDING_SOURCE2); + irqarray10_csr.rmwf(utra::irqarray10::EV_PENDING_SOURCE2, bar); + let mut baz = irqarray10_csr.zf(utra::irqarray10::EV_PENDING_SOURCE2, bar); + baz |= irqarray10_csr.ms(utra::irqarray10::EV_PENDING_SOURCE2, 1); + irqarray10_csr.wfo(utra::irqarray10::EV_PENDING_SOURCE2, baz); + let bar = irqarray10_csr.rf(utra::irqarray10::EV_PENDING_SOURCE3); + irqarray10_csr.rmwf(utra::irqarray10::EV_PENDING_SOURCE3, bar); + let mut baz = irqarray10_csr.zf(utra::irqarray10::EV_PENDING_SOURCE3, bar); + baz |= irqarray10_csr.ms(utra::irqarray10::EV_PENDING_SOURCE3, 1); + irqarray10_csr.wfo(utra::irqarray10::EV_PENDING_SOURCE3, baz); + let bar = irqarray10_csr.rf(utra::irqarray10::EV_PENDING_SOURCE4); + irqarray10_csr.rmwf(utra::irqarray10::EV_PENDING_SOURCE4, bar); + let mut baz = irqarray10_csr.zf(utra::irqarray10::EV_PENDING_SOURCE4, bar); + baz |= irqarray10_csr.ms(utra::irqarray10::EV_PENDING_SOURCE4, 1); + irqarray10_csr.wfo(utra::irqarray10::EV_PENDING_SOURCE4, baz); + let bar = irqarray10_csr.rf(utra::irqarray10::EV_PENDING_SOURCE5); + irqarray10_csr.rmwf(utra::irqarray10::EV_PENDING_SOURCE5, bar); + let mut baz = irqarray10_csr.zf(utra::irqarray10::EV_PENDING_SOURCE5, bar); + baz |= irqarray10_csr.ms(utra::irqarray10::EV_PENDING_SOURCE5, 1); + irqarray10_csr.wfo(utra::irqarray10::EV_PENDING_SOURCE5, baz); + let bar = irqarray10_csr.rf(utra::irqarray10::EV_PENDING_SOURCE6); + irqarray10_csr.rmwf(utra::irqarray10::EV_PENDING_SOURCE6, bar); + let mut baz = irqarray10_csr.zf(utra::irqarray10::EV_PENDING_SOURCE6, bar); + baz |= irqarray10_csr.ms(utra::irqarray10::EV_PENDING_SOURCE6, 1); + irqarray10_csr.wfo(utra::irqarray10::EV_PENDING_SOURCE6, baz); + let bar = irqarray10_csr.rf(utra::irqarray10::EV_PENDING_SOURCE7); + irqarray10_csr.rmwf(utra::irqarray10::EV_PENDING_SOURCE7, bar); + let mut baz = irqarray10_csr.zf(utra::irqarray10::EV_PENDING_SOURCE7, bar); + baz |= irqarray10_csr.ms(utra::irqarray10::EV_PENDING_SOURCE7, 1); + irqarray10_csr.wfo(utra::irqarray10::EV_PENDING_SOURCE7, baz); + let bar = irqarray10_csr.rf(utra::irqarray10::EV_PENDING_SOURCE8); + irqarray10_csr.rmwf(utra::irqarray10::EV_PENDING_SOURCE8, bar); + let mut baz = irqarray10_csr.zf(utra::irqarray10::EV_PENDING_SOURCE8, bar); + baz |= irqarray10_csr.ms(utra::irqarray10::EV_PENDING_SOURCE8, 1); + irqarray10_csr.wfo(utra::irqarray10::EV_PENDING_SOURCE8, baz); + let bar = irqarray10_csr.rf(utra::irqarray10::EV_PENDING_SOURCE9); + irqarray10_csr.rmwf(utra::irqarray10::EV_PENDING_SOURCE9, bar); + let mut baz = irqarray10_csr.zf(utra::irqarray10::EV_PENDING_SOURCE9, bar); + baz |= irqarray10_csr.ms(utra::irqarray10::EV_PENDING_SOURCE9, 1); + irqarray10_csr.wfo(utra::irqarray10::EV_PENDING_SOURCE9, baz); + let bar = irqarray10_csr.rf(utra::irqarray10::EV_PENDING_SOURCE10); + irqarray10_csr.rmwf(utra::irqarray10::EV_PENDING_SOURCE10, bar); + let mut baz = irqarray10_csr.zf(utra::irqarray10::EV_PENDING_SOURCE10, bar); + baz |= irqarray10_csr.ms(utra::irqarray10::EV_PENDING_SOURCE10, 1); + irqarray10_csr.wfo(utra::irqarray10::EV_PENDING_SOURCE10, baz); + let bar = irqarray10_csr.rf(utra::irqarray10::EV_PENDING_SOURCE11); + irqarray10_csr.rmwf(utra::irqarray10::EV_PENDING_SOURCE11, bar); + let mut baz = irqarray10_csr.zf(utra::irqarray10::EV_PENDING_SOURCE11, bar); + baz |= irqarray10_csr.ms(utra::irqarray10::EV_PENDING_SOURCE11, 1); + irqarray10_csr.wfo(utra::irqarray10::EV_PENDING_SOURCE11, baz); + let bar = irqarray10_csr.rf(utra::irqarray10::EV_PENDING_SOURCE12); + irqarray10_csr.rmwf(utra::irqarray10::EV_PENDING_SOURCE12, bar); + let mut baz = irqarray10_csr.zf(utra::irqarray10::EV_PENDING_SOURCE12, bar); + baz |= irqarray10_csr.ms(utra::irqarray10::EV_PENDING_SOURCE12, 1); + irqarray10_csr.wfo(utra::irqarray10::EV_PENDING_SOURCE12, baz); + let bar = irqarray10_csr.rf(utra::irqarray10::EV_PENDING_SOURCE13); + irqarray10_csr.rmwf(utra::irqarray10::EV_PENDING_SOURCE13, bar); + let mut baz = irqarray10_csr.zf(utra::irqarray10::EV_PENDING_SOURCE13, bar); + baz |= irqarray10_csr.ms(utra::irqarray10::EV_PENDING_SOURCE13, 1); + irqarray10_csr.wfo(utra::irqarray10::EV_PENDING_SOURCE13, baz); + let bar = irqarray10_csr.rf(utra::irqarray10::EV_PENDING_SOURCE14); + irqarray10_csr.rmwf(utra::irqarray10::EV_PENDING_SOURCE14, bar); + let mut baz = irqarray10_csr.zf(utra::irqarray10::EV_PENDING_SOURCE14, bar); + baz |= irqarray10_csr.ms(utra::irqarray10::EV_PENDING_SOURCE14, 1); + irqarray10_csr.wfo(utra::irqarray10::EV_PENDING_SOURCE14, baz); + let bar = irqarray10_csr.rf(utra::irqarray10::EV_PENDING_SOURCE15); + irqarray10_csr.rmwf(utra::irqarray10::EV_PENDING_SOURCE15, bar); + let mut baz = irqarray10_csr.zf(utra::irqarray10::EV_PENDING_SOURCE15, bar); + baz |= irqarray10_csr.ms(utra::irqarray10::EV_PENDING_SOURCE15, 1); + irqarray10_csr.wfo(utra::irqarray10::EV_PENDING_SOURCE15, baz); + let bar = irqarray10_csr.rf(utra::irqarray10::EV_PENDING_SOURCE16); + irqarray10_csr.rmwf(utra::irqarray10::EV_PENDING_SOURCE16, bar); + let mut baz = irqarray10_csr.zf(utra::irqarray10::EV_PENDING_SOURCE16, bar); + baz |= irqarray10_csr.ms(utra::irqarray10::EV_PENDING_SOURCE16, 1); + irqarray10_csr.wfo(utra::irqarray10::EV_PENDING_SOURCE16, baz); + let bar = irqarray10_csr.rf(utra::irqarray10::EV_PENDING_SOURCE17); + irqarray10_csr.rmwf(utra::irqarray10::EV_PENDING_SOURCE17, bar); + let mut baz = irqarray10_csr.zf(utra::irqarray10::EV_PENDING_SOURCE17, bar); + baz |= irqarray10_csr.ms(utra::irqarray10::EV_PENDING_SOURCE17, 1); + irqarray10_csr.wfo(utra::irqarray10::EV_PENDING_SOURCE17, baz); + let bar = irqarray10_csr.rf(utra::irqarray10::EV_PENDING_SOURCE18); + irqarray10_csr.rmwf(utra::irqarray10::EV_PENDING_SOURCE18, bar); + let mut baz = irqarray10_csr.zf(utra::irqarray10::EV_PENDING_SOURCE18, bar); + baz |= irqarray10_csr.ms(utra::irqarray10::EV_PENDING_SOURCE18, 1); + irqarray10_csr.wfo(utra::irqarray10::EV_PENDING_SOURCE18, baz); + let bar = irqarray10_csr.rf(utra::irqarray10::EV_PENDING_SOURCE19); + irqarray10_csr.rmwf(utra::irqarray10::EV_PENDING_SOURCE19, bar); + let mut baz = irqarray10_csr.zf(utra::irqarray10::EV_PENDING_SOURCE19, bar); + baz |= irqarray10_csr.ms(utra::irqarray10::EV_PENDING_SOURCE19, 1); + irqarray10_csr.wfo(utra::irqarray10::EV_PENDING_SOURCE19, baz); + + let foo = irqarray10_csr.r(utra::irqarray10::EV_ENABLE); + irqarray10_csr.wo(utra::irqarray10::EV_ENABLE, foo); + let bar = irqarray10_csr.rf(utra::irqarray10::EV_ENABLE_SOURCE0); + irqarray10_csr.rmwf(utra::irqarray10::EV_ENABLE_SOURCE0, bar); + let mut baz = irqarray10_csr.zf(utra::irqarray10::EV_ENABLE_SOURCE0, bar); + baz |= irqarray10_csr.ms(utra::irqarray10::EV_ENABLE_SOURCE0, 1); + irqarray10_csr.wfo(utra::irqarray10::EV_ENABLE_SOURCE0, baz); + let bar = irqarray10_csr.rf(utra::irqarray10::EV_ENABLE_SOURCE1); + irqarray10_csr.rmwf(utra::irqarray10::EV_ENABLE_SOURCE1, bar); + let mut baz = irqarray10_csr.zf(utra::irqarray10::EV_ENABLE_SOURCE1, bar); + baz |= irqarray10_csr.ms(utra::irqarray10::EV_ENABLE_SOURCE1, 1); + irqarray10_csr.wfo(utra::irqarray10::EV_ENABLE_SOURCE1, baz); + let bar = irqarray10_csr.rf(utra::irqarray10::EV_ENABLE_SOURCE2); + irqarray10_csr.rmwf(utra::irqarray10::EV_ENABLE_SOURCE2, bar); + let mut baz = irqarray10_csr.zf(utra::irqarray10::EV_ENABLE_SOURCE2, bar); + baz |= irqarray10_csr.ms(utra::irqarray10::EV_ENABLE_SOURCE2, 1); + irqarray10_csr.wfo(utra::irqarray10::EV_ENABLE_SOURCE2, baz); + let bar = irqarray10_csr.rf(utra::irqarray10::EV_ENABLE_SOURCE3); + irqarray10_csr.rmwf(utra::irqarray10::EV_ENABLE_SOURCE3, bar); + let mut baz = irqarray10_csr.zf(utra::irqarray10::EV_ENABLE_SOURCE3, bar); + baz |= irqarray10_csr.ms(utra::irqarray10::EV_ENABLE_SOURCE3, 1); + irqarray10_csr.wfo(utra::irqarray10::EV_ENABLE_SOURCE3, baz); + let bar = irqarray10_csr.rf(utra::irqarray10::EV_ENABLE_SOURCE4); + irqarray10_csr.rmwf(utra::irqarray10::EV_ENABLE_SOURCE4, bar); + let mut baz = irqarray10_csr.zf(utra::irqarray10::EV_ENABLE_SOURCE4, bar); + baz |= irqarray10_csr.ms(utra::irqarray10::EV_ENABLE_SOURCE4, 1); + irqarray10_csr.wfo(utra::irqarray10::EV_ENABLE_SOURCE4, baz); + let bar = irqarray10_csr.rf(utra::irqarray10::EV_ENABLE_SOURCE5); + irqarray10_csr.rmwf(utra::irqarray10::EV_ENABLE_SOURCE5, bar); + let mut baz = irqarray10_csr.zf(utra::irqarray10::EV_ENABLE_SOURCE5, bar); + baz |= irqarray10_csr.ms(utra::irqarray10::EV_ENABLE_SOURCE5, 1); + irqarray10_csr.wfo(utra::irqarray10::EV_ENABLE_SOURCE5, baz); + let bar = irqarray10_csr.rf(utra::irqarray10::EV_ENABLE_SOURCE6); + irqarray10_csr.rmwf(utra::irqarray10::EV_ENABLE_SOURCE6, bar); + let mut baz = irqarray10_csr.zf(utra::irqarray10::EV_ENABLE_SOURCE6, bar); + baz |= irqarray10_csr.ms(utra::irqarray10::EV_ENABLE_SOURCE6, 1); + irqarray10_csr.wfo(utra::irqarray10::EV_ENABLE_SOURCE6, baz); + let bar = irqarray10_csr.rf(utra::irqarray10::EV_ENABLE_SOURCE7); + irqarray10_csr.rmwf(utra::irqarray10::EV_ENABLE_SOURCE7, bar); + let mut baz = irqarray10_csr.zf(utra::irqarray10::EV_ENABLE_SOURCE7, bar); + baz |= irqarray10_csr.ms(utra::irqarray10::EV_ENABLE_SOURCE7, 1); + irqarray10_csr.wfo(utra::irqarray10::EV_ENABLE_SOURCE7, baz); + let bar = irqarray10_csr.rf(utra::irqarray10::EV_ENABLE_SOURCE8); + irqarray10_csr.rmwf(utra::irqarray10::EV_ENABLE_SOURCE8, bar); + let mut baz = irqarray10_csr.zf(utra::irqarray10::EV_ENABLE_SOURCE8, bar); + baz |= irqarray10_csr.ms(utra::irqarray10::EV_ENABLE_SOURCE8, 1); + irqarray10_csr.wfo(utra::irqarray10::EV_ENABLE_SOURCE8, baz); + let bar = irqarray10_csr.rf(utra::irqarray10::EV_ENABLE_SOURCE9); + irqarray10_csr.rmwf(utra::irqarray10::EV_ENABLE_SOURCE9, bar); + let mut baz = irqarray10_csr.zf(utra::irqarray10::EV_ENABLE_SOURCE9, bar); + baz |= irqarray10_csr.ms(utra::irqarray10::EV_ENABLE_SOURCE9, 1); + irqarray10_csr.wfo(utra::irqarray10::EV_ENABLE_SOURCE9, baz); + let bar = irqarray10_csr.rf(utra::irqarray10::EV_ENABLE_SOURCE10); + irqarray10_csr.rmwf(utra::irqarray10::EV_ENABLE_SOURCE10, bar); + let mut baz = irqarray10_csr.zf(utra::irqarray10::EV_ENABLE_SOURCE10, bar); + baz |= irqarray10_csr.ms(utra::irqarray10::EV_ENABLE_SOURCE10, 1); + irqarray10_csr.wfo(utra::irqarray10::EV_ENABLE_SOURCE10, baz); + let bar = irqarray10_csr.rf(utra::irqarray10::EV_ENABLE_SOURCE11); + irqarray10_csr.rmwf(utra::irqarray10::EV_ENABLE_SOURCE11, bar); + let mut baz = irqarray10_csr.zf(utra::irqarray10::EV_ENABLE_SOURCE11, bar); + baz |= irqarray10_csr.ms(utra::irqarray10::EV_ENABLE_SOURCE11, 1); + irqarray10_csr.wfo(utra::irqarray10::EV_ENABLE_SOURCE11, baz); + let bar = irqarray10_csr.rf(utra::irqarray10::EV_ENABLE_SOURCE12); + irqarray10_csr.rmwf(utra::irqarray10::EV_ENABLE_SOURCE12, bar); + let mut baz = irqarray10_csr.zf(utra::irqarray10::EV_ENABLE_SOURCE12, bar); + baz |= irqarray10_csr.ms(utra::irqarray10::EV_ENABLE_SOURCE12, 1); + irqarray10_csr.wfo(utra::irqarray10::EV_ENABLE_SOURCE12, baz); + let bar = irqarray10_csr.rf(utra::irqarray10::EV_ENABLE_SOURCE13); + irqarray10_csr.rmwf(utra::irqarray10::EV_ENABLE_SOURCE13, bar); + let mut baz = irqarray10_csr.zf(utra::irqarray10::EV_ENABLE_SOURCE13, bar); + baz |= irqarray10_csr.ms(utra::irqarray10::EV_ENABLE_SOURCE13, 1); + irqarray10_csr.wfo(utra::irqarray10::EV_ENABLE_SOURCE13, baz); + let bar = irqarray10_csr.rf(utra::irqarray10::EV_ENABLE_SOURCE14); + irqarray10_csr.rmwf(utra::irqarray10::EV_ENABLE_SOURCE14, bar); + let mut baz = irqarray10_csr.zf(utra::irqarray10::EV_ENABLE_SOURCE14, bar); + baz |= irqarray10_csr.ms(utra::irqarray10::EV_ENABLE_SOURCE14, 1); + irqarray10_csr.wfo(utra::irqarray10::EV_ENABLE_SOURCE14, baz); + let bar = irqarray10_csr.rf(utra::irqarray10::EV_ENABLE_SOURCE15); + irqarray10_csr.rmwf(utra::irqarray10::EV_ENABLE_SOURCE15, bar); + let mut baz = irqarray10_csr.zf(utra::irqarray10::EV_ENABLE_SOURCE15, bar); + baz |= irqarray10_csr.ms(utra::irqarray10::EV_ENABLE_SOURCE15, 1); + irqarray10_csr.wfo(utra::irqarray10::EV_ENABLE_SOURCE15, baz); + let bar = irqarray10_csr.rf(utra::irqarray10::EV_ENABLE_SOURCE16); + irqarray10_csr.rmwf(utra::irqarray10::EV_ENABLE_SOURCE16, bar); + let mut baz = irqarray10_csr.zf(utra::irqarray10::EV_ENABLE_SOURCE16, bar); + baz |= irqarray10_csr.ms(utra::irqarray10::EV_ENABLE_SOURCE16, 1); + irqarray10_csr.wfo(utra::irqarray10::EV_ENABLE_SOURCE16, baz); + let bar = irqarray10_csr.rf(utra::irqarray10::EV_ENABLE_SOURCE17); + irqarray10_csr.rmwf(utra::irqarray10::EV_ENABLE_SOURCE17, bar); + let mut baz = irqarray10_csr.zf(utra::irqarray10::EV_ENABLE_SOURCE17, bar); + baz |= irqarray10_csr.ms(utra::irqarray10::EV_ENABLE_SOURCE17, 1); + irqarray10_csr.wfo(utra::irqarray10::EV_ENABLE_SOURCE17, baz); + let bar = irqarray10_csr.rf(utra::irqarray10::EV_ENABLE_SOURCE18); + irqarray10_csr.rmwf(utra::irqarray10::EV_ENABLE_SOURCE18, bar); + let mut baz = irqarray10_csr.zf(utra::irqarray10::EV_ENABLE_SOURCE18, bar); + baz |= irqarray10_csr.ms(utra::irqarray10::EV_ENABLE_SOURCE18, 1); + irqarray10_csr.wfo(utra::irqarray10::EV_ENABLE_SOURCE18, baz); + let bar = irqarray10_csr.rf(utra::irqarray10::EV_ENABLE_SOURCE19); + irqarray10_csr.rmwf(utra::irqarray10::EV_ENABLE_SOURCE19, bar); + let mut baz = irqarray10_csr.zf(utra::irqarray10::EV_ENABLE_SOURCE19, bar); + baz |= irqarray10_csr.ms(utra::irqarray10::EV_ENABLE_SOURCE19, 1); + irqarray10_csr.wfo(utra::irqarray10::EV_ENABLE_SOURCE19, baz); + } + + #[test] + #[ignore] + fn compile_check_irqarray11_csr() { + use super::*; + let mut irqarray11_csr = CSR::new(HW_IRQARRAY11_BASE as *mut u32); + + let foo = irqarray11_csr.r(utra::irqarray11::EV_SOFT); + irqarray11_csr.wo(utra::irqarray11::EV_SOFT, foo); + let bar = irqarray11_csr.rf(utra::irqarray11::EV_SOFT_TRIGGER); + irqarray11_csr.rmwf(utra::irqarray11::EV_SOFT_TRIGGER, bar); + let mut baz = irqarray11_csr.zf(utra::irqarray11::EV_SOFT_TRIGGER, bar); + baz |= irqarray11_csr.ms(utra::irqarray11::EV_SOFT_TRIGGER, 1); + irqarray11_csr.wfo(utra::irqarray11::EV_SOFT_TRIGGER, baz); + + let foo = irqarray11_csr.r(utra::irqarray11::EV_STATUS); + irqarray11_csr.wo(utra::irqarray11::EV_STATUS, foo); + let bar = irqarray11_csr.rf(utra::irqarray11::EV_STATUS_SOURCE0); + irqarray11_csr.rmwf(utra::irqarray11::EV_STATUS_SOURCE0, bar); + let mut baz = irqarray11_csr.zf(utra::irqarray11::EV_STATUS_SOURCE0, bar); + baz |= irqarray11_csr.ms(utra::irqarray11::EV_STATUS_SOURCE0, 1); + irqarray11_csr.wfo(utra::irqarray11::EV_STATUS_SOURCE0, baz); + let bar = irqarray11_csr.rf(utra::irqarray11::EV_STATUS_SOURCE1); + irqarray11_csr.rmwf(utra::irqarray11::EV_STATUS_SOURCE1, bar); + let mut baz = irqarray11_csr.zf(utra::irqarray11::EV_STATUS_SOURCE1, bar); + baz |= irqarray11_csr.ms(utra::irqarray11::EV_STATUS_SOURCE1, 1); + irqarray11_csr.wfo(utra::irqarray11::EV_STATUS_SOURCE1, baz); + let bar = irqarray11_csr.rf(utra::irqarray11::EV_STATUS_SOURCE2); + irqarray11_csr.rmwf(utra::irqarray11::EV_STATUS_SOURCE2, bar); + let mut baz = irqarray11_csr.zf(utra::irqarray11::EV_STATUS_SOURCE2, bar); + baz |= irqarray11_csr.ms(utra::irqarray11::EV_STATUS_SOURCE2, 1); + irqarray11_csr.wfo(utra::irqarray11::EV_STATUS_SOURCE2, baz); + let bar = irqarray11_csr.rf(utra::irqarray11::EV_STATUS_SOURCE3); + irqarray11_csr.rmwf(utra::irqarray11::EV_STATUS_SOURCE3, bar); + let mut baz = irqarray11_csr.zf(utra::irqarray11::EV_STATUS_SOURCE3, bar); + baz |= irqarray11_csr.ms(utra::irqarray11::EV_STATUS_SOURCE3, 1); + irqarray11_csr.wfo(utra::irqarray11::EV_STATUS_SOURCE3, baz); + let bar = irqarray11_csr.rf(utra::irqarray11::EV_STATUS_SOURCE4); + irqarray11_csr.rmwf(utra::irqarray11::EV_STATUS_SOURCE4, bar); + let mut baz = irqarray11_csr.zf(utra::irqarray11::EV_STATUS_SOURCE4, bar); + baz |= irqarray11_csr.ms(utra::irqarray11::EV_STATUS_SOURCE4, 1); + irqarray11_csr.wfo(utra::irqarray11::EV_STATUS_SOURCE4, baz); + let bar = irqarray11_csr.rf(utra::irqarray11::EV_STATUS_SOURCE5); + irqarray11_csr.rmwf(utra::irqarray11::EV_STATUS_SOURCE5, bar); + let mut baz = irqarray11_csr.zf(utra::irqarray11::EV_STATUS_SOURCE5, bar); + baz |= irqarray11_csr.ms(utra::irqarray11::EV_STATUS_SOURCE5, 1); + irqarray11_csr.wfo(utra::irqarray11::EV_STATUS_SOURCE5, baz); + let bar = irqarray11_csr.rf(utra::irqarray11::EV_STATUS_SOURCE6); + irqarray11_csr.rmwf(utra::irqarray11::EV_STATUS_SOURCE6, bar); + let mut baz = irqarray11_csr.zf(utra::irqarray11::EV_STATUS_SOURCE6, bar); + baz |= irqarray11_csr.ms(utra::irqarray11::EV_STATUS_SOURCE6, 1); + irqarray11_csr.wfo(utra::irqarray11::EV_STATUS_SOURCE6, baz); + let bar = irqarray11_csr.rf(utra::irqarray11::EV_STATUS_SOURCE7); + irqarray11_csr.rmwf(utra::irqarray11::EV_STATUS_SOURCE7, bar); + let mut baz = irqarray11_csr.zf(utra::irqarray11::EV_STATUS_SOURCE7, bar); + baz |= irqarray11_csr.ms(utra::irqarray11::EV_STATUS_SOURCE7, 1); + irqarray11_csr.wfo(utra::irqarray11::EV_STATUS_SOURCE7, baz); + let bar = irqarray11_csr.rf(utra::irqarray11::EV_STATUS_SOURCE8); + irqarray11_csr.rmwf(utra::irqarray11::EV_STATUS_SOURCE8, bar); + let mut baz = irqarray11_csr.zf(utra::irqarray11::EV_STATUS_SOURCE8, bar); + baz |= irqarray11_csr.ms(utra::irqarray11::EV_STATUS_SOURCE8, 1); + irqarray11_csr.wfo(utra::irqarray11::EV_STATUS_SOURCE8, baz); + let bar = irqarray11_csr.rf(utra::irqarray11::EV_STATUS_SOURCE9); + irqarray11_csr.rmwf(utra::irqarray11::EV_STATUS_SOURCE9, bar); + let mut baz = irqarray11_csr.zf(utra::irqarray11::EV_STATUS_SOURCE9, bar); + baz |= irqarray11_csr.ms(utra::irqarray11::EV_STATUS_SOURCE9, 1); + irqarray11_csr.wfo(utra::irqarray11::EV_STATUS_SOURCE9, baz); + let bar = irqarray11_csr.rf(utra::irqarray11::EV_STATUS_SOURCE10); + irqarray11_csr.rmwf(utra::irqarray11::EV_STATUS_SOURCE10, bar); + let mut baz = irqarray11_csr.zf(utra::irqarray11::EV_STATUS_SOURCE10, bar); + baz |= irqarray11_csr.ms(utra::irqarray11::EV_STATUS_SOURCE10, 1); + irqarray11_csr.wfo(utra::irqarray11::EV_STATUS_SOURCE10, baz); + let bar = irqarray11_csr.rf(utra::irqarray11::EV_STATUS_SOURCE11); + irqarray11_csr.rmwf(utra::irqarray11::EV_STATUS_SOURCE11, bar); + let mut baz = irqarray11_csr.zf(utra::irqarray11::EV_STATUS_SOURCE11, bar); + baz |= irqarray11_csr.ms(utra::irqarray11::EV_STATUS_SOURCE11, 1); + irqarray11_csr.wfo(utra::irqarray11::EV_STATUS_SOURCE11, baz); + let bar = irqarray11_csr.rf(utra::irqarray11::EV_STATUS_SOURCE12); + irqarray11_csr.rmwf(utra::irqarray11::EV_STATUS_SOURCE12, bar); + let mut baz = irqarray11_csr.zf(utra::irqarray11::EV_STATUS_SOURCE12, bar); + baz |= irqarray11_csr.ms(utra::irqarray11::EV_STATUS_SOURCE12, 1); + irqarray11_csr.wfo(utra::irqarray11::EV_STATUS_SOURCE12, baz); + let bar = irqarray11_csr.rf(utra::irqarray11::EV_STATUS_SOURCE13); + irqarray11_csr.rmwf(utra::irqarray11::EV_STATUS_SOURCE13, bar); + let mut baz = irqarray11_csr.zf(utra::irqarray11::EV_STATUS_SOURCE13, bar); + baz |= irqarray11_csr.ms(utra::irqarray11::EV_STATUS_SOURCE13, 1); + irqarray11_csr.wfo(utra::irqarray11::EV_STATUS_SOURCE13, baz); + let bar = irqarray11_csr.rf(utra::irqarray11::EV_STATUS_SOURCE14); + irqarray11_csr.rmwf(utra::irqarray11::EV_STATUS_SOURCE14, bar); + let mut baz = irqarray11_csr.zf(utra::irqarray11::EV_STATUS_SOURCE14, bar); + baz |= irqarray11_csr.ms(utra::irqarray11::EV_STATUS_SOURCE14, 1); + irqarray11_csr.wfo(utra::irqarray11::EV_STATUS_SOURCE14, baz); + let bar = irqarray11_csr.rf(utra::irqarray11::EV_STATUS_SOURCE15); + irqarray11_csr.rmwf(utra::irqarray11::EV_STATUS_SOURCE15, bar); + let mut baz = irqarray11_csr.zf(utra::irqarray11::EV_STATUS_SOURCE15, bar); + baz |= irqarray11_csr.ms(utra::irqarray11::EV_STATUS_SOURCE15, 1); + irqarray11_csr.wfo(utra::irqarray11::EV_STATUS_SOURCE15, baz); + let bar = irqarray11_csr.rf(utra::irqarray11::EV_STATUS_SOURCE16); + irqarray11_csr.rmwf(utra::irqarray11::EV_STATUS_SOURCE16, bar); + let mut baz = irqarray11_csr.zf(utra::irqarray11::EV_STATUS_SOURCE16, bar); + baz |= irqarray11_csr.ms(utra::irqarray11::EV_STATUS_SOURCE16, 1); + irqarray11_csr.wfo(utra::irqarray11::EV_STATUS_SOURCE16, baz); + let bar = irqarray11_csr.rf(utra::irqarray11::EV_STATUS_SOURCE17); + irqarray11_csr.rmwf(utra::irqarray11::EV_STATUS_SOURCE17, bar); + let mut baz = irqarray11_csr.zf(utra::irqarray11::EV_STATUS_SOURCE17, bar); + baz |= irqarray11_csr.ms(utra::irqarray11::EV_STATUS_SOURCE17, 1); + irqarray11_csr.wfo(utra::irqarray11::EV_STATUS_SOURCE17, baz); + let bar = irqarray11_csr.rf(utra::irqarray11::EV_STATUS_SOURCE18); + irqarray11_csr.rmwf(utra::irqarray11::EV_STATUS_SOURCE18, bar); + let mut baz = irqarray11_csr.zf(utra::irqarray11::EV_STATUS_SOURCE18, bar); + baz |= irqarray11_csr.ms(utra::irqarray11::EV_STATUS_SOURCE18, 1); + irqarray11_csr.wfo(utra::irqarray11::EV_STATUS_SOURCE18, baz); + let bar = irqarray11_csr.rf(utra::irqarray11::EV_STATUS_SOURCE19); + irqarray11_csr.rmwf(utra::irqarray11::EV_STATUS_SOURCE19, bar); + let mut baz = irqarray11_csr.zf(utra::irqarray11::EV_STATUS_SOURCE19, bar); + baz |= irqarray11_csr.ms(utra::irqarray11::EV_STATUS_SOURCE19, 1); + irqarray11_csr.wfo(utra::irqarray11::EV_STATUS_SOURCE19, baz); + + let foo = irqarray11_csr.r(utra::irqarray11::EV_PENDING); + irqarray11_csr.wo(utra::irqarray11::EV_PENDING, foo); + let bar = irqarray11_csr.rf(utra::irqarray11::EV_PENDING_SOURCE0); + irqarray11_csr.rmwf(utra::irqarray11::EV_PENDING_SOURCE0, bar); + let mut baz = irqarray11_csr.zf(utra::irqarray11::EV_PENDING_SOURCE0, bar); + baz |= irqarray11_csr.ms(utra::irqarray11::EV_PENDING_SOURCE0, 1); + irqarray11_csr.wfo(utra::irqarray11::EV_PENDING_SOURCE0, baz); + let bar = irqarray11_csr.rf(utra::irqarray11::EV_PENDING_SOURCE1); + irqarray11_csr.rmwf(utra::irqarray11::EV_PENDING_SOURCE1, bar); + let mut baz = irqarray11_csr.zf(utra::irqarray11::EV_PENDING_SOURCE1, bar); + baz |= irqarray11_csr.ms(utra::irqarray11::EV_PENDING_SOURCE1, 1); + irqarray11_csr.wfo(utra::irqarray11::EV_PENDING_SOURCE1, baz); + let bar = irqarray11_csr.rf(utra::irqarray11::EV_PENDING_SOURCE2); + irqarray11_csr.rmwf(utra::irqarray11::EV_PENDING_SOURCE2, bar); + let mut baz = irqarray11_csr.zf(utra::irqarray11::EV_PENDING_SOURCE2, bar); + baz |= irqarray11_csr.ms(utra::irqarray11::EV_PENDING_SOURCE2, 1); + irqarray11_csr.wfo(utra::irqarray11::EV_PENDING_SOURCE2, baz); + let bar = irqarray11_csr.rf(utra::irqarray11::EV_PENDING_SOURCE3); + irqarray11_csr.rmwf(utra::irqarray11::EV_PENDING_SOURCE3, bar); + let mut baz = irqarray11_csr.zf(utra::irqarray11::EV_PENDING_SOURCE3, bar); + baz |= irqarray11_csr.ms(utra::irqarray11::EV_PENDING_SOURCE3, 1); + irqarray11_csr.wfo(utra::irqarray11::EV_PENDING_SOURCE3, baz); + let bar = irqarray11_csr.rf(utra::irqarray11::EV_PENDING_SOURCE4); + irqarray11_csr.rmwf(utra::irqarray11::EV_PENDING_SOURCE4, bar); + let mut baz = irqarray11_csr.zf(utra::irqarray11::EV_PENDING_SOURCE4, bar); + baz |= irqarray11_csr.ms(utra::irqarray11::EV_PENDING_SOURCE4, 1); + irqarray11_csr.wfo(utra::irqarray11::EV_PENDING_SOURCE4, baz); + let bar = irqarray11_csr.rf(utra::irqarray11::EV_PENDING_SOURCE5); + irqarray11_csr.rmwf(utra::irqarray11::EV_PENDING_SOURCE5, bar); + let mut baz = irqarray11_csr.zf(utra::irqarray11::EV_PENDING_SOURCE5, bar); + baz |= irqarray11_csr.ms(utra::irqarray11::EV_PENDING_SOURCE5, 1); + irqarray11_csr.wfo(utra::irqarray11::EV_PENDING_SOURCE5, baz); + let bar = irqarray11_csr.rf(utra::irqarray11::EV_PENDING_SOURCE6); + irqarray11_csr.rmwf(utra::irqarray11::EV_PENDING_SOURCE6, bar); + let mut baz = irqarray11_csr.zf(utra::irqarray11::EV_PENDING_SOURCE6, bar); + baz |= irqarray11_csr.ms(utra::irqarray11::EV_PENDING_SOURCE6, 1); + irqarray11_csr.wfo(utra::irqarray11::EV_PENDING_SOURCE6, baz); + let bar = irqarray11_csr.rf(utra::irqarray11::EV_PENDING_SOURCE7); + irqarray11_csr.rmwf(utra::irqarray11::EV_PENDING_SOURCE7, bar); + let mut baz = irqarray11_csr.zf(utra::irqarray11::EV_PENDING_SOURCE7, bar); + baz |= irqarray11_csr.ms(utra::irqarray11::EV_PENDING_SOURCE7, 1); + irqarray11_csr.wfo(utra::irqarray11::EV_PENDING_SOURCE7, baz); + let bar = irqarray11_csr.rf(utra::irqarray11::EV_PENDING_SOURCE8); + irqarray11_csr.rmwf(utra::irqarray11::EV_PENDING_SOURCE8, bar); + let mut baz = irqarray11_csr.zf(utra::irqarray11::EV_PENDING_SOURCE8, bar); + baz |= irqarray11_csr.ms(utra::irqarray11::EV_PENDING_SOURCE8, 1); + irqarray11_csr.wfo(utra::irqarray11::EV_PENDING_SOURCE8, baz); + let bar = irqarray11_csr.rf(utra::irqarray11::EV_PENDING_SOURCE9); + irqarray11_csr.rmwf(utra::irqarray11::EV_PENDING_SOURCE9, bar); + let mut baz = irqarray11_csr.zf(utra::irqarray11::EV_PENDING_SOURCE9, bar); + baz |= irqarray11_csr.ms(utra::irqarray11::EV_PENDING_SOURCE9, 1); + irqarray11_csr.wfo(utra::irqarray11::EV_PENDING_SOURCE9, baz); + let bar = irqarray11_csr.rf(utra::irqarray11::EV_PENDING_SOURCE10); + irqarray11_csr.rmwf(utra::irqarray11::EV_PENDING_SOURCE10, bar); + let mut baz = irqarray11_csr.zf(utra::irqarray11::EV_PENDING_SOURCE10, bar); + baz |= irqarray11_csr.ms(utra::irqarray11::EV_PENDING_SOURCE10, 1); + irqarray11_csr.wfo(utra::irqarray11::EV_PENDING_SOURCE10, baz); + let bar = irqarray11_csr.rf(utra::irqarray11::EV_PENDING_SOURCE11); + irqarray11_csr.rmwf(utra::irqarray11::EV_PENDING_SOURCE11, bar); + let mut baz = irqarray11_csr.zf(utra::irqarray11::EV_PENDING_SOURCE11, bar); + baz |= irqarray11_csr.ms(utra::irqarray11::EV_PENDING_SOURCE11, 1); + irqarray11_csr.wfo(utra::irqarray11::EV_PENDING_SOURCE11, baz); + let bar = irqarray11_csr.rf(utra::irqarray11::EV_PENDING_SOURCE12); + irqarray11_csr.rmwf(utra::irqarray11::EV_PENDING_SOURCE12, bar); + let mut baz = irqarray11_csr.zf(utra::irqarray11::EV_PENDING_SOURCE12, bar); + baz |= irqarray11_csr.ms(utra::irqarray11::EV_PENDING_SOURCE12, 1); + irqarray11_csr.wfo(utra::irqarray11::EV_PENDING_SOURCE12, baz); + let bar = irqarray11_csr.rf(utra::irqarray11::EV_PENDING_SOURCE13); + irqarray11_csr.rmwf(utra::irqarray11::EV_PENDING_SOURCE13, bar); + let mut baz = irqarray11_csr.zf(utra::irqarray11::EV_PENDING_SOURCE13, bar); + baz |= irqarray11_csr.ms(utra::irqarray11::EV_PENDING_SOURCE13, 1); + irqarray11_csr.wfo(utra::irqarray11::EV_PENDING_SOURCE13, baz); + let bar = irqarray11_csr.rf(utra::irqarray11::EV_PENDING_SOURCE14); + irqarray11_csr.rmwf(utra::irqarray11::EV_PENDING_SOURCE14, bar); + let mut baz = irqarray11_csr.zf(utra::irqarray11::EV_PENDING_SOURCE14, bar); + baz |= irqarray11_csr.ms(utra::irqarray11::EV_PENDING_SOURCE14, 1); + irqarray11_csr.wfo(utra::irqarray11::EV_PENDING_SOURCE14, baz); + let bar = irqarray11_csr.rf(utra::irqarray11::EV_PENDING_SOURCE15); + irqarray11_csr.rmwf(utra::irqarray11::EV_PENDING_SOURCE15, bar); + let mut baz = irqarray11_csr.zf(utra::irqarray11::EV_PENDING_SOURCE15, bar); + baz |= irqarray11_csr.ms(utra::irqarray11::EV_PENDING_SOURCE15, 1); + irqarray11_csr.wfo(utra::irqarray11::EV_PENDING_SOURCE15, baz); + let bar = irqarray11_csr.rf(utra::irqarray11::EV_PENDING_SOURCE16); + irqarray11_csr.rmwf(utra::irqarray11::EV_PENDING_SOURCE16, bar); + let mut baz = irqarray11_csr.zf(utra::irqarray11::EV_PENDING_SOURCE16, bar); + baz |= irqarray11_csr.ms(utra::irqarray11::EV_PENDING_SOURCE16, 1); + irqarray11_csr.wfo(utra::irqarray11::EV_PENDING_SOURCE16, baz); + let bar = irqarray11_csr.rf(utra::irqarray11::EV_PENDING_SOURCE17); + irqarray11_csr.rmwf(utra::irqarray11::EV_PENDING_SOURCE17, bar); + let mut baz = irqarray11_csr.zf(utra::irqarray11::EV_PENDING_SOURCE17, bar); + baz |= irqarray11_csr.ms(utra::irqarray11::EV_PENDING_SOURCE17, 1); + irqarray11_csr.wfo(utra::irqarray11::EV_PENDING_SOURCE17, baz); + let bar = irqarray11_csr.rf(utra::irqarray11::EV_PENDING_SOURCE18); + irqarray11_csr.rmwf(utra::irqarray11::EV_PENDING_SOURCE18, bar); + let mut baz = irqarray11_csr.zf(utra::irqarray11::EV_PENDING_SOURCE18, bar); + baz |= irqarray11_csr.ms(utra::irqarray11::EV_PENDING_SOURCE18, 1); + irqarray11_csr.wfo(utra::irqarray11::EV_PENDING_SOURCE18, baz); + let bar = irqarray11_csr.rf(utra::irqarray11::EV_PENDING_SOURCE19); + irqarray11_csr.rmwf(utra::irqarray11::EV_PENDING_SOURCE19, bar); + let mut baz = irqarray11_csr.zf(utra::irqarray11::EV_PENDING_SOURCE19, bar); + baz |= irqarray11_csr.ms(utra::irqarray11::EV_PENDING_SOURCE19, 1); + irqarray11_csr.wfo(utra::irqarray11::EV_PENDING_SOURCE19, baz); + + let foo = irqarray11_csr.r(utra::irqarray11::EV_ENABLE); + irqarray11_csr.wo(utra::irqarray11::EV_ENABLE, foo); + let bar = irqarray11_csr.rf(utra::irqarray11::EV_ENABLE_SOURCE0); + irqarray11_csr.rmwf(utra::irqarray11::EV_ENABLE_SOURCE0, bar); + let mut baz = irqarray11_csr.zf(utra::irqarray11::EV_ENABLE_SOURCE0, bar); + baz |= irqarray11_csr.ms(utra::irqarray11::EV_ENABLE_SOURCE0, 1); + irqarray11_csr.wfo(utra::irqarray11::EV_ENABLE_SOURCE0, baz); + let bar = irqarray11_csr.rf(utra::irqarray11::EV_ENABLE_SOURCE1); + irqarray11_csr.rmwf(utra::irqarray11::EV_ENABLE_SOURCE1, bar); + let mut baz = irqarray11_csr.zf(utra::irqarray11::EV_ENABLE_SOURCE1, bar); + baz |= irqarray11_csr.ms(utra::irqarray11::EV_ENABLE_SOURCE1, 1); + irqarray11_csr.wfo(utra::irqarray11::EV_ENABLE_SOURCE1, baz); + let bar = irqarray11_csr.rf(utra::irqarray11::EV_ENABLE_SOURCE2); + irqarray11_csr.rmwf(utra::irqarray11::EV_ENABLE_SOURCE2, bar); + let mut baz = irqarray11_csr.zf(utra::irqarray11::EV_ENABLE_SOURCE2, bar); + baz |= irqarray11_csr.ms(utra::irqarray11::EV_ENABLE_SOURCE2, 1); + irqarray11_csr.wfo(utra::irqarray11::EV_ENABLE_SOURCE2, baz); + let bar = irqarray11_csr.rf(utra::irqarray11::EV_ENABLE_SOURCE3); + irqarray11_csr.rmwf(utra::irqarray11::EV_ENABLE_SOURCE3, bar); + let mut baz = irqarray11_csr.zf(utra::irqarray11::EV_ENABLE_SOURCE3, bar); + baz |= irqarray11_csr.ms(utra::irqarray11::EV_ENABLE_SOURCE3, 1); + irqarray11_csr.wfo(utra::irqarray11::EV_ENABLE_SOURCE3, baz); + let bar = irqarray11_csr.rf(utra::irqarray11::EV_ENABLE_SOURCE4); + irqarray11_csr.rmwf(utra::irqarray11::EV_ENABLE_SOURCE4, bar); + let mut baz = irqarray11_csr.zf(utra::irqarray11::EV_ENABLE_SOURCE4, bar); + baz |= irqarray11_csr.ms(utra::irqarray11::EV_ENABLE_SOURCE4, 1); + irqarray11_csr.wfo(utra::irqarray11::EV_ENABLE_SOURCE4, baz); + let bar = irqarray11_csr.rf(utra::irqarray11::EV_ENABLE_SOURCE5); + irqarray11_csr.rmwf(utra::irqarray11::EV_ENABLE_SOURCE5, bar); + let mut baz = irqarray11_csr.zf(utra::irqarray11::EV_ENABLE_SOURCE5, bar); + baz |= irqarray11_csr.ms(utra::irqarray11::EV_ENABLE_SOURCE5, 1); + irqarray11_csr.wfo(utra::irqarray11::EV_ENABLE_SOURCE5, baz); + let bar = irqarray11_csr.rf(utra::irqarray11::EV_ENABLE_SOURCE6); + irqarray11_csr.rmwf(utra::irqarray11::EV_ENABLE_SOURCE6, bar); + let mut baz = irqarray11_csr.zf(utra::irqarray11::EV_ENABLE_SOURCE6, bar); + baz |= irqarray11_csr.ms(utra::irqarray11::EV_ENABLE_SOURCE6, 1); + irqarray11_csr.wfo(utra::irqarray11::EV_ENABLE_SOURCE6, baz); + let bar = irqarray11_csr.rf(utra::irqarray11::EV_ENABLE_SOURCE7); + irqarray11_csr.rmwf(utra::irqarray11::EV_ENABLE_SOURCE7, bar); + let mut baz = irqarray11_csr.zf(utra::irqarray11::EV_ENABLE_SOURCE7, bar); + baz |= irqarray11_csr.ms(utra::irqarray11::EV_ENABLE_SOURCE7, 1); + irqarray11_csr.wfo(utra::irqarray11::EV_ENABLE_SOURCE7, baz); + let bar = irqarray11_csr.rf(utra::irqarray11::EV_ENABLE_SOURCE8); + irqarray11_csr.rmwf(utra::irqarray11::EV_ENABLE_SOURCE8, bar); + let mut baz = irqarray11_csr.zf(utra::irqarray11::EV_ENABLE_SOURCE8, bar); + baz |= irqarray11_csr.ms(utra::irqarray11::EV_ENABLE_SOURCE8, 1); + irqarray11_csr.wfo(utra::irqarray11::EV_ENABLE_SOURCE8, baz); + let bar = irqarray11_csr.rf(utra::irqarray11::EV_ENABLE_SOURCE9); + irqarray11_csr.rmwf(utra::irqarray11::EV_ENABLE_SOURCE9, bar); + let mut baz = irqarray11_csr.zf(utra::irqarray11::EV_ENABLE_SOURCE9, bar); + baz |= irqarray11_csr.ms(utra::irqarray11::EV_ENABLE_SOURCE9, 1); + irqarray11_csr.wfo(utra::irqarray11::EV_ENABLE_SOURCE9, baz); + let bar = irqarray11_csr.rf(utra::irqarray11::EV_ENABLE_SOURCE10); + irqarray11_csr.rmwf(utra::irqarray11::EV_ENABLE_SOURCE10, bar); + let mut baz = irqarray11_csr.zf(utra::irqarray11::EV_ENABLE_SOURCE10, bar); + baz |= irqarray11_csr.ms(utra::irqarray11::EV_ENABLE_SOURCE10, 1); + irqarray11_csr.wfo(utra::irqarray11::EV_ENABLE_SOURCE10, baz); + let bar = irqarray11_csr.rf(utra::irqarray11::EV_ENABLE_SOURCE11); + irqarray11_csr.rmwf(utra::irqarray11::EV_ENABLE_SOURCE11, bar); + let mut baz = irqarray11_csr.zf(utra::irqarray11::EV_ENABLE_SOURCE11, bar); + baz |= irqarray11_csr.ms(utra::irqarray11::EV_ENABLE_SOURCE11, 1); + irqarray11_csr.wfo(utra::irqarray11::EV_ENABLE_SOURCE11, baz); + let bar = irqarray11_csr.rf(utra::irqarray11::EV_ENABLE_SOURCE12); + irqarray11_csr.rmwf(utra::irqarray11::EV_ENABLE_SOURCE12, bar); + let mut baz = irqarray11_csr.zf(utra::irqarray11::EV_ENABLE_SOURCE12, bar); + baz |= irqarray11_csr.ms(utra::irqarray11::EV_ENABLE_SOURCE12, 1); + irqarray11_csr.wfo(utra::irqarray11::EV_ENABLE_SOURCE12, baz); + let bar = irqarray11_csr.rf(utra::irqarray11::EV_ENABLE_SOURCE13); + irqarray11_csr.rmwf(utra::irqarray11::EV_ENABLE_SOURCE13, bar); + let mut baz = irqarray11_csr.zf(utra::irqarray11::EV_ENABLE_SOURCE13, bar); + baz |= irqarray11_csr.ms(utra::irqarray11::EV_ENABLE_SOURCE13, 1); + irqarray11_csr.wfo(utra::irqarray11::EV_ENABLE_SOURCE13, baz); + let bar = irqarray11_csr.rf(utra::irqarray11::EV_ENABLE_SOURCE14); + irqarray11_csr.rmwf(utra::irqarray11::EV_ENABLE_SOURCE14, bar); + let mut baz = irqarray11_csr.zf(utra::irqarray11::EV_ENABLE_SOURCE14, bar); + baz |= irqarray11_csr.ms(utra::irqarray11::EV_ENABLE_SOURCE14, 1); + irqarray11_csr.wfo(utra::irqarray11::EV_ENABLE_SOURCE14, baz); + let bar = irqarray11_csr.rf(utra::irqarray11::EV_ENABLE_SOURCE15); + irqarray11_csr.rmwf(utra::irqarray11::EV_ENABLE_SOURCE15, bar); + let mut baz = irqarray11_csr.zf(utra::irqarray11::EV_ENABLE_SOURCE15, bar); + baz |= irqarray11_csr.ms(utra::irqarray11::EV_ENABLE_SOURCE15, 1); + irqarray11_csr.wfo(utra::irqarray11::EV_ENABLE_SOURCE15, baz); + let bar = irqarray11_csr.rf(utra::irqarray11::EV_ENABLE_SOURCE16); + irqarray11_csr.rmwf(utra::irqarray11::EV_ENABLE_SOURCE16, bar); + let mut baz = irqarray11_csr.zf(utra::irqarray11::EV_ENABLE_SOURCE16, bar); + baz |= irqarray11_csr.ms(utra::irqarray11::EV_ENABLE_SOURCE16, 1); + irqarray11_csr.wfo(utra::irqarray11::EV_ENABLE_SOURCE16, baz); + let bar = irqarray11_csr.rf(utra::irqarray11::EV_ENABLE_SOURCE17); + irqarray11_csr.rmwf(utra::irqarray11::EV_ENABLE_SOURCE17, bar); + let mut baz = irqarray11_csr.zf(utra::irqarray11::EV_ENABLE_SOURCE17, bar); + baz |= irqarray11_csr.ms(utra::irqarray11::EV_ENABLE_SOURCE17, 1); + irqarray11_csr.wfo(utra::irqarray11::EV_ENABLE_SOURCE17, baz); + let bar = irqarray11_csr.rf(utra::irqarray11::EV_ENABLE_SOURCE18); + irqarray11_csr.rmwf(utra::irqarray11::EV_ENABLE_SOURCE18, bar); + let mut baz = irqarray11_csr.zf(utra::irqarray11::EV_ENABLE_SOURCE18, bar); + baz |= irqarray11_csr.ms(utra::irqarray11::EV_ENABLE_SOURCE18, 1); + irqarray11_csr.wfo(utra::irqarray11::EV_ENABLE_SOURCE18, baz); + let bar = irqarray11_csr.rf(utra::irqarray11::EV_ENABLE_SOURCE19); + irqarray11_csr.rmwf(utra::irqarray11::EV_ENABLE_SOURCE19, bar); + let mut baz = irqarray11_csr.zf(utra::irqarray11::EV_ENABLE_SOURCE19, bar); + baz |= irqarray11_csr.ms(utra::irqarray11::EV_ENABLE_SOURCE19, 1); + irqarray11_csr.wfo(utra::irqarray11::EV_ENABLE_SOURCE19, baz); + } + + #[test] + #[ignore] + fn compile_check_irqarray12_csr() { + use super::*; + let mut irqarray12_csr = CSR::new(HW_IRQARRAY12_BASE as *mut u32); + + let foo = irqarray12_csr.r(utra::irqarray12::EV_SOFT); + irqarray12_csr.wo(utra::irqarray12::EV_SOFT, foo); + let bar = irqarray12_csr.rf(utra::irqarray12::EV_SOFT_TRIGGER); + irqarray12_csr.rmwf(utra::irqarray12::EV_SOFT_TRIGGER, bar); + let mut baz = irqarray12_csr.zf(utra::irqarray12::EV_SOFT_TRIGGER, bar); + baz |= irqarray12_csr.ms(utra::irqarray12::EV_SOFT_TRIGGER, 1); + irqarray12_csr.wfo(utra::irqarray12::EV_SOFT_TRIGGER, baz); + + let foo = irqarray12_csr.r(utra::irqarray12::EV_STATUS); + irqarray12_csr.wo(utra::irqarray12::EV_STATUS, foo); + let bar = irqarray12_csr.rf(utra::irqarray12::EV_STATUS_SOURCE0); + irqarray12_csr.rmwf(utra::irqarray12::EV_STATUS_SOURCE0, bar); + let mut baz = irqarray12_csr.zf(utra::irqarray12::EV_STATUS_SOURCE0, bar); + baz |= irqarray12_csr.ms(utra::irqarray12::EV_STATUS_SOURCE0, 1); + irqarray12_csr.wfo(utra::irqarray12::EV_STATUS_SOURCE0, baz); + let bar = irqarray12_csr.rf(utra::irqarray12::EV_STATUS_SOURCE1); + irqarray12_csr.rmwf(utra::irqarray12::EV_STATUS_SOURCE1, bar); + let mut baz = irqarray12_csr.zf(utra::irqarray12::EV_STATUS_SOURCE1, bar); + baz |= irqarray12_csr.ms(utra::irqarray12::EV_STATUS_SOURCE1, 1); + irqarray12_csr.wfo(utra::irqarray12::EV_STATUS_SOURCE1, baz); + let bar = irqarray12_csr.rf(utra::irqarray12::EV_STATUS_SOURCE2); + irqarray12_csr.rmwf(utra::irqarray12::EV_STATUS_SOURCE2, bar); + let mut baz = irqarray12_csr.zf(utra::irqarray12::EV_STATUS_SOURCE2, bar); + baz |= irqarray12_csr.ms(utra::irqarray12::EV_STATUS_SOURCE2, 1); + irqarray12_csr.wfo(utra::irqarray12::EV_STATUS_SOURCE2, baz); + let bar = irqarray12_csr.rf(utra::irqarray12::EV_STATUS_SOURCE3); + irqarray12_csr.rmwf(utra::irqarray12::EV_STATUS_SOURCE3, bar); + let mut baz = irqarray12_csr.zf(utra::irqarray12::EV_STATUS_SOURCE3, bar); + baz |= irqarray12_csr.ms(utra::irqarray12::EV_STATUS_SOURCE3, 1); + irqarray12_csr.wfo(utra::irqarray12::EV_STATUS_SOURCE3, baz); + let bar = irqarray12_csr.rf(utra::irqarray12::EV_STATUS_SOURCE4); + irqarray12_csr.rmwf(utra::irqarray12::EV_STATUS_SOURCE4, bar); + let mut baz = irqarray12_csr.zf(utra::irqarray12::EV_STATUS_SOURCE4, bar); + baz |= irqarray12_csr.ms(utra::irqarray12::EV_STATUS_SOURCE4, 1); + irqarray12_csr.wfo(utra::irqarray12::EV_STATUS_SOURCE4, baz); + let bar = irqarray12_csr.rf(utra::irqarray12::EV_STATUS_SOURCE5); + irqarray12_csr.rmwf(utra::irqarray12::EV_STATUS_SOURCE5, bar); + let mut baz = irqarray12_csr.zf(utra::irqarray12::EV_STATUS_SOURCE5, bar); + baz |= irqarray12_csr.ms(utra::irqarray12::EV_STATUS_SOURCE5, 1); + irqarray12_csr.wfo(utra::irqarray12::EV_STATUS_SOURCE5, baz); + let bar = irqarray12_csr.rf(utra::irqarray12::EV_STATUS_SOURCE6); + irqarray12_csr.rmwf(utra::irqarray12::EV_STATUS_SOURCE6, bar); + let mut baz = irqarray12_csr.zf(utra::irqarray12::EV_STATUS_SOURCE6, bar); + baz |= irqarray12_csr.ms(utra::irqarray12::EV_STATUS_SOURCE6, 1); + irqarray12_csr.wfo(utra::irqarray12::EV_STATUS_SOURCE6, baz); + let bar = irqarray12_csr.rf(utra::irqarray12::EV_STATUS_SOURCE7); + irqarray12_csr.rmwf(utra::irqarray12::EV_STATUS_SOURCE7, bar); + let mut baz = irqarray12_csr.zf(utra::irqarray12::EV_STATUS_SOURCE7, bar); + baz |= irqarray12_csr.ms(utra::irqarray12::EV_STATUS_SOURCE7, 1); + irqarray12_csr.wfo(utra::irqarray12::EV_STATUS_SOURCE7, baz); + let bar = irqarray12_csr.rf(utra::irqarray12::EV_STATUS_SOURCE8); + irqarray12_csr.rmwf(utra::irqarray12::EV_STATUS_SOURCE8, bar); + let mut baz = irqarray12_csr.zf(utra::irqarray12::EV_STATUS_SOURCE8, bar); + baz |= irqarray12_csr.ms(utra::irqarray12::EV_STATUS_SOURCE8, 1); + irqarray12_csr.wfo(utra::irqarray12::EV_STATUS_SOURCE8, baz); + let bar = irqarray12_csr.rf(utra::irqarray12::EV_STATUS_SOURCE9); + irqarray12_csr.rmwf(utra::irqarray12::EV_STATUS_SOURCE9, bar); + let mut baz = irqarray12_csr.zf(utra::irqarray12::EV_STATUS_SOURCE9, bar); + baz |= irqarray12_csr.ms(utra::irqarray12::EV_STATUS_SOURCE9, 1); + irqarray12_csr.wfo(utra::irqarray12::EV_STATUS_SOURCE9, baz); + let bar = irqarray12_csr.rf(utra::irqarray12::EV_STATUS_SOURCE10); + irqarray12_csr.rmwf(utra::irqarray12::EV_STATUS_SOURCE10, bar); + let mut baz = irqarray12_csr.zf(utra::irqarray12::EV_STATUS_SOURCE10, bar); + baz |= irqarray12_csr.ms(utra::irqarray12::EV_STATUS_SOURCE10, 1); + irqarray12_csr.wfo(utra::irqarray12::EV_STATUS_SOURCE10, baz); + let bar = irqarray12_csr.rf(utra::irqarray12::EV_STATUS_SOURCE11); + irqarray12_csr.rmwf(utra::irqarray12::EV_STATUS_SOURCE11, bar); + let mut baz = irqarray12_csr.zf(utra::irqarray12::EV_STATUS_SOURCE11, bar); + baz |= irqarray12_csr.ms(utra::irqarray12::EV_STATUS_SOURCE11, 1); + irqarray12_csr.wfo(utra::irqarray12::EV_STATUS_SOURCE11, baz); + let bar = irqarray12_csr.rf(utra::irqarray12::EV_STATUS_SOURCE12); + irqarray12_csr.rmwf(utra::irqarray12::EV_STATUS_SOURCE12, bar); + let mut baz = irqarray12_csr.zf(utra::irqarray12::EV_STATUS_SOURCE12, bar); + baz |= irqarray12_csr.ms(utra::irqarray12::EV_STATUS_SOURCE12, 1); + irqarray12_csr.wfo(utra::irqarray12::EV_STATUS_SOURCE12, baz); + let bar = irqarray12_csr.rf(utra::irqarray12::EV_STATUS_SOURCE13); + irqarray12_csr.rmwf(utra::irqarray12::EV_STATUS_SOURCE13, bar); + let mut baz = irqarray12_csr.zf(utra::irqarray12::EV_STATUS_SOURCE13, bar); + baz |= irqarray12_csr.ms(utra::irqarray12::EV_STATUS_SOURCE13, 1); + irqarray12_csr.wfo(utra::irqarray12::EV_STATUS_SOURCE13, baz); + let bar = irqarray12_csr.rf(utra::irqarray12::EV_STATUS_SOURCE14); + irqarray12_csr.rmwf(utra::irqarray12::EV_STATUS_SOURCE14, bar); + let mut baz = irqarray12_csr.zf(utra::irqarray12::EV_STATUS_SOURCE14, bar); + baz |= irqarray12_csr.ms(utra::irqarray12::EV_STATUS_SOURCE14, 1); + irqarray12_csr.wfo(utra::irqarray12::EV_STATUS_SOURCE14, baz); + let bar = irqarray12_csr.rf(utra::irqarray12::EV_STATUS_SOURCE15); + irqarray12_csr.rmwf(utra::irqarray12::EV_STATUS_SOURCE15, bar); + let mut baz = irqarray12_csr.zf(utra::irqarray12::EV_STATUS_SOURCE15, bar); + baz |= irqarray12_csr.ms(utra::irqarray12::EV_STATUS_SOURCE15, 1); + irqarray12_csr.wfo(utra::irqarray12::EV_STATUS_SOURCE15, baz); + let bar = irqarray12_csr.rf(utra::irqarray12::EV_STATUS_SOURCE16); + irqarray12_csr.rmwf(utra::irqarray12::EV_STATUS_SOURCE16, bar); + let mut baz = irqarray12_csr.zf(utra::irqarray12::EV_STATUS_SOURCE16, bar); + baz |= irqarray12_csr.ms(utra::irqarray12::EV_STATUS_SOURCE16, 1); + irqarray12_csr.wfo(utra::irqarray12::EV_STATUS_SOURCE16, baz); + let bar = irqarray12_csr.rf(utra::irqarray12::EV_STATUS_SOURCE17); + irqarray12_csr.rmwf(utra::irqarray12::EV_STATUS_SOURCE17, bar); + let mut baz = irqarray12_csr.zf(utra::irqarray12::EV_STATUS_SOURCE17, bar); + baz |= irqarray12_csr.ms(utra::irqarray12::EV_STATUS_SOURCE17, 1); + irqarray12_csr.wfo(utra::irqarray12::EV_STATUS_SOURCE17, baz); + let bar = irqarray12_csr.rf(utra::irqarray12::EV_STATUS_SOURCE18); + irqarray12_csr.rmwf(utra::irqarray12::EV_STATUS_SOURCE18, bar); + let mut baz = irqarray12_csr.zf(utra::irqarray12::EV_STATUS_SOURCE18, bar); + baz |= irqarray12_csr.ms(utra::irqarray12::EV_STATUS_SOURCE18, 1); + irqarray12_csr.wfo(utra::irqarray12::EV_STATUS_SOURCE18, baz); + let bar = irqarray12_csr.rf(utra::irqarray12::EV_STATUS_SOURCE19); + irqarray12_csr.rmwf(utra::irqarray12::EV_STATUS_SOURCE19, bar); + let mut baz = irqarray12_csr.zf(utra::irqarray12::EV_STATUS_SOURCE19, bar); + baz |= irqarray12_csr.ms(utra::irqarray12::EV_STATUS_SOURCE19, 1); + irqarray12_csr.wfo(utra::irqarray12::EV_STATUS_SOURCE19, baz); + + let foo = irqarray12_csr.r(utra::irqarray12::EV_PENDING); + irqarray12_csr.wo(utra::irqarray12::EV_PENDING, foo); + let bar = irqarray12_csr.rf(utra::irqarray12::EV_PENDING_SOURCE0); + irqarray12_csr.rmwf(utra::irqarray12::EV_PENDING_SOURCE0, bar); + let mut baz = irqarray12_csr.zf(utra::irqarray12::EV_PENDING_SOURCE0, bar); + baz |= irqarray12_csr.ms(utra::irqarray12::EV_PENDING_SOURCE0, 1); + irqarray12_csr.wfo(utra::irqarray12::EV_PENDING_SOURCE0, baz); + let bar = irqarray12_csr.rf(utra::irqarray12::EV_PENDING_SOURCE1); + irqarray12_csr.rmwf(utra::irqarray12::EV_PENDING_SOURCE1, bar); + let mut baz = irqarray12_csr.zf(utra::irqarray12::EV_PENDING_SOURCE1, bar); + baz |= irqarray12_csr.ms(utra::irqarray12::EV_PENDING_SOURCE1, 1); + irqarray12_csr.wfo(utra::irqarray12::EV_PENDING_SOURCE1, baz); + let bar = irqarray12_csr.rf(utra::irqarray12::EV_PENDING_SOURCE2); + irqarray12_csr.rmwf(utra::irqarray12::EV_PENDING_SOURCE2, bar); + let mut baz = irqarray12_csr.zf(utra::irqarray12::EV_PENDING_SOURCE2, bar); + baz |= irqarray12_csr.ms(utra::irqarray12::EV_PENDING_SOURCE2, 1); + irqarray12_csr.wfo(utra::irqarray12::EV_PENDING_SOURCE2, baz); + let bar = irqarray12_csr.rf(utra::irqarray12::EV_PENDING_SOURCE3); + irqarray12_csr.rmwf(utra::irqarray12::EV_PENDING_SOURCE3, bar); + let mut baz = irqarray12_csr.zf(utra::irqarray12::EV_PENDING_SOURCE3, bar); + baz |= irqarray12_csr.ms(utra::irqarray12::EV_PENDING_SOURCE3, 1); + irqarray12_csr.wfo(utra::irqarray12::EV_PENDING_SOURCE3, baz); + let bar = irqarray12_csr.rf(utra::irqarray12::EV_PENDING_SOURCE4); + irqarray12_csr.rmwf(utra::irqarray12::EV_PENDING_SOURCE4, bar); + let mut baz = irqarray12_csr.zf(utra::irqarray12::EV_PENDING_SOURCE4, bar); + baz |= irqarray12_csr.ms(utra::irqarray12::EV_PENDING_SOURCE4, 1); + irqarray12_csr.wfo(utra::irqarray12::EV_PENDING_SOURCE4, baz); + let bar = irqarray12_csr.rf(utra::irqarray12::EV_PENDING_SOURCE5); + irqarray12_csr.rmwf(utra::irqarray12::EV_PENDING_SOURCE5, bar); + let mut baz = irqarray12_csr.zf(utra::irqarray12::EV_PENDING_SOURCE5, bar); + baz |= irqarray12_csr.ms(utra::irqarray12::EV_PENDING_SOURCE5, 1); + irqarray12_csr.wfo(utra::irqarray12::EV_PENDING_SOURCE5, baz); + let bar = irqarray12_csr.rf(utra::irqarray12::EV_PENDING_SOURCE6); + irqarray12_csr.rmwf(utra::irqarray12::EV_PENDING_SOURCE6, bar); + let mut baz = irqarray12_csr.zf(utra::irqarray12::EV_PENDING_SOURCE6, bar); + baz |= irqarray12_csr.ms(utra::irqarray12::EV_PENDING_SOURCE6, 1); + irqarray12_csr.wfo(utra::irqarray12::EV_PENDING_SOURCE6, baz); + let bar = irqarray12_csr.rf(utra::irqarray12::EV_PENDING_SOURCE7); + irqarray12_csr.rmwf(utra::irqarray12::EV_PENDING_SOURCE7, bar); + let mut baz = irqarray12_csr.zf(utra::irqarray12::EV_PENDING_SOURCE7, bar); + baz |= irqarray12_csr.ms(utra::irqarray12::EV_PENDING_SOURCE7, 1); + irqarray12_csr.wfo(utra::irqarray12::EV_PENDING_SOURCE7, baz); + let bar = irqarray12_csr.rf(utra::irqarray12::EV_PENDING_SOURCE8); + irqarray12_csr.rmwf(utra::irqarray12::EV_PENDING_SOURCE8, bar); + let mut baz = irqarray12_csr.zf(utra::irqarray12::EV_PENDING_SOURCE8, bar); + baz |= irqarray12_csr.ms(utra::irqarray12::EV_PENDING_SOURCE8, 1); + irqarray12_csr.wfo(utra::irqarray12::EV_PENDING_SOURCE8, baz); + let bar = irqarray12_csr.rf(utra::irqarray12::EV_PENDING_SOURCE9); + irqarray12_csr.rmwf(utra::irqarray12::EV_PENDING_SOURCE9, bar); + let mut baz = irqarray12_csr.zf(utra::irqarray12::EV_PENDING_SOURCE9, bar); + baz |= irqarray12_csr.ms(utra::irqarray12::EV_PENDING_SOURCE9, 1); + irqarray12_csr.wfo(utra::irqarray12::EV_PENDING_SOURCE9, baz); + let bar = irqarray12_csr.rf(utra::irqarray12::EV_PENDING_SOURCE10); + irqarray12_csr.rmwf(utra::irqarray12::EV_PENDING_SOURCE10, bar); + let mut baz = irqarray12_csr.zf(utra::irqarray12::EV_PENDING_SOURCE10, bar); + baz |= irqarray12_csr.ms(utra::irqarray12::EV_PENDING_SOURCE10, 1); + irqarray12_csr.wfo(utra::irqarray12::EV_PENDING_SOURCE10, baz); + let bar = irqarray12_csr.rf(utra::irqarray12::EV_PENDING_SOURCE11); + irqarray12_csr.rmwf(utra::irqarray12::EV_PENDING_SOURCE11, bar); + let mut baz = irqarray12_csr.zf(utra::irqarray12::EV_PENDING_SOURCE11, bar); + baz |= irqarray12_csr.ms(utra::irqarray12::EV_PENDING_SOURCE11, 1); + irqarray12_csr.wfo(utra::irqarray12::EV_PENDING_SOURCE11, baz); + let bar = irqarray12_csr.rf(utra::irqarray12::EV_PENDING_SOURCE12); + irqarray12_csr.rmwf(utra::irqarray12::EV_PENDING_SOURCE12, bar); + let mut baz = irqarray12_csr.zf(utra::irqarray12::EV_PENDING_SOURCE12, bar); + baz |= irqarray12_csr.ms(utra::irqarray12::EV_PENDING_SOURCE12, 1); + irqarray12_csr.wfo(utra::irqarray12::EV_PENDING_SOURCE12, baz); + let bar = irqarray12_csr.rf(utra::irqarray12::EV_PENDING_SOURCE13); + irqarray12_csr.rmwf(utra::irqarray12::EV_PENDING_SOURCE13, bar); + let mut baz = irqarray12_csr.zf(utra::irqarray12::EV_PENDING_SOURCE13, bar); + baz |= irqarray12_csr.ms(utra::irqarray12::EV_PENDING_SOURCE13, 1); + irqarray12_csr.wfo(utra::irqarray12::EV_PENDING_SOURCE13, baz); + let bar = irqarray12_csr.rf(utra::irqarray12::EV_PENDING_SOURCE14); + irqarray12_csr.rmwf(utra::irqarray12::EV_PENDING_SOURCE14, bar); + let mut baz = irqarray12_csr.zf(utra::irqarray12::EV_PENDING_SOURCE14, bar); + baz |= irqarray12_csr.ms(utra::irqarray12::EV_PENDING_SOURCE14, 1); + irqarray12_csr.wfo(utra::irqarray12::EV_PENDING_SOURCE14, baz); + let bar = irqarray12_csr.rf(utra::irqarray12::EV_PENDING_SOURCE15); + irqarray12_csr.rmwf(utra::irqarray12::EV_PENDING_SOURCE15, bar); + let mut baz = irqarray12_csr.zf(utra::irqarray12::EV_PENDING_SOURCE15, bar); + baz |= irqarray12_csr.ms(utra::irqarray12::EV_PENDING_SOURCE15, 1); + irqarray12_csr.wfo(utra::irqarray12::EV_PENDING_SOURCE15, baz); + let bar = irqarray12_csr.rf(utra::irqarray12::EV_PENDING_SOURCE16); + irqarray12_csr.rmwf(utra::irqarray12::EV_PENDING_SOURCE16, bar); + let mut baz = irqarray12_csr.zf(utra::irqarray12::EV_PENDING_SOURCE16, bar); + baz |= irqarray12_csr.ms(utra::irqarray12::EV_PENDING_SOURCE16, 1); + irqarray12_csr.wfo(utra::irqarray12::EV_PENDING_SOURCE16, baz); + let bar = irqarray12_csr.rf(utra::irqarray12::EV_PENDING_SOURCE17); + irqarray12_csr.rmwf(utra::irqarray12::EV_PENDING_SOURCE17, bar); + let mut baz = irqarray12_csr.zf(utra::irqarray12::EV_PENDING_SOURCE17, bar); + baz |= irqarray12_csr.ms(utra::irqarray12::EV_PENDING_SOURCE17, 1); + irqarray12_csr.wfo(utra::irqarray12::EV_PENDING_SOURCE17, baz); + let bar = irqarray12_csr.rf(utra::irqarray12::EV_PENDING_SOURCE18); + irqarray12_csr.rmwf(utra::irqarray12::EV_PENDING_SOURCE18, bar); + let mut baz = irqarray12_csr.zf(utra::irqarray12::EV_PENDING_SOURCE18, bar); + baz |= irqarray12_csr.ms(utra::irqarray12::EV_PENDING_SOURCE18, 1); + irqarray12_csr.wfo(utra::irqarray12::EV_PENDING_SOURCE18, baz); + let bar = irqarray12_csr.rf(utra::irqarray12::EV_PENDING_SOURCE19); + irqarray12_csr.rmwf(utra::irqarray12::EV_PENDING_SOURCE19, bar); + let mut baz = irqarray12_csr.zf(utra::irqarray12::EV_PENDING_SOURCE19, bar); + baz |= irqarray12_csr.ms(utra::irqarray12::EV_PENDING_SOURCE19, 1); + irqarray12_csr.wfo(utra::irqarray12::EV_PENDING_SOURCE19, baz); + + let foo = irqarray12_csr.r(utra::irqarray12::EV_ENABLE); + irqarray12_csr.wo(utra::irqarray12::EV_ENABLE, foo); + let bar = irqarray12_csr.rf(utra::irqarray12::EV_ENABLE_SOURCE0); + irqarray12_csr.rmwf(utra::irqarray12::EV_ENABLE_SOURCE0, bar); + let mut baz = irqarray12_csr.zf(utra::irqarray12::EV_ENABLE_SOURCE0, bar); + baz |= irqarray12_csr.ms(utra::irqarray12::EV_ENABLE_SOURCE0, 1); + irqarray12_csr.wfo(utra::irqarray12::EV_ENABLE_SOURCE0, baz); + let bar = irqarray12_csr.rf(utra::irqarray12::EV_ENABLE_SOURCE1); + irqarray12_csr.rmwf(utra::irqarray12::EV_ENABLE_SOURCE1, bar); + let mut baz = irqarray12_csr.zf(utra::irqarray12::EV_ENABLE_SOURCE1, bar); + baz |= irqarray12_csr.ms(utra::irqarray12::EV_ENABLE_SOURCE1, 1); + irqarray12_csr.wfo(utra::irqarray12::EV_ENABLE_SOURCE1, baz); + let bar = irqarray12_csr.rf(utra::irqarray12::EV_ENABLE_SOURCE2); + irqarray12_csr.rmwf(utra::irqarray12::EV_ENABLE_SOURCE2, bar); + let mut baz = irqarray12_csr.zf(utra::irqarray12::EV_ENABLE_SOURCE2, bar); + baz |= irqarray12_csr.ms(utra::irqarray12::EV_ENABLE_SOURCE2, 1); + irqarray12_csr.wfo(utra::irqarray12::EV_ENABLE_SOURCE2, baz); + let bar = irqarray12_csr.rf(utra::irqarray12::EV_ENABLE_SOURCE3); + irqarray12_csr.rmwf(utra::irqarray12::EV_ENABLE_SOURCE3, bar); + let mut baz = irqarray12_csr.zf(utra::irqarray12::EV_ENABLE_SOURCE3, bar); + baz |= irqarray12_csr.ms(utra::irqarray12::EV_ENABLE_SOURCE3, 1); + irqarray12_csr.wfo(utra::irqarray12::EV_ENABLE_SOURCE3, baz); + let bar = irqarray12_csr.rf(utra::irqarray12::EV_ENABLE_SOURCE4); + irqarray12_csr.rmwf(utra::irqarray12::EV_ENABLE_SOURCE4, bar); + let mut baz = irqarray12_csr.zf(utra::irqarray12::EV_ENABLE_SOURCE4, bar); + baz |= irqarray12_csr.ms(utra::irqarray12::EV_ENABLE_SOURCE4, 1); + irqarray12_csr.wfo(utra::irqarray12::EV_ENABLE_SOURCE4, baz); + let bar = irqarray12_csr.rf(utra::irqarray12::EV_ENABLE_SOURCE5); + irqarray12_csr.rmwf(utra::irqarray12::EV_ENABLE_SOURCE5, bar); + let mut baz = irqarray12_csr.zf(utra::irqarray12::EV_ENABLE_SOURCE5, bar); + baz |= irqarray12_csr.ms(utra::irqarray12::EV_ENABLE_SOURCE5, 1); + irqarray12_csr.wfo(utra::irqarray12::EV_ENABLE_SOURCE5, baz); + let bar = irqarray12_csr.rf(utra::irqarray12::EV_ENABLE_SOURCE6); + irqarray12_csr.rmwf(utra::irqarray12::EV_ENABLE_SOURCE6, bar); + let mut baz = irqarray12_csr.zf(utra::irqarray12::EV_ENABLE_SOURCE6, bar); + baz |= irqarray12_csr.ms(utra::irqarray12::EV_ENABLE_SOURCE6, 1); + irqarray12_csr.wfo(utra::irqarray12::EV_ENABLE_SOURCE6, baz); + let bar = irqarray12_csr.rf(utra::irqarray12::EV_ENABLE_SOURCE7); + irqarray12_csr.rmwf(utra::irqarray12::EV_ENABLE_SOURCE7, bar); + let mut baz = irqarray12_csr.zf(utra::irqarray12::EV_ENABLE_SOURCE7, bar); + baz |= irqarray12_csr.ms(utra::irqarray12::EV_ENABLE_SOURCE7, 1); + irqarray12_csr.wfo(utra::irqarray12::EV_ENABLE_SOURCE7, baz); + let bar = irqarray12_csr.rf(utra::irqarray12::EV_ENABLE_SOURCE8); + irqarray12_csr.rmwf(utra::irqarray12::EV_ENABLE_SOURCE8, bar); + let mut baz = irqarray12_csr.zf(utra::irqarray12::EV_ENABLE_SOURCE8, bar); + baz |= irqarray12_csr.ms(utra::irqarray12::EV_ENABLE_SOURCE8, 1); + irqarray12_csr.wfo(utra::irqarray12::EV_ENABLE_SOURCE8, baz); + let bar = irqarray12_csr.rf(utra::irqarray12::EV_ENABLE_SOURCE9); + irqarray12_csr.rmwf(utra::irqarray12::EV_ENABLE_SOURCE9, bar); + let mut baz = irqarray12_csr.zf(utra::irqarray12::EV_ENABLE_SOURCE9, bar); + baz |= irqarray12_csr.ms(utra::irqarray12::EV_ENABLE_SOURCE9, 1); + irqarray12_csr.wfo(utra::irqarray12::EV_ENABLE_SOURCE9, baz); + let bar = irqarray12_csr.rf(utra::irqarray12::EV_ENABLE_SOURCE10); + irqarray12_csr.rmwf(utra::irqarray12::EV_ENABLE_SOURCE10, bar); + let mut baz = irqarray12_csr.zf(utra::irqarray12::EV_ENABLE_SOURCE10, bar); + baz |= irqarray12_csr.ms(utra::irqarray12::EV_ENABLE_SOURCE10, 1); + irqarray12_csr.wfo(utra::irqarray12::EV_ENABLE_SOURCE10, baz); + let bar = irqarray12_csr.rf(utra::irqarray12::EV_ENABLE_SOURCE11); + irqarray12_csr.rmwf(utra::irqarray12::EV_ENABLE_SOURCE11, bar); + let mut baz = irqarray12_csr.zf(utra::irqarray12::EV_ENABLE_SOURCE11, bar); + baz |= irqarray12_csr.ms(utra::irqarray12::EV_ENABLE_SOURCE11, 1); + irqarray12_csr.wfo(utra::irqarray12::EV_ENABLE_SOURCE11, baz); + let bar = irqarray12_csr.rf(utra::irqarray12::EV_ENABLE_SOURCE12); + irqarray12_csr.rmwf(utra::irqarray12::EV_ENABLE_SOURCE12, bar); + let mut baz = irqarray12_csr.zf(utra::irqarray12::EV_ENABLE_SOURCE12, bar); + baz |= irqarray12_csr.ms(utra::irqarray12::EV_ENABLE_SOURCE12, 1); + irqarray12_csr.wfo(utra::irqarray12::EV_ENABLE_SOURCE12, baz); + let bar = irqarray12_csr.rf(utra::irqarray12::EV_ENABLE_SOURCE13); + irqarray12_csr.rmwf(utra::irqarray12::EV_ENABLE_SOURCE13, bar); + let mut baz = irqarray12_csr.zf(utra::irqarray12::EV_ENABLE_SOURCE13, bar); + baz |= irqarray12_csr.ms(utra::irqarray12::EV_ENABLE_SOURCE13, 1); + irqarray12_csr.wfo(utra::irqarray12::EV_ENABLE_SOURCE13, baz); + let bar = irqarray12_csr.rf(utra::irqarray12::EV_ENABLE_SOURCE14); + irqarray12_csr.rmwf(utra::irqarray12::EV_ENABLE_SOURCE14, bar); + let mut baz = irqarray12_csr.zf(utra::irqarray12::EV_ENABLE_SOURCE14, bar); + baz |= irqarray12_csr.ms(utra::irqarray12::EV_ENABLE_SOURCE14, 1); + irqarray12_csr.wfo(utra::irqarray12::EV_ENABLE_SOURCE14, baz); + let bar = irqarray12_csr.rf(utra::irqarray12::EV_ENABLE_SOURCE15); + irqarray12_csr.rmwf(utra::irqarray12::EV_ENABLE_SOURCE15, bar); + let mut baz = irqarray12_csr.zf(utra::irqarray12::EV_ENABLE_SOURCE15, bar); + baz |= irqarray12_csr.ms(utra::irqarray12::EV_ENABLE_SOURCE15, 1); + irqarray12_csr.wfo(utra::irqarray12::EV_ENABLE_SOURCE15, baz); + let bar = irqarray12_csr.rf(utra::irqarray12::EV_ENABLE_SOURCE16); + irqarray12_csr.rmwf(utra::irqarray12::EV_ENABLE_SOURCE16, bar); + let mut baz = irqarray12_csr.zf(utra::irqarray12::EV_ENABLE_SOURCE16, bar); + baz |= irqarray12_csr.ms(utra::irqarray12::EV_ENABLE_SOURCE16, 1); + irqarray12_csr.wfo(utra::irqarray12::EV_ENABLE_SOURCE16, baz); + let bar = irqarray12_csr.rf(utra::irqarray12::EV_ENABLE_SOURCE17); + irqarray12_csr.rmwf(utra::irqarray12::EV_ENABLE_SOURCE17, bar); + let mut baz = irqarray12_csr.zf(utra::irqarray12::EV_ENABLE_SOURCE17, bar); + baz |= irqarray12_csr.ms(utra::irqarray12::EV_ENABLE_SOURCE17, 1); + irqarray12_csr.wfo(utra::irqarray12::EV_ENABLE_SOURCE17, baz); + let bar = irqarray12_csr.rf(utra::irqarray12::EV_ENABLE_SOURCE18); + irqarray12_csr.rmwf(utra::irqarray12::EV_ENABLE_SOURCE18, bar); + let mut baz = irqarray12_csr.zf(utra::irqarray12::EV_ENABLE_SOURCE18, bar); + baz |= irqarray12_csr.ms(utra::irqarray12::EV_ENABLE_SOURCE18, 1); + irqarray12_csr.wfo(utra::irqarray12::EV_ENABLE_SOURCE18, baz); + let bar = irqarray12_csr.rf(utra::irqarray12::EV_ENABLE_SOURCE19); + irqarray12_csr.rmwf(utra::irqarray12::EV_ENABLE_SOURCE19, bar); + let mut baz = irqarray12_csr.zf(utra::irqarray12::EV_ENABLE_SOURCE19, bar); + baz |= irqarray12_csr.ms(utra::irqarray12::EV_ENABLE_SOURCE19, 1); + irqarray12_csr.wfo(utra::irqarray12::EV_ENABLE_SOURCE19, baz); + } + + #[test] + #[ignore] + fn compile_check_irqarray13_csr() { + use super::*; + let mut irqarray13_csr = CSR::new(HW_IRQARRAY13_BASE as *mut u32); + + let foo = irqarray13_csr.r(utra::irqarray13::EV_SOFT); + irqarray13_csr.wo(utra::irqarray13::EV_SOFT, foo); + let bar = irqarray13_csr.rf(utra::irqarray13::EV_SOFT_TRIGGER); + irqarray13_csr.rmwf(utra::irqarray13::EV_SOFT_TRIGGER, bar); + let mut baz = irqarray13_csr.zf(utra::irqarray13::EV_SOFT_TRIGGER, bar); + baz |= irqarray13_csr.ms(utra::irqarray13::EV_SOFT_TRIGGER, 1); + irqarray13_csr.wfo(utra::irqarray13::EV_SOFT_TRIGGER, baz); + + let foo = irqarray13_csr.r(utra::irqarray13::EV_STATUS); + irqarray13_csr.wo(utra::irqarray13::EV_STATUS, foo); + let bar = irqarray13_csr.rf(utra::irqarray13::EV_STATUS_SOURCE0); + irqarray13_csr.rmwf(utra::irqarray13::EV_STATUS_SOURCE0, bar); + let mut baz = irqarray13_csr.zf(utra::irqarray13::EV_STATUS_SOURCE0, bar); + baz |= irqarray13_csr.ms(utra::irqarray13::EV_STATUS_SOURCE0, 1); + irqarray13_csr.wfo(utra::irqarray13::EV_STATUS_SOURCE0, baz); + let bar = irqarray13_csr.rf(utra::irqarray13::EV_STATUS_SOURCE1); + irqarray13_csr.rmwf(utra::irqarray13::EV_STATUS_SOURCE1, bar); + let mut baz = irqarray13_csr.zf(utra::irqarray13::EV_STATUS_SOURCE1, bar); + baz |= irqarray13_csr.ms(utra::irqarray13::EV_STATUS_SOURCE1, 1); + irqarray13_csr.wfo(utra::irqarray13::EV_STATUS_SOURCE1, baz); + let bar = irqarray13_csr.rf(utra::irqarray13::EV_STATUS_SOURCE2); + irqarray13_csr.rmwf(utra::irqarray13::EV_STATUS_SOURCE2, bar); + let mut baz = irqarray13_csr.zf(utra::irqarray13::EV_STATUS_SOURCE2, bar); + baz |= irqarray13_csr.ms(utra::irqarray13::EV_STATUS_SOURCE2, 1); + irqarray13_csr.wfo(utra::irqarray13::EV_STATUS_SOURCE2, baz); + let bar = irqarray13_csr.rf(utra::irqarray13::EV_STATUS_SOURCE3); + irqarray13_csr.rmwf(utra::irqarray13::EV_STATUS_SOURCE3, bar); + let mut baz = irqarray13_csr.zf(utra::irqarray13::EV_STATUS_SOURCE3, bar); + baz |= irqarray13_csr.ms(utra::irqarray13::EV_STATUS_SOURCE3, 1); + irqarray13_csr.wfo(utra::irqarray13::EV_STATUS_SOURCE3, baz); + let bar = irqarray13_csr.rf(utra::irqarray13::EV_STATUS_SOURCE4); + irqarray13_csr.rmwf(utra::irqarray13::EV_STATUS_SOURCE4, bar); + let mut baz = irqarray13_csr.zf(utra::irqarray13::EV_STATUS_SOURCE4, bar); + baz |= irqarray13_csr.ms(utra::irqarray13::EV_STATUS_SOURCE4, 1); + irqarray13_csr.wfo(utra::irqarray13::EV_STATUS_SOURCE4, baz); + let bar = irqarray13_csr.rf(utra::irqarray13::EV_STATUS_SOURCE5); + irqarray13_csr.rmwf(utra::irqarray13::EV_STATUS_SOURCE5, bar); + let mut baz = irqarray13_csr.zf(utra::irqarray13::EV_STATUS_SOURCE5, bar); + baz |= irqarray13_csr.ms(utra::irqarray13::EV_STATUS_SOURCE5, 1); + irqarray13_csr.wfo(utra::irqarray13::EV_STATUS_SOURCE5, baz); + let bar = irqarray13_csr.rf(utra::irqarray13::EV_STATUS_SOURCE6); + irqarray13_csr.rmwf(utra::irqarray13::EV_STATUS_SOURCE6, bar); + let mut baz = irqarray13_csr.zf(utra::irqarray13::EV_STATUS_SOURCE6, bar); + baz |= irqarray13_csr.ms(utra::irqarray13::EV_STATUS_SOURCE6, 1); + irqarray13_csr.wfo(utra::irqarray13::EV_STATUS_SOURCE6, baz); + let bar = irqarray13_csr.rf(utra::irqarray13::EV_STATUS_SOURCE7); + irqarray13_csr.rmwf(utra::irqarray13::EV_STATUS_SOURCE7, bar); + let mut baz = irqarray13_csr.zf(utra::irqarray13::EV_STATUS_SOURCE7, bar); + baz |= irqarray13_csr.ms(utra::irqarray13::EV_STATUS_SOURCE7, 1); + irqarray13_csr.wfo(utra::irqarray13::EV_STATUS_SOURCE7, baz); + let bar = irqarray13_csr.rf(utra::irqarray13::EV_STATUS_SOURCE8); + irqarray13_csr.rmwf(utra::irqarray13::EV_STATUS_SOURCE8, bar); + let mut baz = irqarray13_csr.zf(utra::irqarray13::EV_STATUS_SOURCE8, bar); + baz |= irqarray13_csr.ms(utra::irqarray13::EV_STATUS_SOURCE8, 1); + irqarray13_csr.wfo(utra::irqarray13::EV_STATUS_SOURCE8, baz); + let bar = irqarray13_csr.rf(utra::irqarray13::EV_STATUS_SOURCE9); + irqarray13_csr.rmwf(utra::irqarray13::EV_STATUS_SOURCE9, bar); + let mut baz = irqarray13_csr.zf(utra::irqarray13::EV_STATUS_SOURCE9, bar); + baz |= irqarray13_csr.ms(utra::irqarray13::EV_STATUS_SOURCE9, 1); + irqarray13_csr.wfo(utra::irqarray13::EV_STATUS_SOURCE9, baz); + let bar = irqarray13_csr.rf(utra::irqarray13::EV_STATUS_SOURCE10); + irqarray13_csr.rmwf(utra::irqarray13::EV_STATUS_SOURCE10, bar); + let mut baz = irqarray13_csr.zf(utra::irqarray13::EV_STATUS_SOURCE10, bar); + baz |= irqarray13_csr.ms(utra::irqarray13::EV_STATUS_SOURCE10, 1); + irqarray13_csr.wfo(utra::irqarray13::EV_STATUS_SOURCE10, baz); + let bar = irqarray13_csr.rf(utra::irqarray13::EV_STATUS_SOURCE11); + irqarray13_csr.rmwf(utra::irqarray13::EV_STATUS_SOURCE11, bar); + let mut baz = irqarray13_csr.zf(utra::irqarray13::EV_STATUS_SOURCE11, bar); + baz |= irqarray13_csr.ms(utra::irqarray13::EV_STATUS_SOURCE11, 1); + irqarray13_csr.wfo(utra::irqarray13::EV_STATUS_SOURCE11, baz); + let bar = irqarray13_csr.rf(utra::irqarray13::EV_STATUS_SOURCE12); + irqarray13_csr.rmwf(utra::irqarray13::EV_STATUS_SOURCE12, bar); + let mut baz = irqarray13_csr.zf(utra::irqarray13::EV_STATUS_SOURCE12, bar); + baz |= irqarray13_csr.ms(utra::irqarray13::EV_STATUS_SOURCE12, 1); + irqarray13_csr.wfo(utra::irqarray13::EV_STATUS_SOURCE12, baz); + let bar = irqarray13_csr.rf(utra::irqarray13::EV_STATUS_SOURCE13); + irqarray13_csr.rmwf(utra::irqarray13::EV_STATUS_SOURCE13, bar); + let mut baz = irqarray13_csr.zf(utra::irqarray13::EV_STATUS_SOURCE13, bar); + baz |= irqarray13_csr.ms(utra::irqarray13::EV_STATUS_SOURCE13, 1); + irqarray13_csr.wfo(utra::irqarray13::EV_STATUS_SOURCE13, baz); + let bar = irqarray13_csr.rf(utra::irqarray13::EV_STATUS_SOURCE14); + irqarray13_csr.rmwf(utra::irqarray13::EV_STATUS_SOURCE14, bar); + let mut baz = irqarray13_csr.zf(utra::irqarray13::EV_STATUS_SOURCE14, bar); + baz |= irqarray13_csr.ms(utra::irqarray13::EV_STATUS_SOURCE14, 1); + irqarray13_csr.wfo(utra::irqarray13::EV_STATUS_SOURCE14, baz); + let bar = irqarray13_csr.rf(utra::irqarray13::EV_STATUS_SOURCE15); + irqarray13_csr.rmwf(utra::irqarray13::EV_STATUS_SOURCE15, bar); + let mut baz = irqarray13_csr.zf(utra::irqarray13::EV_STATUS_SOURCE15, bar); + baz |= irqarray13_csr.ms(utra::irqarray13::EV_STATUS_SOURCE15, 1); + irqarray13_csr.wfo(utra::irqarray13::EV_STATUS_SOURCE15, baz); + let bar = irqarray13_csr.rf(utra::irqarray13::EV_STATUS_SOURCE16); + irqarray13_csr.rmwf(utra::irqarray13::EV_STATUS_SOURCE16, bar); + let mut baz = irqarray13_csr.zf(utra::irqarray13::EV_STATUS_SOURCE16, bar); + baz |= irqarray13_csr.ms(utra::irqarray13::EV_STATUS_SOURCE16, 1); + irqarray13_csr.wfo(utra::irqarray13::EV_STATUS_SOURCE16, baz); + let bar = irqarray13_csr.rf(utra::irqarray13::EV_STATUS_SOURCE17); + irqarray13_csr.rmwf(utra::irqarray13::EV_STATUS_SOURCE17, bar); + let mut baz = irqarray13_csr.zf(utra::irqarray13::EV_STATUS_SOURCE17, bar); + baz |= irqarray13_csr.ms(utra::irqarray13::EV_STATUS_SOURCE17, 1); + irqarray13_csr.wfo(utra::irqarray13::EV_STATUS_SOURCE17, baz); + let bar = irqarray13_csr.rf(utra::irqarray13::EV_STATUS_SOURCE18); + irqarray13_csr.rmwf(utra::irqarray13::EV_STATUS_SOURCE18, bar); + let mut baz = irqarray13_csr.zf(utra::irqarray13::EV_STATUS_SOURCE18, bar); + baz |= irqarray13_csr.ms(utra::irqarray13::EV_STATUS_SOURCE18, 1); + irqarray13_csr.wfo(utra::irqarray13::EV_STATUS_SOURCE18, baz); + let bar = irqarray13_csr.rf(utra::irqarray13::EV_STATUS_SOURCE19); + irqarray13_csr.rmwf(utra::irqarray13::EV_STATUS_SOURCE19, bar); + let mut baz = irqarray13_csr.zf(utra::irqarray13::EV_STATUS_SOURCE19, bar); + baz |= irqarray13_csr.ms(utra::irqarray13::EV_STATUS_SOURCE19, 1); + irqarray13_csr.wfo(utra::irqarray13::EV_STATUS_SOURCE19, baz); + + let foo = irqarray13_csr.r(utra::irqarray13::EV_PENDING); + irqarray13_csr.wo(utra::irqarray13::EV_PENDING, foo); + let bar = irqarray13_csr.rf(utra::irqarray13::EV_PENDING_SOURCE0); + irqarray13_csr.rmwf(utra::irqarray13::EV_PENDING_SOURCE0, bar); + let mut baz = irqarray13_csr.zf(utra::irqarray13::EV_PENDING_SOURCE0, bar); + baz |= irqarray13_csr.ms(utra::irqarray13::EV_PENDING_SOURCE0, 1); + irqarray13_csr.wfo(utra::irqarray13::EV_PENDING_SOURCE0, baz); + let bar = irqarray13_csr.rf(utra::irqarray13::EV_PENDING_SOURCE1); + irqarray13_csr.rmwf(utra::irqarray13::EV_PENDING_SOURCE1, bar); + let mut baz = irqarray13_csr.zf(utra::irqarray13::EV_PENDING_SOURCE1, bar); + baz |= irqarray13_csr.ms(utra::irqarray13::EV_PENDING_SOURCE1, 1); + irqarray13_csr.wfo(utra::irqarray13::EV_PENDING_SOURCE1, baz); + let bar = irqarray13_csr.rf(utra::irqarray13::EV_PENDING_SOURCE2); + irqarray13_csr.rmwf(utra::irqarray13::EV_PENDING_SOURCE2, bar); + let mut baz = irqarray13_csr.zf(utra::irqarray13::EV_PENDING_SOURCE2, bar); + baz |= irqarray13_csr.ms(utra::irqarray13::EV_PENDING_SOURCE2, 1); + irqarray13_csr.wfo(utra::irqarray13::EV_PENDING_SOURCE2, baz); + let bar = irqarray13_csr.rf(utra::irqarray13::EV_PENDING_SOURCE3); + irqarray13_csr.rmwf(utra::irqarray13::EV_PENDING_SOURCE3, bar); + let mut baz = irqarray13_csr.zf(utra::irqarray13::EV_PENDING_SOURCE3, bar); + baz |= irqarray13_csr.ms(utra::irqarray13::EV_PENDING_SOURCE3, 1); + irqarray13_csr.wfo(utra::irqarray13::EV_PENDING_SOURCE3, baz); + let bar = irqarray13_csr.rf(utra::irqarray13::EV_PENDING_SOURCE4); + irqarray13_csr.rmwf(utra::irqarray13::EV_PENDING_SOURCE4, bar); + let mut baz = irqarray13_csr.zf(utra::irqarray13::EV_PENDING_SOURCE4, bar); + baz |= irqarray13_csr.ms(utra::irqarray13::EV_PENDING_SOURCE4, 1); + irqarray13_csr.wfo(utra::irqarray13::EV_PENDING_SOURCE4, baz); + let bar = irqarray13_csr.rf(utra::irqarray13::EV_PENDING_SOURCE5); + irqarray13_csr.rmwf(utra::irqarray13::EV_PENDING_SOURCE5, bar); + let mut baz = irqarray13_csr.zf(utra::irqarray13::EV_PENDING_SOURCE5, bar); + baz |= irqarray13_csr.ms(utra::irqarray13::EV_PENDING_SOURCE5, 1); + irqarray13_csr.wfo(utra::irqarray13::EV_PENDING_SOURCE5, baz); + let bar = irqarray13_csr.rf(utra::irqarray13::EV_PENDING_SOURCE6); + irqarray13_csr.rmwf(utra::irqarray13::EV_PENDING_SOURCE6, bar); + let mut baz = irqarray13_csr.zf(utra::irqarray13::EV_PENDING_SOURCE6, bar); + baz |= irqarray13_csr.ms(utra::irqarray13::EV_PENDING_SOURCE6, 1); + irqarray13_csr.wfo(utra::irqarray13::EV_PENDING_SOURCE6, baz); + let bar = irqarray13_csr.rf(utra::irqarray13::EV_PENDING_SOURCE7); + irqarray13_csr.rmwf(utra::irqarray13::EV_PENDING_SOURCE7, bar); + let mut baz = irqarray13_csr.zf(utra::irqarray13::EV_PENDING_SOURCE7, bar); + baz |= irqarray13_csr.ms(utra::irqarray13::EV_PENDING_SOURCE7, 1); + irqarray13_csr.wfo(utra::irqarray13::EV_PENDING_SOURCE7, baz); + let bar = irqarray13_csr.rf(utra::irqarray13::EV_PENDING_SOURCE8); + irqarray13_csr.rmwf(utra::irqarray13::EV_PENDING_SOURCE8, bar); + let mut baz = irqarray13_csr.zf(utra::irqarray13::EV_PENDING_SOURCE8, bar); + baz |= irqarray13_csr.ms(utra::irqarray13::EV_PENDING_SOURCE8, 1); + irqarray13_csr.wfo(utra::irqarray13::EV_PENDING_SOURCE8, baz); + let bar = irqarray13_csr.rf(utra::irqarray13::EV_PENDING_SOURCE9); + irqarray13_csr.rmwf(utra::irqarray13::EV_PENDING_SOURCE9, bar); + let mut baz = irqarray13_csr.zf(utra::irqarray13::EV_PENDING_SOURCE9, bar); + baz |= irqarray13_csr.ms(utra::irqarray13::EV_PENDING_SOURCE9, 1); + irqarray13_csr.wfo(utra::irqarray13::EV_PENDING_SOURCE9, baz); + let bar = irqarray13_csr.rf(utra::irqarray13::EV_PENDING_SOURCE10); + irqarray13_csr.rmwf(utra::irqarray13::EV_PENDING_SOURCE10, bar); + let mut baz = irqarray13_csr.zf(utra::irqarray13::EV_PENDING_SOURCE10, bar); + baz |= irqarray13_csr.ms(utra::irqarray13::EV_PENDING_SOURCE10, 1); + irqarray13_csr.wfo(utra::irqarray13::EV_PENDING_SOURCE10, baz); + let bar = irqarray13_csr.rf(utra::irqarray13::EV_PENDING_SOURCE11); + irqarray13_csr.rmwf(utra::irqarray13::EV_PENDING_SOURCE11, bar); + let mut baz = irqarray13_csr.zf(utra::irqarray13::EV_PENDING_SOURCE11, bar); + baz |= irqarray13_csr.ms(utra::irqarray13::EV_PENDING_SOURCE11, 1); + irqarray13_csr.wfo(utra::irqarray13::EV_PENDING_SOURCE11, baz); + let bar = irqarray13_csr.rf(utra::irqarray13::EV_PENDING_SOURCE12); + irqarray13_csr.rmwf(utra::irqarray13::EV_PENDING_SOURCE12, bar); + let mut baz = irqarray13_csr.zf(utra::irqarray13::EV_PENDING_SOURCE12, bar); + baz |= irqarray13_csr.ms(utra::irqarray13::EV_PENDING_SOURCE12, 1); + irqarray13_csr.wfo(utra::irqarray13::EV_PENDING_SOURCE12, baz); + let bar = irqarray13_csr.rf(utra::irqarray13::EV_PENDING_SOURCE13); + irqarray13_csr.rmwf(utra::irqarray13::EV_PENDING_SOURCE13, bar); + let mut baz = irqarray13_csr.zf(utra::irqarray13::EV_PENDING_SOURCE13, bar); + baz |= irqarray13_csr.ms(utra::irqarray13::EV_PENDING_SOURCE13, 1); + irqarray13_csr.wfo(utra::irqarray13::EV_PENDING_SOURCE13, baz); + let bar = irqarray13_csr.rf(utra::irqarray13::EV_PENDING_SOURCE14); + irqarray13_csr.rmwf(utra::irqarray13::EV_PENDING_SOURCE14, bar); + let mut baz = irqarray13_csr.zf(utra::irqarray13::EV_PENDING_SOURCE14, bar); + baz |= irqarray13_csr.ms(utra::irqarray13::EV_PENDING_SOURCE14, 1); + irqarray13_csr.wfo(utra::irqarray13::EV_PENDING_SOURCE14, baz); + let bar = irqarray13_csr.rf(utra::irqarray13::EV_PENDING_SOURCE15); + irqarray13_csr.rmwf(utra::irqarray13::EV_PENDING_SOURCE15, bar); + let mut baz = irqarray13_csr.zf(utra::irqarray13::EV_PENDING_SOURCE15, bar); + baz |= irqarray13_csr.ms(utra::irqarray13::EV_PENDING_SOURCE15, 1); + irqarray13_csr.wfo(utra::irqarray13::EV_PENDING_SOURCE15, baz); + let bar = irqarray13_csr.rf(utra::irqarray13::EV_PENDING_SOURCE16); + irqarray13_csr.rmwf(utra::irqarray13::EV_PENDING_SOURCE16, bar); + let mut baz = irqarray13_csr.zf(utra::irqarray13::EV_PENDING_SOURCE16, bar); + baz |= irqarray13_csr.ms(utra::irqarray13::EV_PENDING_SOURCE16, 1); + irqarray13_csr.wfo(utra::irqarray13::EV_PENDING_SOURCE16, baz); + let bar = irqarray13_csr.rf(utra::irqarray13::EV_PENDING_SOURCE17); + irqarray13_csr.rmwf(utra::irqarray13::EV_PENDING_SOURCE17, bar); + let mut baz = irqarray13_csr.zf(utra::irqarray13::EV_PENDING_SOURCE17, bar); + baz |= irqarray13_csr.ms(utra::irqarray13::EV_PENDING_SOURCE17, 1); + irqarray13_csr.wfo(utra::irqarray13::EV_PENDING_SOURCE17, baz); + let bar = irqarray13_csr.rf(utra::irqarray13::EV_PENDING_SOURCE18); + irqarray13_csr.rmwf(utra::irqarray13::EV_PENDING_SOURCE18, bar); + let mut baz = irqarray13_csr.zf(utra::irqarray13::EV_PENDING_SOURCE18, bar); + baz |= irqarray13_csr.ms(utra::irqarray13::EV_PENDING_SOURCE18, 1); + irqarray13_csr.wfo(utra::irqarray13::EV_PENDING_SOURCE18, baz); + let bar = irqarray13_csr.rf(utra::irqarray13::EV_PENDING_SOURCE19); + irqarray13_csr.rmwf(utra::irqarray13::EV_PENDING_SOURCE19, bar); + let mut baz = irqarray13_csr.zf(utra::irqarray13::EV_PENDING_SOURCE19, bar); + baz |= irqarray13_csr.ms(utra::irqarray13::EV_PENDING_SOURCE19, 1); + irqarray13_csr.wfo(utra::irqarray13::EV_PENDING_SOURCE19, baz); + + let foo = irqarray13_csr.r(utra::irqarray13::EV_ENABLE); + irqarray13_csr.wo(utra::irqarray13::EV_ENABLE, foo); + let bar = irqarray13_csr.rf(utra::irqarray13::EV_ENABLE_SOURCE0); + irqarray13_csr.rmwf(utra::irqarray13::EV_ENABLE_SOURCE0, bar); + let mut baz = irqarray13_csr.zf(utra::irqarray13::EV_ENABLE_SOURCE0, bar); + baz |= irqarray13_csr.ms(utra::irqarray13::EV_ENABLE_SOURCE0, 1); + irqarray13_csr.wfo(utra::irqarray13::EV_ENABLE_SOURCE0, baz); + let bar = irqarray13_csr.rf(utra::irqarray13::EV_ENABLE_SOURCE1); + irqarray13_csr.rmwf(utra::irqarray13::EV_ENABLE_SOURCE1, bar); + let mut baz = irqarray13_csr.zf(utra::irqarray13::EV_ENABLE_SOURCE1, bar); + baz |= irqarray13_csr.ms(utra::irqarray13::EV_ENABLE_SOURCE1, 1); + irqarray13_csr.wfo(utra::irqarray13::EV_ENABLE_SOURCE1, baz); + let bar = irqarray13_csr.rf(utra::irqarray13::EV_ENABLE_SOURCE2); + irqarray13_csr.rmwf(utra::irqarray13::EV_ENABLE_SOURCE2, bar); + let mut baz = irqarray13_csr.zf(utra::irqarray13::EV_ENABLE_SOURCE2, bar); + baz |= irqarray13_csr.ms(utra::irqarray13::EV_ENABLE_SOURCE2, 1); + irqarray13_csr.wfo(utra::irqarray13::EV_ENABLE_SOURCE2, baz); + let bar = irqarray13_csr.rf(utra::irqarray13::EV_ENABLE_SOURCE3); + irqarray13_csr.rmwf(utra::irqarray13::EV_ENABLE_SOURCE3, bar); + let mut baz = irqarray13_csr.zf(utra::irqarray13::EV_ENABLE_SOURCE3, bar); + baz |= irqarray13_csr.ms(utra::irqarray13::EV_ENABLE_SOURCE3, 1); + irqarray13_csr.wfo(utra::irqarray13::EV_ENABLE_SOURCE3, baz); + let bar = irqarray13_csr.rf(utra::irqarray13::EV_ENABLE_SOURCE4); + irqarray13_csr.rmwf(utra::irqarray13::EV_ENABLE_SOURCE4, bar); + let mut baz = irqarray13_csr.zf(utra::irqarray13::EV_ENABLE_SOURCE4, bar); + baz |= irqarray13_csr.ms(utra::irqarray13::EV_ENABLE_SOURCE4, 1); + irqarray13_csr.wfo(utra::irqarray13::EV_ENABLE_SOURCE4, baz); + let bar = irqarray13_csr.rf(utra::irqarray13::EV_ENABLE_SOURCE5); + irqarray13_csr.rmwf(utra::irqarray13::EV_ENABLE_SOURCE5, bar); + let mut baz = irqarray13_csr.zf(utra::irqarray13::EV_ENABLE_SOURCE5, bar); + baz |= irqarray13_csr.ms(utra::irqarray13::EV_ENABLE_SOURCE5, 1); + irqarray13_csr.wfo(utra::irqarray13::EV_ENABLE_SOURCE5, baz); + let bar = irqarray13_csr.rf(utra::irqarray13::EV_ENABLE_SOURCE6); + irqarray13_csr.rmwf(utra::irqarray13::EV_ENABLE_SOURCE6, bar); + let mut baz = irqarray13_csr.zf(utra::irqarray13::EV_ENABLE_SOURCE6, bar); + baz |= irqarray13_csr.ms(utra::irqarray13::EV_ENABLE_SOURCE6, 1); + irqarray13_csr.wfo(utra::irqarray13::EV_ENABLE_SOURCE6, baz); + let bar = irqarray13_csr.rf(utra::irqarray13::EV_ENABLE_SOURCE7); + irqarray13_csr.rmwf(utra::irqarray13::EV_ENABLE_SOURCE7, bar); + let mut baz = irqarray13_csr.zf(utra::irqarray13::EV_ENABLE_SOURCE7, bar); + baz |= irqarray13_csr.ms(utra::irqarray13::EV_ENABLE_SOURCE7, 1); + irqarray13_csr.wfo(utra::irqarray13::EV_ENABLE_SOURCE7, baz); + let bar = irqarray13_csr.rf(utra::irqarray13::EV_ENABLE_SOURCE8); + irqarray13_csr.rmwf(utra::irqarray13::EV_ENABLE_SOURCE8, bar); + let mut baz = irqarray13_csr.zf(utra::irqarray13::EV_ENABLE_SOURCE8, bar); + baz |= irqarray13_csr.ms(utra::irqarray13::EV_ENABLE_SOURCE8, 1); + irqarray13_csr.wfo(utra::irqarray13::EV_ENABLE_SOURCE8, baz); + let bar = irqarray13_csr.rf(utra::irqarray13::EV_ENABLE_SOURCE9); + irqarray13_csr.rmwf(utra::irqarray13::EV_ENABLE_SOURCE9, bar); + let mut baz = irqarray13_csr.zf(utra::irqarray13::EV_ENABLE_SOURCE9, bar); + baz |= irqarray13_csr.ms(utra::irqarray13::EV_ENABLE_SOURCE9, 1); + irqarray13_csr.wfo(utra::irqarray13::EV_ENABLE_SOURCE9, baz); + let bar = irqarray13_csr.rf(utra::irqarray13::EV_ENABLE_SOURCE10); + irqarray13_csr.rmwf(utra::irqarray13::EV_ENABLE_SOURCE10, bar); + let mut baz = irqarray13_csr.zf(utra::irqarray13::EV_ENABLE_SOURCE10, bar); + baz |= irqarray13_csr.ms(utra::irqarray13::EV_ENABLE_SOURCE10, 1); + irqarray13_csr.wfo(utra::irqarray13::EV_ENABLE_SOURCE10, baz); + let bar = irqarray13_csr.rf(utra::irqarray13::EV_ENABLE_SOURCE11); + irqarray13_csr.rmwf(utra::irqarray13::EV_ENABLE_SOURCE11, bar); + let mut baz = irqarray13_csr.zf(utra::irqarray13::EV_ENABLE_SOURCE11, bar); + baz |= irqarray13_csr.ms(utra::irqarray13::EV_ENABLE_SOURCE11, 1); + irqarray13_csr.wfo(utra::irqarray13::EV_ENABLE_SOURCE11, baz); + let bar = irqarray13_csr.rf(utra::irqarray13::EV_ENABLE_SOURCE12); + irqarray13_csr.rmwf(utra::irqarray13::EV_ENABLE_SOURCE12, bar); + let mut baz = irqarray13_csr.zf(utra::irqarray13::EV_ENABLE_SOURCE12, bar); + baz |= irqarray13_csr.ms(utra::irqarray13::EV_ENABLE_SOURCE12, 1); + irqarray13_csr.wfo(utra::irqarray13::EV_ENABLE_SOURCE12, baz); + let bar = irqarray13_csr.rf(utra::irqarray13::EV_ENABLE_SOURCE13); + irqarray13_csr.rmwf(utra::irqarray13::EV_ENABLE_SOURCE13, bar); + let mut baz = irqarray13_csr.zf(utra::irqarray13::EV_ENABLE_SOURCE13, bar); + baz |= irqarray13_csr.ms(utra::irqarray13::EV_ENABLE_SOURCE13, 1); + irqarray13_csr.wfo(utra::irqarray13::EV_ENABLE_SOURCE13, baz); + let bar = irqarray13_csr.rf(utra::irqarray13::EV_ENABLE_SOURCE14); + irqarray13_csr.rmwf(utra::irqarray13::EV_ENABLE_SOURCE14, bar); + let mut baz = irqarray13_csr.zf(utra::irqarray13::EV_ENABLE_SOURCE14, bar); + baz |= irqarray13_csr.ms(utra::irqarray13::EV_ENABLE_SOURCE14, 1); + irqarray13_csr.wfo(utra::irqarray13::EV_ENABLE_SOURCE14, baz); + let bar = irqarray13_csr.rf(utra::irqarray13::EV_ENABLE_SOURCE15); + irqarray13_csr.rmwf(utra::irqarray13::EV_ENABLE_SOURCE15, bar); + let mut baz = irqarray13_csr.zf(utra::irqarray13::EV_ENABLE_SOURCE15, bar); + baz |= irqarray13_csr.ms(utra::irqarray13::EV_ENABLE_SOURCE15, 1); + irqarray13_csr.wfo(utra::irqarray13::EV_ENABLE_SOURCE15, baz); + let bar = irqarray13_csr.rf(utra::irqarray13::EV_ENABLE_SOURCE16); + irqarray13_csr.rmwf(utra::irqarray13::EV_ENABLE_SOURCE16, bar); + let mut baz = irqarray13_csr.zf(utra::irqarray13::EV_ENABLE_SOURCE16, bar); + baz |= irqarray13_csr.ms(utra::irqarray13::EV_ENABLE_SOURCE16, 1); + irqarray13_csr.wfo(utra::irqarray13::EV_ENABLE_SOURCE16, baz); + let bar = irqarray13_csr.rf(utra::irqarray13::EV_ENABLE_SOURCE17); + irqarray13_csr.rmwf(utra::irqarray13::EV_ENABLE_SOURCE17, bar); + let mut baz = irqarray13_csr.zf(utra::irqarray13::EV_ENABLE_SOURCE17, bar); + baz |= irqarray13_csr.ms(utra::irqarray13::EV_ENABLE_SOURCE17, 1); + irqarray13_csr.wfo(utra::irqarray13::EV_ENABLE_SOURCE17, baz); + let bar = irqarray13_csr.rf(utra::irqarray13::EV_ENABLE_SOURCE18); + irqarray13_csr.rmwf(utra::irqarray13::EV_ENABLE_SOURCE18, bar); + let mut baz = irqarray13_csr.zf(utra::irqarray13::EV_ENABLE_SOURCE18, bar); + baz |= irqarray13_csr.ms(utra::irqarray13::EV_ENABLE_SOURCE18, 1); + irqarray13_csr.wfo(utra::irqarray13::EV_ENABLE_SOURCE18, baz); + let bar = irqarray13_csr.rf(utra::irqarray13::EV_ENABLE_SOURCE19); + irqarray13_csr.rmwf(utra::irqarray13::EV_ENABLE_SOURCE19, bar); + let mut baz = irqarray13_csr.zf(utra::irqarray13::EV_ENABLE_SOURCE19, bar); + baz |= irqarray13_csr.ms(utra::irqarray13::EV_ENABLE_SOURCE19, 1); + irqarray13_csr.wfo(utra::irqarray13::EV_ENABLE_SOURCE19, baz); + } + + #[test] + #[ignore] + fn compile_check_irqarray14_csr() { + use super::*; + let mut irqarray14_csr = CSR::new(HW_IRQARRAY14_BASE as *mut u32); + + let foo = irqarray14_csr.r(utra::irqarray14::EV_SOFT); + irqarray14_csr.wo(utra::irqarray14::EV_SOFT, foo); + let bar = irqarray14_csr.rf(utra::irqarray14::EV_SOFT_TRIGGER); + irqarray14_csr.rmwf(utra::irqarray14::EV_SOFT_TRIGGER, bar); + let mut baz = irqarray14_csr.zf(utra::irqarray14::EV_SOFT_TRIGGER, bar); + baz |= irqarray14_csr.ms(utra::irqarray14::EV_SOFT_TRIGGER, 1); + irqarray14_csr.wfo(utra::irqarray14::EV_SOFT_TRIGGER, baz); + + let foo = irqarray14_csr.r(utra::irqarray14::EV_STATUS); + irqarray14_csr.wo(utra::irqarray14::EV_STATUS, foo); + let bar = irqarray14_csr.rf(utra::irqarray14::EV_STATUS_SOURCE0); + irqarray14_csr.rmwf(utra::irqarray14::EV_STATUS_SOURCE0, bar); + let mut baz = irqarray14_csr.zf(utra::irqarray14::EV_STATUS_SOURCE0, bar); + baz |= irqarray14_csr.ms(utra::irqarray14::EV_STATUS_SOURCE0, 1); + irqarray14_csr.wfo(utra::irqarray14::EV_STATUS_SOURCE0, baz); + let bar = irqarray14_csr.rf(utra::irqarray14::EV_STATUS_SOURCE1); + irqarray14_csr.rmwf(utra::irqarray14::EV_STATUS_SOURCE1, bar); + let mut baz = irqarray14_csr.zf(utra::irqarray14::EV_STATUS_SOURCE1, bar); + baz |= irqarray14_csr.ms(utra::irqarray14::EV_STATUS_SOURCE1, 1); + irqarray14_csr.wfo(utra::irqarray14::EV_STATUS_SOURCE1, baz); + let bar = irqarray14_csr.rf(utra::irqarray14::EV_STATUS_SOURCE2); + irqarray14_csr.rmwf(utra::irqarray14::EV_STATUS_SOURCE2, bar); + let mut baz = irqarray14_csr.zf(utra::irqarray14::EV_STATUS_SOURCE2, bar); + baz |= irqarray14_csr.ms(utra::irqarray14::EV_STATUS_SOURCE2, 1); + irqarray14_csr.wfo(utra::irqarray14::EV_STATUS_SOURCE2, baz); + let bar = irqarray14_csr.rf(utra::irqarray14::EV_STATUS_SOURCE3); + irqarray14_csr.rmwf(utra::irqarray14::EV_STATUS_SOURCE3, bar); + let mut baz = irqarray14_csr.zf(utra::irqarray14::EV_STATUS_SOURCE3, bar); + baz |= irqarray14_csr.ms(utra::irqarray14::EV_STATUS_SOURCE3, 1); + irqarray14_csr.wfo(utra::irqarray14::EV_STATUS_SOURCE3, baz); + let bar = irqarray14_csr.rf(utra::irqarray14::EV_STATUS_SOURCE4); + irqarray14_csr.rmwf(utra::irqarray14::EV_STATUS_SOURCE4, bar); + let mut baz = irqarray14_csr.zf(utra::irqarray14::EV_STATUS_SOURCE4, bar); + baz |= irqarray14_csr.ms(utra::irqarray14::EV_STATUS_SOURCE4, 1); + irqarray14_csr.wfo(utra::irqarray14::EV_STATUS_SOURCE4, baz); + let bar = irqarray14_csr.rf(utra::irqarray14::EV_STATUS_SOURCE5); + irqarray14_csr.rmwf(utra::irqarray14::EV_STATUS_SOURCE5, bar); + let mut baz = irqarray14_csr.zf(utra::irqarray14::EV_STATUS_SOURCE5, bar); + baz |= irqarray14_csr.ms(utra::irqarray14::EV_STATUS_SOURCE5, 1); + irqarray14_csr.wfo(utra::irqarray14::EV_STATUS_SOURCE5, baz); + let bar = irqarray14_csr.rf(utra::irqarray14::EV_STATUS_SOURCE6); + irqarray14_csr.rmwf(utra::irqarray14::EV_STATUS_SOURCE6, bar); + let mut baz = irqarray14_csr.zf(utra::irqarray14::EV_STATUS_SOURCE6, bar); + baz |= irqarray14_csr.ms(utra::irqarray14::EV_STATUS_SOURCE6, 1); + irqarray14_csr.wfo(utra::irqarray14::EV_STATUS_SOURCE6, baz); + let bar = irqarray14_csr.rf(utra::irqarray14::EV_STATUS_SOURCE7); + irqarray14_csr.rmwf(utra::irqarray14::EV_STATUS_SOURCE7, bar); + let mut baz = irqarray14_csr.zf(utra::irqarray14::EV_STATUS_SOURCE7, bar); + baz |= irqarray14_csr.ms(utra::irqarray14::EV_STATUS_SOURCE7, 1); + irqarray14_csr.wfo(utra::irqarray14::EV_STATUS_SOURCE7, baz); + let bar = irqarray14_csr.rf(utra::irqarray14::EV_STATUS_SOURCE8); + irqarray14_csr.rmwf(utra::irqarray14::EV_STATUS_SOURCE8, bar); + let mut baz = irqarray14_csr.zf(utra::irqarray14::EV_STATUS_SOURCE8, bar); + baz |= irqarray14_csr.ms(utra::irqarray14::EV_STATUS_SOURCE8, 1); + irqarray14_csr.wfo(utra::irqarray14::EV_STATUS_SOURCE8, baz); + let bar = irqarray14_csr.rf(utra::irqarray14::EV_STATUS_SOURCE9); + irqarray14_csr.rmwf(utra::irqarray14::EV_STATUS_SOURCE9, bar); + let mut baz = irqarray14_csr.zf(utra::irqarray14::EV_STATUS_SOURCE9, bar); + baz |= irqarray14_csr.ms(utra::irqarray14::EV_STATUS_SOURCE9, 1); + irqarray14_csr.wfo(utra::irqarray14::EV_STATUS_SOURCE9, baz); + let bar = irqarray14_csr.rf(utra::irqarray14::EV_STATUS_SOURCE10); + irqarray14_csr.rmwf(utra::irqarray14::EV_STATUS_SOURCE10, bar); + let mut baz = irqarray14_csr.zf(utra::irqarray14::EV_STATUS_SOURCE10, bar); + baz |= irqarray14_csr.ms(utra::irqarray14::EV_STATUS_SOURCE10, 1); + irqarray14_csr.wfo(utra::irqarray14::EV_STATUS_SOURCE10, baz); + let bar = irqarray14_csr.rf(utra::irqarray14::EV_STATUS_SOURCE11); + irqarray14_csr.rmwf(utra::irqarray14::EV_STATUS_SOURCE11, bar); + let mut baz = irqarray14_csr.zf(utra::irqarray14::EV_STATUS_SOURCE11, bar); + baz |= irqarray14_csr.ms(utra::irqarray14::EV_STATUS_SOURCE11, 1); + irqarray14_csr.wfo(utra::irqarray14::EV_STATUS_SOURCE11, baz); + let bar = irqarray14_csr.rf(utra::irqarray14::EV_STATUS_SOURCE12); + irqarray14_csr.rmwf(utra::irqarray14::EV_STATUS_SOURCE12, bar); + let mut baz = irqarray14_csr.zf(utra::irqarray14::EV_STATUS_SOURCE12, bar); + baz |= irqarray14_csr.ms(utra::irqarray14::EV_STATUS_SOURCE12, 1); + irqarray14_csr.wfo(utra::irqarray14::EV_STATUS_SOURCE12, baz); + let bar = irqarray14_csr.rf(utra::irqarray14::EV_STATUS_SOURCE13); + irqarray14_csr.rmwf(utra::irqarray14::EV_STATUS_SOURCE13, bar); + let mut baz = irqarray14_csr.zf(utra::irqarray14::EV_STATUS_SOURCE13, bar); + baz |= irqarray14_csr.ms(utra::irqarray14::EV_STATUS_SOURCE13, 1); + irqarray14_csr.wfo(utra::irqarray14::EV_STATUS_SOURCE13, baz); + let bar = irqarray14_csr.rf(utra::irqarray14::EV_STATUS_SOURCE14); + irqarray14_csr.rmwf(utra::irqarray14::EV_STATUS_SOURCE14, bar); + let mut baz = irqarray14_csr.zf(utra::irqarray14::EV_STATUS_SOURCE14, bar); + baz |= irqarray14_csr.ms(utra::irqarray14::EV_STATUS_SOURCE14, 1); + irqarray14_csr.wfo(utra::irqarray14::EV_STATUS_SOURCE14, baz); + let bar = irqarray14_csr.rf(utra::irqarray14::EV_STATUS_SOURCE15); + irqarray14_csr.rmwf(utra::irqarray14::EV_STATUS_SOURCE15, bar); + let mut baz = irqarray14_csr.zf(utra::irqarray14::EV_STATUS_SOURCE15, bar); + baz |= irqarray14_csr.ms(utra::irqarray14::EV_STATUS_SOURCE15, 1); + irqarray14_csr.wfo(utra::irqarray14::EV_STATUS_SOURCE15, baz); + let bar = irqarray14_csr.rf(utra::irqarray14::EV_STATUS_SOURCE16); + irqarray14_csr.rmwf(utra::irqarray14::EV_STATUS_SOURCE16, bar); + let mut baz = irqarray14_csr.zf(utra::irqarray14::EV_STATUS_SOURCE16, bar); + baz |= irqarray14_csr.ms(utra::irqarray14::EV_STATUS_SOURCE16, 1); + irqarray14_csr.wfo(utra::irqarray14::EV_STATUS_SOURCE16, baz); + let bar = irqarray14_csr.rf(utra::irqarray14::EV_STATUS_SOURCE17); + irqarray14_csr.rmwf(utra::irqarray14::EV_STATUS_SOURCE17, bar); + let mut baz = irqarray14_csr.zf(utra::irqarray14::EV_STATUS_SOURCE17, bar); + baz |= irqarray14_csr.ms(utra::irqarray14::EV_STATUS_SOURCE17, 1); + irqarray14_csr.wfo(utra::irqarray14::EV_STATUS_SOURCE17, baz); + let bar = irqarray14_csr.rf(utra::irqarray14::EV_STATUS_SOURCE18); + irqarray14_csr.rmwf(utra::irqarray14::EV_STATUS_SOURCE18, bar); + let mut baz = irqarray14_csr.zf(utra::irqarray14::EV_STATUS_SOURCE18, bar); + baz |= irqarray14_csr.ms(utra::irqarray14::EV_STATUS_SOURCE18, 1); + irqarray14_csr.wfo(utra::irqarray14::EV_STATUS_SOURCE18, baz); + let bar = irqarray14_csr.rf(utra::irqarray14::EV_STATUS_SOURCE19); + irqarray14_csr.rmwf(utra::irqarray14::EV_STATUS_SOURCE19, bar); + let mut baz = irqarray14_csr.zf(utra::irqarray14::EV_STATUS_SOURCE19, bar); + baz |= irqarray14_csr.ms(utra::irqarray14::EV_STATUS_SOURCE19, 1); + irqarray14_csr.wfo(utra::irqarray14::EV_STATUS_SOURCE19, baz); + + let foo = irqarray14_csr.r(utra::irqarray14::EV_PENDING); + irqarray14_csr.wo(utra::irqarray14::EV_PENDING, foo); + let bar = irqarray14_csr.rf(utra::irqarray14::EV_PENDING_SOURCE0); + irqarray14_csr.rmwf(utra::irqarray14::EV_PENDING_SOURCE0, bar); + let mut baz = irqarray14_csr.zf(utra::irqarray14::EV_PENDING_SOURCE0, bar); + baz |= irqarray14_csr.ms(utra::irqarray14::EV_PENDING_SOURCE0, 1); + irqarray14_csr.wfo(utra::irqarray14::EV_PENDING_SOURCE0, baz); + let bar = irqarray14_csr.rf(utra::irqarray14::EV_PENDING_SOURCE1); + irqarray14_csr.rmwf(utra::irqarray14::EV_PENDING_SOURCE1, bar); + let mut baz = irqarray14_csr.zf(utra::irqarray14::EV_PENDING_SOURCE1, bar); + baz |= irqarray14_csr.ms(utra::irqarray14::EV_PENDING_SOURCE1, 1); + irqarray14_csr.wfo(utra::irqarray14::EV_PENDING_SOURCE1, baz); + let bar = irqarray14_csr.rf(utra::irqarray14::EV_PENDING_SOURCE2); + irqarray14_csr.rmwf(utra::irqarray14::EV_PENDING_SOURCE2, bar); + let mut baz = irqarray14_csr.zf(utra::irqarray14::EV_PENDING_SOURCE2, bar); + baz |= irqarray14_csr.ms(utra::irqarray14::EV_PENDING_SOURCE2, 1); + irqarray14_csr.wfo(utra::irqarray14::EV_PENDING_SOURCE2, baz); + let bar = irqarray14_csr.rf(utra::irqarray14::EV_PENDING_SOURCE3); + irqarray14_csr.rmwf(utra::irqarray14::EV_PENDING_SOURCE3, bar); + let mut baz = irqarray14_csr.zf(utra::irqarray14::EV_PENDING_SOURCE3, bar); + baz |= irqarray14_csr.ms(utra::irqarray14::EV_PENDING_SOURCE3, 1); + irqarray14_csr.wfo(utra::irqarray14::EV_PENDING_SOURCE3, baz); + let bar = irqarray14_csr.rf(utra::irqarray14::EV_PENDING_SOURCE4); + irqarray14_csr.rmwf(utra::irqarray14::EV_PENDING_SOURCE4, bar); + let mut baz = irqarray14_csr.zf(utra::irqarray14::EV_PENDING_SOURCE4, bar); + baz |= irqarray14_csr.ms(utra::irqarray14::EV_PENDING_SOURCE4, 1); + irqarray14_csr.wfo(utra::irqarray14::EV_PENDING_SOURCE4, baz); + let bar = irqarray14_csr.rf(utra::irqarray14::EV_PENDING_SOURCE5); + irqarray14_csr.rmwf(utra::irqarray14::EV_PENDING_SOURCE5, bar); + let mut baz = irqarray14_csr.zf(utra::irqarray14::EV_PENDING_SOURCE5, bar); + baz |= irqarray14_csr.ms(utra::irqarray14::EV_PENDING_SOURCE5, 1); + irqarray14_csr.wfo(utra::irqarray14::EV_PENDING_SOURCE5, baz); + let bar = irqarray14_csr.rf(utra::irqarray14::EV_PENDING_SOURCE6); + irqarray14_csr.rmwf(utra::irqarray14::EV_PENDING_SOURCE6, bar); + let mut baz = irqarray14_csr.zf(utra::irqarray14::EV_PENDING_SOURCE6, bar); + baz |= irqarray14_csr.ms(utra::irqarray14::EV_PENDING_SOURCE6, 1); + irqarray14_csr.wfo(utra::irqarray14::EV_PENDING_SOURCE6, baz); + let bar = irqarray14_csr.rf(utra::irqarray14::EV_PENDING_SOURCE7); + irqarray14_csr.rmwf(utra::irqarray14::EV_PENDING_SOURCE7, bar); + let mut baz = irqarray14_csr.zf(utra::irqarray14::EV_PENDING_SOURCE7, bar); + baz |= irqarray14_csr.ms(utra::irqarray14::EV_PENDING_SOURCE7, 1); + irqarray14_csr.wfo(utra::irqarray14::EV_PENDING_SOURCE7, baz); + let bar = irqarray14_csr.rf(utra::irqarray14::EV_PENDING_SOURCE8); + irqarray14_csr.rmwf(utra::irqarray14::EV_PENDING_SOURCE8, bar); + let mut baz = irqarray14_csr.zf(utra::irqarray14::EV_PENDING_SOURCE8, bar); + baz |= irqarray14_csr.ms(utra::irqarray14::EV_PENDING_SOURCE8, 1); + irqarray14_csr.wfo(utra::irqarray14::EV_PENDING_SOURCE8, baz); + let bar = irqarray14_csr.rf(utra::irqarray14::EV_PENDING_SOURCE9); + irqarray14_csr.rmwf(utra::irqarray14::EV_PENDING_SOURCE9, bar); + let mut baz = irqarray14_csr.zf(utra::irqarray14::EV_PENDING_SOURCE9, bar); + baz |= irqarray14_csr.ms(utra::irqarray14::EV_PENDING_SOURCE9, 1); + irqarray14_csr.wfo(utra::irqarray14::EV_PENDING_SOURCE9, baz); + let bar = irqarray14_csr.rf(utra::irqarray14::EV_PENDING_SOURCE10); + irqarray14_csr.rmwf(utra::irqarray14::EV_PENDING_SOURCE10, bar); + let mut baz = irqarray14_csr.zf(utra::irqarray14::EV_PENDING_SOURCE10, bar); + baz |= irqarray14_csr.ms(utra::irqarray14::EV_PENDING_SOURCE10, 1); + irqarray14_csr.wfo(utra::irqarray14::EV_PENDING_SOURCE10, baz); + let bar = irqarray14_csr.rf(utra::irqarray14::EV_PENDING_SOURCE11); + irqarray14_csr.rmwf(utra::irqarray14::EV_PENDING_SOURCE11, bar); + let mut baz = irqarray14_csr.zf(utra::irqarray14::EV_PENDING_SOURCE11, bar); + baz |= irqarray14_csr.ms(utra::irqarray14::EV_PENDING_SOURCE11, 1); + irqarray14_csr.wfo(utra::irqarray14::EV_PENDING_SOURCE11, baz); + let bar = irqarray14_csr.rf(utra::irqarray14::EV_PENDING_SOURCE12); + irqarray14_csr.rmwf(utra::irqarray14::EV_PENDING_SOURCE12, bar); + let mut baz = irqarray14_csr.zf(utra::irqarray14::EV_PENDING_SOURCE12, bar); + baz |= irqarray14_csr.ms(utra::irqarray14::EV_PENDING_SOURCE12, 1); + irqarray14_csr.wfo(utra::irqarray14::EV_PENDING_SOURCE12, baz); + let bar = irqarray14_csr.rf(utra::irqarray14::EV_PENDING_SOURCE13); + irqarray14_csr.rmwf(utra::irqarray14::EV_PENDING_SOURCE13, bar); + let mut baz = irqarray14_csr.zf(utra::irqarray14::EV_PENDING_SOURCE13, bar); + baz |= irqarray14_csr.ms(utra::irqarray14::EV_PENDING_SOURCE13, 1); + irqarray14_csr.wfo(utra::irqarray14::EV_PENDING_SOURCE13, baz); + let bar = irqarray14_csr.rf(utra::irqarray14::EV_PENDING_SOURCE14); + irqarray14_csr.rmwf(utra::irqarray14::EV_PENDING_SOURCE14, bar); + let mut baz = irqarray14_csr.zf(utra::irqarray14::EV_PENDING_SOURCE14, bar); + baz |= irqarray14_csr.ms(utra::irqarray14::EV_PENDING_SOURCE14, 1); + irqarray14_csr.wfo(utra::irqarray14::EV_PENDING_SOURCE14, baz); + let bar = irqarray14_csr.rf(utra::irqarray14::EV_PENDING_SOURCE15); + irqarray14_csr.rmwf(utra::irqarray14::EV_PENDING_SOURCE15, bar); + let mut baz = irqarray14_csr.zf(utra::irqarray14::EV_PENDING_SOURCE15, bar); + baz |= irqarray14_csr.ms(utra::irqarray14::EV_PENDING_SOURCE15, 1); + irqarray14_csr.wfo(utra::irqarray14::EV_PENDING_SOURCE15, baz); + let bar = irqarray14_csr.rf(utra::irqarray14::EV_PENDING_SOURCE16); + irqarray14_csr.rmwf(utra::irqarray14::EV_PENDING_SOURCE16, bar); + let mut baz = irqarray14_csr.zf(utra::irqarray14::EV_PENDING_SOURCE16, bar); + baz |= irqarray14_csr.ms(utra::irqarray14::EV_PENDING_SOURCE16, 1); + irqarray14_csr.wfo(utra::irqarray14::EV_PENDING_SOURCE16, baz); + let bar = irqarray14_csr.rf(utra::irqarray14::EV_PENDING_SOURCE17); + irqarray14_csr.rmwf(utra::irqarray14::EV_PENDING_SOURCE17, bar); + let mut baz = irqarray14_csr.zf(utra::irqarray14::EV_PENDING_SOURCE17, bar); + baz |= irqarray14_csr.ms(utra::irqarray14::EV_PENDING_SOURCE17, 1); + irqarray14_csr.wfo(utra::irqarray14::EV_PENDING_SOURCE17, baz); + let bar = irqarray14_csr.rf(utra::irqarray14::EV_PENDING_SOURCE18); + irqarray14_csr.rmwf(utra::irqarray14::EV_PENDING_SOURCE18, bar); + let mut baz = irqarray14_csr.zf(utra::irqarray14::EV_PENDING_SOURCE18, bar); + baz |= irqarray14_csr.ms(utra::irqarray14::EV_PENDING_SOURCE18, 1); + irqarray14_csr.wfo(utra::irqarray14::EV_PENDING_SOURCE18, baz); + let bar = irqarray14_csr.rf(utra::irqarray14::EV_PENDING_SOURCE19); + irqarray14_csr.rmwf(utra::irqarray14::EV_PENDING_SOURCE19, bar); + let mut baz = irqarray14_csr.zf(utra::irqarray14::EV_PENDING_SOURCE19, bar); + baz |= irqarray14_csr.ms(utra::irqarray14::EV_PENDING_SOURCE19, 1); + irqarray14_csr.wfo(utra::irqarray14::EV_PENDING_SOURCE19, baz); + + let foo = irqarray14_csr.r(utra::irqarray14::EV_ENABLE); + irqarray14_csr.wo(utra::irqarray14::EV_ENABLE, foo); + let bar = irqarray14_csr.rf(utra::irqarray14::EV_ENABLE_SOURCE0); + irqarray14_csr.rmwf(utra::irqarray14::EV_ENABLE_SOURCE0, bar); + let mut baz = irqarray14_csr.zf(utra::irqarray14::EV_ENABLE_SOURCE0, bar); + baz |= irqarray14_csr.ms(utra::irqarray14::EV_ENABLE_SOURCE0, 1); + irqarray14_csr.wfo(utra::irqarray14::EV_ENABLE_SOURCE0, baz); + let bar = irqarray14_csr.rf(utra::irqarray14::EV_ENABLE_SOURCE1); + irqarray14_csr.rmwf(utra::irqarray14::EV_ENABLE_SOURCE1, bar); + let mut baz = irqarray14_csr.zf(utra::irqarray14::EV_ENABLE_SOURCE1, bar); + baz |= irqarray14_csr.ms(utra::irqarray14::EV_ENABLE_SOURCE1, 1); + irqarray14_csr.wfo(utra::irqarray14::EV_ENABLE_SOURCE1, baz); + let bar = irqarray14_csr.rf(utra::irqarray14::EV_ENABLE_SOURCE2); + irqarray14_csr.rmwf(utra::irqarray14::EV_ENABLE_SOURCE2, bar); + let mut baz = irqarray14_csr.zf(utra::irqarray14::EV_ENABLE_SOURCE2, bar); + baz |= irqarray14_csr.ms(utra::irqarray14::EV_ENABLE_SOURCE2, 1); + irqarray14_csr.wfo(utra::irqarray14::EV_ENABLE_SOURCE2, baz); + let bar = irqarray14_csr.rf(utra::irqarray14::EV_ENABLE_SOURCE3); + irqarray14_csr.rmwf(utra::irqarray14::EV_ENABLE_SOURCE3, bar); + let mut baz = irqarray14_csr.zf(utra::irqarray14::EV_ENABLE_SOURCE3, bar); + baz |= irqarray14_csr.ms(utra::irqarray14::EV_ENABLE_SOURCE3, 1); + irqarray14_csr.wfo(utra::irqarray14::EV_ENABLE_SOURCE3, baz); + let bar = irqarray14_csr.rf(utra::irqarray14::EV_ENABLE_SOURCE4); + irqarray14_csr.rmwf(utra::irqarray14::EV_ENABLE_SOURCE4, bar); + let mut baz = irqarray14_csr.zf(utra::irqarray14::EV_ENABLE_SOURCE4, bar); + baz |= irqarray14_csr.ms(utra::irqarray14::EV_ENABLE_SOURCE4, 1); + irqarray14_csr.wfo(utra::irqarray14::EV_ENABLE_SOURCE4, baz); + let bar = irqarray14_csr.rf(utra::irqarray14::EV_ENABLE_SOURCE5); + irqarray14_csr.rmwf(utra::irqarray14::EV_ENABLE_SOURCE5, bar); + let mut baz = irqarray14_csr.zf(utra::irqarray14::EV_ENABLE_SOURCE5, bar); + baz |= irqarray14_csr.ms(utra::irqarray14::EV_ENABLE_SOURCE5, 1); + irqarray14_csr.wfo(utra::irqarray14::EV_ENABLE_SOURCE5, baz); + let bar = irqarray14_csr.rf(utra::irqarray14::EV_ENABLE_SOURCE6); + irqarray14_csr.rmwf(utra::irqarray14::EV_ENABLE_SOURCE6, bar); + let mut baz = irqarray14_csr.zf(utra::irqarray14::EV_ENABLE_SOURCE6, bar); + baz |= irqarray14_csr.ms(utra::irqarray14::EV_ENABLE_SOURCE6, 1); + irqarray14_csr.wfo(utra::irqarray14::EV_ENABLE_SOURCE6, baz); + let bar = irqarray14_csr.rf(utra::irqarray14::EV_ENABLE_SOURCE7); + irqarray14_csr.rmwf(utra::irqarray14::EV_ENABLE_SOURCE7, bar); + let mut baz = irqarray14_csr.zf(utra::irqarray14::EV_ENABLE_SOURCE7, bar); + baz |= irqarray14_csr.ms(utra::irqarray14::EV_ENABLE_SOURCE7, 1); + irqarray14_csr.wfo(utra::irqarray14::EV_ENABLE_SOURCE7, baz); + let bar = irqarray14_csr.rf(utra::irqarray14::EV_ENABLE_SOURCE8); + irqarray14_csr.rmwf(utra::irqarray14::EV_ENABLE_SOURCE8, bar); + let mut baz = irqarray14_csr.zf(utra::irqarray14::EV_ENABLE_SOURCE8, bar); + baz |= irqarray14_csr.ms(utra::irqarray14::EV_ENABLE_SOURCE8, 1); + irqarray14_csr.wfo(utra::irqarray14::EV_ENABLE_SOURCE8, baz); + let bar = irqarray14_csr.rf(utra::irqarray14::EV_ENABLE_SOURCE9); + irqarray14_csr.rmwf(utra::irqarray14::EV_ENABLE_SOURCE9, bar); + let mut baz = irqarray14_csr.zf(utra::irqarray14::EV_ENABLE_SOURCE9, bar); + baz |= irqarray14_csr.ms(utra::irqarray14::EV_ENABLE_SOURCE9, 1); + irqarray14_csr.wfo(utra::irqarray14::EV_ENABLE_SOURCE9, baz); + let bar = irqarray14_csr.rf(utra::irqarray14::EV_ENABLE_SOURCE10); + irqarray14_csr.rmwf(utra::irqarray14::EV_ENABLE_SOURCE10, bar); + let mut baz = irqarray14_csr.zf(utra::irqarray14::EV_ENABLE_SOURCE10, bar); + baz |= irqarray14_csr.ms(utra::irqarray14::EV_ENABLE_SOURCE10, 1); + irqarray14_csr.wfo(utra::irqarray14::EV_ENABLE_SOURCE10, baz); + let bar = irqarray14_csr.rf(utra::irqarray14::EV_ENABLE_SOURCE11); + irqarray14_csr.rmwf(utra::irqarray14::EV_ENABLE_SOURCE11, bar); + let mut baz = irqarray14_csr.zf(utra::irqarray14::EV_ENABLE_SOURCE11, bar); + baz |= irqarray14_csr.ms(utra::irqarray14::EV_ENABLE_SOURCE11, 1); + irqarray14_csr.wfo(utra::irqarray14::EV_ENABLE_SOURCE11, baz); + let bar = irqarray14_csr.rf(utra::irqarray14::EV_ENABLE_SOURCE12); + irqarray14_csr.rmwf(utra::irqarray14::EV_ENABLE_SOURCE12, bar); + let mut baz = irqarray14_csr.zf(utra::irqarray14::EV_ENABLE_SOURCE12, bar); + baz |= irqarray14_csr.ms(utra::irqarray14::EV_ENABLE_SOURCE12, 1); + irqarray14_csr.wfo(utra::irqarray14::EV_ENABLE_SOURCE12, baz); + let bar = irqarray14_csr.rf(utra::irqarray14::EV_ENABLE_SOURCE13); + irqarray14_csr.rmwf(utra::irqarray14::EV_ENABLE_SOURCE13, bar); + let mut baz = irqarray14_csr.zf(utra::irqarray14::EV_ENABLE_SOURCE13, bar); + baz |= irqarray14_csr.ms(utra::irqarray14::EV_ENABLE_SOURCE13, 1); + irqarray14_csr.wfo(utra::irqarray14::EV_ENABLE_SOURCE13, baz); + let bar = irqarray14_csr.rf(utra::irqarray14::EV_ENABLE_SOURCE14); + irqarray14_csr.rmwf(utra::irqarray14::EV_ENABLE_SOURCE14, bar); + let mut baz = irqarray14_csr.zf(utra::irqarray14::EV_ENABLE_SOURCE14, bar); + baz |= irqarray14_csr.ms(utra::irqarray14::EV_ENABLE_SOURCE14, 1); + irqarray14_csr.wfo(utra::irqarray14::EV_ENABLE_SOURCE14, baz); + let bar = irqarray14_csr.rf(utra::irqarray14::EV_ENABLE_SOURCE15); + irqarray14_csr.rmwf(utra::irqarray14::EV_ENABLE_SOURCE15, bar); + let mut baz = irqarray14_csr.zf(utra::irqarray14::EV_ENABLE_SOURCE15, bar); + baz |= irqarray14_csr.ms(utra::irqarray14::EV_ENABLE_SOURCE15, 1); + irqarray14_csr.wfo(utra::irqarray14::EV_ENABLE_SOURCE15, baz); + let bar = irqarray14_csr.rf(utra::irqarray14::EV_ENABLE_SOURCE16); + irqarray14_csr.rmwf(utra::irqarray14::EV_ENABLE_SOURCE16, bar); + let mut baz = irqarray14_csr.zf(utra::irqarray14::EV_ENABLE_SOURCE16, bar); + baz |= irqarray14_csr.ms(utra::irqarray14::EV_ENABLE_SOURCE16, 1); + irqarray14_csr.wfo(utra::irqarray14::EV_ENABLE_SOURCE16, baz); + let bar = irqarray14_csr.rf(utra::irqarray14::EV_ENABLE_SOURCE17); + irqarray14_csr.rmwf(utra::irqarray14::EV_ENABLE_SOURCE17, bar); + let mut baz = irqarray14_csr.zf(utra::irqarray14::EV_ENABLE_SOURCE17, bar); + baz |= irqarray14_csr.ms(utra::irqarray14::EV_ENABLE_SOURCE17, 1); + irqarray14_csr.wfo(utra::irqarray14::EV_ENABLE_SOURCE17, baz); + let bar = irqarray14_csr.rf(utra::irqarray14::EV_ENABLE_SOURCE18); + irqarray14_csr.rmwf(utra::irqarray14::EV_ENABLE_SOURCE18, bar); + let mut baz = irqarray14_csr.zf(utra::irqarray14::EV_ENABLE_SOURCE18, bar); + baz |= irqarray14_csr.ms(utra::irqarray14::EV_ENABLE_SOURCE18, 1); + irqarray14_csr.wfo(utra::irqarray14::EV_ENABLE_SOURCE18, baz); + let bar = irqarray14_csr.rf(utra::irqarray14::EV_ENABLE_SOURCE19); + irqarray14_csr.rmwf(utra::irqarray14::EV_ENABLE_SOURCE19, bar); + let mut baz = irqarray14_csr.zf(utra::irqarray14::EV_ENABLE_SOURCE19, bar); + baz |= irqarray14_csr.ms(utra::irqarray14::EV_ENABLE_SOURCE19, 1); + irqarray14_csr.wfo(utra::irqarray14::EV_ENABLE_SOURCE19, baz); + } + + #[test] + #[ignore] + fn compile_check_irqarray15_csr() { + use super::*; + let mut irqarray15_csr = CSR::new(HW_IRQARRAY15_BASE as *mut u32); + + let foo = irqarray15_csr.r(utra::irqarray15::EV_SOFT); + irqarray15_csr.wo(utra::irqarray15::EV_SOFT, foo); + let bar = irqarray15_csr.rf(utra::irqarray15::EV_SOFT_TRIGGER); + irqarray15_csr.rmwf(utra::irqarray15::EV_SOFT_TRIGGER, bar); + let mut baz = irqarray15_csr.zf(utra::irqarray15::EV_SOFT_TRIGGER, bar); + baz |= irqarray15_csr.ms(utra::irqarray15::EV_SOFT_TRIGGER, 1); + irqarray15_csr.wfo(utra::irqarray15::EV_SOFT_TRIGGER, baz); + + let foo = irqarray15_csr.r(utra::irqarray15::EV_STATUS); + irqarray15_csr.wo(utra::irqarray15::EV_STATUS, foo); + let bar = irqarray15_csr.rf(utra::irqarray15::EV_STATUS_SOURCE0); + irqarray15_csr.rmwf(utra::irqarray15::EV_STATUS_SOURCE0, bar); + let mut baz = irqarray15_csr.zf(utra::irqarray15::EV_STATUS_SOURCE0, bar); + baz |= irqarray15_csr.ms(utra::irqarray15::EV_STATUS_SOURCE0, 1); + irqarray15_csr.wfo(utra::irqarray15::EV_STATUS_SOURCE0, baz); + let bar = irqarray15_csr.rf(utra::irqarray15::EV_STATUS_SOURCE1); + irqarray15_csr.rmwf(utra::irqarray15::EV_STATUS_SOURCE1, bar); + let mut baz = irqarray15_csr.zf(utra::irqarray15::EV_STATUS_SOURCE1, bar); + baz |= irqarray15_csr.ms(utra::irqarray15::EV_STATUS_SOURCE1, 1); + irqarray15_csr.wfo(utra::irqarray15::EV_STATUS_SOURCE1, baz); + let bar = irqarray15_csr.rf(utra::irqarray15::EV_STATUS_SOURCE2); + irqarray15_csr.rmwf(utra::irqarray15::EV_STATUS_SOURCE2, bar); + let mut baz = irqarray15_csr.zf(utra::irqarray15::EV_STATUS_SOURCE2, bar); + baz |= irqarray15_csr.ms(utra::irqarray15::EV_STATUS_SOURCE2, 1); + irqarray15_csr.wfo(utra::irqarray15::EV_STATUS_SOURCE2, baz); + let bar = irqarray15_csr.rf(utra::irqarray15::EV_STATUS_SOURCE3); + irqarray15_csr.rmwf(utra::irqarray15::EV_STATUS_SOURCE3, bar); + let mut baz = irqarray15_csr.zf(utra::irqarray15::EV_STATUS_SOURCE3, bar); + baz |= irqarray15_csr.ms(utra::irqarray15::EV_STATUS_SOURCE3, 1); + irqarray15_csr.wfo(utra::irqarray15::EV_STATUS_SOURCE3, baz); + let bar = irqarray15_csr.rf(utra::irqarray15::EV_STATUS_SOURCE4); + irqarray15_csr.rmwf(utra::irqarray15::EV_STATUS_SOURCE4, bar); + let mut baz = irqarray15_csr.zf(utra::irqarray15::EV_STATUS_SOURCE4, bar); + baz |= irqarray15_csr.ms(utra::irqarray15::EV_STATUS_SOURCE4, 1); + irqarray15_csr.wfo(utra::irqarray15::EV_STATUS_SOURCE4, baz); + let bar = irqarray15_csr.rf(utra::irqarray15::EV_STATUS_SOURCE5); + irqarray15_csr.rmwf(utra::irqarray15::EV_STATUS_SOURCE5, bar); + let mut baz = irqarray15_csr.zf(utra::irqarray15::EV_STATUS_SOURCE5, bar); + baz |= irqarray15_csr.ms(utra::irqarray15::EV_STATUS_SOURCE5, 1); + irqarray15_csr.wfo(utra::irqarray15::EV_STATUS_SOURCE5, baz); + let bar = irqarray15_csr.rf(utra::irqarray15::EV_STATUS_SOURCE6); + irqarray15_csr.rmwf(utra::irqarray15::EV_STATUS_SOURCE6, bar); + let mut baz = irqarray15_csr.zf(utra::irqarray15::EV_STATUS_SOURCE6, bar); + baz |= irqarray15_csr.ms(utra::irqarray15::EV_STATUS_SOURCE6, 1); + irqarray15_csr.wfo(utra::irqarray15::EV_STATUS_SOURCE6, baz); + let bar = irqarray15_csr.rf(utra::irqarray15::EV_STATUS_SOURCE7); + irqarray15_csr.rmwf(utra::irqarray15::EV_STATUS_SOURCE7, bar); + let mut baz = irqarray15_csr.zf(utra::irqarray15::EV_STATUS_SOURCE7, bar); + baz |= irqarray15_csr.ms(utra::irqarray15::EV_STATUS_SOURCE7, 1); + irqarray15_csr.wfo(utra::irqarray15::EV_STATUS_SOURCE7, baz); + let bar = irqarray15_csr.rf(utra::irqarray15::EV_STATUS_SOURCE8); + irqarray15_csr.rmwf(utra::irqarray15::EV_STATUS_SOURCE8, bar); + let mut baz = irqarray15_csr.zf(utra::irqarray15::EV_STATUS_SOURCE8, bar); + baz |= irqarray15_csr.ms(utra::irqarray15::EV_STATUS_SOURCE8, 1); + irqarray15_csr.wfo(utra::irqarray15::EV_STATUS_SOURCE8, baz); + let bar = irqarray15_csr.rf(utra::irqarray15::EV_STATUS_SOURCE9); + irqarray15_csr.rmwf(utra::irqarray15::EV_STATUS_SOURCE9, bar); + let mut baz = irqarray15_csr.zf(utra::irqarray15::EV_STATUS_SOURCE9, bar); + baz |= irqarray15_csr.ms(utra::irqarray15::EV_STATUS_SOURCE9, 1); + irqarray15_csr.wfo(utra::irqarray15::EV_STATUS_SOURCE9, baz); + let bar = irqarray15_csr.rf(utra::irqarray15::EV_STATUS_SOURCE10); + irqarray15_csr.rmwf(utra::irqarray15::EV_STATUS_SOURCE10, bar); + let mut baz = irqarray15_csr.zf(utra::irqarray15::EV_STATUS_SOURCE10, bar); + baz |= irqarray15_csr.ms(utra::irqarray15::EV_STATUS_SOURCE10, 1); + irqarray15_csr.wfo(utra::irqarray15::EV_STATUS_SOURCE10, baz); + let bar = irqarray15_csr.rf(utra::irqarray15::EV_STATUS_SOURCE11); + irqarray15_csr.rmwf(utra::irqarray15::EV_STATUS_SOURCE11, bar); + let mut baz = irqarray15_csr.zf(utra::irqarray15::EV_STATUS_SOURCE11, bar); + baz |= irqarray15_csr.ms(utra::irqarray15::EV_STATUS_SOURCE11, 1); + irqarray15_csr.wfo(utra::irqarray15::EV_STATUS_SOURCE11, baz); + let bar = irqarray15_csr.rf(utra::irqarray15::EV_STATUS_SOURCE12); + irqarray15_csr.rmwf(utra::irqarray15::EV_STATUS_SOURCE12, bar); + let mut baz = irqarray15_csr.zf(utra::irqarray15::EV_STATUS_SOURCE12, bar); + baz |= irqarray15_csr.ms(utra::irqarray15::EV_STATUS_SOURCE12, 1); + irqarray15_csr.wfo(utra::irqarray15::EV_STATUS_SOURCE12, baz); + let bar = irqarray15_csr.rf(utra::irqarray15::EV_STATUS_SOURCE13); + irqarray15_csr.rmwf(utra::irqarray15::EV_STATUS_SOURCE13, bar); + let mut baz = irqarray15_csr.zf(utra::irqarray15::EV_STATUS_SOURCE13, bar); + baz |= irqarray15_csr.ms(utra::irqarray15::EV_STATUS_SOURCE13, 1); + irqarray15_csr.wfo(utra::irqarray15::EV_STATUS_SOURCE13, baz); + let bar = irqarray15_csr.rf(utra::irqarray15::EV_STATUS_SOURCE14); + irqarray15_csr.rmwf(utra::irqarray15::EV_STATUS_SOURCE14, bar); + let mut baz = irqarray15_csr.zf(utra::irqarray15::EV_STATUS_SOURCE14, bar); + baz |= irqarray15_csr.ms(utra::irqarray15::EV_STATUS_SOURCE14, 1); + irqarray15_csr.wfo(utra::irqarray15::EV_STATUS_SOURCE14, baz); + let bar = irqarray15_csr.rf(utra::irqarray15::EV_STATUS_SOURCE15); + irqarray15_csr.rmwf(utra::irqarray15::EV_STATUS_SOURCE15, bar); + let mut baz = irqarray15_csr.zf(utra::irqarray15::EV_STATUS_SOURCE15, bar); + baz |= irqarray15_csr.ms(utra::irqarray15::EV_STATUS_SOURCE15, 1); + irqarray15_csr.wfo(utra::irqarray15::EV_STATUS_SOURCE15, baz); + let bar = irqarray15_csr.rf(utra::irqarray15::EV_STATUS_SOURCE16); + irqarray15_csr.rmwf(utra::irqarray15::EV_STATUS_SOURCE16, bar); + let mut baz = irqarray15_csr.zf(utra::irqarray15::EV_STATUS_SOURCE16, bar); + baz |= irqarray15_csr.ms(utra::irqarray15::EV_STATUS_SOURCE16, 1); + irqarray15_csr.wfo(utra::irqarray15::EV_STATUS_SOURCE16, baz); + let bar = irqarray15_csr.rf(utra::irqarray15::EV_STATUS_SOURCE17); + irqarray15_csr.rmwf(utra::irqarray15::EV_STATUS_SOURCE17, bar); + let mut baz = irqarray15_csr.zf(utra::irqarray15::EV_STATUS_SOURCE17, bar); + baz |= irqarray15_csr.ms(utra::irqarray15::EV_STATUS_SOURCE17, 1); + irqarray15_csr.wfo(utra::irqarray15::EV_STATUS_SOURCE17, baz); + let bar = irqarray15_csr.rf(utra::irqarray15::EV_STATUS_SOURCE18); + irqarray15_csr.rmwf(utra::irqarray15::EV_STATUS_SOURCE18, bar); + let mut baz = irqarray15_csr.zf(utra::irqarray15::EV_STATUS_SOURCE18, bar); + baz |= irqarray15_csr.ms(utra::irqarray15::EV_STATUS_SOURCE18, 1); + irqarray15_csr.wfo(utra::irqarray15::EV_STATUS_SOURCE18, baz); + let bar = irqarray15_csr.rf(utra::irqarray15::EV_STATUS_SOURCE19); + irqarray15_csr.rmwf(utra::irqarray15::EV_STATUS_SOURCE19, bar); + let mut baz = irqarray15_csr.zf(utra::irqarray15::EV_STATUS_SOURCE19, bar); + baz |= irqarray15_csr.ms(utra::irqarray15::EV_STATUS_SOURCE19, 1); + irqarray15_csr.wfo(utra::irqarray15::EV_STATUS_SOURCE19, baz); + + let foo = irqarray15_csr.r(utra::irqarray15::EV_PENDING); + irqarray15_csr.wo(utra::irqarray15::EV_PENDING, foo); + let bar = irqarray15_csr.rf(utra::irqarray15::EV_PENDING_SOURCE0); + irqarray15_csr.rmwf(utra::irqarray15::EV_PENDING_SOURCE0, bar); + let mut baz = irqarray15_csr.zf(utra::irqarray15::EV_PENDING_SOURCE0, bar); + baz |= irqarray15_csr.ms(utra::irqarray15::EV_PENDING_SOURCE0, 1); + irqarray15_csr.wfo(utra::irqarray15::EV_PENDING_SOURCE0, baz); + let bar = irqarray15_csr.rf(utra::irqarray15::EV_PENDING_SOURCE1); + irqarray15_csr.rmwf(utra::irqarray15::EV_PENDING_SOURCE1, bar); + let mut baz = irqarray15_csr.zf(utra::irqarray15::EV_PENDING_SOURCE1, bar); + baz |= irqarray15_csr.ms(utra::irqarray15::EV_PENDING_SOURCE1, 1); + irqarray15_csr.wfo(utra::irqarray15::EV_PENDING_SOURCE1, baz); + let bar = irqarray15_csr.rf(utra::irqarray15::EV_PENDING_SOURCE2); + irqarray15_csr.rmwf(utra::irqarray15::EV_PENDING_SOURCE2, bar); + let mut baz = irqarray15_csr.zf(utra::irqarray15::EV_PENDING_SOURCE2, bar); + baz |= irqarray15_csr.ms(utra::irqarray15::EV_PENDING_SOURCE2, 1); + irqarray15_csr.wfo(utra::irqarray15::EV_PENDING_SOURCE2, baz); + let bar = irqarray15_csr.rf(utra::irqarray15::EV_PENDING_SOURCE3); + irqarray15_csr.rmwf(utra::irqarray15::EV_PENDING_SOURCE3, bar); + let mut baz = irqarray15_csr.zf(utra::irqarray15::EV_PENDING_SOURCE3, bar); + baz |= irqarray15_csr.ms(utra::irqarray15::EV_PENDING_SOURCE3, 1); + irqarray15_csr.wfo(utra::irqarray15::EV_PENDING_SOURCE3, baz); + let bar = irqarray15_csr.rf(utra::irqarray15::EV_PENDING_SOURCE4); + irqarray15_csr.rmwf(utra::irqarray15::EV_PENDING_SOURCE4, bar); + let mut baz = irqarray15_csr.zf(utra::irqarray15::EV_PENDING_SOURCE4, bar); + baz |= irqarray15_csr.ms(utra::irqarray15::EV_PENDING_SOURCE4, 1); + irqarray15_csr.wfo(utra::irqarray15::EV_PENDING_SOURCE4, baz); + let bar = irqarray15_csr.rf(utra::irqarray15::EV_PENDING_SOURCE5); + irqarray15_csr.rmwf(utra::irqarray15::EV_PENDING_SOURCE5, bar); + let mut baz = irqarray15_csr.zf(utra::irqarray15::EV_PENDING_SOURCE5, bar); + baz |= irqarray15_csr.ms(utra::irqarray15::EV_PENDING_SOURCE5, 1); + irqarray15_csr.wfo(utra::irqarray15::EV_PENDING_SOURCE5, baz); + let bar = irqarray15_csr.rf(utra::irqarray15::EV_PENDING_SOURCE6); + irqarray15_csr.rmwf(utra::irqarray15::EV_PENDING_SOURCE6, bar); + let mut baz = irqarray15_csr.zf(utra::irqarray15::EV_PENDING_SOURCE6, bar); + baz |= irqarray15_csr.ms(utra::irqarray15::EV_PENDING_SOURCE6, 1); + irqarray15_csr.wfo(utra::irqarray15::EV_PENDING_SOURCE6, baz); + let bar = irqarray15_csr.rf(utra::irqarray15::EV_PENDING_SOURCE7); + irqarray15_csr.rmwf(utra::irqarray15::EV_PENDING_SOURCE7, bar); + let mut baz = irqarray15_csr.zf(utra::irqarray15::EV_PENDING_SOURCE7, bar); + baz |= irqarray15_csr.ms(utra::irqarray15::EV_PENDING_SOURCE7, 1); + irqarray15_csr.wfo(utra::irqarray15::EV_PENDING_SOURCE7, baz); + let bar = irqarray15_csr.rf(utra::irqarray15::EV_PENDING_SOURCE8); + irqarray15_csr.rmwf(utra::irqarray15::EV_PENDING_SOURCE8, bar); + let mut baz = irqarray15_csr.zf(utra::irqarray15::EV_PENDING_SOURCE8, bar); + baz |= irqarray15_csr.ms(utra::irqarray15::EV_PENDING_SOURCE8, 1); + irqarray15_csr.wfo(utra::irqarray15::EV_PENDING_SOURCE8, baz); + let bar = irqarray15_csr.rf(utra::irqarray15::EV_PENDING_SOURCE9); + irqarray15_csr.rmwf(utra::irqarray15::EV_PENDING_SOURCE9, bar); + let mut baz = irqarray15_csr.zf(utra::irqarray15::EV_PENDING_SOURCE9, bar); + baz |= irqarray15_csr.ms(utra::irqarray15::EV_PENDING_SOURCE9, 1); + irqarray15_csr.wfo(utra::irqarray15::EV_PENDING_SOURCE9, baz); + let bar = irqarray15_csr.rf(utra::irqarray15::EV_PENDING_SOURCE10); + irqarray15_csr.rmwf(utra::irqarray15::EV_PENDING_SOURCE10, bar); + let mut baz = irqarray15_csr.zf(utra::irqarray15::EV_PENDING_SOURCE10, bar); + baz |= irqarray15_csr.ms(utra::irqarray15::EV_PENDING_SOURCE10, 1); + irqarray15_csr.wfo(utra::irqarray15::EV_PENDING_SOURCE10, baz); + let bar = irqarray15_csr.rf(utra::irqarray15::EV_PENDING_SOURCE11); + irqarray15_csr.rmwf(utra::irqarray15::EV_PENDING_SOURCE11, bar); + let mut baz = irqarray15_csr.zf(utra::irqarray15::EV_PENDING_SOURCE11, bar); + baz |= irqarray15_csr.ms(utra::irqarray15::EV_PENDING_SOURCE11, 1); + irqarray15_csr.wfo(utra::irqarray15::EV_PENDING_SOURCE11, baz); + let bar = irqarray15_csr.rf(utra::irqarray15::EV_PENDING_SOURCE12); + irqarray15_csr.rmwf(utra::irqarray15::EV_PENDING_SOURCE12, bar); + let mut baz = irqarray15_csr.zf(utra::irqarray15::EV_PENDING_SOURCE12, bar); + baz |= irqarray15_csr.ms(utra::irqarray15::EV_PENDING_SOURCE12, 1); + irqarray15_csr.wfo(utra::irqarray15::EV_PENDING_SOURCE12, baz); + let bar = irqarray15_csr.rf(utra::irqarray15::EV_PENDING_SOURCE13); + irqarray15_csr.rmwf(utra::irqarray15::EV_PENDING_SOURCE13, bar); + let mut baz = irqarray15_csr.zf(utra::irqarray15::EV_PENDING_SOURCE13, bar); + baz |= irqarray15_csr.ms(utra::irqarray15::EV_PENDING_SOURCE13, 1); + irqarray15_csr.wfo(utra::irqarray15::EV_PENDING_SOURCE13, baz); + let bar = irqarray15_csr.rf(utra::irqarray15::EV_PENDING_SOURCE14); + irqarray15_csr.rmwf(utra::irqarray15::EV_PENDING_SOURCE14, bar); + let mut baz = irqarray15_csr.zf(utra::irqarray15::EV_PENDING_SOURCE14, bar); + baz |= irqarray15_csr.ms(utra::irqarray15::EV_PENDING_SOURCE14, 1); + irqarray15_csr.wfo(utra::irqarray15::EV_PENDING_SOURCE14, baz); + let bar = irqarray15_csr.rf(utra::irqarray15::EV_PENDING_SOURCE15); + irqarray15_csr.rmwf(utra::irqarray15::EV_PENDING_SOURCE15, bar); + let mut baz = irqarray15_csr.zf(utra::irqarray15::EV_PENDING_SOURCE15, bar); + baz |= irqarray15_csr.ms(utra::irqarray15::EV_PENDING_SOURCE15, 1); + irqarray15_csr.wfo(utra::irqarray15::EV_PENDING_SOURCE15, baz); + let bar = irqarray15_csr.rf(utra::irqarray15::EV_PENDING_SOURCE16); + irqarray15_csr.rmwf(utra::irqarray15::EV_PENDING_SOURCE16, bar); + let mut baz = irqarray15_csr.zf(utra::irqarray15::EV_PENDING_SOURCE16, bar); + baz |= irqarray15_csr.ms(utra::irqarray15::EV_PENDING_SOURCE16, 1); + irqarray15_csr.wfo(utra::irqarray15::EV_PENDING_SOURCE16, baz); + let bar = irqarray15_csr.rf(utra::irqarray15::EV_PENDING_SOURCE17); + irqarray15_csr.rmwf(utra::irqarray15::EV_PENDING_SOURCE17, bar); + let mut baz = irqarray15_csr.zf(utra::irqarray15::EV_PENDING_SOURCE17, bar); + baz |= irqarray15_csr.ms(utra::irqarray15::EV_PENDING_SOURCE17, 1); + irqarray15_csr.wfo(utra::irqarray15::EV_PENDING_SOURCE17, baz); + let bar = irqarray15_csr.rf(utra::irqarray15::EV_PENDING_SOURCE18); + irqarray15_csr.rmwf(utra::irqarray15::EV_PENDING_SOURCE18, bar); + let mut baz = irqarray15_csr.zf(utra::irqarray15::EV_PENDING_SOURCE18, bar); + baz |= irqarray15_csr.ms(utra::irqarray15::EV_PENDING_SOURCE18, 1); + irqarray15_csr.wfo(utra::irqarray15::EV_PENDING_SOURCE18, baz); + let bar = irqarray15_csr.rf(utra::irqarray15::EV_PENDING_SOURCE19); + irqarray15_csr.rmwf(utra::irqarray15::EV_PENDING_SOURCE19, bar); + let mut baz = irqarray15_csr.zf(utra::irqarray15::EV_PENDING_SOURCE19, bar); + baz |= irqarray15_csr.ms(utra::irqarray15::EV_PENDING_SOURCE19, 1); + irqarray15_csr.wfo(utra::irqarray15::EV_PENDING_SOURCE19, baz); + + let foo = irqarray15_csr.r(utra::irqarray15::EV_ENABLE); + irqarray15_csr.wo(utra::irqarray15::EV_ENABLE, foo); + let bar = irqarray15_csr.rf(utra::irqarray15::EV_ENABLE_SOURCE0); + irqarray15_csr.rmwf(utra::irqarray15::EV_ENABLE_SOURCE0, bar); + let mut baz = irqarray15_csr.zf(utra::irqarray15::EV_ENABLE_SOURCE0, bar); + baz |= irqarray15_csr.ms(utra::irqarray15::EV_ENABLE_SOURCE0, 1); + irqarray15_csr.wfo(utra::irqarray15::EV_ENABLE_SOURCE0, baz); + let bar = irqarray15_csr.rf(utra::irqarray15::EV_ENABLE_SOURCE1); + irqarray15_csr.rmwf(utra::irqarray15::EV_ENABLE_SOURCE1, bar); + let mut baz = irqarray15_csr.zf(utra::irqarray15::EV_ENABLE_SOURCE1, bar); + baz |= irqarray15_csr.ms(utra::irqarray15::EV_ENABLE_SOURCE1, 1); + irqarray15_csr.wfo(utra::irqarray15::EV_ENABLE_SOURCE1, baz); + let bar = irqarray15_csr.rf(utra::irqarray15::EV_ENABLE_SOURCE2); + irqarray15_csr.rmwf(utra::irqarray15::EV_ENABLE_SOURCE2, bar); + let mut baz = irqarray15_csr.zf(utra::irqarray15::EV_ENABLE_SOURCE2, bar); + baz |= irqarray15_csr.ms(utra::irqarray15::EV_ENABLE_SOURCE2, 1); + irqarray15_csr.wfo(utra::irqarray15::EV_ENABLE_SOURCE2, baz); + let bar = irqarray15_csr.rf(utra::irqarray15::EV_ENABLE_SOURCE3); + irqarray15_csr.rmwf(utra::irqarray15::EV_ENABLE_SOURCE3, bar); + let mut baz = irqarray15_csr.zf(utra::irqarray15::EV_ENABLE_SOURCE3, bar); + baz |= irqarray15_csr.ms(utra::irqarray15::EV_ENABLE_SOURCE3, 1); + irqarray15_csr.wfo(utra::irqarray15::EV_ENABLE_SOURCE3, baz); + let bar = irqarray15_csr.rf(utra::irqarray15::EV_ENABLE_SOURCE4); + irqarray15_csr.rmwf(utra::irqarray15::EV_ENABLE_SOURCE4, bar); + let mut baz = irqarray15_csr.zf(utra::irqarray15::EV_ENABLE_SOURCE4, bar); + baz |= irqarray15_csr.ms(utra::irqarray15::EV_ENABLE_SOURCE4, 1); + irqarray15_csr.wfo(utra::irqarray15::EV_ENABLE_SOURCE4, baz); + let bar = irqarray15_csr.rf(utra::irqarray15::EV_ENABLE_SOURCE5); + irqarray15_csr.rmwf(utra::irqarray15::EV_ENABLE_SOURCE5, bar); + let mut baz = irqarray15_csr.zf(utra::irqarray15::EV_ENABLE_SOURCE5, bar); + baz |= irqarray15_csr.ms(utra::irqarray15::EV_ENABLE_SOURCE5, 1); + irqarray15_csr.wfo(utra::irqarray15::EV_ENABLE_SOURCE5, baz); + let bar = irqarray15_csr.rf(utra::irqarray15::EV_ENABLE_SOURCE6); + irqarray15_csr.rmwf(utra::irqarray15::EV_ENABLE_SOURCE6, bar); + let mut baz = irqarray15_csr.zf(utra::irqarray15::EV_ENABLE_SOURCE6, bar); + baz |= irqarray15_csr.ms(utra::irqarray15::EV_ENABLE_SOURCE6, 1); + irqarray15_csr.wfo(utra::irqarray15::EV_ENABLE_SOURCE6, baz); + let bar = irqarray15_csr.rf(utra::irqarray15::EV_ENABLE_SOURCE7); + irqarray15_csr.rmwf(utra::irqarray15::EV_ENABLE_SOURCE7, bar); + let mut baz = irqarray15_csr.zf(utra::irqarray15::EV_ENABLE_SOURCE7, bar); + baz |= irqarray15_csr.ms(utra::irqarray15::EV_ENABLE_SOURCE7, 1); + irqarray15_csr.wfo(utra::irqarray15::EV_ENABLE_SOURCE7, baz); + let bar = irqarray15_csr.rf(utra::irqarray15::EV_ENABLE_SOURCE8); + irqarray15_csr.rmwf(utra::irqarray15::EV_ENABLE_SOURCE8, bar); + let mut baz = irqarray15_csr.zf(utra::irqarray15::EV_ENABLE_SOURCE8, bar); + baz |= irqarray15_csr.ms(utra::irqarray15::EV_ENABLE_SOURCE8, 1); + irqarray15_csr.wfo(utra::irqarray15::EV_ENABLE_SOURCE8, baz); + let bar = irqarray15_csr.rf(utra::irqarray15::EV_ENABLE_SOURCE9); + irqarray15_csr.rmwf(utra::irqarray15::EV_ENABLE_SOURCE9, bar); + let mut baz = irqarray15_csr.zf(utra::irqarray15::EV_ENABLE_SOURCE9, bar); + baz |= irqarray15_csr.ms(utra::irqarray15::EV_ENABLE_SOURCE9, 1); + irqarray15_csr.wfo(utra::irqarray15::EV_ENABLE_SOURCE9, baz); + let bar = irqarray15_csr.rf(utra::irqarray15::EV_ENABLE_SOURCE10); + irqarray15_csr.rmwf(utra::irqarray15::EV_ENABLE_SOURCE10, bar); + let mut baz = irqarray15_csr.zf(utra::irqarray15::EV_ENABLE_SOURCE10, bar); + baz |= irqarray15_csr.ms(utra::irqarray15::EV_ENABLE_SOURCE10, 1); + irqarray15_csr.wfo(utra::irqarray15::EV_ENABLE_SOURCE10, baz); + let bar = irqarray15_csr.rf(utra::irqarray15::EV_ENABLE_SOURCE11); + irqarray15_csr.rmwf(utra::irqarray15::EV_ENABLE_SOURCE11, bar); + let mut baz = irqarray15_csr.zf(utra::irqarray15::EV_ENABLE_SOURCE11, bar); + baz |= irqarray15_csr.ms(utra::irqarray15::EV_ENABLE_SOURCE11, 1); + irqarray15_csr.wfo(utra::irqarray15::EV_ENABLE_SOURCE11, baz); + let bar = irqarray15_csr.rf(utra::irqarray15::EV_ENABLE_SOURCE12); + irqarray15_csr.rmwf(utra::irqarray15::EV_ENABLE_SOURCE12, bar); + let mut baz = irqarray15_csr.zf(utra::irqarray15::EV_ENABLE_SOURCE12, bar); + baz |= irqarray15_csr.ms(utra::irqarray15::EV_ENABLE_SOURCE12, 1); + irqarray15_csr.wfo(utra::irqarray15::EV_ENABLE_SOURCE12, baz); + let bar = irqarray15_csr.rf(utra::irqarray15::EV_ENABLE_SOURCE13); + irqarray15_csr.rmwf(utra::irqarray15::EV_ENABLE_SOURCE13, bar); + let mut baz = irqarray15_csr.zf(utra::irqarray15::EV_ENABLE_SOURCE13, bar); + baz |= irqarray15_csr.ms(utra::irqarray15::EV_ENABLE_SOURCE13, 1); + irqarray15_csr.wfo(utra::irqarray15::EV_ENABLE_SOURCE13, baz); + let bar = irqarray15_csr.rf(utra::irqarray15::EV_ENABLE_SOURCE14); + irqarray15_csr.rmwf(utra::irqarray15::EV_ENABLE_SOURCE14, bar); + let mut baz = irqarray15_csr.zf(utra::irqarray15::EV_ENABLE_SOURCE14, bar); + baz |= irqarray15_csr.ms(utra::irqarray15::EV_ENABLE_SOURCE14, 1); + irqarray15_csr.wfo(utra::irqarray15::EV_ENABLE_SOURCE14, baz); + let bar = irqarray15_csr.rf(utra::irqarray15::EV_ENABLE_SOURCE15); + irqarray15_csr.rmwf(utra::irqarray15::EV_ENABLE_SOURCE15, bar); + let mut baz = irqarray15_csr.zf(utra::irqarray15::EV_ENABLE_SOURCE15, bar); + baz |= irqarray15_csr.ms(utra::irqarray15::EV_ENABLE_SOURCE15, 1); + irqarray15_csr.wfo(utra::irqarray15::EV_ENABLE_SOURCE15, baz); + let bar = irqarray15_csr.rf(utra::irqarray15::EV_ENABLE_SOURCE16); + irqarray15_csr.rmwf(utra::irqarray15::EV_ENABLE_SOURCE16, bar); + let mut baz = irqarray15_csr.zf(utra::irqarray15::EV_ENABLE_SOURCE16, bar); + baz |= irqarray15_csr.ms(utra::irqarray15::EV_ENABLE_SOURCE16, 1); + irqarray15_csr.wfo(utra::irqarray15::EV_ENABLE_SOURCE16, baz); + let bar = irqarray15_csr.rf(utra::irqarray15::EV_ENABLE_SOURCE17); + irqarray15_csr.rmwf(utra::irqarray15::EV_ENABLE_SOURCE17, bar); + let mut baz = irqarray15_csr.zf(utra::irqarray15::EV_ENABLE_SOURCE17, bar); + baz |= irqarray15_csr.ms(utra::irqarray15::EV_ENABLE_SOURCE17, 1); + irqarray15_csr.wfo(utra::irqarray15::EV_ENABLE_SOURCE17, baz); + let bar = irqarray15_csr.rf(utra::irqarray15::EV_ENABLE_SOURCE18); + irqarray15_csr.rmwf(utra::irqarray15::EV_ENABLE_SOURCE18, bar); + let mut baz = irqarray15_csr.zf(utra::irqarray15::EV_ENABLE_SOURCE18, bar); + baz |= irqarray15_csr.ms(utra::irqarray15::EV_ENABLE_SOURCE18, 1); + irqarray15_csr.wfo(utra::irqarray15::EV_ENABLE_SOURCE18, baz); + let bar = irqarray15_csr.rf(utra::irqarray15::EV_ENABLE_SOURCE19); + irqarray15_csr.rmwf(utra::irqarray15::EV_ENABLE_SOURCE19, bar); + let mut baz = irqarray15_csr.zf(utra::irqarray15::EV_ENABLE_SOURCE19, bar); + baz |= irqarray15_csr.ms(utra::irqarray15::EV_ENABLE_SOURCE19, 1); + irqarray15_csr.wfo(utra::irqarray15::EV_ENABLE_SOURCE19, baz); + } + + #[test] + #[ignore] + fn compile_check_irqarray16_csr() { + use super::*; + let mut irqarray16_csr = CSR::new(HW_IRQARRAY16_BASE as *mut u32); + + let foo = irqarray16_csr.r(utra::irqarray16::EV_SOFT); + irqarray16_csr.wo(utra::irqarray16::EV_SOFT, foo); + let bar = irqarray16_csr.rf(utra::irqarray16::EV_SOFT_TRIGGER); + irqarray16_csr.rmwf(utra::irqarray16::EV_SOFT_TRIGGER, bar); + let mut baz = irqarray16_csr.zf(utra::irqarray16::EV_SOFT_TRIGGER, bar); + baz |= irqarray16_csr.ms(utra::irqarray16::EV_SOFT_TRIGGER, 1); + irqarray16_csr.wfo(utra::irqarray16::EV_SOFT_TRIGGER, baz); + + let foo = irqarray16_csr.r(utra::irqarray16::EV_STATUS); + irqarray16_csr.wo(utra::irqarray16::EV_STATUS, foo); + let bar = irqarray16_csr.rf(utra::irqarray16::EV_STATUS_SOURCE0); + irqarray16_csr.rmwf(utra::irqarray16::EV_STATUS_SOURCE0, bar); + let mut baz = irqarray16_csr.zf(utra::irqarray16::EV_STATUS_SOURCE0, bar); + baz |= irqarray16_csr.ms(utra::irqarray16::EV_STATUS_SOURCE0, 1); + irqarray16_csr.wfo(utra::irqarray16::EV_STATUS_SOURCE0, baz); + let bar = irqarray16_csr.rf(utra::irqarray16::EV_STATUS_SOURCE1); + irqarray16_csr.rmwf(utra::irqarray16::EV_STATUS_SOURCE1, bar); + let mut baz = irqarray16_csr.zf(utra::irqarray16::EV_STATUS_SOURCE1, bar); + baz |= irqarray16_csr.ms(utra::irqarray16::EV_STATUS_SOURCE1, 1); + irqarray16_csr.wfo(utra::irqarray16::EV_STATUS_SOURCE1, baz); + let bar = irqarray16_csr.rf(utra::irqarray16::EV_STATUS_SOURCE2); + irqarray16_csr.rmwf(utra::irqarray16::EV_STATUS_SOURCE2, bar); + let mut baz = irqarray16_csr.zf(utra::irqarray16::EV_STATUS_SOURCE2, bar); + baz |= irqarray16_csr.ms(utra::irqarray16::EV_STATUS_SOURCE2, 1); + irqarray16_csr.wfo(utra::irqarray16::EV_STATUS_SOURCE2, baz); + let bar = irqarray16_csr.rf(utra::irqarray16::EV_STATUS_SOURCE3); + irqarray16_csr.rmwf(utra::irqarray16::EV_STATUS_SOURCE3, bar); + let mut baz = irqarray16_csr.zf(utra::irqarray16::EV_STATUS_SOURCE3, bar); + baz |= irqarray16_csr.ms(utra::irqarray16::EV_STATUS_SOURCE3, 1); + irqarray16_csr.wfo(utra::irqarray16::EV_STATUS_SOURCE3, baz); + let bar = irqarray16_csr.rf(utra::irqarray16::EV_STATUS_SOURCE4); + irqarray16_csr.rmwf(utra::irqarray16::EV_STATUS_SOURCE4, bar); + let mut baz = irqarray16_csr.zf(utra::irqarray16::EV_STATUS_SOURCE4, bar); + baz |= irqarray16_csr.ms(utra::irqarray16::EV_STATUS_SOURCE4, 1); + irqarray16_csr.wfo(utra::irqarray16::EV_STATUS_SOURCE4, baz); + let bar = irqarray16_csr.rf(utra::irqarray16::EV_STATUS_SOURCE5); + irqarray16_csr.rmwf(utra::irqarray16::EV_STATUS_SOURCE5, bar); + let mut baz = irqarray16_csr.zf(utra::irqarray16::EV_STATUS_SOURCE5, bar); + baz |= irqarray16_csr.ms(utra::irqarray16::EV_STATUS_SOURCE5, 1); + irqarray16_csr.wfo(utra::irqarray16::EV_STATUS_SOURCE5, baz); + let bar = irqarray16_csr.rf(utra::irqarray16::EV_STATUS_SOURCE6); + irqarray16_csr.rmwf(utra::irqarray16::EV_STATUS_SOURCE6, bar); + let mut baz = irqarray16_csr.zf(utra::irqarray16::EV_STATUS_SOURCE6, bar); + baz |= irqarray16_csr.ms(utra::irqarray16::EV_STATUS_SOURCE6, 1); + irqarray16_csr.wfo(utra::irqarray16::EV_STATUS_SOURCE6, baz); + let bar = irqarray16_csr.rf(utra::irqarray16::EV_STATUS_SOURCE7); + irqarray16_csr.rmwf(utra::irqarray16::EV_STATUS_SOURCE7, bar); + let mut baz = irqarray16_csr.zf(utra::irqarray16::EV_STATUS_SOURCE7, bar); + baz |= irqarray16_csr.ms(utra::irqarray16::EV_STATUS_SOURCE7, 1); + irqarray16_csr.wfo(utra::irqarray16::EV_STATUS_SOURCE7, baz); + let bar = irqarray16_csr.rf(utra::irqarray16::EV_STATUS_SOURCE8); + irqarray16_csr.rmwf(utra::irqarray16::EV_STATUS_SOURCE8, bar); + let mut baz = irqarray16_csr.zf(utra::irqarray16::EV_STATUS_SOURCE8, bar); + baz |= irqarray16_csr.ms(utra::irqarray16::EV_STATUS_SOURCE8, 1); + irqarray16_csr.wfo(utra::irqarray16::EV_STATUS_SOURCE8, baz); + let bar = irqarray16_csr.rf(utra::irqarray16::EV_STATUS_SOURCE9); + irqarray16_csr.rmwf(utra::irqarray16::EV_STATUS_SOURCE9, bar); + let mut baz = irqarray16_csr.zf(utra::irqarray16::EV_STATUS_SOURCE9, bar); + baz |= irqarray16_csr.ms(utra::irqarray16::EV_STATUS_SOURCE9, 1); + irqarray16_csr.wfo(utra::irqarray16::EV_STATUS_SOURCE9, baz); + let bar = irqarray16_csr.rf(utra::irqarray16::EV_STATUS_SOURCE10); + irqarray16_csr.rmwf(utra::irqarray16::EV_STATUS_SOURCE10, bar); + let mut baz = irqarray16_csr.zf(utra::irqarray16::EV_STATUS_SOURCE10, bar); + baz |= irqarray16_csr.ms(utra::irqarray16::EV_STATUS_SOURCE10, 1); + irqarray16_csr.wfo(utra::irqarray16::EV_STATUS_SOURCE10, baz); + let bar = irqarray16_csr.rf(utra::irqarray16::EV_STATUS_SOURCE11); + irqarray16_csr.rmwf(utra::irqarray16::EV_STATUS_SOURCE11, bar); + let mut baz = irqarray16_csr.zf(utra::irqarray16::EV_STATUS_SOURCE11, bar); + baz |= irqarray16_csr.ms(utra::irqarray16::EV_STATUS_SOURCE11, 1); + irqarray16_csr.wfo(utra::irqarray16::EV_STATUS_SOURCE11, baz); + let bar = irqarray16_csr.rf(utra::irqarray16::EV_STATUS_SOURCE12); + irqarray16_csr.rmwf(utra::irqarray16::EV_STATUS_SOURCE12, bar); + let mut baz = irqarray16_csr.zf(utra::irqarray16::EV_STATUS_SOURCE12, bar); + baz |= irqarray16_csr.ms(utra::irqarray16::EV_STATUS_SOURCE12, 1); + irqarray16_csr.wfo(utra::irqarray16::EV_STATUS_SOURCE12, baz); + let bar = irqarray16_csr.rf(utra::irqarray16::EV_STATUS_SOURCE13); + irqarray16_csr.rmwf(utra::irqarray16::EV_STATUS_SOURCE13, bar); + let mut baz = irqarray16_csr.zf(utra::irqarray16::EV_STATUS_SOURCE13, bar); + baz |= irqarray16_csr.ms(utra::irqarray16::EV_STATUS_SOURCE13, 1); + irqarray16_csr.wfo(utra::irqarray16::EV_STATUS_SOURCE13, baz); + let bar = irqarray16_csr.rf(utra::irqarray16::EV_STATUS_SOURCE14); + irqarray16_csr.rmwf(utra::irqarray16::EV_STATUS_SOURCE14, bar); + let mut baz = irqarray16_csr.zf(utra::irqarray16::EV_STATUS_SOURCE14, bar); + baz |= irqarray16_csr.ms(utra::irqarray16::EV_STATUS_SOURCE14, 1); + irqarray16_csr.wfo(utra::irqarray16::EV_STATUS_SOURCE14, baz); + let bar = irqarray16_csr.rf(utra::irqarray16::EV_STATUS_SOURCE15); + irqarray16_csr.rmwf(utra::irqarray16::EV_STATUS_SOURCE15, bar); + let mut baz = irqarray16_csr.zf(utra::irqarray16::EV_STATUS_SOURCE15, bar); + baz |= irqarray16_csr.ms(utra::irqarray16::EV_STATUS_SOURCE15, 1); + irqarray16_csr.wfo(utra::irqarray16::EV_STATUS_SOURCE15, baz); + let bar = irqarray16_csr.rf(utra::irqarray16::EV_STATUS_SOURCE16); + irqarray16_csr.rmwf(utra::irqarray16::EV_STATUS_SOURCE16, bar); + let mut baz = irqarray16_csr.zf(utra::irqarray16::EV_STATUS_SOURCE16, bar); + baz |= irqarray16_csr.ms(utra::irqarray16::EV_STATUS_SOURCE16, 1); + irqarray16_csr.wfo(utra::irqarray16::EV_STATUS_SOURCE16, baz); + let bar = irqarray16_csr.rf(utra::irqarray16::EV_STATUS_SOURCE17); + irqarray16_csr.rmwf(utra::irqarray16::EV_STATUS_SOURCE17, bar); + let mut baz = irqarray16_csr.zf(utra::irqarray16::EV_STATUS_SOURCE17, bar); + baz |= irqarray16_csr.ms(utra::irqarray16::EV_STATUS_SOURCE17, 1); + irqarray16_csr.wfo(utra::irqarray16::EV_STATUS_SOURCE17, baz); + let bar = irqarray16_csr.rf(utra::irqarray16::EV_STATUS_SOURCE18); + irqarray16_csr.rmwf(utra::irqarray16::EV_STATUS_SOURCE18, bar); + let mut baz = irqarray16_csr.zf(utra::irqarray16::EV_STATUS_SOURCE18, bar); + baz |= irqarray16_csr.ms(utra::irqarray16::EV_STATUS_SOURCE18, 1); + irqarray16_csr.wfo(utra::irqarray16::EV_STATUS_SOURCE18, baz); + let bar = irqarray16_csr.rf(utra::irqarray16::EV_STATUS_SOURCE19); + irqarray16_csr.rmwf(utra::irqarray16::EV_STATUS_SOURCE19, bar); + let mut baz = irqarray16_csr.zf(utra::irqarray16::EV_STATUS_SOURCE19, bar); + baz |= irqarray16_csr.ms(utra::irqarray16::EV_STATUS_SOURCE19, 1); + irqarray16_csr.wfo(utra::irqarray16::EV_STATUS_SOURCE19, baz); + + let foo = irqarray16_csr.r(utra::irqarray16::EV_PENDING); + irqarray16_csr.wo(utra::irqarray16::EV_PENDING, foo); + let bar = irqarray16_csr.rf(utra::irqarray16::EV_PENDING_SOURCE0); + irqarray16_csr.rmwf(utra::irqarray16::EV_PENDING_SOURCE0, bar); + let mut baz = irqarray16_csr.zf(utra::irqarray16::EV_PENDING_SOURCE0, bar); + baz |= irqarray16_csr.ms(utra::irqarray16::EV_PENDING_SOURCE0, 1); + irqarray16_csr.wfo(utra::irqarray16::EV_PENDING_SOURCE0, baz); + let bar = irqarray16_csr.rf(utra::irqarray16::EV_PENDING_SOURCE1); + irqarray16_csr.rmwf(utra::irqarray16::EV_PENDING_SOURCE1, bar); + let mut baz = irqarray16_csr.zf(utra::irqarray16::EV_PENDING_SOURCE1, bar); + baz |= irqarray16_csr.ms(utra::irqarray16::EV_PENDING_SOURCE1, 1); + irqarray16_csr.wfo(utra::irqarray16::EV_PENDING_SOURCE1, baz); + let bar = irqarray16_csr.rf(utra::irqarray16::EV_PENDING_SOURCE2); + irqarray16_csr.rmwf(utra::irqarray16::EV_PENDING_SOURCE2, bar); + let mut baz = irqarray16_csr.zf(utra::irqarray16::EV_PENDING_SOURCE2, bar); + baz |= irqarray16_csr.ms(utra::irqarray16::EV_PENDING_SOURCE2, 1); + irqarray16_csr.wfo(utra::irqarray16::EV_PENDING_SOURCE2, baz); + let bar = irqarray16_csr.rf(utra::irqarray16::EV_PENDING_SOURCE3); + irqarray16_csr.rmwf(utra::irqarray16::EV_PENDING_SOURCE3, bar); + let mut baz = irqarray16_csr.zf(utra::irqarray16::EV_PENDING_SOURCE3, bar); + baz |= irqarray16_csr.ms(utra::irqarray16::EV_PENDING_SOURCE3, 1); + irqarray16_csr.wfo(utra::irqarray16::EV_PENDING_SOURCE3, baz); + let bar = irqarray16_csr.rf(utra::irqarray16::EV_PENDING_SOURCE4); + irqarray16_csr.rmwf(utra::irqarray16::EV_PENDING_SOURCE4, bar); + let mut baz = irqarray16_csr.zf(utra::irqarray16::EV_PENDING_SOURCE4, bar); + baz |= irqarray16_csr.ms(utra::irqarray16::EV_PENDING_SOURCE4, 1); + irqarray16_csr.wfo(utra::irqarray16::EV_PENDING_SOURCE4, baz); + let bar = irqarray16_csr.rf(utra::irqarray16::EV_PENDING_SOURCE5); + irqarray16_csr.rmwf(utra::irqarray16::EV_PENDING_SOURCE5, bar); + let mut baz = irqarray16_csr.zf(utra::irqarray16::EV_PENDING_SOURCE5, bar); + baz |= irqarray16_csr.ms(utra::irqarray16::EV_PENDING_SOURCE5, 1); + irqarray16_csr.wfo(utra::irqarray16::EV_PENDING_SOURCE5, baz); + let bar = irqarray16_csr.rf(utra::irqarray16::EV_PENDING_SOURCE6); + irqarray16_csr.rmwf(utra::irqarray16::EV_PENDING_SOURCE6, bar); + let mut baz = irqarray16_csr.zf(utra::irqarray16::EV_PENDING_SOURCE6, bar); + baz |= irqarray16_csr.ms(utra::irqarray16::EV_PENDING_SOURCE6, 1); + irqarray16_csr.wfo(utra::irqarray16::EV_PENDING_SOURCE6, baz); + let bar = irqarray16_csr.rf(utra::irqarray16::EV_PENDING_SOURCE7); + irqarray16_csr.rmwf(utra::irqarray16::EV_PENDING_SOURCE7, bar); + let mut baz = irqarray16_csr.zf(utra::irqarray16::EV_PENDING_SOURCE7, bar); + baz |= irqarray16_csr.ms(utra::irqarray16::EV_PENDING_SOURCE7, 1); + irqarray16_csr.wfo(utra::irqarray16::EV_PENDING_SOURCE7, baz); + let bar = irqarray16_csr.rf(utra::irqarray16::EV_PENDING_SOURCE8); + irqarray16_csr.rmwf(utra::irqarray16::EV_PENDING_SOURCE8, bar); + let mut baz = irqarray16_csr.zf(utra::irqarray16::EV_PENDING_SOURCE8, bar); + baz |= irqarray16_csr.ms(utra::irqarray16::EV_PENDING_SOURCE8, 1); + irqarray16_csr.wfo(utra::irqarray16::EV_PENDING_SOURCE8, baz); + let bar = irqarray16_csr.rf(utra::irqarray16::EV_PENDING_SOURCE9); + irqarray16_csr.rmwf(utra::irqarray16::EV_PENDING_SOURCE9, bar); + let mut baz = irqarray16_csr.zf(utra::irqarray16::EV_PENDING_SOURCE9, bar); + baz |= irqarray16_csr.ms(utra::irqarray16::EV_PENDING_SOURCE9, 1); + irqarray16_csr.wfo(utra::irqarray16::EV_PENDING_SOURCE9, baz); + let bar = irqarray16_csr.rf(utra::irqarray16::EV_PENDING_SOURCE10); + irqarray16_csr.rmwf(utra::irqarray16::EV_PENDING_SOURCE10, bar); + let mut baz = irqarray16_csr.zf(utra::irqarray16::EV_PENDING_SOURCE10, bar); + baz |= irqarray16_csr.ms(utra::irqarray16::EV_PENDING_SOURCE10, 1); + irqarray16_csr.wfo(utra::irqarray16::EV_PENDING_SOURCE10, baz); + let bar = irqarray16_csr.rf(utra::irqarray16::EV_PENDING_SOURCE11); + irqarray16_csr.rmwf(utra::irqarray16::EV_PENDING_SOURCE11, bar); + let mut baz = irqarray16_csr.zf(utra::irqarray16::EV_PENDING_SOURCE11, bar); + baz |= irqarray16_csr.ms(utra::irqarray16::EV_PENDING_SOURCE11, 1); + irqarray16_csr.wfo(utra::irqarray16::EV_PENDING_SOURCE11, baz); + let bar = irqarray16_csr.rf(utra::irqarray16::EV_PENDING_SOURCE12); + irqarray16_csr.rmwf(utra::irqarray16::EV_PENDING_SOURCE12, bar); + let mut baz = irqarray16_csr.zf(utra::irqarray16::EV_PENDING_SOURCE12, bar); + baz |= irqarray16_csr.ms(utra::irqarray16::EV_PENDING_SOURCE12, 1); + irqarray16_csr.wfo(utra::irqarray16::EV_PENDING_SOURCE12, baz); + let bar = irqarray16_csr.rf(utra::irqarray16::EV_PENDING_SOURCE13); + irqarray16_csr.rmwf(utra::irqarray16::EV_PENDING_SOURCE13, bar); + let mut baz = irqarray16_csr.zf(utra::irqarray16::EV_PENDING_SOURCE13, bar); + baz |= irqarray16_csr.ms(utra::irqarray16::EV_PENDING_SOURCE13, 1); + irqarray16_csr.wfo(utra::irqarray16::EV_PENDING_SOURCE13, baz); + let bar = irqarray16_csr.rf(utra::irqarray16::EV_PENDING_SOURCE14); + irqarray16_csr.rmwf(utra::irqarray16::EV_PENDING_SOURCE14, bar); + let mut baz = irqarray16_csr.zf(utra::irqarray16::EV_PENDING_SOURCE14, bar); + baz |= irqarray16_csr.ms(utra::irqarray16::EV_PENDING_SOURCE14, 1); + irqarray16_csr.wfo(utra::irqarray16::EV_PENDING_SOURCE14, baz); + let bar = irqarray16_csr.rf(utra::irqarray16::EV_PENDING_SOURCE15); + irqarray16_csr.rmwf(utra::irqarray16::EV_PENDING_SOURCE15, bar); + let mut baz = irqarray16_csr.zf(utra::irqarray16::EV_PENDING_SOURCE15, bar); + baz |= irqarray16_csr.ms(utra::irqarray16::EV_PENDING_SOURCE15, 1); + irqarray16_csr.wfo(utra::irqarray16::EV_PENDING_SOURCE15, baz); + let bar = irqarray16_csr.rf(utra::irqarray16::EV_PENDING_SOURCE16); + irqarray16_csr.rmwf(utra::irqarray16::EV_PENDING_SOURCE16, bar); + let mut baz = irqarray16_csr.zf(utra::irqarray16::EV_PENDING_SOURCE16, bar); + baz |= irqarray16_csr.ms(utra::irqarray16::EV_PENDING_SOURCE16, 1); + irqarray16_csr.wfo(utra::irqarray16::EV_PENDING_SOURCE16, baz); + let bar = irqarray16_csr.rf(utra::irqarray16::EV_PENDING_SOURCE17); + irqarray16_csr.rmwf(utra::irqarray16::EV_PENDING_SOURCE17, bar); + let mut baz = irqarray16_csr.zf(utra::irqarray16::EV_PENDING_SOURCE17, bar); + baz |= irqarray16_csr.ms(utra::irqarray16::EV_PENDING_SOURCE17, 1); + irqarray16_csr.wfo(utra::irqarray16::EV_PENDING_SOURCE17, baz); + let bar = irqarray16_csr.rf(utra::irqarray16::EV_PENDING_SOURCE18); + irqarray16_csr.rmwf(utra::irqarray16::EV_PENDING_SOURCE18, bar); + let mut baz = irqarray16_csr.zf(utra::irqarray16::EV_PENDING_SOURCE18, bar); + baz |= irqarray16_csr.ms(utra::irqarray16::EV_PENDING_SOURCE18, 1); + irqarray16_csr.wfo(utra::irqarray16::EV_PENDING_SOURCE18, baz); + let bar = irqarray16_csr.rf(utra::irqarray16::EV_PENDING_SOURCE19); + irqarray16_csr.rmwf(utra::irqarray16::EV_PENDING_SOURCE19, bar); + let mut baz = irqarray16_csr.zf(utra::irqarray16::EV_PENDING_SOURCE19, bar); + baz |= irqarray16_csr.ms(utra::irqarray16::EV_PENDING_SOURCE19, 1); + irqarray16_csr.wfo(utra::irqarray16::EV_PENDING_SOURCE19, baz); + + let foo = irqarray16_csr.r(utra::irqarray16::EV_ENABLE); + irqarray16_csr.wo(utra::irqarray16::EV_ENABLE, foo); + let bar = irqarray16_csr.rf(utra::irqarray16::EV_ENABLE_SOURCE0); + irqarray16_csr.rmwf(utra::irqarray16::EV_ENABLE_SOURCE0, bar); + let mut baz = irqarray16_csr.zf(utra::irqarray16::EV_ENABLE_SOURCE0, bar); + baz |= irqarray16_csr.ms(utra::irqarray16::EV_ENABLE_SOURCE0, 1); + irqarray16_csr.wfo(utra::irqarray16::EV_ENABLE_SOURCE0, baz); + let bar = irqarray16_csr.rf(utra::irqarray16::EV_ENABLE_SOURCE1); + irqarray16_csr.rmwf(utra::irqarray16::EV_ENABLE_SOURCE1, bar); + let mut baz = irqarray16_csr.zf(utra::irqarray16::EV_ENABLE_SOURCE1, bar); + baz |= irqarray16_csr.ms(utra::irqarray16::EV_ENABLE_SOURCE1, 1); + irqarray16_csr.wfo(utra::irqarray16::EV_ENABLE_SOURCE1, baz); + let bar = irqarray16_csr.rf(utra::irqarray16::EV_ENABLE_SOURCE2); + irqarray16_csr.rmwf(utra::irqarray16::EV_ENABLE_SOURCE2, bar); + let mut baz = irqarray16_csr.zf(utra::irqarray16::EV_ENABLE_SOURCE2, bar); + baz |= irqarray16_csr.ms(utra::irqarray16::EV_ENABLE_SOURCE2, 1); + irqarray16_csr.wfo(utra::irqarray16::EV_ENABLE_SOURCE2, baz); + let bar = irqarray16_csr.rf(utra::irqarray16::EV_ENABLE_SOURCE3); + irqarray16_csr.rmwf(utra::irqarray16::EV_ENABLE_SOURCE3, bar); + let mut baz = irqarray16_csr.zf(utra::irqarray16::EV_ENABLE_SOURCE3, bar); + baz |= irqarray16_csr.ms(utra::irqarray16::EV_ENABLE_SOURCE3, 1); + irqarray16_csr.wfo(utra::irqarray16::EV_ENABLE_SOURCE3, baz); + let bar = irqarray16_csr.rf(utra::irqarray16::EV_ENABLE_SOURCE4); + irqarray16_csr.rmwf(utra::irqarray16::EV_ENABLE_SOURCE4, bar); + let mut baz = irqarray16_csr.zf(utra::irqarray16::EV_ENABLE_SOURCE4, bar); + baz |= irqarray16_csr.ms(utra::irqarray16::EV_ENABLE_SOURCE4, 1); + irqarray16_csr.wfo(utra::irqarray16::EV_ENABLE_SOURCE4, baz); + let bar = irqarray16_csr.rf(utra::irqarray16::EV_ENABLE_SOURCE5); + irqarray16_csr.rmwf(utra::irqarray16::EV_ENABLE_SOURCE5, bar); + let mut baz = irqarray16_csr.zf(utra::irqarray16::EV_ENABLE_SOURCE5, bar); + baz |= irqarray16_csr.ms(utra::irqarray16::EV_ENABLE_SOURCE5, 1); + irqarray16_csr.wfo(utra::irqarray16::EV_ENABLE_SOURCE5, baz); + let bar = irqarray16_csr.rf(utra::irqarray16::EV_ENABLE_SOURCE6); + irqarray16_csr.rmwf(utra::irqarray16::EV_ENABLE_SOURCE6, bar); + let mut baz = irqarray16_csr.zf(utra::irqarray16::EV_ENABLE_SOURCE6, bar); + baz |= irqarray16_csr.ms(utra::irqarray16::EV_ENABLE_SOURCE6, 1); + irqarray16_csr.wfo(utra::irqarray16::EV_ENABLE_SOURCE6, baz); + let bar = irqarray16_csr.rf(utra::irqarray16::EV_ENABLE_SOURCE7); + irqarray16_csr.rmwf(utra::irqarray16::EV_ENABLE_SOURCE7, bar); + let mut baz = irqarray16_csr.zf(utra::irqarray16::EV_ENABLE_SOURCE7, bar); + baz |= irqarray16_csr.ms(utra::irqarray16::EV_ENABLE_SOURCE7, 1); + irqarray16_csr.wfo(utra::irqarray16::EV_ENABLE_SOURCE7, baz); + let bar = irqarray16_csr.rf(utra::irqarray16::EV_ENABLE_SOURCE8); + irqarray16_csr.rmwf(utra::irqarray16::EV_ENABLE_SOURCE8, bar); + let mut baz = irqarray16_csr.zf(utra::irqarray16::EV_ENABLE_SOURCE8, bar); + baz |= irqarray16_csr.ms(utra::irqarray16::EV_ENABLE_SOURCE8, 1); + irqarray16_csr.wfo(utra::irqarray16::EV_ENABLE_SOURCE8, baz); + let bar = irqarray16_csr.rf(utra::irqarray16::EV_ENABLE_SOURCE9); + irqarray16_csr.rmwf(utra::irqarray16::EV_ENABLE_SOURCE9, bar); + let mut baz = irqarray16_csr.zf(utra::irqarray16::EV_ENABLE_SOURCE9, bar); + baz |= irqarray16_csr.ms(utra::irqarray16::EV_ENABLE_SOURCE9, 1); + irqarray16_csr.wfo(utra::irqarray16::EV_ENABLE_SOURCE9, baz); + let bar = irqarray16_csr.rf(utra::irqarray16::EV_ENABLE_SOURCE10); + irqarray16_csr.rmwf(utra::irqarray16::EV_ENABLE_SOURCE10, bar); + let mut baz = irqarray16_csr.zf(utra::irqarray16::EV_ENABLE_SOURCE10, bar); + baz |= irqarray16_csr.ms(utra::irqarray16::EV_ENABLE_SOURCE10, 1); + irqarray16_csr.wfo(utra::irqarray16::EV_ENABLE_SOURCE10, baz); + let bar = irqarray16_csr.rf(utra::irqarray16::EV_ENABLE_SOURCE11); + irqarray16_csr.rmwf(utra::irqarray16::EV_ENABLE_SOURCE11, bar); + let mut baz = irqarray16_csr.zf(utra::irqarray16::EV_ENABLE_SOURCE11, bar); + baz |= irqarray16_csr.ms(utra::irqarray16::EV_ENABLE_SOURCE11, 1); + irqarray16_csr.wfo(utra::irqarray16::EV_ENABLE_SOURCE11, baz); + let bar = irqarray16_csr.rf(utra::irqarray16::EV_ENABLE_SOURCE12); + irqarray16_csr.rmwf(utra::irqarray16::EV_ENABLE_SOURCE12, bar); + let mut baz = irqarray16_csr.zf(utra::irqarray16::EV_ENABLE_SOURCE12, bar); + baz |= irqarray16_csr.ms(utra::irqarray16::EV_ENABLE_SOURCE12, 1); + irqarray16_csr.wfo(utra::irqarray16::EV_ENABLE_SOURCE12, baz); + let bar = irqarray16_csr.rf(utra::irqarray16::EV_ENABLE_SOURCE13); + irqarray16_csr.rmwf(utra::irqarray16::EV_ENABLE_SOURCE13, bar); + let mut baz = irqarray16_csr.zf(utra::irqarray16::EV_ENABLE_SOURCE13, bar); + baz |= irqarray16_csr.ms(utra::irqarray16::EV_ENABLE_SOURCE13, 1); + irqarray16_csr.wfo(utra::irqarray16::EV_ENABLE_SOURCE13, baz); + let bar = irqarray16_csr.rf(utra::irqarray16::EV_ENABLE_SOURCE14); + irqarray16_csr.rmwf(utra::irqarray16::EV_ENABLE_SOURCE14, bar); + let mut baz = irqarray16_csr.zf(utra::irqarray16::EV_ENABLE_SOURCE14, bar); + baz |= irqarray16_csr.ms(utra::irqarray16::EV_ENABLE_SOURCE14, 1); + irqarray16_csr.wfo(utra::irqarray16::EV_ENABLE_SOURCE14, baz); + let bar = irqarray16_csr.rf(utra::irqarray16::EV_ENABLE_SOURCE15); + irqarray16_csr.rmwf(utra::irqarray16::EV_ENABLE_SOURCE15, bar); + let mut baz = irqarray16_csr.zf(utra::irqarray16::EV_ENABLE_SOURCE15, bar); + baz |= irqarray16_csr.ms(utra::irqarray16::EV_ENABLE_SOURCE15, 1); + irqarray16_csr.wfo(utra::irqarray16::EV_ENABLE_SOURCE15, baz); + let bar = irqarray16_csr.rf(utra::irqarray16::EV_ENABLE_SOURCE16); + irqarray16_csr.rmwf(utra::irqarray16::EV_ENABLE_SOURCE16, bar); + let mut baz = irqarray16_csr.zf(utra::irqarray16::EV_ENABLE_SOURCE16, bar); + baz |= irqarray16_csr.ms(utra::irqarray16::EV_ENABLE_SOURCE16, 1); + irqarray16_csr.wfo(utra::irqarray16::EV_ENABLE_SOURCE16, baz); + let bar = irqarray16_csr.rf(utra::irqarray16::EV_ENABLE_SOURCE17); + irqarray16_csr.rmwf(utra::irqarray16::EV_ENABLE_SOURCE17, bar); + let mut baz = irqarray16_csr.zf(utra::irqarray16::EV_ENABLE_SOURCE17, bar); + baz |= irqarray16_csr.ms(utra::irqarray16::EV_ENABLE_SOURCE17, 1); + irqarray16_csr.wfo(utra::irqarray16::EV_ENABLE_SOURCE17, baz); + let bar = irqarray16_csr.rf(utra::irqarray16::EV_ENABLE_SOURCE18); + irqarray16_csr.rmwf(utra::irqarray16::EV_ENABLE_SOURCE18, bar); + let mut baz = irqarray16_csr.zf(utra::irqarray16::EV_ENABLE_SOURCE18, bar); + baz |= irqarray16_csr.ms(utra::irqarray16::EV_ENABLE_SOURCE18, 1); + irqarray16_csr.wfo(utra::irqarray16::EV_ENABLE_SOURCE18, baz); + let bar = irqarray16_csr.rf(utra::irqarray16::EV_ENABLE_SOURCE19); + irqarray16_csr.rmwf(utra::irqarray16::EV_ENABLE_SOURCE19, bar); + let mut baz = irqarray16_csr.zf(utra::irqarray16::EV_ENABLE_SOURCE19, bar); + baz |= irqarray16_csr.ms(utra::irqarray16::EV_ENABLE_SOURCE19, 1); + irqarray16_csr.wfo(utra::irqarray16::EV_ENABLE_SOURCE19, baz); + } + + #[test] + #[ignore] + fn compile_check_irqarray17_csr() { + use super::*; + let mut irqarray17_csr = CSR::new(HW_IRQARRAY17_BASE as *mut u32); + + let foo = irqarray17_csr.r(utra::irqarray17::EV_SOFT); + irqarray17_csr.wo(utra::irqarray17::EV_SOFT, foo); + let bar = irqarray17_csr.rf(utra::irqarray17::EV_SOFT_TRIGGER); + irqarray17_csr.rmwf(utra::irqarray17::EV_SOFT_TRIGGER, bar); + let mut baz = irqarray17_csr.zf(utra::irqarray17::EV_SOFT_TRIGGER, bar); + baz |= irqarray17_csr.ms(utra::irqarray17::EV_SOFT_TRIGGER, 1); + irqarray17_csr.wfo(utra::irqarray17::EV_SOFT_TRIGGER, baz); + + let foo = irqarray17_csr.r(utra::irqarray17::EV_STATUS); + irqarray17_csr.wo(utra::irqarray17::EV_STATUS, foo); + let bar = irqarray17_csr.rf(utra::irqarray17::EV_STATUS_SOURCE0); + irqarray17_csr.rmwf(utra::irqarray17::EV_STATUS_SOURCE0, bar); + let mut baz = irqarray17_csr.zf(utra::irqarray17::EV_STATUS_SOURCE0, bar); + baz |= irqarray17_csr.ms(utra::irqarray17::EV_STATUS_SOURCE0, 1); + irqarray17_csr.wfo(utra::irqarray17::EV_STATUS_SOURCE0, baz); + let bar = irqarray17_csr.rf(utra::irqarray17::EV_STATUS_SOURCE1); + irqarray17_csr.rmwf(utra::irqarray17::EV_STATUS_SOURCE1, bar); + let mut baz = irqarray17_csr.zf(utra::irqarray17::EV_STATUS_SOURCE1, bar); + baz |= irqarray17_csr.ms(utra::irqarray17::EV_STATUS_SOURCE1, 1); + irqarray17_csr.wfo(utra::irqarray17::EV_STATUS_SOURCE1, baz); + let bar = irqarray17_csr.rf(utra::irqarray17::EV_STATUS_SOURCE2); + irqarray17_csr.rmwf(utra::irqarray17::EV_STATUS_SOURCE2, bar); + let mut baz = irqarray17_csr.zf(utra::irqarray17::EV_STATUS_SOURCE2, bar); + baz |= irqarray17_csr.ms(utra::irqarray17::EV_STATUS_SOURCE2, 1); + irqarray17_csr.wfo(utra::irqarray17::EV_STATUS_SOURCE2, baz); + let bar = irqarray17_csr.rf(utra::irqarray17::EV_STATUS_SOURCE3); + irqarray17_csr.rmwf(utra::irqarray17::EV_STATUS_SOURCE3, bar); + let mut baz = irqarray17_csr.zf(utra::irqarray17::EV_STATUS_SOURCE3, bar); + baz |= irqarray17_csr.ms(utra::irqarray17::EV_STATUS_SOURCE3, 1); + irqarray17_csr.wfo(utra::irqarray17::EV_STATUS_SOURCE3, baz); + let bar = irqarray17_csr.rf(utra::irqarray17::EV_STATUS_SOURCE4); + irqarray17_csr.rmwf(utra::irqarray17::EV_STATUS_SOURCE4, bar); + let mut baz = irqarray17_csr.zf(utra::irqarray17::EV_STATUS_SOURCE4, bar); + baz |= irqarray17_csr.ms(utra::irqarray17::EV_STATUS_SOURCE4, 1); + irqarray17_csr.wfo(utra::irqarray17::EV_STATUS_SOURCE4, baz); + let bar = irqarray17_csr.rf(utra::irqarray17::EV_STATUS_SOURCE5); + irqarray17_csr.rmwf(utra::irqarray17::EV_STATUS_SOURCE5, bar); + let mut baz = irqarray17_csr.zf(utra::irqarray17::EV_STATUS_SOURCE5, bar); + baz |= irqarray17_csr.ms(utra::irqarray17::EV_STATUS_SOURCE5, 1); + irqarray17_csr.wfo(utra::irqarray17::EV_STATUS_SOURCE5, baz); + let bar = irqarray17_csr.rf(utra::irqarray17::EV_STATUS_SOURCE6); + irqarray17_csr.rmwf(utra::irqarray17::EV_STATUS_SOURCE6, bar); + let mut baz = irqarray17_csr.zf(utra::irqarray17::EV_STATUS_SOURCE6, bar); + baz |= irqarray17_csr.ms(utra::irqarray17::EV_STATUS_SOURCE6, 1); + irqarray17_csr.wfo(utra::irqarray17::EV_STATUS_SOURCE6, baz); + let bar = irqarray17_csr.rf(utra::irqarray17::EV_STATUS_SOURCE7); + irqarray17_csr.rmwf(utra::irqarray17::EV_STATUS_SOURCE7, bar); + let mut baz = irqarray17_csr.zf(utra::irqarray17::EV_STATUS_SOURCE7, bar); + baz |= irqarray17_csr.ms(utra::irqarray17::EV_STATUS_SOURCE7, 1); + irqarray17_csr.wfo(utra::irqarray17::EV_STATUS_SOURCE7, baz); + let bar = irqarray17_csr.rf(utra::irqarray17::EV_STATUS_SOURCE8); + irqarray17_csr.rmwf(utra::irqarray17::EV_STATUS_SOURCE8, bar); + let mut baz = irqarray17_csr.zf(utra::irqarray17::EV_STATUS_SOURCE8, bar); + baz |= irqarray17_csr.ms(utra::irqarray17::EV_STATUS_SOURCE8, 1); + irqarray17_csr.wfo(utra::irqarray17::EV_STATUS_SOURCE8, baz); + let bar = irqarray17_csr.rf(utra::irqarray17::EV_STATUS_SOURCE9); + irqarray17_csr.rmwf(utra::irqarray17::EV_STATUS_SOURCE9, bar); + let mut baz = irqarray17_csr.zf(utra::irqarray17::EV_STATUS_SOURCE9, bar); + baz |= irqarray17_csr.ms(utra::irqarray17::EV_STATUS_SOURCE9, 1); + irqarray17_csr.wfo(utra::irqarray17::EV_STATUS_SOURCE9, baz); + let bar = irqarray17_csr.rf(utra::irqarray17::EV_STATUS_SOURCE10); + irqarray17_csr.rmwf(utra::irqarray17::EV_STATUS_SOURCE10, bar); + let mut baz = irqarray17_csr.zf(utra::irqarray17::EV_STATUS_SOURCE10, bar); + baz |= irqarray17_csr.ms(utra::irqarray17::EV_STATUS_SOURCE10, 1); + irqarray17_csr.wfo(utra::irqarray17::EV_STATUS_SOURCE10, baz); + let bar = irqarray17_csr.rf(utra::irqarray17::EV_STATUS_SOURCE11); + irqarray17_csr.rmwf(utra::irqarray17::EV_STATUS_SOURCE11, bar); + let mut baz = irqarray17_csr.zf(utra::irqarray17::EV_STATUS_SOURCE11, bar); + baz |= irqarray17_csr.ms(utra::irqarray17::EV_STATUS_SOURCE11, 1); + irqarray17_csr.wfo(utra::irqarray17::EV_STATUS_SOURCE11, baz); + let bar = irqarray17_csr.rf(utra::irqarray17::EV_STATUS_SOURCE12); + irqarray17_csr.rmwf(utra::irqarray17::EV_STATUS_SOURCE12, bar); + let mut baz = irqarray17_csr.zf(utra::irqarray17::EV_STATUS_SOURCE12, bar); + baz |= irqarray17_csr.ms(utra::irqarray17::EV_STATUS_SOURCE12, 1); + irqarray17_csr.wfo(utra::irqarray17::EV_STATUS_SOURCE12, baz); + let bar = irqarray17_csr.rf(utra::irqarray17::EV_STATUS_SOURCE13); + irqarray17_csr.rmwf(utra::irqarray17::EV_STATUS_SOURCE13, bar); + let mut baz = irqarray17_csr.zf(utra::irqarray17::EV_STATUS_SOURCE13, bar); + baz |= irqarray17_csr.ms(utra::irqarray17::EV_STATUS_SOURCE13, 1); + irqarray17_csr.wfo(utra::irqarray17::EV_STATUS_SOURCE13, baz); + let bar = irqarray17_csr.rf(utra::irqarray17::EV_STATUS_SOURCE14); + irqarray17_csr.rmwf(utra::irqarray17::EV_STATUS_SOURCE14, bar); + let mut baz = irqarray17_csr.zf(utra::irqarray17::EV_STATUS_SOURCE14, bar); + baz |= irqarray17_csr.ms(utra::irqarray17::EV_STATUS_SOURCE14, 1); + irqarray17_csr.wfo(utra::irqarray17::EV_STATUS_SOURCE14, baz); + let bar = irqarray17_csr.rf(utra::irqarray17::EV_STATUS_SOURCE15); + irqarray17_csr.rmwf(utra::irqarray17::EV_STATUS_SOURCE15, bar); + let mut baz = irqarray17_csr.zf(utra::irqarray17::EV_STATUS_SOURCE15, bar); + baz |= irqarray17_csr.ms(utra::irqarray17::EV_STATUS_SOURCE15, 1); + irqarray17_csr.wfo(utra::irqarray17::EV_STATUS_SOURCE15, baz); + let bar = irqarray17_csr.rf(utra::irqarray17::EV_STATUS_SOURCE16); + irqarray17_csr.rmwf(utra::irqarray17::EV_STATUS_SOURCE16, bar); + let mut baz = irqarray17_csr.zf(utra::irqarray17::EV_STATUS_SOURCE16, bar); + baz |= irqarray17_csr.ms(utra::irqarray17::EV_STATUS_SOURCE16, 1); + irqarray17_csr.wfo(utra::irqarray17::EV_STATUS_SOURCE16, baz); + let bar = irqarray17_csr.rf(utra::irqarray17::EV_STATUS_SOURCE17); + irqarray17_csr.rmwf(utra::irqarray17::EV_STATUS_SOURCE17, bar); + let mut baz = irqarray17_csr.zf(utra::irqarray17::EV_STATUS_SOURCE17, bar); + baz |= irqarray17_csr.ms(utra::irqarray17::EV_STATUS_SOURCE17, 1); + irqarray17_csr.wfo(utra::irqarray17::EV_STATUS_SOURCE17, baz); + let bar = irqarray17_csr.rf(utra::irqarray17::EV_STATUS_SOURCE18); + irqarray17_csr.rmwf(utra::irqarray17::EV_STATUS_SOURCE18, bar); + let mut baz = irqarray17_csr.zf(utra::irqarray17::EV_STATUS_SOURCE18, bar); + baz |= irqarray17_csr.ms(utra::irqarray17::EV_STATUS_SOURCE18, 1); + irqarray17_csr.wfo(utra::irqarray17::EV_STATUS_SOURCE18, baz); + let bar = irqarray17_csr.rf(utra::irqarray17::EV_STATUS_SOURCE19); + irqarray17_csr.rmwf(utra::irqarray17::EV_STATUS_SOURCE19, bar); + let mut baz = irqarray17_csr.zf(utra::irqarray17::EV_STATUS_SOURCE19, bar); + baz |= irqarray17_csr.ms(utra::irqarray17::EV_STATUS_SOURCE19, 1); + irqarray17_csr.wfo(utra::irqarray17::EV_STATUS_SOURCE19, baz); + + let foo = irqarray17_csr.r(utra::irqarray17::EV_PENDING); + irqarray17_csr.wo(utra::irqarray17::EV_PENDING, foo); + let bar = irqarray17_csr.rf(utra::irqarray17::EV_PENDING_SOURCE0); + irqarray17_csr.rmwf(utra::irqarray17::EV_PENDING_SOURCE0, bar); + let mut baz = irqarray17_csr.zf(utra::irqarray17::EV_PENDING_SOURCE0, bar); + baz |= irqarray17_csr.ms(utra::irqarray17::EV_PENDING_SOURCE0, 1); + irqarray17_csr.wfo(utra::irqarray17::EV_PENDING_SOURCE0, baz); + let bar = irqarray17_csr.rf(utra::irqarray17::EV_PENDING_SOURCE1); + irqarray17_csr.rmwf(utra::irqarray17::EV_PENDING_SOURCE1, bar); + let mut baz = irqarray17_csr.zf(utra::irqarray17::EV_PENDING_SOURCE1, bar); + baz |= irqarray17_csr.ms(utra::irqarray17::EV_PENDING_SOURCE1, 1); + irqarray17_csr.wfo(utra::irqarray17::EV_PENDING_SOURCE1, baz); + let bar = irqarray17_csr.rf(utra::irqarray17::EV_PENDING_SOURCE2); + irqarray17_csr.rmwf(utra::irqarray17::EV_PENDING_SOURCE2, bar); + let mut baz = irqarray17_csr.zf(utra::irqarray17::EV_PENDING_SOURCE2, bar); + baz |= irqarray17_csr.ms(utra::irqarray17::EV_PENDING_SOURCE2, 1); + irqarray17_csr.wfo(utra::irqarray17::EV_PENDING_SOURCE2, baz); + let bar = irqarray17_csr.rf(utra::irqarray17::EV_PENDING_SOURCE3); + irqarray17_csr.rmwf(utra::irqarray17::EV_PENDING_SOURCE3, bar); + let mut baz = irqarray17_csr.zf(utra::irqarray17::EV_PENDING_SOURCE3, bar); + baz |= irqarray17_csr.ms(utra::irqarray17::EV_PENDING_SOURCE3, 1); + irqarray17_csr.wfo(utra::irqarray17::EV_PENDING_SOURCE3, baz); + let bar = irqarray17_csr.rf(utra::irqarray17::EV_PENDING_SOURCE4); + irqarray17_csr.rmwf(utra::irqarray17::EV_PENDING_SOURCE4, bar); + let mut baz = irqarray17_csr.zf(utra::irqarray17::EV_PENDING_SOURCE4, bar); + baz |= irqarray17_csr.ms(utra::irqarray17::EV_PENDING_SOURCE4, 1); + irqarray17_csr.wfo(utra::irqarray17::EV_PENDING_SOURCE4, baz); + let bar = irqarray17_csr.rf(utra::irqarray17::EV_PENDING_SOURCE5); + irqarray17_csr.rmwf(utra::irqarray17::EV_PENDING_SOURCE5, bar); + let mut baz = irqarray17_csr.zf(utra::irqarray17::EV_PENDING_SOURCE5, bar); + baz |= irqarray17_csr.ms(utra::irqarray17::EV_PENDING_SOURCE5, 1); + irqarray17_csr.wfo(utra::irqarray17::EV_PENDING_SOURCE5, baz); + let bar = irqarray17_csr.rf(utra::irqarray17::EV_PENDING_SOURCE6); + irqarray17_csr.rmwf(utra::irqarray17::EV_PENDING_SOURCE6, bar); + let mut baz = irqarray17_csr.zf(utra::irqarray17::EV_PENDING_SOURCE6, bar); + baz |= irqarray17_csr.ms(utra::irqarray17::EV_PENDING_SOURCE6, 1); + irqarray17_csr.wfo(utra::irqarray17::EV_PENDING_SOURCE6, baz); + let bar = irqarray17_csr.rf(utra::irqarray17::EV_PENDING_SOURCE7); + irqarray17_csr.rmwf(utra::irqarray17::EV_PENDING_SOURCE7, bar); + let mut baz = irqarray17_csr.zf(utra::irqarray17::EV_PENDING_SOURCE7, bar); + baz |= irqarray17_csr.ms(utra::irqarray17::EV_PENDING_SOURCE7, 1); + irqarray17_csr.wfo(utra::irqarray17::EV_PENDING_SOURCE7, baz); + let bar = irqarray17_csr.rf(utra::irqarray17::EV_PENDING_SOURCE8); + irqarray17_csr.rmwf(utra::irqarray17::EV_PENDING_SOURCE8, bar); + let mut baz = irqarray17_csr.zf(utra::irqarray17::EV_PENDING_SOURCE8, bar); + baz |= irqarray17_csr.ms(utra::irqarray17::EV_PENDING_SOURCE8, 1); + irqarray17_csr.wfo(utra::irqarray17::EV_PENDING_SOURCE8, baz); + let bar = irqarray17_csr.rf(utra::irqarray17::EV_PENDING_SOURCE9); + irqarray17_csr.rmwf(utra::irqarray17::EV_PENDING_SOURCE9, bar); + let mut baz = irqarray17_csr.zf(utra::irqarray17::EV_PENDING_SOURCE9, bar); + baz |= irqarray17_csr.ms(utra::irqarray17::EV_PENDING_SOURCE9, 1); + irqarray17_csr.wfo(utra::irqarray17::EV_PENDING_SOURCE9, baz); + let bar = irqarray17_csr.rf(utra::irqarray17::EV_PENDING_SOURCE10); + irqarray17_csr.rmwf(utra::irqarray17::EV_PENDING_SOURCE10, bar); + let mut baz = irqarray17_csr.zf(utra::irqarray17::EV_PENDING_SOURCE10, bar); + baz |= irqarray17_csr.ms(utra::irqarray17::EV_PENDING_SOURCE10, 1); + irqarray17_csr.wfo(utra::irqarray17::EV_PENDING_SOURCE10, baz); + let bar = irqarray17_csr.rf(utra::irqarray17::EV_PENDING_SOURCE11); + irqarray17_csr.rmwf(utra::irqarray17::EV_PENDING_SOURCE11, bar); + let mut baz = irqarray17_csr.zf(utra::irqarray17::EV_PENDING_SOURCE11, bar); + baz |= irqarray17_csr.ms(utra::irqarray17::EV_PENDING_SOURCE11, 1); + irqarray17_csr.wfo(utra::irqarray17::EV_PENDING_SOURCE11, baz); + let bar = irqarray17_csr.rf(utra::irqarray17::EV_PENDING_SOURCE12); + irqarray17_csr.rmwf(utra::irqarray17::EV_PENDING_SOURCE12, bar); + let mut baz = irqarray17_csr.zf(utra::irqarray17::EV_PENDING_SOURCE12, bar); + baz |= irqarray17_csr.ms(utra::irqarray17::EV_PENDING_SOURCE12, 1); + irqarray17_csr.wfo(utra::irqarray17::EV_PENDING_SOURCE12, baz); + let bar = irqarray17_csr.rf(utra::irqarray17::EV_PENDING_SOURCE13); + irqarray17_csr.rmwf(utra::irqarray17::EV_PENDING_SOURCE13, bar); + let mut baz = irqarray17_csr.zf(utra::irqarray17::EV_PENDING_SOURCE13, bar); + baz |= irqarray17_csr.ms(utra::irqarray17::EV_PENDING_SOURCE13, 1); + irqarray17_csr.wfo(utra::irqarray17::EV_PENDING_SOURCE13, baz); + let bar = irqarray17_csr.rf(utra::irqarray17::EV_PENDING_SOURCE14); + irqarray17_csr.rmwf(utra::irqarray17::EV_PENDING_SOURCE14, bar); + let mut baz = irqarray17_csr.zf(utra::irqarray17::EV_PENDING_SOURCE14, bar); + baz |= irqarray17_csr.ms(utra::irqarray17::EV_PENDING_SOURCE14, 1); + irqarray17_csr.wfo(utra::irqarray17::EV_PENDING_SOURCE14, baz); + let bar = irqarray17_csr.rf(utra::irqarray17::EV_PENDING_SOURCE15); + irqarray17_csr.rmwf(utra::irqarray17::EV_PENDING_SOURCE15, bar); + let mut baz = irqarray17_csr.zf(utra::irqarray17::EV_PENDING_SOURCE15, bar); + baz |= irqarray17_csr.ms(utra::irqarray17::EV_PENDING_SOURCE15, 1); + irqarray17_csr.wfo(utra::irqarray17::EV_PENDING_SOURCE15, baz); + let bar = irqarray17_csr.rf(utra::irqarray17::EV_PENDING_SOURCE16); + irqarray17_csr.rmwf(utra::irqarray17::EV_PENDING_SOURCE16, bar); + let mut baz = irqarray17_csr.zf(utra::irqarray17::EV_PENDING_SOURCE16, bar); + baz |= irqarray17_csr.ms(utra::irqarray17::EV_PENDING_SOURCE16, 1); + irqarray17_csr.wfo(utra::irqarray17::EV_PENDING_SOURCE16, baz); + let bar = irqarray17_csr.rf(utra::irqarray17::EV_PENDING_SOURCE17); + irqarray17_csr.rmwf(utra::irqarray17::EV_PENDING_SOURCE17, bar); + let mut baz = irqarray17_csr.zf(utra::irqarray17::EV_PENDING_SOURCE17, bar); + baz |= irqarray17_csr.ms(utra::irqarray17::EV_PENDING_SOURCE17, 1); + irqarray17_csr.wfo(utra::irqarray17::EV_PENDING_SOURCE17, baz); + let bar = irqarray17_csr.rf(utra::irqarray17::EV_PENDING_SOURCE18); + irqarray17_csr.rmwf(utra::irqarray17::EV_PENDING_SOURCE18, bar); + let mut baz = irqarray17_csr.zf(utra::irqarray17::EV_PENDING_SOURCE18, bar); + baz |= irqarray17_csr.ms(utra::irqarray17::EV_PENDING_SOURCE18, 1); + irqarray17_csr.wfo(utra::irqarray17::EV_PENDING_SOURCE18, baz); + let bar = irqarray17_csr.rf(utra::irqarray17::EV_PENDING_SOURCE19); + irqarray17_csr.rmwf(utra::irqarray17::EV_PENDING_SOURCE19, bar); + let mut baz = irqarray17_csr.zf(utra::irqarray17::EV_PENDING_SOURCE19, bar); + baz |= irqarray17_csr.ms(utra::irqarray17::EV_PENDING_SOURCE19, 1); + irqarray17_csr.wfo(utra::irqarray17::EV_PENDING_SOURCE19, baz); + + let foo = irqarray17_csr.r(utra::irqarray17::EV_ENABLE); + irqarray17_csr.wo(utra::irqarray17::EV_ENABLE, foo); + let bar = irqarray17_csr.rf(utra::irqarray17::EV_ENABLE_SOURCE0); + irqarray17_csr.rmwf(utra::irqarray17::EV_ENABLE_SOURCE0, bar); + let mut baz = irqarray17_csr.zf(utra::irqarray17::EV_ENABLE_SOURCE0, bar); + baz |= irqarray17_csr.ms(utra::irqarray17::EV_ENABLE_SOURCE0, 1); + irqarray17_csr.wfo(utra::irqarray17::EV_ENABLE_SOURCE0, baz); + let bar = irqarray17_csr.rf(utra::irqarray17::EV_ENABLE_SOURCE1); + irqarray17_csr.rmwf(utra::irqarray17::EV_ENABLE_SOURCE1, bar); + let mut baz = irqarray17_csr.zf(utra::irqarray17::EV_ENABLE_SOURCE1, bar); + baz |= irqarray17_csr.ms(utra::irqarray17::EV_ENABLE_SOURCE1, 1); + irqarray17_csr.wfo(utra::irqarray17::EV_ENABLE_SOURCE1, baz); + let bar = irqarray17_csr.rf(utra::irqarray17::EV_ENABLE_SOURCE2); + irqarray17_csr.rmwf(utra::irqarray17::EV_ENABLE_SOURCE2, bar); + let mut baz = irqarray17_csr.zf(utra::irqarray17::EV_ENABLE_SOURCE2, bar); + baz |= irqarray17_csr.ms(utra::irqarray17::EV_ENABLE_SOURCE2, 1); + irqarray17_csr.wfo(utra::irqarray17::EV_ENABLE_SOURCE2, baz); + let bar = irqarray17_csr.rf(utra::irqarray17::EV_ENABLE_SOURCE3); + irqarray17_csr.rmwf(utra::irqarray17::EV_ENABLE_SOURCE3, bar); + let mut baz = irqarray17_csr.zf(utra::irqarray17::EV_ENABLE_SOURCE3, bar); + baz |= irqarray17_csr.ms(utra::irqarray17::EV_ENABLE_SOURCE3, 1); + irqarray17_csr.wfo(utra::irqarray17::EV_ENABLE_SOURCE3, baz); + let bar = irqarray17_csr.rf(utra::irqarray17::EV_ENABLE_SOURCE4); + irqarray17_csr.rmwf(utra::irqarray17::EV_ENABLE_SOURCE4, bar); + let mut baz = irqarray17_csr.zf(utra::irqarray17::EV_ENABLE_SOURCE4, bar); + baz |= irqarray17_csr.ms(utra::irqarray17::EV_ENABLE_SOURCE4, 1); + irqarray17_csr.wfo(utra::irqarray17::EV_ENABLE_SOURCE4, baz); + let bar = irqarray17_csr.rf(utra::irqarray17::EV_ENABLE_SOURCE5); + irqarray17_csr.rmwf(utra::irqarray17::EV_ENABLE_SOURCE5, bar); + let mut baz = irqarray17_csr.zf(utra::irqarray17::EV_ENABLE_SOURCE5, bar); + baz |= irqarray17_csr.ms(utra::irqarray17::EV_ENABLE_SOURCE5, 1); + irqarray17_csr.wfo(utra::irqarray17::EV_ENABLE_SOURCE5, baz); + let bar = irqarray17_csr.rf(utra::irqarray17::EV_ENABLE_SOURCE6); + irqarray17_csr.rmwf(utra::irqarray17::EV_ENABLE_SOURCE6, bar); + let mut baz = irqarray17_csr.zf(utra::irqarray17::EV_ENABLE_SOURCE6, bar); + baz |= irqarray17_csr.ms(utra::irqarray17::EV_ENABLE_SOURCE6, 1); + irqarray17_csr.wfo(utra::irqarray17::EV_ENABLE_SOURCE6, baz); + let bar = irqarray17_csr.rf(utra::irqarray17::EV_ENABLE_SOURCE7); + irqarray17_csr.rmwf(utra::irqarray17::EV_ENABLE_SOURCE7, bar); + let mut baz = irqarray17_csr.zf(utra::irqarray17::EV_ENABLE_SOURCE7, bar); + baz |= irqarray17_csr.ms(utra::irqarray17::EV_ENABLE_SOURCE7, 1); + irqarray17_csr.wfo(utra::irqarray17::EV_ENABLE_SOURCE7, baz); + let bar = irqarray17_csr.rf(utra::irqarray17::EV_ENABLE_SOURCE8); + irqarray17_csr.rmwf(utra::irqarray17::EV_ENABLE_SOURCE8, bar); + let mut baz = irqarray17_csr.zf(utra::irqarray17::EV_ENABLE_SOURCE8, bar); + baz |= irqarray17_csr.ms(utra::irqarray17::EV_ENABLE_SOURCE8, 1); + irqarray17_csr.wfo(utra::irqarray17::EV_ENABLE_SOURCE8, baz); + let bar = irqarray17_csr.rf(utra::irqarray17::EV_ENABLE_SOURCE9); + irqarray17_csr.rmwf(utra::irqarray17::EV_ENABLE_SOURCE9, bar); + let mut baz = irqarray17_csr.zf(utra::irqarray17::EV_ENABLE_SOURCE9, bar); + baz |= irqarray17_csr.ms(utra::irqarray17::EV_ENABLE_SOURCE9, 1); + irqarray17_csr.wfo(utra::irqarray17::EV_ENABLE_SOURCE9, baz); + let bar = irqarray17_csr.rf(utra::irqarray17::EV_ENABLE_SOURCE10); + irqarray17_csr.rmwf(utra::irqarray17::EV_ENABLE_SOURCE10, bar); + let mut baz = irqarray17_csr.zf(utra::irqarray17::EV_ENABLE_SOURCE10, bar); + baz |= irqarray17_csr.ms(utra::irqarray17::EV_ENABLE_SOURCE10, 1); + irqarray17_csr.wfo(utra::irqarray17::EV_ENABLE_SOURCE10, baz); + let bar = irqarray17_csr.rf(utra::irqarray17::EV_ENABLE_SOURCE11); + irqarray17_csr.rmwf(utra::irqarray17::EV_ENABLE_SOURCE11, bar); + let mut baz = irqarray17_csr.zf(utra::irqarray17::EV_ENABLE_SOURCE11, bar); + baz |= irqarray17_csr.ms(utra::irqarray17::EV_ENABLE_SOURCE11, 1); + irqarray17_csr.wfo(utra::irqarray17::EV_ENABLE_SOURCE11, baz); + let bar = irqarray17_csr.rf(utra::irqarray17::EV_ENABLE_SOURCE12); + irqarray17_csr.rmwf(utra::irqarray17::EV_ENABLE_SOURCE12, bar); + let mut baz = irqarray17_csr.zf(utra::irqarray17::EV_ENABLE_SOURCE12, bar); + baz |= irqarray17_csr.ms(utra::irqarray17::EV_ENABLE_SOURCE12, 1); + irqarray17_csr.wfo(utra::irqarray17::EV_ENABLE_SOURCE12, baz); + let bar = irqarray17_csr.rf(utra::irqarray17::EV_ENABLE_SOURCE13); + irqarray17_csr.rmwf(utra::irqarray17::EV_ENABLE_SOURCE13, bar); + let mut baz = irqarray17_csr.zf(utra::irqarray17::EV_ENABLE_SOURCE13, bar); + baz |= irqarray17_csr.ms(utra::irqarray17::EV_ENABLE_SOURCE13, 1); + irqarray17_csr.wfo(utra::irqarray17::EV_ENABLE_SOURCE13, baz); + let bar = irqarray17_csr.rf(utra::irqarray17::EV_ENABLE_SOURCE14); + irqarray17_csr.rmwf(utra::irqarray17::EV_ENABLE_SOURCE14, bar); + let mut baz = irqarray17_csr.zf(utra::irqarray17::EV_ENABLE_SOURCE14, bar); + baz |= irqarray17_csr.ms(utra::irqarray17::EV_ENABLE_SOURCE14, 1); + irqarray17_csr.wfo(utra::irqarray17::EV_ENABLE_SOURCE14, baz); + let bar = irqarray17_csr.rf(utra::irqarray17::EV_ENABLE_SOURCE15); + irqarray17_csr.rmwf(utra::irqarray17::EV_ENABLE_SOURCE15, bar); + let mut baz = irqarray17_csr.zf(utra::irqarray17::EV_ENABLE_SOURCE15, bar); + baz |= irqarray17_csr.ms(utra::irqarray17::EV_ENABLE_SOURCE15, 1); + irqarray17_csr.wfo(utra::irqarray17::EV_ENABLE_SOURCE15, baz); + let bar = irqarray17_csr.rf(utra::irqarray17::EV_ENABLE_SOURCE16); + irqarray17_csr.rmwf(utra::irqarray17::EV_ENABLE_SOURCE16, bar); + let mut baz = irqarray17_csr.zf(utra::irqarray17::EV_ENABLE_SOURCE16, bar); + baz |= irqarray17_csr.ms(utra::irqarray17::EV_ENABLE_SOURCE16, 1); + irqarray17_csr.wfo(utra::irqarray17::EV_ENABLE_SOURCE16, baz); + let bar = irqarray17_csr.rf(utra::irqarray17::EV_ENABLE_SOURCE17); + irqarray17_csr.rmwf(utra::irqarray17::EV_ENABLE_SOURCE17, bar); + let mut baz = irqarray17_csr.zf(utra::irqarray17::EV_ENABLE_SOURCE17, bar); + baz |= irqarray17_csr.ms(utra::irqarray17::EV_ENABLE_SOURCE17, 1); + irqarray17_csr.wfo(utra::irqarray17::EV_ENABLE_SOURCE17, baz); + let bar = irqarray17_csr.rf(utra::irqarray17::EV_ENABLE_SOURCE18); + irqarray17_csr.rmwf(utra::irqarray17::EV_ENABLE_SOURCE18, bar); + let mut baz = irqarray17_csr.zf(utra::irqarray17::EV_ENABLE_SOURCE18, bar); + baz |= irqarray17_csr.ms(utra::irqarray17::EV_ENABLE_SOURCE18, 1); + irqarray17_csr.wfo(utra::irqarray17::EV_ENABLE_SOURCE18, baz); + let bar = irqarray17_csr.rf(utra::irqarray17::EV_ENABLE_SOURCE19); + irqarray17_csr.rmwf(utra::irqarray17::EV_ENABLE_SOURCE19, bar); + let mut baz = irqarray17_csr.zf(utra::irqarray17::EV_ENABLE_SOURCE19, bar); + baz |= irqarray17_csr.ms(utra::irqarray17::EV_ENABLE_SOURCE19, 1); + irqarray17_csr.wfo(utra::irqarray17::EV_ENABLE_SOURCE19, baz); + } + + #[test] + #[ignore] + fn compile_check_irqarray18_csr() { + use super::*; + let mut irqarray18_csr = CSR::new(HW_IRQARRAY18_BASE as *mut u32); + + let foo = irqarray18_csr.r(utra::irqarray18::EV_SOFT); + irqarray18_csr.wo(utra::irqarray18::EV_SOFT, foo); + let bar = irqarray18_csr.rf(utra::irqarray18::EV_SOFT_TRIGGER); + irqarray18_csr.rmwf(utra::irqarray18::EV_SOFT_TRIGGER, bar); + let mut baz = irqarray18_csr.zf(utra::irqarray18::EV_SOFT_TRIGGER, bar); + baz |= irqarray18_csr.ms(utra::irqarray18::EV_SOFT_TRIGGER, 1); + irqarray18_csr.wfo(utra::irqarray18::EV_SOFT_TRIGGER, baz); + + let foo = irqarray18_csr.r(utra::irqarray18::EV_STATUS); + irqarray18_csr.wo(utra::irqarray18::EV_STATUS, foo); + let bar = irqarray18_csr.rf(utra::irqarray18::EV_STATUS_SOURCE0); + irqarray18_csr.rmwf(utra::irqarray18::EV_STATUS_SOURCE0, bar); + let mut baz = irqarray18_csr.zf(utra::irqarray18::EV_STATUS_SOURCE0, bar); + baz |= irqarray18_csr.ms(utra::irqarray18::EV_STATUS_SOURCE0, 1); + irqarray18_csr.wfo(utra::irqarray18::EV_STATUS_SOURCE0, baz); + let bar = irqarray18_csr.rf(utra::irqarray18::EV_STATUS_SOURCE1); + irqarray18_csr.rmwf(utra::irqarray18::EV_STATUS_SOURCE1, bar); + let mut baz = irqarray18_csr.zf(utra::irqarray18::EV_STATUS_SOURCE1, bar); + baz |= irqarray18_csr.ms(utra::irqarray18::EV_STATUS_SOURCE1, 1); + irqarray18_csr.wfo(utra::irqarray18::EV_STATUS_SOURCE1, baz); + let bar = irqarray18_csr.rf(utra::irqarray18::EV_STATUS_SOURCE2); + irqarray18_csr.rmwf(utra::irqarray18::EV_STATUS_SOURCE2, bar); + let mut baz = irqarray18_csr.zf(utra::irqarray18::EV_STATUS_SOURCE2, bar); + baz |= irqarray18_csr.ms(utra::irqarray18::EV_STATUS_SOURCE2, 1); + irqarray18_csr.wfo(utra::irqarray18::EV_STATUS_SOURCE2, baz); + let bar = irqarray18_csr.rf(utra::irqarray18::EV_STATUS_SOURCE3); + irqarray18_csr.rmwf(utra::irqarray18::EV_STATUS_SOURCE3, bar); + let mut baz = irqarray18_csr.zf(utra::irqarray18::EV_STATUS_SOURCE3, bar); + baz |= irqarray18_csr.ms(utra::irqarray18::EV_STATUS_SOURCE3, 1); + irqarray18_csr.wfo(utra::irqarray18::EV_STATUS_SOURCE3, baz); + let bar = irqarray18_csr.rf(utra::irqarray18::EV_STATUS_SOURCE4); + irqarray18_csr.rmwf(utra::irqarray18::EV_STATUS_SOURCE4, bar); + let mut baz = irqarray18_csr.zf(utra::irqarray18::EV_STATUS_SOURCE4, bar); + baz |= irqarray18_csr.ms(utra::irqarray18::EV_STATUS_SOURCE4, 1); + irqarray18_csr.wfo(utra::irqarray18::EV_STATUS_SOURCE4, baz); + let bar = irqarray18_csr.rf(utra::irqarray18::EV_STATUS_SOURCE5); + irqarray18_csr.rmwf(utra::irqarray18::EV_STATUS_SOURCE5, bar); + let mut baz = irqarray18_csr.zf(utra::irqarray18::EV_STATUS_SOURCE5, bar); + baz |= irqarray18_csr.ms(utra::irqarray18::EV_STATUS_SOURCE5, 1); + irqarray18_csr.wfo(utra::irqarray18::EV_STATUS_SOURCE5, baz); + let bar = irqarray18_csr.rf(utra::irqarray18::EV_STATUS_SOURCE6); + irqarray18_csr.rmwf(utra::irqarray18::EV_STATUS_SOURCE6, bar); + let mut baz = irqarray18_csr.zf(utra::irqarray18::EV_STATUS_SOURCE6, bar); + baz |= irqarray18_csr.ms(utra::irqarray18::EV_STATUS_SOURCE6, 1); + irqarray18_csr.wfo(utra::irqarray18::EV_STATUS_SOURCE6, baz); + let bar = irqarray18_csr.rf(utra::irqarray18::EV_STATUS_SOURCE7); + irqarray18_csr.rmwf(utra::irqarray18::EV_STATUS_SOURCE7, bar); + let mut baz = irqarray18_csr.zf(utra::irqarray18::EV_STATUS_SOURCE7, bar); + baz |= irqarray18_csr.ms(utra::irqarray18::EV_STATUS_SOURCE7, 1); + irqarray18_csr.wfo(utra::irqarray18::EV_STATUS_SOURCE7, baz); + let bar = irqarray18_csr.rf(utra::irqarray18::EV_STATUS_SOURCE8); + irqarray18_csr.rmwf(utra::irqarray18::EV_STATUS_SOURCE8, bar); + let mut baz = irqarray18_csr.zf(utra::irqarray18::EV_STATUS_SOURCE8, bar); + baz |= irqarray18_csr.ms(utra::irqarray18::EV_STATUS_SOURCE8, 1); + irqarray18_csr.wfo(utra::irqarray18::EV_STATUS_SOURCE8, baz); + let bar = irqarray18_csr.rf(utra::irqarray18::EV_STATUS_SOURCE9); + irqarray18_csr.rmwf(utra::irqarray18::EV_STATUS_SOURCE9, bar); + let mut baz = irqarray18_csr.zf(utra::irqarray18::EV_STATUS_SOURCE9, bar); + baz |= irqarray18_csr.ms(utra::irqarray18::EV_STATUS_SOURCE9, 1); + irqarray18_csr.wfo(utra::irqarray18::EV_STATUS_SOURCE9, baz); + let bar = irqarray18_csr.rf(utra::irqarray18::EV_STATUS_SOURCE10); + irqarray18_csr.rmwf(utra::irqarray18::EV_STATUS_SOURCE10, bar); + let mut baz = irqarray18_csr.zf(utra::irqarray18::EV_STATUS_SOURCE10, bar); + baz |= irqarray18_csr.ms(utra::irqarray18::EV_STATUS_SOURCE10, 1); + irqarray18_csr.wfo(utra::irqarray18::EV_STATUS_SOURCE10, baz); + let bar = irqarray18_csr.rf(utra::irqarray18::EV_STATUS_SOURCE11); + irqarray18_csr.rmwf(utra::irqarray18::EV_STATUS_SOURCE11, bar); + let mut baz = irqarray18_csr.zf(utra::irqarray18::EV_STATUS_SOURCE11, bar); + baz |= irqarray18_csr.ms(utra::irqarray18::EV_STATUS_SOURCE11, 1); + irqarray18_csr.wfo(utra::irqarray18::EV_STATUS_SOURCE11, baz); + let bar = irqarray18_csr.rf(utra::irqarray18::EV_STATUS_SOURCE12); + irqarray18_csr.rmwf(utra::irqarray18::EV_STATUS_SOURCE12, bar); + let mut baz = irqarray18_csr.zf(utra::irqarray18::EV_STATUS_SOURCE12, bar); + baz |= irqarray18_csr.ms(utra::irqarray18::EV_STATUS_SOURCE12, 1); + irqarray18_csr.wfo(utra::irqarray18::EV_STATUS_SOURCE12, baz); + let bar = irqarray18_csr.rf(utra::irqarray18::EV_STATUS_SOURCE13); + irqarray18_csr.rmwf(utra::irqarray18::EV_STATUS_SOURCE13, bar); + let mut baz = irqarray18_csr.zf(utra::irqarray18::EV_STATUS_SOURCE13, bar); + baz |= irqarray18_csr.ms(utra::irqarray18::EV_STATUS_SOURCE13, 1); + irqarray18_csr.wfo(utra::irqarray18::EV_STATUS_SOURCE13, baz); + let bar = irqarray18_csr.rf(utra::irqarray18::EV_STATUS_SOURCE14); + irqarray18_csr.rmwf(utra::irqarray18::EV_STATUS_SOURCE14, bar); + let mut baz = irqarray18_csr.zf(utra::irqarray18::EV_STATUS_SOURCE14, bar); + baz |= irqarray18_csr.ms(utra::irqarray18::EV_STATUS_SOURCE14, 1); + irqarray18_csr.wfo(utra::irqarray18::EV_STATUS_SOURCE14, baz); + let bar = irqarray18_csr.rf(utra::irqarray18::EV_STATUS_SOURCE15); + irqarray18_csr.rmwf(utra::irqarray18::EV_STATUS_SOURCE15, bar); + let mut baz = irqarray18_csr.zf(utra::irqarray18::EV_STATUS_SOURCE15, bar); + baz |= irqarray18_csr.ms(utra::irqarray18::EV_STATUS_SOURCE15, 1); + irqarray18_csr.wfo(utra::irqarray18::EV_STATUS_SOURCE15, baz); + let bar = irqarray18_csr.rf(utra::irqarray18::EV_STATUS_SOURCE16); + irqarray18_csr.rmwf(utra::irqarray18::EV_STATUS_SOURCE16, bar); + let mut baz = irqarray18_csr.zf(utra::irqarray18::EV_STATUS_SOURCE16, bar); + baz |= irqarray18_csr.ms(utra::irqarray18::EV_STATUS_SOURCE16, 1); + irqarray18_csr.wfo(utra::irqarray18::EV_STATUS_SOURCE16, baz); + let bar = irqarray18_csr.rf(utra::irqarray18::EV_STATUS_SOURCE17); + irqarray18_csr.rmwf(utra::irqarray18::EV_STATUS_SOURCE17, bar); + let mut baz = irqarray18_csr.zf(utra::irqarray18::EV_STATUS_SOURCE17, bar); + baz |= irqarray18_csr.ms(utra::irqarray18::EV_STATUS_SOURCE17, 1); + irqarray18_csr.wfo(utra::irqarray18::EV_STATUS_SOURCE17, baz); + let bar = irqarray18_csr.rf(utra::irqarray18::EV_STATUS_SOURCE18); + irqarray18_csr.rmwf(utra::irqarray18::EV_STATUS_SOURCE18, bar); + let mut baz = irqarray18_csr.zf(utra::irqarray18::EV_STATUS_SOURCE18, bar); + baz |= irqarray18_csr.ms(utra::irqarray18::EV_STATUS_SOURCE18, 1); + irqarray18_csr.wfo(utra::irqarray18::EV_STATUS_SOURCE18, baz); + let bar = irqarray18_csr.rf(utra::irqarray18::EV_STATUS_SOURCE19); + irqarray18_csr.rmwf(utra::irqarray18::EV_STATUS_SOURCE19, bar); + let mut baz = irqarray18_csr.zf(utra::irqarray18::EV_STATUS_SOURCE19, bar); + baz |= irqarray18_csr.ms(utra::irqarray18::EV_STATUS_SOURCE19, 1); + irqarray18_csr.wfo(utra::irqarray18::EV_STATUS_SOURCE19, baz); + + let foo = irqarray18_csr.r(utra::irqarray18::EV_PENDING); + irqarray18_csr.wo(utra::irqarray18::EV_PENDING, foo); + let bar = irqarray18_csr.rf(utra::irqarray18::EV_PENDING_SOURCE0); + irqarray18_csr.rmwf(utra::irqarray18::EV_PENDING_SOURCE0, bar); + let mut baz = irqarray18_csr.zf(utra::irqarray18::EV_PENDING_SOURCE0, bar); + baz |= irqarray18_csr.ms(utra::irqarray18::EV_PENDING_SOURCE0, 1); + irqarray18_csr.wfo(utra::irqarray18::EV_PENDING_SOURCE0, baz); + let bar = irqarray18_csr.rf(utra::irqarray18::EV_PENDING_SOURCE1); + irqarray18_csr.rmwf(utra::irqarray18::EV_PENDING_SOURCE1, bar); + let mut baz = irqarray18_csr.zf(utra::irqarray18::EV_PENDING_SOURCE1, bar); + baz |= irqarray18_csr.ms(utra::irqarray18::EV_PENDING_SOURCE1, 1); + irqarray18_csr.wfo(utra::irqarray18::EV_PENDING_SOURCE1, baz); + let bar = irqarray18_csr.rf(utra::irqarray18::EV_PENDING_SOURCE2); + irqarray18_csr.rmwf(utra::irqarray18::EV_PENDING_SOURCE2, bar); + let mut baz = irqarray18_csr.zf(utra::irqarray18::EV_PENDING_SOURCE2, bar); + baz |= irqarray18_csr.ms(utra::irqarray18::EV_PENDING_SOURCE2, 1); + irqarray18_csr.wfo(utra::irqarray18::EV_PENDING_SOURCE2, baz); + let bar = irqarray18_csr.rf(utra::irqarray18::EV_PENDING_SOURCE3); + irqarray18_csr.rmwf(utra::irqarray18::EV_PENDING_SOURCE3, bar); + let mut baz = irqarray18_csr.zf(utra::irqarray18::EV_PENDING_SOURCE3, bar); + baz |= irqarray18_csr.ms(utra::irqarray18::EV_PENDING_SOURCE3, 1); + irqarray18_csr.wfo(utra::irqarray18::EV_PENDING_SOURCE3, baz); + let bar = irqarray18_csr.rf(utra::irqarray18::EV_PENDING_SOURCE4); + irqarray18_csr.rmwf(utra::irqarray18::EV_PENDING_SOURCE4, bar); + let mut baz = irqarray18_csr.zf(utra::irqarray18::EV_PENDING_SOURCE4, bar); + baz |= irqarray18_csr.ms(utra::irqarray18::EV_PENDING_SOURCE4, 1); + irqarray18_csr.wfo(utra::irqarray18::EV_PENDING_SOURCE4, baz); + let bar = irqarray18_csr.rf(utra::irqarray18::EV_PENDING_SOURCE5); + irqarray18_csr.rmwf(utra::irqarray18::EV_PENDING_SOURCE5, bar); + let mut baz = irqarray18_csr.zf(utra::irqarray18::EV_PENDING_SOURCE5, bar); + baz |= irqarray18_csr.ms(utra::irqarray18::EV_PENDING_SOURCE5, 1); + irqarray18_csr.wfo(utra::irqarray18::EV_PENDING_SOURCE5, baz); + let bar = irqarray18_csr.rf(utra::irqarray18::EV_PENDING_SOURCE6); + irqarray18_csr.rmwf(utra::irqarray18::EV_PENDING_SOURCE6, bar); + let mut baz = irqarray18_csr.zf(utra::irqarray18::EV_PENDING_SOURCE6, bar); + baz |= irqarray18_csr.ms(utra::irqarray18::EV_PENDING_SOURCE6, 1); + irqarray18_csr.wfo(utra::irqarray18::EV_PENDING_SOURCE6, baz); + let bar = irqarray18_csr.rf(utra::irqarray18::EV_PENDING_SOURCE7); + irqarray18_csr.rmwf(utra::irqarray18::EV_PENDING_SOURCE7, bar); + let mut baz = irqarray18_csr.zf(utra::irqarray18::EV_PENDING_SOURCE7, bar); + baz |= irqarray18_csr.ms(utra::irqarray18::EV_PENDING_SOURCE7, 1); + irqarray18_csr.wfo(utra::irqarray18::EV_PENDING_SOURCE7, baz); + let bar = irqarray18_csr.rf(utra::irqarray18::EV_PENDING_SOURCE8); + irqarray18_csr.rmwf(utra::irqarray18::EV_PENDING_SOURCE8, bar); + let mut baz = irqarray18_csr.zf(utra::irqarray18::EV_PENDING_SOURCE8, bar); + baz |= irqarray18_csr.ms(utra::irqarray18::EV_PENDING_SOURCE8, 1); + irqarray18_csr.wfo(utra::irqarray18::EV_PENDING_SOURCE8, baz); + let bar = irqarray18_csr.rf(utra::irqarray18::EV_PENDING_SOURCE9); + irqarray18_csr.rmwf(utra::irqarray18::EV_PENDING_SOURCE9, bar); + let mut baz = irqarray18_csr.zf(utra::irqarray18::EV_PENDING_SOURCE9, bar); + baz |= irqarray18_csr.ms(utra::irqarray18::EV_PENDING_SOURCE9, 1); + irqarray18_csr.wfo(utra::irqarray18::EV_PENDING_SOURCE9, baz); + let bar = irqarray18_csr.rf(utra::irqarray18::EV_PENDING_SOURCE10); + irqarray18_csr.rmwf(utra::irqarray18::EV_PENDING_SOURCE10, bar); + let mut baz = irqarray18_csr.zf(utra::irqarray18::EV_PENDING_SOURCE10, bar); + baz |= irqarray18_csr.ms(utra::irqarray18::EV_PENDING_SOURCE10, 1); + irqarray18_csr.wfo(utra::irqarray18::EV_PENDING_SOURCE10, baz); + let bar = irqarray18_csr.rf(utra::irqarray18::EV_PENDING_SOURCE11); + irqarray18_csr.rmwf(utra::irqarray18::EV_PENDING_SOURCE11, bar); + let mut baz = irqarray18_csr.zf(utra::irqarray18::EV_PENDING_SOURCE11, bar); + baz |= irqarray18_csr.ms(utra::irqarray18::EV_PENDING_SOURCE11, 1); + irqarray18_csr.wfo(utra::irqarray18::EV_PENDING_SOURCE11, baz); + let bar = irqarray18_csr.rf(utra::irqarray18::EV_PENDING_SOURCE12); + irqarray18_csr.rmwf(utra::irqarray18::EV_PENDING_SOURCE12, bar); + let mut baz = irqarray18_csr.zf(utra::irqarray18::EV_PENDING_SOURCE12, bar); + baz |= irqarray18_csr.ms(utra::irqarray18::EV_PENDING_SOURCE12, 1); + irqarray18_csr.wfo(utra::irqarray18::EV_PENDING_SOURCE12, baz); + let bar = irqarray18_csr.rf(utra::irqarray18::EV_PENDING_SOURCE13); + irqarray18_csr.rmwf(utra::irqarray18::EV_PENDING_SOURCE13, bar); + let mut baz = irqarray18_csr.zf(utra::irqarray18::EV_PENDING_SOURCE13, bar); + baz |= irqarray18_csr.ms(utra::irqarray18::EV_PENDING_SOURCE13, 1); + irqarray18_csr.wfo(utra::irqarray18::EV_PENDING_SOURCE13, baz); + let bar = irqarray18_csr.rf(utra::irqarray18::EV_PENDING_SOURCE14); + irqarray18_csr.rmwf(utra::irqarray18::EV_PENDING_SOURCE14, bar); + let mut baz = irqarray18_csr.zf(utra::irqarray18::EV_PENDING_SOURCE14, bar); + baz |= irqarray18_csr.ms(utra::irqarray18::EV_PENDING_SOURCE14, 1); + irqarray18_csr.wfo(utra::irqarray18::EV_PENDING_SOURCE14, baz); + let bar = irqarray18_csr.rf(utra::irqarray18::EV_PENDING_SOURCE15); + irqarray18_csr.rmwf(utra::irqarray18::EV_PENDING_SOURCE15, bar); + let mut baz = irqarray18_csr.zf(utra::irqarray18::EV_PENDING_SOURCE15, bar); + baz |= irqarray18_csr.ms(utra::irqarray18::EV_PENDING_SOURCE15, 1); + irqarray18_csr.wfo(utra::irqarray18::EV_PENDING_SOURCE15, baz); + let bar = irqarray18_csr.rf(utra::irqarray18::EV_PENDING_SOURCE16); + irqarray18_csr.rmwf(utra::irqarray18::EV_PENDING_SOURCE16, bar); + let mut baz = irqarray18_csr.zf(utra::irqarray18::EV_PENDING_SOURCE16, bar); + baz |= irqarray18_csr.ms(utra::irqarray18::EV_PENDING_SOURCE16, 1); + irqarray18_csr.wfo(utra::irqarray18::EV_PENDING_SOURCE16, baz); + let bar = irqarray18_csr.rf(utra::irqarray18::EV_PENDING_SOURCE17); + irqarray18_csr.rmwf(utra::irqarray18::EV_PENDING_SOURCE17, bar); + let mut baz = irqarray18_csr.zf(utra::irqarray18::EV_PENDING_SOURCE17, bar); + baz |= irqarray18_csr.ms(utra::irqarray18::EV_PENDING_SOURCE17, 1); + irqarray18_csr.wfo(utra::irqarray18::EV_PENDING_SOURCE17, baz); + let bar = irqarray18_csr.rf(utra::irqarray18::EV_PENDING_SOURCE18); + irqarray18_csr.rmwf(utra::irqarray18::EV_PENDING_SOURCE18, bar); + let mut baz = irqarray18_csr.zf(utra::irqarray18::EV_PENDING_SOURCE18, bar); + baz |= irqarray18_csr.ms(utra::irqarray18::EV_PENDING_SOURCE18, 1); + irqarray18_csr.wfo(utra::irqarray18::EV_PENDING_SOURCE18, baz); + let bar = irqarray18_csr.rf(utra::irqarray18::EV_PENDING_SOURCE19); + irqarray18_csr.rmwf(utra::irqarray18::EV_PENDING_SOURCE19, bar); + let mut baz = irqarray18_csr.zf(utra::irqarray18::EV_PENDING_SOURCE19, bar); + baz |= irqarray18_csr.ms(utra::irqarray18::EV_PENDING_SOURCE19, 1); + irqarray18_csr.wfo(utra::irqarray18::EV_PENDING_SOURCE19, baz); + + let foo = irqarray18_csr.r(utra::irqarray18::EV_ENABLE); + irqarray18_csr.wo(utra::irqarray18::EV_ENABLE, foo); + let bar = irqarray18_csr.rf(utra::irqarray18::EV_ENABLE_SOURCE0); + irqarray18_csr.rmwf(utra::irqarray18::EV_ENABLE_SOURCE0, bar); + let mut baz = irqarray18_csr.zf(utra::irqarray18::EV_ENABLE_SOURCE0, bar); + baz |= irqarray18_csr.ms(utra::irqarray18::EV_ENABLE_SOURCE0, 1); + irqarray18_csr.wfo(utra::irqarray18::EV_ENABLE_SOURCE0, baz); + let bar = irqarray18_csr.rf(utra::irqarray18::EV_ENABLE_SOURCE1); + irqarray18_csr.rmwf(utra::irqarray18::EV_ENABLE_SOURCE1, bar); + let mut baz = irqarray18_csr.zf(utra::irqarray18::EV_ENABLE_SOURCE1, bar); + baz |= irqarray18_csr.ms(utra::irqarray18::EV_ENABLE_SOURCE1, 1); + irqarray18_csr.wfo(utra::irqarray18::EV_ENABLE_SOURCE1, baz); + let bar = irqarray18_csr.rf(utra::irqarray18::EV_ENABLE_SOURCE2); + irqarray18_csr.rmwf(utra::irqarray18::EV_ENABLE_SOURCE2, bar); + let mut baz = irqarray18_csr.zf(utra::irqarray18::EV_ENABLE_SOURCE2, bar); + baz |= irqarray18_csr.ms(utra::irqarray18::EV_ENABLE_SOURCE2, 1); + irqarray18_csr.wfo(utra::irqarray18::EV_ENABLE_SOURCE2, baz); + let bar = irqarray18_csr.rf(utra::irqarray18::EV_ENABLE_SOURCE3); + irqarray18_csr.rmwf(utra::irqarray18::EV_ENABLE_SOURCE3, bar); + let mut baz = irqarray18_csr.zf(utra::irqarray18::EV_ENABLE_SOURCE3, bar); + baz |= irqarray18_csr.ms(utra::irqarray18::EV_ENABLE_SOURCE3, 1); + irqarray18_csr.wfo(utra::irqarray18::EV_ENABLE_SOURCE3, baz); + let bar = irqarray18_csr.rf(utra::irqarray18::EV_ENABLE_SOURCE4); + irqarray18_csr.rmwf(utra::irqarray18::EV_ENABLE_SOURCE4, bar); + let mut baz = irqarray18_csr.zf(utra::irqarray18::EV_ENABLE_SOURCE4, bar); + baz |= irqarray18_csr.ms(utra::irqarray18::EV_ENABLE_SOURCE4, 1); + irqarray18_csr.wfo(utra::irqarray18::EV_ENABLE_SOURCE4, baz); + let bar = irqarray18_csr.rf(utra::irqarray18::EV_ENABLE_SOURCE5); + irqarray18_csr.rmwf(utra::irqarray18::EV_ENABLE_SOURCE5, bar); + let mut baz = irqarray18_csr.zf(utra::irqarray18::EV_ENABLE_SOURCE5, bar); + baz |= irqarray18_csr.ms(utra::irqarray18::EV_ENABLE_SOURCE5, 1); + irqarray18_csr.wfo(utra::irqarray18::EV_ENABLE_SOURCE5, baz); + let bar = irqarray18_csr.rf(utra::irqarray18::EV_ENABLE_SOURCE6); + irqarray18_csr.rmwf(utra::irqarray18::EV_ENABLE_SOURCE6, bar); + let mut baz = irqarray18_csr.zf(utra::irqarray18::EV_ENABLE_SOURCE6, bar); + baz |= irqarray18_csr.ms(utra::irqarray18::EV_ENABLE_SOURCE6, 1); + irqarray18_csr.wfo(utra::irqarray18::EV_ENABLE_SOURCE6, baz); + let bar = irqarray18_csr.rf(utra::irqarray18::EV_ENABLE_SOURCE7); + irqarray18_csr.rmwf(utra::irqarray18::EV_ENABLE_SOURCE7, bar); + let mut baz = irqarray18_csr.zf(utra::irqarray18::EV_ENABLE_SOURCE7, bar); + baz |= irqarray18_csr.ms(utra::irqarray18::EV_ENABLE_SOURCE7, 1); + irqarray18_csr.wfo(utra::irqarray18::EV_ENABLE_SOURCE7, baz); + let bar = irqarray18_csr.rf(utra::irqarray18::EV_ENABLE_SOURCE8); + irqarray18_csr.rmwf(utra::irqarray18::EV_ENABLE_SOURCE8, bar); + let mut baz = irqarray18_csr.zf(utra::irqarray18::EV_ENABLE_SOURCE8, bar); + baz |= irqarray18_csr.ms(utra::irqarray18::EV_ENABLE_SOURCE8, 1); + irqarray18_csr.wfo(utra::irqarray18::EV_ENABLE_SOURCE8, baz); + let bar = irqarray18_csr.rf(utra::irqarray18::EV_ENABLE_SOURCE9); + irqarray18_csr.rmwf(utra::irqarray18::EV_ENABLE_SOURCE9, bar); + let mut baz = irqarray18_csr.zf(utra::irqarray18::EV_ENABLE_SOURCE9, bar); + baz |= irqarray18_csr.ms(utra::irqarray18::EV_ENABLE_SOURCE9, 1); + irqarray18_csr.wfo(utra::irqarray18::EV_ENABLE_SOURCE9, baz); + let bar = irqarray18_csr.rf(utra::irqarray18::EV_ENABLE_SOURCE10); + irqarray18_csr.rmwf(utra::irqarray18::EV_ENABLE_SOURCE10, bar); + let mut baz = irqarray18_csr.zf(utra::irqarray18::EV_ENABLE_SOURCE10, bar); + baz |= irqarray18_csr.ms(utra::irqarray18::EV_ENABLE_SOURCE10, 1); + irqarray18_csr.wfo(utra::irqarray18::EV_ENABLE_SOURCE10, baz); + let bar = irqarray18_csr.rf(utra::irqarray18::EV_ENABLE_SOURCE11); + irqarray18_csr.rmwf(utra::irqarray18::EV_ENABLE_SOURCE11, bar); + let mut baz = irqarray18_csr.zf(utra::irqarray18::EV_ENABLE_SOURCE11, bar); + baz |= irqarray18_csr.ms(utra::irqarray18::EV_ENABLE_SOURCE11, 1); + irqarray18_csr.wfo(utra::irqarray18::EV_ENABLE_SOURCE11, baz); + let bar = irqarray18_csr.rf(utra::irqarray18::EV_ENABLE_SOURCE12); + irqarray18_csr.rmwf(utra::irqarray18::EV_ENABLE_SOURCE12, bar); + let mut baz = irqarray18_csr.zf(utra::irqarray18::EV_ENABLE_SOURCE12, bar); + baz |= irqarray18_csr.ms(utra::irqarray18::EV_ENABLE_SOURCE12, 1); + irqarray18_csr.wfo(utra::irqarray18::EV_ENABLE_SOURCE12, baz); + let bar = irqarray18_csr.rf(utra::irqarray18::EV_ENABLE_SOURCE13); + irqarray18_csr.rmwf(utra::irqarray18::EV_ENABLE_SOURCE13, bar); + let mut baz = irqarray18_csr.zf(utra::irqarray18::EV_ENABLE_SOURCE13, bar); + baz |= irqarray18_csr.ms(utra::irqarray18::EV_ENABLE_SOURCE13, 1); + irqarray18_csr.wfo(utra::irqarray18::EV_ENABLE_SOURCE13, baz); + let bar = irqarray18_csr.rf(utra::irqarray18::EV_ENABLE_SOURCE14); + irqarray18_csr.rmwf(utra::irqarray18::EV_ENABLE_SOURCE14, bar); + let mut baz = irqarray18_csr.zf(utra::irqarray18::EV_ENABLE_SOURCE14, bar); + baz |= irqarray18_csr.ms(utra::irqarray18::EV_ENABLE_SOURCE14, 1); + irqarray18_csr.wfo(utra::irqarray18::EV_ENABLE_SOURCE14, baz); + let bar = irqarray18_csr.rf(utra::irqarray18::EV_ENABLE_SOURCE15); + irqarray18_csr.rmwf(utra::irqarray18::EV_ENABLE_SOURCE15, bar); + let mut baz = irqarray18_csr.zf(utra::irqarray18::EV_ENABLE_SOURCE15, bar); + baz |= irqarray18_csr.ms(utra::irqarray18::EV_ENABLE_SOURCE15, 1); + irqarray18_csr.wfo(utra::irqarray18::EV_ENABLE_SOURCE15, baz); + let bar = irqarray18_csr.rf(utra::irqarray18::EV_ENABLE_SOURCE16); + irqarray18_csr.rmwf(utra::irqarray18::EV_ENABLE_SOURCE16, bar); + let mut baz = irqarray18_csr.zf(utra::irqarray18::EV_ENABLE_SOURCE16, bar); + baz |= irqarray18_csr.ms(utra::irqarray18::EV_ENABLE_SOURCE16, 1); + irqarray18_csr.wfo(utra::irqarray18::EV_ENABLE_SOURCE16, baz); + let bar = irqarray18_csr.rf(utra::irqarray18::EV_ENABLE_SOURCE17); + irqarray18_csr.rmwf(utra::irqarray18::EV_ENABLE_SOURCE17, bar); + let mut baz = irqarray18_csr.zf(utra::irqarray18::EV_ENABLE_SOURCE17, bar); + baz |= irqarray18_csr.ms(utra::irqarray18::EV_ENABLE_SOURCE17, 1); + irqarray18_csr.wfo(utra::irqarray18::EV_ENABLE_SOURCE17, baz); + let bar = irqarray18_csr.rf(utra::irqarray18::EV_ENABLE_SOURCE18); + irqarray18_csr.rmwf(utra::irqarray18::EV_ENABLE_SOURCE18, bar); + let mut baz = irqarray18_csr.zf(utra::irqarray18::EV_ENABLE_SOURCE18, bar); + baz |= irqarray18_csr.ms(utra::irqarray18::EV_ENABLE_SOURCE18, 1); + irqarray18_csr.wfo(utra::irqarray18::EV_ENABLE_SOURCE18, baz); + let bar = irqarray18_csr.rf(utra::irqarray18::EV_ENABLE_SOURCE19); + irqarray18_csr.rmwf(utra::irqarray18::EV_ENABLE_SOURCE19, bar); + let mut baz = irqarray18_csr.zf(utra::irqarray18::EV_ENABLE_SOURCE19, bar); + baz |= irqarray18_csr.ms(utra::irqarray18::EV_ENABLE_SOURCE19, 1); + irqarray18_csr.wfo(utra::irqarray18::EV_ENABLE_SOURCE19, baz); + } + + #[test] + #[ignore] + fn compile_check_irqarray19_csr() { + use super::*; + let mut irqarray19_csr = CSR::new(HW_IRQARRAY19_BASE as *mut u32); + + let foo = irqarray19_csr.r(utra::irqarray19::EV_SOFT); + irqarray19_csr.wo(utra::irqarray19::EV_SOFT, foo); + let bar = irqarray19_csr.rf(utra::irqarray19::EV_SOFT_TRIGGER); + irqarray19_csr.rmwf(utra::irqarray19::EV_SOFT_TRIGGER, bar); + let mut baz = irqarray19_csr.zf(utra::irqarray19::EV_SOFT_TRIGGER, bar); + baz |= irqarray19_csr.ms(utra::irqarray19::EV_SOFT_TRIGGER, 1); + irqarray19_csr.wfo(utra::irqarray19::EV_SOFT_TRIGGER, baz); + + let foo = irqarray19_csr.r(utra::irqarray19::EV_STATUS); + irqarray19_csr.wo(utra::irqarray19::EV_STATUS, foo); + let bar = irqarray19_csr.rf(utra::irqarray19::EV_STATUS_SOURCE0); + irqarray19_csr.rmwf(utra::irqarray19::EV_STATUS_SOURCE0, bar); + let mut baz = irqarray19_csr.zf(utra::irqarray19::EV_STATUS_SOURCE0, bar); + baz |= irqarray19_csr.ms(utra::irqarray19::EV_STATUS_SOURCE0, 1); + irqarray19_csr.wfo(utra::irqarray19::EV_STATUS_SOURCE0, baz); + let bar = irqarray19_csr.rf(utra::irqarray19::EV_STATUS_SOURCE1); + irqarray19_csr.rmwf(utra::irqarray19::EV_STATUS_SOURCE1, bar); + let mut baz = irqarray19_csr.zf(utra::irqarray19::EV_STATUS_SOURCE1, bar); + baz |= irqarray19_csr.ms(utra::irqarray19::EV_STATUS_SOURCE1, 1); + irqarray19_csr.wfo(utra::irqarray19::EV_STATUS_SOURCE1, baz); + let bar = irqarray19_csr.rf(utra::irqarray19::EV_STATUS_SOURCE2); + irqarray19_csr.rmwf(utra::irqarray19::EV_STATUS_SOURCE2, bar); + let mut baz = irqarray19_csr.zf(utra::irqarray19::EV_STATUS_SOURCE2, bar); + baz |= irqarray19_csr.ms(utra::irqarray19::EV_STATUS_SOURCE2, 1); + irqarray19_csr.wfo(utra::irqarray19::EV_STATUS_SOURCE2, baz); + let bar = irqarray19_csr.rf(utra::irqarray19::EV_STATUS_SOURCE3); + irqarray19_csr.rmwf(utra::irqarray19::EV_STATUS_SOURCE3, bar); + let mut baz = irqarray19_csr.zf(utra::irqarray19::EV_STATUS_SOURCE3, bar); + baz |= irqarray19_csr.ms(utra::irqarray19::EV_STATUS_SOURCE3, 1); + irqarray19_csr.wfo(utra::irqarray19::EV_STATUS_SOURCE3, baz); + let bar = irqarray19_csr.rf(utra::irqarray19::EV_STATUS_SOURCE4); + irqarray19_csr.rmwf(utra::irqarray19::EV_STATUS_SOURCE4, bar); + let mut baz = irqarray19_csr.zf(utra::irqarray19::EV_STATUS_SOURCE4, bar); + baz |= irqarray19_csr.ms(utra::irqarray19::EV_STATUS_SOURCE4, 1); + irqarray19_csr.wfo(utra::irqarray19::EV_STATUS_SOURCE4, baz); + let bar = irqarray19_csr.rf(utra::irqarray19::EV_STATUS_SOURCE5); + irqarray19_csr.rmwf(utra::irqarray19::EV_STATUS_SOURCE5, bar); + let mut baz = irqarray19_csr.zf(utra::irqarray19::EV_STATUS_SOURCE5, bar); + baz |= irqarray19_csr.ms(utra::irqarray19::EV_STATUS_SOURCE5, 1); + irqarray19_csr.wfo(utra::irqarray19::EV_STATUS_SOURCE5, baz); + let bar = irqarray19_csr.rf(utra::irqarray19::EV_STATUS_SOURCE6); + irqarray19_csr.rmwf(utra::irqarray19::EV_STATUS_SOURCE6, bar); + let mut baz = irqarray19_csr.zf(utra::irqarray19::EV_STATUS_SOURCE6, bar); + baz |= irqarray19_csr.ms(utra::irqarray19::EV_STATUS_SOURCE6, 1); + irqarray19_csr.wfo(utra::irqarray19::EV_STATUS_SOURCE6, baz); + let bar = irqarray19_csr.rf(utra::irqarray19::EV_STATUS_SOURCE7); + irqarray19_csr.rmwf(utra::irqarray19::EV_STATUS_SOURCE7, bar); + let mut baz = irqarray19_csr.zf(utra::irqarray19::EV_STATUS_SOURCE7, bar); + baz |= irqarray19_csr.ms(utra::irqarray19::EV_STATUS_SOURCE7, 1); + irqarray19_csr.wfo(utra::irqarray19::EV_STATUS_SOURCE7, baz); + let bar = irqarray19_csr.rf(utra::irqarray19::EV_STATUS_SOURCE8); + irqarray19_csr.rmwf(utra::irqarray19::EV_STATUS_SOURCE8, bar); + let mut baz = irqarray19_csr.zf(utra::irqarray19::EV_STATUS_SOURCE8, bar); + baz |= irqarray19_csr.ms(utra::irqarray19::EV_STATUS_SOURCE8, 1); + irqarray19_csr.wfo(utra::irqarray19::EV_STATUS_SOURCE8, baz); + let bar = irqarray19_csr.rf(utra::irqarray19::EV_STATUS_SOURCE9); + irqarray19_csr.rmwf(utra::irqarray19::EV_STATUS_SOURCE9, bar); + let mut baz = irqarray19_csr.zf(utra::irqarray19::EV_STATUS_SOURCE9, bar); + baz |= irqarray19_csr.ms(utra::irqarray19::EV_STATUS_SOURCE9, 1); + irqarray19_csr.wfo(utra::irqarray19::EV_STATUS_SOURCE9, baz); + let bar = irqarray19_csr.rf(utra::irqarray19::EV_STATUS_SOURCE10); + irqarray19_csr.rmwf(utra::irqarray19::EV_STATUS_SOURCE10, bar); + let mut baz = irqarray19_csr.zf(utra::irqarray19::EV_STATUS_SOURCE10, bar); + baz |= irqarray19_csr.ms(utra::irqarray19::EV_STATUS_SOURCE10, 1); + irqarray19_csr.wfo(utra::irqarray19::EV_STATUS_SOURCE10, baz); + let bar = irqarray19_csr.rf(utra::irqarray19::EV_STATUS_SOURCE11); + irqarray19_csr.rmwf(utra::irqarray19::EV_STATUS_SOURCE11, bar); + let mut baz = irqarray19_csr.zf(utra::irqarray19::EV_STATUS_SOURCE11, bar); + baz |= irqarray19_csr.ms(utra::irqarray19::EV_STATUS_SOURCE11, 1); + irqarray19_csr.wfo(utra::irqarray19::EV_STATUS_SOURCE11, baz); + let bar = irqarray19_csr.rf(utra::irqarray19::EV_STATUS_SOURCE12); + irqarray19_csr.rmwf(utra::irqarray19::EV_STATUS_SOURCE12, bar); + let mut baz = irqarray19_csr.zf(utra::irqarray19::EV_STATUS_SOURCE12, bar); + baz |= irqarray19_csr.ms(utra::irqarray19::EV_STATUS_SOURCE12, 1); + irqarray19_csr.wfo(utra::irqarray19::EV_STATUS_SOURCE12, baz); + let bar = irqarray19_csr.rf(utra::irqarray19::EV_STATUS_SOURCE13); + irqarray19_csr.rmwf(utra::irqarray19::EV_STATUS_SOURCE13, bar); + let mut baz = irqarray19_csr.zf(utra::irqarray19::EV_STATUS_SOURCE13, bar); + baz |= irqarray19_csr.ms(utra::irqarray19::EV_STATUS_SOURCE13, 1); + irqarray19_csr.wfo(utra::irqarray19::EV_STATUS_SOURCE13, baz); + let bar = irqarray19_csr.rf(utra::irqarray19::EV_STATUS_SOURCE14); + irqarray19_csr.rmwf(utra::irqarray19::EV_STATUS_SOURCE14, bar); + let mut baz = irqarray19_csr.zf(utra::irqarray19::EV_STATUS_SOURCE14, bar); + baz |= irqarray19_csr.ms(utra::irqarray19::EV_STATUS_SOURCE14, 1); + irqarray19_csr.wfo(utra::irqarray19::EV_STATUS_SOURCE14, baz); + let bar = irqarray19_csr.rf(utra::irqarray19::EV_STATUS_SOURCE15); + irqarray19_csr.rmwf(utra::irqarray19::EV_STATUS_SOURCE15, bar); + let mut baz = irqarray19_csr.zf(utra::irqarray19::EV_STATUS_SOURCE15, bar); + baz |= irqarray19_csr.ms(utra::irqarray19::EV_STATUS_SOURCE15, 1); + irqarray19_csr.wfo(utra::irqarray19::EV_STATUS_SOURCE15, baz); + let bar = irqarray19_csr.rf(utra::irqarray19::EV_STATUS_SOURCE16); + irqarray19_csr.rmwf(utra::irqarray19::EV_STATUS_SOURCE16, bar); + let mut baz = irqarray19_csr.zf(utra::irqarray19::EV_STATUS_SOURCE16, bar); + baz |= irqarray19_csr.ms(utra::irqarray19::EV_STATUS_SOURCE16, 1); + irqarray19_csr.wfo(utra::irqarray19::EV_STATUS_SOURCE16, baz); + let bar = irqarray19_csr.rf(utra::irqarray19::EV_STATUS_SOURCE17); + irqarray19_csr.rmwf(utra::irqarray19::EV_STATUS_SOURCE17, bar); + let mut baz = irqarray19_csr.zf(utra::irqarray19::EV_STATUS_SOURCE17, bar); + baz |= irqarray19_csr.ms(utra::irqarray19::EV_STATUS_SOURCE17, 1); + irqarray19_csr.wfo(utra::irqarray19::EV_STATUS_SOURCE17, baz); + let bar = irqarray19_csr.rf(utra::irqarray19::EV_STATUS_SOURCE18); + irqarray19_csr.rmwf(utra::irqarray19::EV_STATUS_SOURCE18, bar); + let mut baz = irqarray19_csr.zf(utra::irqarray19::EV_STATUS_SOURCE18, bar); + baz |= irqarray19_csr.ms(utra::irqarray19::EV_STATUS_SOURCE18, 1); + irqarray19_csr.wfo(utra::irqarray19::EV_STATUS_SOURCE18, baz); + let bar = irqarray19_csr.rf(utra::irqarray19::EV_STATUS_SOURCE19); + irqarray19_csr.rmwf(utra::irqarray19::EV_STATUS_SOURCE19, bar); + let mut baz = irqarray19_csr.zf(utra::irqarray19::EV_STATUS_SOURCE19, bar); + baz |= irqarray19_csr.ms(utra::irqarray19::EV_STATUS_SOURCE19, 1); + irqarray19_csr.wfo(utra::irqarray19::EV_STATUS_SOURCE19, baz); + + let foo = irqarray19_csr.r(utra::irqarray19::EV_PENDING); + irqarray19_csr.wo(utra::irqarray19::EV_PENDING, foo); + let bar = irqarray19_csr.rf(utra::irqarray19::EV_PENDING_SOURCE0); + irqarray19_csr.rmwf(utra::irqarray19::EV_PENDING_SOURCE0, bar); + let mut baz = irqarray19_csr.zf(utra::irqarray19::EV_PENDING_SOURCE0, bar); + baz |= irqarray19_csr.ms(utra::irqarray19::EV_PENDING_SOURCE0, 1); + irqarray19_csr.wfo(utra::irqarray19::EV_PENDING_SOURCE0, baz); + let bar = irqarray19_csr.rf(utra::irqarray19::EV_PENDING_SOURCE1); + irqarray19_csr.rmwf(utra::irqarray19::EV_PENDING_SOURCE1, bar); + let mut baz = irqarray19_csr.zf(utra::irqarray19::EV_PENDING_SOURCE1, bar); + baz |= irqarray19_csr.ms(utra::irqarray19::EV_PENDING_SOURCE1, 1); + irqarray19_csr.wfo(utra::irqarray19::EV_PENDING_SOURCE1, baz); + let bar = irqarray19_csr.rf(utra::irqarray19::EV_PENDING_SOURCE2); + irqarray19_csr.rmwf(utra::irqarray19::EV_PENDING_SOURCE2, bar); + let mut baz = irqarray19_csr.zf(utra::irqarray19::EV_PENDING_SOURCE2, bar); + baz |= irqarray19_csr.ms(utra::irqarray19::EV_PENDING_SOURCE2, 1); + irqarray19_csr.wfo(utra::irqarray19::EV_PENDING_SOURCE2, baz); + let bar = irqarray19_csr.rf(utra::irqarray19::EV_PENDING_SOURCE3); + irqarray19_csr.rmwf(utra::irqarray19::EV_PENDING_SOURCE3, bar); + let mut baz = irqarray19_csr.zf(utra::irqarray19::EV_PENDING_SOURCE3, bar); + baz |= irqarray19_csr.ms(utra::irqarray19::EV_PENDING_SOURCE3, 1); + irqarray19_csr.wfo(utra::irqarray19::EV_PENDING_SOURCE3, baz); + let bar = irqarray19_csr.rf(utra::irqarray19::EV_PENDING_SOURCE4); + irqarray19_csr.rmwf(utra::irqarray19::EV_PENDING_SOURCE4, bar); + let mut baz = irqarray19_csr.zf(utra::irqarray19::EV_PENDING_SOURCE4, bar); + baz |= irqarray19_csr.ms(utra::irqarray19::EV_PENDING_SOURCE4, 1); + irqarray19_csr.wfo(utra::irqarray19::EV_PENDING_SOURCE4, baz); + let bar = irqarray19_csr.rf(utra::irqarray19::EV_PENDING_SOURCE5); + irqarray19_csr.rmwf(utra::irqarray19::EV_PENDING_SOURCE5, bar); + let mut baz = irqarray19_csr.zf(utra::irqarray19::EV_PENDING_SOURCE5, bar); + baz |= irqarray19_csr.ms(utra::irqarray19::EV_PENDING_SOURCE5, 1); + irqarray19_csr.wfo(utra::irqarray19::EV_PENDING_SOURCE5, baz); + let bar = irqarray19_csr.rf(utra::irqarray19::EV_PENDING_SOURCE6); + irqarray19_csr.rmwf(utra::irqarray19::EV_PENDING_SOURCE6, bar); + let mut baz = irqarray19_csr.zf(utra::irqarray19::EV_PENDING_SOURCE6, bar); + baz |= irqarray19_csr.ms(utra::irqarray19::EV_PENDING_SOURCE6, 1); + irqarray19_csr.wfo(utra::irqarray19::EV_PENDING_SOURCE6, baz); + let bar = irqarray19_csr.rf(utra::irqarray19::EV_PENDING_SOURCE7); + irqarray19_csr.rmwf(utra::irqarray19::EV_PENDING_SOURCE7, bar); + let mut baz = irqarray19_csr.zf(utra::irqarray19::EV_PENDING_SOURCE7, bar); + baz |= irqarray19_csr.ms(utra::irqarray19::EV_PENDING_SOURCE7, 1); + irqarray19_csr.wfo(utra::irqarray19::EV_PENDING_SOURCE7, baz); + let bar = irqarray19_csr.rf(utra::irqarray19::EV_PENDING_SOURCE8); + irqarray19_csr.rmwf(utra::irqarray19::EV_PENDING_SOURCE8, bar); + let mut baz = irqarray19_csr.zf(utra::irqarray19::EV_PENDING_SOURCE8, bar); + baz |= irqarray19_csr.ms(utra::irqarray19::EV_PENDING_SOURCE8, 1); + irqarray19_csr.wfo(utra::irqarray19::EV_PENDING_SOURCE8, baz); + let bar = irqarray19_csr.rf(utra::irqarray19::EV_PENDING_SOURCE9); + irqarray19_csr.rmwf(utra::irqarray19::EV_PENDING_SOURCE9, bar); + let mut baz = irqarray19_csr.zf(utra::irqarray19::EV_PENDING_SOURCE9, bar); + baz |= irqarray19_csr.ms(utra::irqarray19::EV_PENDING_SOURCE9, 1); + irqarray19_csr.wfo(utra::irqarray19::EV_PENDING_SOURCE9, baz); + let bar = irqarray19_csr.rf(utra::irqarray19::EV_PENDING_SOURCE10); + irqarray19_csr.rmwf(utra::irqarray19::EV_PENDING_SOURCE10, bar); + let mut baz = irqarray19_csr.zf(utra::irqarray19::EV_PENDING_SOURCE10, bar); + baz |= irqarray19_csr.ms(utra::irqarray19::EV_PENDING_SOURCE10, 1); + irqarray19_csr.wfo(utra::irqarray19::EV_PENDING_SOURCE10, baz); + let bar = irqarray19_csr.rf(utra::irqarray19::EV_PENDING_SOURCE11); + irqarray19_csr.rmwf(utra::irqarray19::EV_PENDING_SOURCE11, bar); + let mut baz = irqarray19_csr.zf(utra::irqarray19::EV_PENDING_SOURCE11, bar); + baz |= irqarray19_csr.ms(utra::irqarray19::EV_PENDING_SOURCE11, 1); + irqarray19_csr.wfo(utra::irqarray19::EV_PENDING_SOURCE11, baz); + let bar = irqarray19_csr.rf(utra::irqarray19::EV_PENDING_SOURCE12); + irqarray19_csr.rmwf(utra::irqarray19::EV_PENDING_SOURCE12, bar); + let mut baz = irqarray19_csr.zf(utra::irqarray19::EV_PENDING_SOURCE12, bar); + baz |= irqarray19_csr.ms(utra::irqarray19::EV_PENDING_SOURCE12, 1); + irqarray19_csr.wfo(utra::irqarray19::EV_PENDING_SOURCE12, baz); + let bar = irqarray19_csr.rf(utra::irqarray19::EV_PENDING_SOURCE13); + irqarray19_csr.rmwf(utra::irqarray19::EV_PENDING_SOURCE13, bar); + let mut baz = irqarray19_csr.zf(utra::irqarray19::EV_PENDING_SOURCE13, bar); + baz |= irqarray19_csr.ms(utra::irqarray19::EV_PENDING_SOURCE13, 1); + irqarray19_csr.wfo(utra::irqarray19::EV_PENDING_SOURCE13, baz); + let bar = irqarray19_csr.rf(utra::irqarray19::EV_PENDING_SOURCE14); + irqarray19_csr.rmwf(utra::irqarray19::EV_PENDING_SOURCE14, bar); + let mut baz = irqarray19_csr.zf(utra::irqarray19::EV_PENDING_SOURCE14, bar); + baz |= irqarray19_csr.ms(utra::irqarray19::EV_PENDING_SOURCE14, 1); + irqarray19_csr.wfo(utra::irqarray19::EV_PENDING_SOURCE14, baz); + let bar = irqarray19_csr.rf(utra::irqarray19::EV_PENDING_SOURCE15); + irqarray19_csr.rmwf(utra::irqarray19::EV_PENDING_SOURCE15, bar); + let mut baz = irqarray19_csr.zf(utra::irqarray19::EV_PENDING_SOURCE15, bar); + baz |= irqarray19_csr.ms(utra::irqarray19::EV_PENDING_SOURCE15, 1); + irqarray19_csr.wfo(utra::irqarray19::EV_PENDING_SOURCE15, baz); + let bar = irqarray19_csr.rf(utra::irqarray19::EV_PENDING_SOURCE16); + irqarray19_csr.rmwf(utra::irqarray19::EV_PENDING_SOURCE16, bar); + let mut baz = irqarray19_csr.zf(utra::irqarray19::EV_PENDING_SOURCE16, bar); + baz |= irqarray19_csr.ms(utra::irqarray19::EV_PENDING_SOURCE16, 1); + irqarray19_csr.wfo(utra::irqarray19::EV_PENDING_SOURCE16, baz); + let bar = irqarray19_csr.rf(utra::irqarray19::EV_PENDING_SOURCE17); + irqarray19_csr.rmwf(utra::irqarray19::EV_PENDING_SOURCE17, bar); + let mut baz = irqarray19_csr.zf(utra::irqarray19::EV_PENDING_SOURCE17, bar); + baz |= irqarray19_csr.ms(utra::irqarray19::EV_PENDING_SOURCE17, 1); + irqarray19_csr.wfo(utra::irqarray19::EV_PENDING_SOURCE17, baz); + let bar = irqarray19_csr.rf(utra::irqarray19::EV_PENDING_SOURCE18); + irqarray19_csr.rmwf(utra::irqarray19::EV_PENDING_SOURCE18, bar); + let mut baz = irqarray19_csr.zf(utra::irqarray19::EV_PENDING_SOURCE18, bar); + baz |= irqarray19_csr.ms(utra::irqarray19::EV_PENDING_SOURCE18, 1); + irqarray19_csr.wfo(utra::irqarray19::EV_PENDING_SOURCE18, baz); + let bar = irqarray19_csr.rf(utra::irqarray19::EV_PENDING_SOURCE19); + irqarray19_csr.rmwf(utra::irqarray19::EV_PENDING_SOURCE19, bar); + let mut baz = irqarray19_csr.zf(utra::irqarray19::EV_PENDING_SOURCE19, bar); + baz |= irqarray19_csr.ms(utra::irqarray19::EV_PENDING_SOURCE19, 1); + irqarray19_csr.wfo(utra::irqarray19::EV_PENDING_SOURCE19, baz); + + let foo = irqarray19_csr.r(utra::irqarray19::EV_ENABLE); + irqarray19_csr.wo(utra::irqarray19::EV_ENABLE, foo); + let bar = irqarray19_csr.rf(utra::irqarray19::EV_ENABLE_SOURCE0); + irqarray19_csr.rmwf(utra::irqarray19::EV_ENABLE_SOURCE0, bar); + let mut baz = irqarray19_csr.zf(utra::irqarray19::EV_ENABLE_SOURCE0, bar); + baz |= irqarray19_csr.ms(utra::irqarray19::EV_ENABLE_SOURCE0, 1); + irqarray19_csr.wfo(utra::irqarray19::EV_ENABLE_SOURCE0, baz); + let bar = irqarray19_csr.rf(utra::irqarray19::EV_ENABLE_SOURCE1); + irqarray19_csr.rmwf(utra::irqarray19::EV_ENABLE_SOURCE1, bar); + let mut baz = irqarray19_csr.zf(utra::irqarray19::EV_ENABLE_SOURCE1, bar); + baz |= irqarray19_csr.ms(utra::irqarray19::EV_ENABLE_SOURCE1, 1); + irqarray19_csr.wfo(utra::irqarray19::EV_ENABLE_SOURCE1, baz); + let bar = irqarray19_csr.rf(utra::irqarray19::EV_ENABLE_SOURCE2); + irqarray19_csr.rmwf(utra::irqarray19::EV_ENABLE_SOURCE2, bar); + let mut baz = irqarray19_csr.zf(utra::irqarray19::EV_ENABLE_SOURCE2, bar); + baz |= irqarray19_csr.ms(utra::irqarray19::EV_ENABLE_SOURCE2, 1); + irqarray19_csr.wfo(utra::irqarray19::EV_ENABLE_SOURCE2, baz); + let bar = irqarray19_csr.rf(utra::irqarray19::EV_ENABLE_SOURCE3); + irqarray19_csr.rmwf(utra::irqarray19::EV_ENABLE_SOURCE3, bar); + let mut baz = irqarray19_csr.zf(utra::irqarray19::EV_ENABLE_SOURCE3, bar); + baz |= irqarray19_csr.ms(utra::irqarray19::EV_ENABLE_SOURCE3, 1); + irqarray19_csr.wfo(utra::irqarray19::EV_ENABLE_SOURCE3, baz); + let bar = irqarray19_csr.rf(utra::irqarray19::EV_ENABLE_SOURCE4); + irqarray19_csr.rmwf(utra::irqarray19::EV_ENABLE_SOURCE4, bar); + let mut baz = irqarray19_csr.zf(utra::irqarray19::EV_ENABLE_SOURCE4, bar); + baz |= irqarray19_csr.ms(utra::irqarray19::EV_ENABLE_SOURCE4, 1); + irqarray19_csr.wfo(utra::irqarray19::EV_ENABLE_SOURCE4, baz); + let bar = irqarray19_csr.rf(utra::irqarray19::EV_ENABLE_SOURCE5); + irqarray19_csr.rmwf(utra::irqarray19::EV_ENABLE_SOURCE5, bar); + let mut baz = irqarray19_csr.zf(utra::irqarray19::EV_ENABLE_SOURCE5, bar); + baz |= irqarray19_csr.ms(utra::irqarray19::EV_ENABLE_SOURCE5, 1); + irqarray19_csr.wfo(utra::irqarray19::EV_ENABLE_SOURCE5, baz); + let bar = irqarray19_csr.rf(utra::irqarray19::EV_ENABLE_SOURCE6); + irqarray19_csr.rmwf(utra::irqarray19::EV_ENABLE_SOURCE6, bar); + let mut baz = irqarray19_csr.zf(utra::irqarray19::EV_ENABLE_SOURCE6, bar); + baz |= irqarray19_csr.ms(utra::irqarray19::EV_ENABLE_SOURCE6, 1); + irqarray19_csr.wfo(utra::irqarray19::EV_ENABLE_SOURCE6, baz); + let bar = irqarray19_csr.rf(utra::irqarray19::EV_ENABLE_SOURCE7); + irqarray19_csr.rmwf(utra::irqarray19::EV_ENABLE_SOURCE7, bar); + let mut baz = irqarray19_csr.zf(utra::irqarray19::EV_ENABLE_SOURCE7, bar); + baz |= irqarray19_csr.ms(utra::irqarray19::EV_ENABLE_SOURCE7, 1); + irqarray19_csr.wfo(utra::irqarray19::EV_ENABLE_SOURCE7, baz); + let bar = irqarray19_csr.rf(utra::irqarray19::EV_ENABLE_SOURCE8); + irqarray19_csr.rmwf(utra::irqarray19::EV_ENABLE_SOURCE8, bar); + let mut baz = irqarray19_csr.zf(utra::irqarray19::EV_ENABLE_SOURCE8, bar); + baz |= irqarray19_csr.ms(utra::irqarray19::EV_ENABLE_SOURCE8, 1); + irqarray19_csr.wfo(utra::irqarray19::EV_ENABLE_SOURCE8, baz); + let bar = irqarray19_csr.rf(utra::irqarray19::EV_ENABLE_SOURCE9); + irqarray19_csr.rmwf(utra::irqarray19::EV_ENABLE_SOURCE9, bar); + let mut baz = irqarray19_csr.zf(utra::irqarray19::EV_ENABLE_SOURCE9, bar); + baz |= irqarray19_csr.ms(utra::irqarray19::EV_ENABLE_SOURCE9, 1); + irqarray19_csr.wfo(utra::irqarray19::EV_ENABLE_SOURCE9, baz); + let bar = irqarray19_csr.rf(utra::irqarray19::EV_ENABLE_SOURCE10); + irqarray19_csr.rmwf(utra::irqarray19::EV_ENABLE_SOURCE10, bar); + let mut baz = irqarray19_csr.zf(utra::irqarray19::EV_ENABLE_SOURCE10, bar); + baz |= irqarray19_csr.ms(utra::irqarray19::EV_ENABLE_SOURCE10, 1); + irqarray19_csr.wfo(utra::irqarray19::EV_ENABLE_SOURCE10, baz); + let bar = irqarray19_csr.rf(utra::irqarray19::EV_ENABLE_SOURCE11); + irqarray19_csr.rmwf(utra::irqarray19::EV_ENABLE_SOURCE11, bar); + let mut baz = irqarray19_csr.zf(utra::irqarray19::EV_ENABLE_SOURCE11, bar); + baz |= irqarray19_csr.ms(utra::irqarray19::EV_ENABLE_SOURCE11, 1); + irqarray19_csr.wfo(utra::irqarray19::EV_ENABLE_SOURCE11, baz); + let bar = irqarray19_csr.rf(utra::irqarray19::EV_ENABLE_SOURCE12); + irqarray19_csr.rmwf(utra::irqarray19::EV_ENABLE_SOURCE12, bar); + let mut baz = irqarray19_csr.zf(utra::irqarray19::EV_ENABLE_SOURCE12, bar); + baz |= irqarray19_csr.ms(utra::irqarray19::EV_ENABLE_SOURCE12, 1); + irqarray19_csr.wfo(utra::irqarray19::EV_ENABLE_SOURCE12, baz); + let bar = irqarray19_csr.rf(utra::irqarray19::EV_ENABLE_SOURCE13); + irqarray19_csr.rmwf(utra::irqarray19::EV_ENABLE_SOURCE13, bar); + let mut baz = irqarray19_csr.zf(utra::irqarray19::EV_ENABLE_SOURCE13, bar); + baz |= irqarray19_csr.ms(utra::irqarray19::EV_ENABLE_SOURCE13, 1); + irqarray19_csr.wfo(utra::irqarray19::EV_ENABLE_SOURCE13, baz); + let bar = irqarray19_csr.rf(utra::irqarray19::EV_ENABLE_SOURCE14); + irqarray19_csr.rmwf(utra::irqarray19::EV_ENABLE_SOURCE14, bar); + let mut baz = irqarray19_csr.zf(utra::irqarray19::EV_ENABLE_SOURCE14, bar); + baz |= irqarray19_csr.ms(utra::irqarray19::EV_ENABLE_SOURCE14, 1); + irqarray19_csr.wfo(utra::irqarray19::EV_ENABLE_SOURCE14, baz); + let bar = irqarray19_csr.rf(utra::irqarray19::EV_ENABLE_SOURCE15); + irqarray19_csr.rmwf(utra::irqarray19::EV_ENABLE_SOURCE15, bar); + let mut baz = irqarray19_csr.zf(utra::irqarray19::EV_ENABLE_SOURCE15, bar); + baz |= irqarray19_csr.ms(utra::irqarray19::EV_ENABLE_SOURCE15, 1); + irqarray19_csr.wfo(utra::irqarray19::EV_ENABLE_SOURCE15, baz); + let bar = irqarray19_csr.rf(utra::irqarray19::EV_ENABLE_SOURCE16); + irqarray19_csr.rmwf(utra::irqarray19::EV_ENABLE_SOURCE16, bar); + let mut baz = irqarray19_csr.zf(utra::irqarray19::EV_ENABLE_SOURCE16, bar); + baz |= irqarray19_csr.ms(utra::irqarray19::EV_ENABLE_SOURCE16, 1); + irqarray19_csr.wfo(utra::irqarray19::EV_ENABLE_SOURCE16, baz); + let bar = irqarray19_csr.rf(utra::irqarray19::EV_ENABLE_SOURCE17); + irqarray19_csr.rmwf(utra::irqarray19::EV_ENABLE_SOURCE17, bar); + let mut baz = irqarray19_csr.zf(utra::irqarray19::EV_ENABLE_SOURCE17, bar); + baz |= irqarray19_csr.ms(utra::irqarray19::EV_ENABLE_SOURCE17, 1); + irqarray19_csr.wfo(utra::irqarray19::EV_ENABLE_SOURCE17, baz); + let bar = irqarray19_csr.rf(utra::irqarray19::EV_ENABLE_SOURCE18); + irqarray19_csr.rmwf(utra::irqarray19::EV_ENABLE_SOURCE18, bar); + let mut baz = irqarray19_csr.zf(utra::irqarray19::EV_ENABLE_SOURCE18, bar); + baz |= irqarray19_csr.ms(utra::irqarray19::EV_ENABLE_SOURCE18, 1); + irqarray19_csr.wfo(utra::irqarray19::EV_ENABLE_SOURCE18, baz); + let bar = irqarray19_csr.rf(utra::irqarray19::EV_ENABLE_SOURCE19); + irqarray19_csr.rmwf(utra::irqarray19::EV_ENABLE_SOURCE19, bar); + let mut baz = irqarray19_csr.zf(utra::irqarray19::EV_ENABLE_SOURCE19, bar); + baz |= irqarray19_csr.ms(utra::irqarray19::EV_ENABLE_SOURCE19, 1); + irqarray19_csr.wfo(utra::irqarray19::EV_ENABLE_SOURCE19, baz); + } + + #[test] + #[ignore] + fn compile_check_irqarray2_csr() { + use super::*; + let mut irqarray2_csr = CSR::new(HW_IRQARRAY2_BASE as *mut u32); + + let foo = irqarray2_csr.r(utra::irqarray2::EV_SOFT); + irqarray2_csr.wo(utra::irqarray2::EV_SOFT, foo); + let bar = irqarray2_csr.rf(utra::irqarray2::EV_SOFT_TRIGGER); + irqarray2_csr.rmwf(utra::irqarray2::EV_SOFT_TRIGGER, bar); + let mut baz = irqarray2_csr.zf(utra::irqarray2::EV_SOFT_TRIGGER, bar); + baz |= irqarray2_csr.ms(utra::irqarray2::EV_SOFT_TRIGGER, 1); + irqarray2_csr.wfo(utra::irqarray2::EV_SOFT_TRIGGER, baz); + + let foo = irqarray2_csr.r(utra::irqarray2::EV_STATUS); + irqarray2_csr.wo(utra::irqarray2::EV_STATUS, foo); + let bar = irqarray2_csr.rf(utra::irqarray2::EV_STATUS_SOURCE0); + irqarray2_csr.rmwf(utra::irqarray2::EV_STATUS_SOURCE0, bar); + let mut baz = irqarray2_csr.zf(utra::irqarray2::EV_STATUS_SOURCE0, bar); + baz |= irqarray2_csr.ms(utra::irqarray2::EV_STATUS_SOURCE0, 1); + irqarray2_csr.wfo(utra::irqarray2::EV_STATUS_SOURCE0, baz); + let bar = irqarray2_csr.rf(utra::irqarray2::EV_STATUS_SOURCE1); + irqarray2_csr.rmwf(utra::irqarray2::EV_STATUS_SOURCE1, bar); + let mut baz = irqarray2_csr.zf(utra::irqarray2::EV_STATUS_SOURCE1, bar); + baz |= irqarray2_csr.ms(utra::irqarray2::EV_STATUS_SOURCE1, 1); + irqarray2_csr.wfo(utra::irqarray2::EV_STATUS_SOURCE1, baz); + let bar = irqarray2_csr.rf(utra::irqarray2::EV_STATUS_SOURCE2); + irqarray2_csr.rmwf(utra::irqarray2::EV_STATUS_SOURCE2, bar); + let mut baz = irqarray2_csr.zf(utra::irqarray2::EV_STATUS_SOURCE2, bar); + baz |= irqarray2_csr.ms(utra::irqarray2::EV_STATUS_SOURCE2, 1); + irqarray2_csr.wfo(utra::irqarray2::EV_STATUS_SOURCE2, baz); + let bar = irqarray2_csr.rf(utra::irqarray2::EV_STATUS_SOURCE3); + irqarray2_csr.rmwf(utra::irqarray2::EV_STATUS_SOURCE3, bar); + let mut baz = irqarray2_csr.zf(utra::irqarray2::EV_STATUS_SOURCE3, bar); + baz |= irqarray2_csr.ms(utra::irqarray2::EV_STATUS_SOURCE3, 1); + irqarray2_csr.wfo(utra::irqarray2::EV_STATUS_SOURCE3, baz); + let bar = irqarray2_csr.rf(utra::irqarray2::EV_STATUS_SOURCE4); + irqarray2_csr.rmwf(utra::irqarray2::EV_STATUS_SOURCE4, bar); + let mut baz = irqarray2_csr.zf(utra::irqarray2::EV_STATUS_SOURCE4, bar); + baz |= irqarray2_csr.ms(utra::irqarray2::EV_STATUS_SOURCE4, 1); + irqarray2_csr.wfo(utra::irqarray2::EV_STATUS_SOURCE4, baz); + let bar = irqarray2_csr.rf(utra::irqarray2::EV_STATUS_SOURCE5); + irqarray2_csr.rmwf(utra::irqarray2::EV_STATUS_SOURCE5, bar); + let mut baz = irqarray2_csr.zf(utra::irqarray2::EV_STATUS_SOURCE5, bar); + baz |= irqarray2_csr.ms(utra::irqarray2::EV_STATUS_SOURCE5, 1); + irqarray2_csr.wfo(utra::irqarray2::EV_STATUS_SOURCE5, baz); + let bar = irqarray2_csr.rf(utra::irqarray2::EV_STATUS_SOURCE6); + irqarray2_csr.rmwf(utra::irqarray2::EV_STATUS_SOURCE6, bar); + let mut baz = irqarray2_csr.zf(utra::irqarray2::EV_STATUS_SOURCE6, bar); + baz |= irqarray2_csr.ms(utra::irqarray2::EV_STATUS_SOURCE6, 1); + irqarray2_csr.wfo(utra::irqarray2::EV_STATUS_SOURCE6, baz); + let bar = irqarray2_csr.rf(utra::irqarray2::EV_STATUS_SOURCE7); + irqarray2_csr.rmwf(utra::irqarray2::EV_STATUS_SOURCE7, bar); + let mut baz = irqarray2_csr.zf(utra::irqarray2::EV_STATUS_SOURCE7, bar); + baz |= irqarray2_csr.ms(utra::irqarray2::EV_STATUS_SOURCE7, 1); + irqarray2_csr.wfo(utra::irqarray2::EV_STATUS_SOURCE7, baz); + let bar = irqarray2_csr.rf(utra::irqarray2::EV_STATUS_SOURCE8); + irqarray2_csr.rmwf(utra::irqarray2::EV_STATUS_SOURCE8, bar); + let mut baz = irqarray2_csr.zf(utra::irqarray2::EV_STATUS_SOURCE8, bar); + baz |= irqarray2_csr.ms(utra::irqarray2::EV_STATUS_SOURCE8, 1); + irqarray2_csr.wfo(utra::irqarray2::EV_STATUS_SOURCE8, baz); + let bar = irqarray2_csr.rf(utra::irqarray2::EV_STATUS_SOURCE9); + irqarray2_csr.rmwf(utra::irqarray2::EV_STATUS_SOURCE9, bar); + let mut baz = irqarray2_csr.zf(utra::irqarray2::EV_STATUS_SOURCE9, bar); + baz |= irqarray2_csr.ms(utra::irqarray2::EV_STATUS_SOURCE9, 1); + irqarray2_csr.wfo(utra::irqarray2::EV_STATUS_SOURCE9, baz); + let bar = irqarray2_csr.rf(utra::irqarray2::EV_STATUS_SOURCE10); + irqarray2_csr.rmwf(utra::irqarray2::EV_STATUS_SOURCE10, bar); + let mut baz = irqarray2_csr.zf(utra::irqarray2::EV_STATUS_SOURCE10, bar); + baz |= irqarray2_csr.ms(utra::irqarray2::EV_STATUS_SOURCE10, 1); + irqarray2_csr.wfo(utra::irqarray2::EV_STATUS_SOURCE10, baz); + let bar = irqarray2_csr.rf(utra::irqarray2::EV_STATUS_SOURCE11); + irqarray2_csr.rmwf(utra::irqarray2::EV_STATUS_SOURCE11, bar); + let mut baz = irqarray2_csr.zf(utra::irqarray2::EV_STATUS_SOURCE11, bar); + baz |= irqarray2_csr.ms(utra::irqarray2::EV_STATUS_SOURCE11, 1); + irqarray2_csr.wfo(utra::irqarray2::EV_STATUS_SOURCE11, baz); + let bar = irqarray2_csr.rf(utra::irqarray2::EV_STATUS_SOURCE12); + irqarray2_csr.rmwf(utra::irqarray2::EV_STATUS_SOURCE12, bar); + let mut baz = irqarray2_csr.zf(utra::irqarray2::EV_STATUS_SOURCE12, bar); + baz |= irqarray2_csr.ms(utra::irqarray2::EV_STATUS_SOURCE12, 1); + irqarray2_csr.wfo(utra::irqarray2::EV_STATUS_SOURCE12, baz); + let bar = irqarray2_csr.rf(utra::irqarray2::EV_STATUS_SOURCE13); + irqarray2_csr.rmwf(utra::irqarray2::EV_STATUS_SOURCE13, bar); + let mut baz = irqarray2_csr.zf(utra::irqarray2::EV_STATUS_SOURCE13, bar); + baz |= irqarray2_csr.ms(utra::irqarray2::EV_STATUS_SOURCE13, 1); + irqarray2_csr.wfo(utra::irqarray2::EV_STATUS_SOURCE13, baz); + let bar = irqarray2_csr.rf(utra::irqarray2::EV_STATUS_SOURCE14); + irqarray2_csr.rmwf(utra::irqarray2::EV_STATUS_SOURCE14, bar); + let mut baz = irqarray2_csr.zf(utra::irqarray2::EV_STATUS_SOURCE14, bar); + baz |= irqarray2_csr.ms(utra::irqarray2::EV_STATUS_SOURCE14, 1); + irqarray2_csr.wfo(utra::irqarray2::EV_STATUS_SOURCE14, baz); + let bar = irqarray2_csr.rf(utra::irqarray2::EV_STATUS_SOURCE15); + irqarray2_csr.rmwf(utra::irqarray2::EV_STATUS_SOURCE15, bar); + let mut baz = irqarray2_csr.zf(utra::irqarray2::EV_STATUS_SOURCE15, bar); + baz |= irqarray2_csr.ms(utra::irqarray2::EV_STATUS_SOURCE15, 1); + irqarray2_csr.wfo(utra::irqarray2::EV_STATUS_SOURCE15, baz); + let bar = irqarray2_csr.rf(utra::irqarray2::EV_STATUS_SOURCE16); + irqarray2_csr.rmwf(utra::irqarray2::EV_STATUS_SOURCE16, bar); + let mut baz = irqarray2_csr.zf(utra::irqarray2::EV_STATUS_SOURCE16, bar); + baz |= irqarray2_csr.ms(utra::irqarray2::EV_STATUS_SOURCE16, 1); + irqarray2_csr.wfo(utra::irqarray2::EV_STATUS_SOURCE16, baz); + let bar = irqarray2_csr.rf(utra::irqarray2::EV_STATUS_SOURCE17); + irqarray2_csr.rmwf(utra::irqarray2::EV_STATUS_SOURCE17, bar); + let mut baz = irqarray2_csr.zf(utra::irqarray2::EV_STATUS_SOURCE17, bar); + baz |= irqarray2_csr.ms(utra::irqarray2::EV_STATUS_SOURCE17, 1); + irqarray2_csr.wfo(utra::irqarray2::EV_STATUS_SOURCE17, baz); + let bar = irqarray2_csr.rf(utra::irqarray2::EV_STATUS_SOURCE18); + irqarray2_csr.rmwf(utra::irqarray2::EV_STATUS_SOURCE18, bar); + let mut baz = irqarray2_csr.zf(utra::irqarray2::EV_STATUS_SOURCE18, bar); + baz |= irqarray2_csr.ms(utra::irqarray2::EV_STATUS_SOURCE18, 1); + irqarray2_csr.wfo(utra::irqarray2::EV_STATUS_SOURCE18, baz); + let bar = irqarray2_csr.rf(utra::irqarray2::EV_STATUS_SOURCE19); + irqarray2_csr.rmwf(utra::irqarray2::EV_STATUS_SOURCE19, bar); + let mut baz = irqarray2_csr.zf(utra::irqarray2::EV_STATUS_SOURCE19, bar); + baz |= irqarray2_csr.ms(utra::irqarray2::EV_STATUS_SOURCE19, 1); + irqarray2_csr.wfo(utra::irqarray2::EV_STATUS_SOURCE19, baz); + + let foo = irqarray2_csr.r(utra::irqarray2::EV_PENDING); + irqarray2_csr.wo(utra::irqarray2::EV_PENDING, foo); + let bar = irqarray2_csr.rf(utra::irqarray2::EV_PENDING_SOURCE0); + irqarray2_csr.rmwf(utra::irqarray2::EV_PENDING_SOURCE0, bar); + let mut baz = irqarray2_csr.zf(utra::irqarray2::EV_PENDING_SOURCE0, bar); + baz |= irqarray2_csr.ms(utra::irqarray2::EV_PENDING_SOURCE0, 1); + irqarray2_csr.wfo(utra::irqarray2::EV_PENDING_SOURCE0, baz); + let bar = irqarray2_csr.rf(utra::irqarray2::EV_PENDING_SOURCE1); + irqarray2_csr.rmwf(utra::irqarray2::EV_PENDING_SOURCE1, bar); + let mut baz = irqarray2_csr.zf(utra::irqarray2::EV_PENDING_SOURCE1, bar); + baz |= irqarray2_csr.ms(utra::irqarray2::EV_PENDING_SOURCE1, 1); + irqarray2_csr.wfo(utra::irqarray2::EV_PENDING_SOURCE1, baz); + let bar = irqarray2_csr.rf(utra::irqarray2::EV_PENDING_SOURCE2); + irqarray2_csr.rmwf(utra::irqarray2::EV_PENDING_SOURCE2, bar); + let mut baz = irqarray2_csr.zf(utra::irqarray2::EV_PENDING_SOURCE2, bar); + baz |= irqarray2_csr.ms(utra::irqarray2::EV_PENDING_SOURCE2, 1); + irqarray2_csr.wfo(utra::irqarray2::EV_PENDING_SOURCE2, baz); + let bar = irqarray2_csr.rf(utra::irqarray2::EV_PENDING_SOURCE3); + irqarray2_csr.rmwf(utra::irqarray2::EV_PENDING_SOURCE3, bar); + let mut baz = irqarray2_csr.zf(utra::irqarray2::EV_PENDING_SOURCE3, bar); + baz |= irqarray2_csr.ms(utra::irqarray2::EV_PENDING_SOURCE3, 1); + irqarray2_csr.wfo(utra::irqarray2::EV_PENDING_SOURCE3, baz); + let bar = irqarray2_csr.rf(utra::irqarray2::EV_PENDING_SOURCE4); + irqarray2_csr.rmwf(utra::irqarray2::EV_PENDING_SOURCE4, bar); + let mut baz = irqarray2_csr.zf(utra::irqarray2::EV_PENDING_SOURCE4, bar); + baz |= irqarray2_csr.ms(utra::irqarray2::EV_PENDING_SOURCE4, 1); + irqarray2_csr.wfo(utra::irqarray2::EV_PENDING_SOURCE4, baz); + let bar = irqarray2_csr.rf(utra::irqarray2::EV_PENDING_SOURCE5); + irqarray2_csr.rmwf(utra::irqarray2::EV_PENDING_SOURCE5, bar); + let mut baz = irqarray2_csr.zf(utra::irqarray2::EV_PENDING_SOURCE5, bar); + baz |= irqarray2_csr.ms(utra::irqarray2::EV_PENDING_SOURCE5, 1); + irqarray2_csr.wfo(utra::irqarray2::EV_PENDING_SOURCE5, baz); + let bar = irqarray2_csr.rf(utra::irqarray2::EV_PENDING_SOURCE6); + irqarray2_csr.rmwf(utra::irqarray2::EV_PENDING_SOURCE6, bar); + let mut baz = irqarray2_csr.zf(utra::irqarray2::EV_PENDING_SOURCE6, bar); + baz |= irqarray2_csr.ms(utra::irqarray2::EV_PENDING_SOURCE6, 1); + irqarray2_csr.wfo(utra::irqarray2::EV_PENDING_SOURCE6, baz); + let bar = irqarray2_csr.rf(utra::irqarray2::EV_PENDING_SOURCE7); + irqarray2_csr.rmwf(utra::irqarray2::EV_PENDING_SOURCE7, bar); + let mut baz = irqarray2_csr.zf(utra::irqarray2::EV_PENDING_SOURCE7, bar); + baz |= irqarray2_csr.ms(utra::irqarray2::EV_PENDING_SOURCE7, 1); + irqarray2_csr.wfo(utra::irqarray2::EV_PENDING_SOURCE7, baz); + let bar = irqarray2_csr.rf(utra::irqarray2::EV_PENDING_SOURCE8); + irqarray2_csr.rmwf(utra::irqarray2::EV_PENDING_SOURCE8, bar); + let mut baz = irqarray2_csr.zf(utra::irqarray2::EV_PENDING_SOURCE8, bar); + baz |= irqarray2_csr.ms(utra::irqarray2::EV_PENDING_SOURCE8, 1); + irqarray2_csr.wfo(utra::irqarray2::EV_PENDING_SOURCE8, baz); + let bar = irqarray2_csr.rf(utra::irqarray2::EV_PENDING_SOURCE9); + irqarray2_csr.rmwf(utra::irqarray2::EV_PENDING_SOURCE9, bar); + let mut baz = irqarray2_csr.zf(utra::irqarray2::EV_PENDING_SOURCE9, bar); + baz |= irqarray2_csr.ms(utra::irqarray2::EV_PENDING_SOURCE9, 1); + irqarray2_csr.wfo(utra::irqarray2::EV_PENDING_SOURCE9, baz); + let bar = irqarray2_csr.rf(utra::irqarray2::EV_PENDING_SOURCE10); + irqarray2_csr.rmwf(utra::irqarray2::EV_PENDING_SOURCE10, bar); + let mut baz = irqarray2_csr.zf(utra::irqarray2::EV_PENDING_SOURCE10, bar); + baz |= irqarray2_csr.ms(utra::irqarray2::EV_PENDING_SOURCE10, 1); + irqarray2_csr.wfo(utra::irqarray2::EV_PENDING_SOURCE10, baz); + let bar = irqarray2_csr.rf(utra::irqarray2::EV_PENDING_SOURCE11); + irqarray2_csr.rmwf(utra::irqarray2::EV_PENDING_SOURCE11, bar); + let mut baz = irqarray2_csr.zf(utra::irqarray2::EV_PENDING_SOURCE11, bar); + baz |= irqarray2_csr.ms(utra::irqarray2::EV_PENDING_SOURCE11, 1); + irqarray2_csr.wfo(utra::irqarray2::EV_PENDING_SOURCE11, baz); + let bar = irqarray2_csr.rf(utra::irqarray2::EV_PENDING_SOURCE12); + irqarray2_csr.rmwf(utra::irqarray2::EV_PENDING_SOURCE12, bar); + let mut baz = irqarray2_csr.zf(utra::irqarray2::EV_PENDING_SOURCE12, bar); + baz |= irqarray2_csr.ms(utra::irqarray2::EV_PENDING_SOURCE12, 1); + irqarray2_csr.wfo(utra::irqarray2::EV_PENDING_SOURCE12, baz); + let bar = irqarray2_csr.rf(utra::irqarray2::EV_PENDING_SOURCE13); + irqarray2_csr.rmwf(utra::irqarray2::EV_PENDING_SOURCE13, bar); + let mut baz = irqarray2_csr.zf(utra::irqarray2::EV_PENDING_SOURCE13, bar); + baz |= irqarray2_csr.ms(utra::irqarray2::EV_PENDING_SOURCE13, 1); + irqarray2_csr.wfo(utra::irqarray2::EV_PENDING_SOURCE13, baz); + let bar = irqarray2_csr.rf(utra::irqarray2::EV_PENDING_SOURCE14); + irqarray2_csr.rmwf(utra::irqarray2::EV_PENDING_SOURCE14, bar); + let mut baz = irqarray2_csr.zf(utra::irqarray2::EV_PENDING_SOURCE14, bar); + baz |= irqarray2_csr.ms(utra::irqarray2::EV_PENDING_SOURCE14, 1); + irqarray2_csr.wfo(utra::irqarray2::EV_PENDING_SOURCE14, baz); + let bar = irqarray2_csr.rf(utra::irqarray2::EV_PENDING_SOURCE15); + irqarray2_csr.rmwf(utra::irqarray2::EV_PENDING_SOURCE15, bar); + let mut baz = irqarray2_csr.zf(utra::irqarray2::EV_PENDING_SOURCE15, bar); + baz |= irqarray2_csr.ms(utra::irqarray2::EV_PENDING_SOURCE15, 1); + irqarray2_csr.wfo(utra::irqarray2::EV_PENDING_SOURCE15, baz); + let bar = irqarray2_csr.rf(utra::irqarray2::EV_PENDING_SOURCE16); + irqarray2_csr.rmwf(utra::irqarray2::EV_PENDING_SOURCE16, bar); + let mut baz = irqarray2_csr.zf(utra::irqarray2::EV_PENDING_SOURCE16, bar); + baz |= irqarray2_csr.ms(utra::irqarray2::EV_PENDING_SOURCE16, 1); + irqarray2_csr.wfo(utra::irqarray2::EV_PENDING_SOURCE16, baz); + let bar = irqarray2_csr.rf(utra::irqarray2::EV_PENDING_SOURCE17); + irqarray2_csr.rmwf(utra::irqarray2::EV_PENDING_SOURCE17, bar); + let mut baz = irqarray2_csr.zf(utra::irqarray2::EV_PENDING_SOURCE17, bar); + baz |= irqarray2_csr.ms(utra::irqarray2::EV_PENDING_SOURCE17, 1); + irqarray2_csr.wfo(utra::irqarray2::EV_PENDING_SOURCE17, baz); + let bar = irqarray2_csr.rf(utra::irqarray2::EV_PENDING_SOURCE18); + irqarray2_csr.rmwf(utra::irqarray2::EV_PENDING_SOURCE18, bar); + let mut baz = irqarray2_csr.zf(utra::irqarray2::EV_PENDING_SOURCE18, bar); + baz |= irqarray2_csr.ms(utra::irqarray2::EV_PENDING_SOURCE18, 1); + irqarray2_csr.wfo(utra::irqarray2::EV_PENDING_SOURCE18, baz); + let bar = irqarray2_csr.rf(utra::irqarray2::EV_PENDING_SOURCE19); + irqarray2_csr.rmwf(utra::irqarray2::EV_PENDING_SOURCE19, bar); + let mut baz = irqarray2_csr.zf(utra::irqarray2::EV_PENDING_SOURCE19, bar); + baz |= irqarray2_csr.ms(utra::irqarray2::EV_PENDING_SOURCE19, 1); + irqarray2_csr.wfo(utra::irqarray2::EV_PENDING_SOURCE19, baz); + + let foo = irqarray2_csr.r(utra::irqarray2::EV_ENABLE); + irqarray2_csr.wo(utra::irqarray2::EV_ENABLE, foo); + let bar = irqarray2_csr.rf(utra::irqarray2::EV_ENABLE_SOURCE0); + irqarray2_csr.rmwf(utra::irqarray2::EV_ENABLE_SOURCE0, bar); + let mut baz = irqarray2_csr.zf(utra::irqarray2::EV_ENABLE_SOURCE0, bar); + baz |= irqarray2_csr.ms(utra::irqarray2::EV_ENABLE_SOURCE0, 1); + irqarray2_csr.wfo(utra::irqarray2::EV_ENABLE_SOURCE0, baz); + let bar = irqarray2_csr.rf(utra::irqarray2::EV_ENABLE_SOURCE1); + irqarray2_csr.rmwf(utra::irqarray2::EV_ENABLE_SOURCE1, bar); + let mut baz = irqarray2_csr.zf(utra::irqarray2::EV_ENABLE_SOURCE1, bar); + baz |= irqarray2_csr.ms(utra::irqarray2::EV_ENABLE_SOURCE1, 1); + irqarray2_csr.wfo(utra::irqarray2::EV_ENABLE_SOURCE1, baz); + let bar = irqarray2_csr.rf(utra::irqarray2::EV_ENABLE_SOURCE2); + irqarray2_csr.rmwf(utra::irqarray2::EV_ENABLE_SOURCE2, bar); + let mut baz = irqarray2_csr.zf(utra::irqarray2::EV_ENABLE_SOURCE2, bar); + baz |= irqarray2_csr.ms(utra::irqarray2::EV_ENABLE_SOURCE2, 1); + irqarray2_csr.wfo(utra::irqarray2::EV_ENABLE_SOURCE2, baz); + let bar = irqarray2_csr.rf(utra::irqarray2::EV_ENABLE_SOURCE3); + irqarray2_csr.rmwf(utra::irqarray2::EV_ENABLE_SOURCE3, bar); + let mut baz = irqarray2_csr.zf(utra::irqarray2::EV_ENABLE_SOURCE3, bar); + baz |= irqarray2_csr.ms(utra::irqarray2::EV_ENABLE_SOURCE3, 1); + irqarray2_csr.wfo(utra::irqarray2::EV_ENABLE_SOURCE3, baz); + let bar = irqarray2_csr.rf(utra::irqarray2::EV_ENABLE_SOURCE4); + irqarray2_csr.rmwf(utra::irqarray2::EV_ENABLE_SOURCE4, bar); + let mut baz = irqarray2_csr.zf(utra::irqarray2::EV_ENABLE_SOURCE4, bar); + baz |= irqarray2_csr.ms(utra::irqarray2::EV_ENABLE_SOURCE4, 1); + irqarray2_csr.wfo(utra::irqarray2::EV_ENABLE_SOURCE4, baz); + let bar = irqarray2_csr.rf(utra::irqarray2::EV_ENABLE_SOURCE5); + irqarray2_csr.rmwf(utra::irqarray2::EV_ENABLE_SOURCE5, bar); + let mut baz = irqarray2_csr.zf(utra::irqarray2::EV_ENABLE_SOURCE5, bar); + baz |= irqarray2_csr.ms(utra::irqarray2::EV_ENABLE_SOURCE5, 1); + irqarray2_csr.wfo(utra::irqarray2::EV_ENABLE_SOURCE5, baz); + let bar = irqarray2_csr.rf(utra::irqarray2::EV_ENABLE_SOURCE6); + irqarray2_csr.rmwf(utra::irqarray2::EV_ENABLE_SOURCE6, bar); + let mut baz = irqarray2_csr.zf(utra::irqarray2::EV_ENABLE_SOURCE6, bar); + baz |= irqarray2_csr.ms(utra::irqarray2::EV_ENABLE_SOURCE6, 1); + irqarray2_csr.wfo(utra::irqarray2::EV_ENABLE_SOURCE6, baz); + let bar = irqarray2_csr.rf(utra::irqarray2::EV_ENABLE_SOURCE7); + irqarray2_csr.rmwf(utra::irqarray2::EV_ENABLE_SOURCE7, bar); + let mut baz = irqarray2_csr.zf(utra::irqarray2::EV_ENABLE_SOURCE7, bar); + baz |= irqarray2_csr.ms(utra::irqarray2::EV_ENABLE_SOURCE7, 1); + irqarray2_csr.wfo(utra::irqarray2::EV_ENABLE_SOURCE7, baz); + let bar = irqarray2_csr.rf(utra::irqarray2::EV_ENABLE_SOURCE8); + irqarray2_csr.rmwf(utra::irqarray2::EV_ENABLE_SOURCE8, bar); + let mut baz = irqarray2_csr.zf(utra::irqarray2::EV_ENABLE_SOURCE8, bar); + baz |= irqarray2_csr.ms(utra::irqarray2::EV_ENABLE_SOURCE8, 1); + irqarray2_csr.wfo(utra::irqarray2::EV_ENABLE_SOURCE8, baz); + let bar = irqarray2_csr.rf(utra::irqarray2::EV_ENABLE_SOURCE9); + irqarray2_csr.rmwf(utra::irqarray2::EV_ENABLE_SOURCE9, bar); + let mut baz = irqarray2_csr.zf(utra::irqarray2::EV_ENABLE_SOURCE9, bar); + baz |= irqarray2_csr.ms(utra::irqarray2::EV_ENABLE_SOURCE9, 1); + irqarray2_csr.wfo(utra::irqarray2::EV_ENABLE_SOURCE9, baz); + let bar = irqarray2_csr.rf(utra::irqarray2::EV_ENABLE_SOURCE10); + irqarray2_csr.rmwf(utra::irqarray2::EV_ENABLE_SOURCE10, bar); + let mut baz = irqarray2_csr.zf(utra::irqarray2::EV_ENABLE_SOURCE10, bar); + baz |= irqarray2_csr.ms(utra::irqarray2::EV_ENABLE_SOURCE10, 1); + irqarray2_csr.wfo(utra::irqarray2::EV_ENABLE_SOURCE10, baz); + let bar = irqarray2_csr.rf(utra::irqarray2::EV_ENABLE_SOURCE11); + irqarray2_csr.rmwf(utra::irqarray2::EV_ENABLE_SOURCE11, bar); + let mut baz = irqarray2_csr.zf(utra::irqarray2::EV_ENABLE_SOURCE11, bar); + baz |= irqarray2_csr.ms(utra::irqarray2::EV_ENABLE_SOURCE11, 1); + irqarray2_csr.wfo(utra::irqarray2::EV_ENABLE_SOURCE11, baz); + let bar = irqarray2_csr.rf(utra::irqarray2::EV_ENABLE_SOURCE12); + irqarray2_csr.rmwf(utra::irqarray2::EV_ENABLE_SOURCE12, bar); + let mut baz = irqarray2_csr.zf(utra::irqarray2::EV_ENABLE_SOURCE12, bar); + baz |= irqarray2_csr.ms(utra::irqarray2::EV_ENABLE_SOURCE12, 1); + irqarray2_csr.wfo(utra::irqarray2::EV_ENABLE_SOURCE12, baz); + let bar = irqarray2_csr.rf(utra::irqarray2::EV_ENABLE_SOURCE13); + irqarray2_csr.rmwf(utra::irqarray2::EV_ENABLE_SOURCE13, bar); + let mut baz = irqarray2_csr.zf(utra::irqarray2::EV_ENABLE_SOURCE13, bar); + baz |= irqarray2_csr.ms(utra::irqarray2::EV_ENABLE_SOURCE13, 1); + irqarray2_csr.wfo(utra::irqarray2::EV_ENABLE_SOURCE13, baz); + let bar = irqarray2_csr.rf(utra::irqarray2::EV_ENABLE_SOURCE14); + irqarray2_csr.rmwf(utra::irqarray2::EV_ENABLE_SOURCE14, bar); + let mut baz = irqarray2_csr.zf(utra::irqarray2::EV_ENABLE_SOURCE14, bar); + baz |= irqarray2_csr.ms(utra::irqarray2::EV_ENABLE_SOURCE14, 1); + irqarray2_csr.wfo(utra::irqarray2::EV_ENABLE_SOURCE14, baz); + let bar = irqarray2_csr.rf(utra::irqarray2::EV_ENABLE_SOURCE15); + irqarray2_csr.rmwf(utra::irqarray2::EV_ENABLE_SOURCE15, bar); + let mut baz = irqarray2_csr.zf(utra::irqarray2::EV_ENABLE_SOURCE15, bar); + baz |= irqarray2_csr.ms(utra::irqarray2::EV_ENABLE_SOURCE15, 1); + irqarray2_csr.wfo(utra::irqarray2::EV_ENABLE_SOURCE15, baz); + let bar = irqarray2_csr.rf(utra::irqarray2::EV_ENABLE_SOURCE16); + irqarray2_csr.rmwf(utra::irqarray2::EV_ENABLE_SOURCE16, bar); + let mut baz = irqarray2_csr.zf(utra::irqarray2::EV_ENABLE_SOURCE16, bar); + baz |= irqarray2_csr.ms(utra::irqarray2::EV_ENABLE_SOURCE16, 1); + irqarray2_csr.wfo(utra::irqarray2::EV_ENABLE_SOURCE16, baz); + let bar = irqarray2_csr.rf(utra::irqarray2::EV_ENABLE_SOURCE17); + irqarray2_csr.rmwf(utra::irqarray2::EV_ENABLE_SOURCE17, bar); + let mut baz = irqarray2_csr.zf(utra::irqarray2::EV_ENABLE_SOURCE17, bar); + baz |= irqarray2_csr.ms(utra::irqarray2::EV_ENABLE_SOURCE17, 1); + irqarray2_csr.wfo(utra::irqarray2::EV_ENABLE_SOURCE17, baz); + let bar = irqarray2_csr.rf(utra::irqarray2::EV_ENABLE_SOURCE18); + irqarray2_csr.rmwf(utra::irqarray2::EV_ENABLE_SOURCE18, bar); + let mut baz = irqarray2_csr.zf(utra::irqarray2::EV_ENABLE_SOURCE18, bar); + baz |= irqarray2_csr.ms(utra::irqarray2::EV_ENABLE_SOURCE18, 1); + irqarray2_csr.wfo(utra::irqarray2::EV_ENABLE_SOURCE18, baz); + let bar = irqarray2_csr.rf(utra::irqarray2::EV_ENABLE_SOURCE19); + irqarray2_csr.rmwf(utra::irqarray2::EV_ENABLE_SOURCE19, bar); + let mut baz = irqarray2_csr.zf(utra::irqarray2::EV_ENABLE_SOURCE19, bar); + baz |= irqarray2_csr.ms(utra::irqarray2::EV_ENABLE_SOURCE19, 1); + irqarray2_csr.wfo(utra::irqarray2::EV_ENABLE_SOURCE19, baz); + } + + #[test] + #[ignore] + fn compile_check_irqarray3_csr() { + use super::*; + let mut irqarray3_csr = CSR::new(HW_IRQARRAY3_BASE as *mut u32); + + let foo = irqarray3_csr.r(utra::irqarray3::EV_SOFT); + irqarray3_csr.wo(utra::irqarray3::EV_SOFT, foo); + let bar = irqarray3_csr.rf(utra::irqarray3::EV_SOFT_TRIGGER); + irqarray3_csr.rmwf(utra::irqarray3::EV_SOFT_TRIGGER, bar); + let mut baz = irqarray3_csr.zf(utra::irqarray3::EV_SOFT_TRIGGER, bar); + baz |= irqarray3_csr.ms(utra::irqarray3::EV_SOFT_TRIGGER, 1); + irqarray3_csr.wfo(utra::irqarray3::EV_SOFT_TRIGGER, baz); + + let foo = irqarray3_csr.r(utra::irqarray3::EV_STATUS); + irqarray3_csr.wo(utra::irqarray3::EV_STATUS, foo); + let bar = irqarray3_csr.rf(utra::irqarray3::EV_STATUS_SOURCE0); + irqarray3_csr.rmwf(utra::irqarray3::EV_STATUS_SOURCE0, bar); + let mut baz = irqarray3_csr.zf(utra::irqarray3::EV_STATUS_SOURCE0, bar); + baz |= irqarray3_csr.ms(utra::irqarray3::EV_STATUS_SOURCE0, 1); + irqarray3_csr.wfo(utra::irqarray3::EV_STATUS_SOURCE0, baz); + let bar = irqarray3_csr.rf(utra::irqarray3::EV_STATUS_SOURCE1); + irqarray3_csr.rmwf(utra::irqarray3::EV_STATUS_SOURCE1, bar); + let mut baz = irqarray3_csr.zf(utra::irqarray3::EV_STATUS_SOURCE1, bar); + baz |= irqarray3_csr.ms(utra::irqarray3::EV_STATUS_SOURCE1, 1); + irqarray3_csr.wfo(utra::irqarray3::EV_STATUS_SOURCE1, baz); + let bar = irqarray3_csr.rf(utra::irqarray3::EV_STATUS_SOURCE2); + irqarray3_csr.rmwf(utra::irqarray3::EV_STATUS_SOURCE2, bar); + let mut baz = irqarray3_csr.zf(utra::irqarray3::EV_STATUS_SOURCE2, bar); + baz |= irqarray3_csr.ms(utra::irqarray3::EV_STATUS_SOURCE2, 1); + irqarray3_csr.wfo(utra::irqarray3::EV_STATUS_SOURCE2, baz); + let bar = irqarray3_csr.rf(utra::irqarray3::EV_STATUS_SOURCE3); + irqarray3_csr.rmwf(utra::irqarray3::EV_STATUS_SOURCE3, bar); + let mut baz = irqarray3_csr.zf(utra::irqarray3::EV_STATUS_SOURCE3, bar); + baz |= irqarray3_csr.ms(utra::irqarray3::EV_STATUS_SOURCE3, 1); + irqarray3_csr.wfo(utra::irqarray3::EV_STATUS_SOURCE3, baz); + let bar = irqarray3_csr.rf(utra::irqarray3::EV_STATUS_SOURCE4); + irqarray3_csr.rmwf(utra::irqarray3::EV_STATUS_SOURCE4, bar); + let mut baz = irqarray3_csr.zf(utra::irqarray3::EV_STATUS_SOURCE4, bar); + baz |= irqarray3_csr.ms(utra::irqarray3::EV_STATUS_SOURCE4, 1); + irqarray3_csr.wfo(utra::irqarray3::EV_STATUS_SOURCE4, baz); + let bar = irqarray3_csr.rf(utra::irqarray3::EV_STATUS_SOURCE5); + irqarray3_csr.rmwf(utra::irqarray3::EV_STATUS_SOURCE5, bar); + let mut baz = irqarray3_csr.zf(utra::irqarray3::EV_STATUS_SOURCE5, bar); + baz |= irqarray3_csr.ms(utra::irqarray3::EV_STATUS_SOURCE5, 1); + irqarray3_csr.wfo(utra::irqarray3::EV_STATUS_SOURCE5, baz); + let bar = irqarray3_csr.rf(utra::irqarray3::EV_STATUS_SOURCE6); + irqarray3_csr.rmwf(utra::irqarray3::EV_STATUS_SOURCE6, bar); + let mut baz = irqarray3_csr.zf(utra::irqarray3::EV_STATUS_SOURCE6, bar); + baz |= irqarray3_csr.ms(utra::irqarray3::EV_STATUS_SOURCE6, 1); + irqarray3_csr.wfo(utra::irqarray3::EV_STATUS_SOURCE6, baz); + let bar = irqarray3_csr.rf(utra::irqarray3::EV_STATUS_SOURCE7); + irqarray3_csr.rmwf(utra::irqarray3::EV_STATUS_SOURCE7, bar); + let mut baz = irqarray3_csr.zf(utra::irqarray3::EV_STATUS_SOURCE7, bar); + baz |= irqarray3_csr.ms(utra::irqarray3::EV_STATUS_SOURCE7, 1); + irqarray3_csr.wfo(utra::irqarray3::EV_STATUS_SOURCE7, baz); + let bar = irqarray3_csr.rf(utra::irqarray3::EV_STATUS_SOURCE8); + irqarray3_csr.rmwf(utra::irqarray3::EV_STATUS_SOURCE8, bar); + let mut baz = irqarray3_csr.zf(utra::irqarray3::EV_STATUS_SOURCE8, bar); + baz |= irqarray3_csr.ms(utra::irqarray3::EV_STATUS_SOURCE8, 1); + irqarray3_csr.wfo(utra::irqarray3::EV_STATUS_SOURCE8, baz); + let bar = irqarray3_csr.rf(utra::irqarray3::EV_STATUS_SOURCE9); + irqarray3_csr.rmwf(utra::irqarray3::EV_STATUS_SOURCE9, bar); + let mut baz = irqarray3_csr.zf(utra::irqarray3::EV_STATUS_SOURCE9, bar); + baz |= irqarray3_csr.ms(utra::irqarray3::EV_STATUS_SOURCE9, 1); + irqarray3_csr.wfo(utra::irqarray3::EV_STATUS_SOURCE9, baz); + let bar = irqarray3_csr.rf(utra::irqarray3::EV_STATUS_SOURCE10); + irqarray3_csr.rmwf(utra::irqarray3::EV_STATUS_SOURCE10, bar); + let mut baz = irqarray3_csr.zf(utra::irqarray3::EV_STATUS_SOURCE10, bar); + baz |= irqarray3_csr.ms(utra::irqarray3::EV_STATUS_SOURCE10, 1); + irqarray3_csr.wfo(utra::irqarray3::EV_STATUS_SOURCE10, baz); + let bar = irqarray3_csr.rf(utra::irqarray3::EV_STATUS_SOURCE11); + irqarray3_csr.rmwf(utra::irqarray3::EV_STATUS_SOURCE11, bar); + let mut baz = irqarray3_csr.zf(utra::irqarray3::EV_STATUS_SOURCE11, bar); + baz |= irqarray3_csr.ms(utra::irqarray3::EV_STATUS_SOURCE11, 1); + irqarray3_csr.wfo(utra::irqarray3::EV_STATUS_SOURCE11, baz); + let bar = irqarray3_csr.rf(utra::irqarray3::EV_STATUS_SOURCE12); + irqarray3_csr.rmwf(utra::irqarray3::EV_STATUS_SOURCE12, bar); + let mut baz = irqarray3_csr.zf(utra::irqarray3::EV_STATUS_SOURCE12, bar); + baz |= irqarray3_csr.ms(utra::irqarray3::EV_STATUS_SOURCE12, 1); + irqarray3_csr.wfo(utra::irqarray3::EV_STATUS_SOURCE12, baz); + let bar = irqarray3_csr.rf(utra::irqarray3::EV_STATUS_SOURCE13); + irqarray3_csr.rmwf(utra::irqarray3::EV_STATUS_SOURCE13, bar); + let mut baz = irqarray3_csr.zf(utra::irqarray3::EV_STATUS_SOURCE13, bar); + baz |= irqarray3_csr.ms(utra::irqarray3::EV_STATUS_SOURCE13, 1); + irqarray3_csr.wfo(utra::irqarray3::EV_STATUS_SOURCE13, baz); + let bar = irqarray3_csr.rf(utra::irqarray3::EV_STATUS_SOURCE14); + irqarray3_csr.rmwf(utra::irqarray3::EV_STATUS_SOURCE14, bar); + let mut baz = irqarray3_csr.zf(utra::irqarray3::EV_STATUS_SOURCE14, bar); + baz |= irqarray3_csr.ms(utra::irqarray3::EV_STATUS_SOURCE14, 1); + irqarray3_csr.wfo(utra::irqarray3::EV_STATUS_SOURCE14, baz); + let bar = irqarray3_csr.rf(utra::irqarray3::EV_STATUS_SOURCE15); + irqarray3_csr.rmwf(utra::irqarray3::EV_STATUS_SOURCE15, bar); + let mut baz = irqarray3_csr.zf(utra::irqarray3::EV_STATUS_SOURCE15, bar); + baz |= irqarray3_csr.ms(utra::irqarray3::EV_STATUS_SOURCE15, 1); + irqarray3_csr.wfo(utra::irqarray3::EV_STATUS_SOURCE15, baz); + let bar = irqarray3_csr.rf(utra::irqarray3::EV_STATUS_SOURCE16); + irqarray3_csr.rmwf(utra::irqarray3::EV_STATUS_SOURCE16, bar); + let mut baz = irqarray3_csr.zf(utra::irqarray3::EV_STATUS_SOURCE16, bar); + baz |= irqarray3_csr.ms(utra::irqarray3::EV_STATUS_SOURCE16, 1); + irqarray3_csr.wfo(utra::irqarray3::EV_STATUS_SOURCE16, baz); + let bar = irqarray3_csr.rf(utra::irqarray3::EV_STATUS_SOURCE17); + irqarray3_csr.rmwf(utra::irqarray3::EV_STATUS_SOURCE17, bar); + let mut baz = irqarray3_csr.zf(utra::irqarray3::EV_STATUS_SOURCE17, bar); + baz |= irqarray3_csr.ms(utra::irqarray3::EV_STATUS_SOURCE17, 1); + irqarray3_csr.wfo(utra::irqarray3::EV_STATUS_SOURCE17, baz); + let bar = irqarray3_csr.rf(utra::irqarray3::EV_STATUS_SOURCE18); + irqarray3_csr.rmwf(utra::irqarray3::EV_STATUS_SOURCE18, bar); + let mut baz = irqarray3_csr.zf(utra::irqarray3::EV_STATUS_SOURCE18, bar); + baz |= irqarray3_csr.ms(utra::irqarray3::EV_STATUS_SOURCE18, 1); + irqarray3_csr.wfo(utra::irqarray3::EV_STATUS_SOURCE18, baz); + let bar = irqarray3_csr.rf(utra::irqarray3::EV_STATUS_SOURCE19); + irqarray3_csr.rmwf(utra::irqarray3::EV_STATUS_SOURCE19, bar); + let mut baz = irqarray3_csr.zf(utra::irqarray3::EV_STATUS_SOURCE19, bar); + baz |= irqarray3_csr.ms(utra::irqarray3::EV_STATUS_SOURCE19, 1); + irqarray3_csr.wfo(utra::irqarray3::EV_STATUS_SOURCE19, baz); + + let foo = irqarray3_csr.r(utra::irqarray3::EV_PENDING); + irqarray3_csr.wo(utra::irqarray3::EV_PENDING, foo); + let bar = irqarray3_csr.rf(utra::irqarray3::EV_PENDING_SOURCE0); + irqarray3_csr.rmwf(utra::irqarray3::EV_PENDING_SOURCE0, bar); + let mut baz = irqarray3_csr.zf(utra::irqarray3::EV_PENDING_SOURCE0, bar); + baz |= irqarray3_csr.ms(utra::irqarray3::EV_PENDING_SOURCE0, 1); + irqarray3_csr.wfo(utra::irqarray3::EV_PENDING_SOURCE0, baz); + let bar = irqarray3_csr.rf(utra::irqarray3::EV_PENDING_SOURCE1); + irqarray3_csr.rmwf(utra::irqarray3::EV_PENDING_SOURCE1, bar); + let mut baz = irqarray3_csr.zf(utra::irqarray3::EV_PENDING_SOURCE1, bar); + baz |= irqarray3_csr.ms(utra::irqarray3::EV_PENDING_SOURCE1, 1); + irqarray3_csr.wfo(utra::irqarray3::EV_PENDING_SOURCE1, baz); + let bar = irqarray3_csr.rf(utra::irqarray3::EV_PENDING_SOURCE2); + irqarray3_csr.rmwf(utra::irqarray3::EV_PENDING_SOURCE2, bar); + let mut baz = irqarray3_csr.zf(utra::irqarray3::EV_PENDING_SOURCE2, bar); + baz |= irqarray3_csr.ms(utra::irqarray3::EV_PENDING_SOURCE2, 1); + irqarray3_csr.wfo(utra::irqarray3::EV_PENDING_SOURCE2, baz); + let bar = irqarray3_csr.rf(utra::irqarray3::EV_PENDING_SOURCE3); + irqarray3_csr.rmwf(utra::irqarray3::EV_PENDING_SOURCE3, bar); + let mut baz = irqarray3_csr.zf(utra::irqarray3::EV_PENDING_SOURCE3, bar); + baz |= irqarray3_csr.ms(utra::irqarray3::EV_PENDING_SOURCE3, 1); + irqarray3_csr.wfo(utra::irqarray3::EV_PENDING_SOURCE3, baz); + let bar = irqarray3_csr.rf(utra::irqarray3::EV_PENDING_SOURCE4); + irqarray3_csr.rmwf(utra::irqarray3::EV_PENDING_SOURCE4, bar); + let mut baz = irqarray3_csr.zf(utra::irqarray3::EV_PENDING_SOURCE4, bar); + baz |= irqarray3_csr.ms(utra::irqarray3::EV_PENDING_SOURCE4, 1); + irqarray3_csr.wfo(utra::irqarray3::EV_PENDING_SOURCE4, baz); + let bar = irqarray3_csr.rf(utra::irqarray3::EV_PENDING_SOURCE5); + irqarray3_csr.rmwf(utra::irqarray3::EV_PENDING_SOURCE5, bar); + let mut baz = irqarray3_csr.zf(utra::irqarray3::EV_PENDING_SOURCE5, bar); + baz |= irqarray3_csr.ms(utra::irqarray3::EV_PENDING_SOURCE5, 1); + irqarray3_csr.wfo(utra::irqarray3::EV_PENDING_SOURCE5, baz); + let bar = irqarray3_csr.rf(utra::irqarray3::EV_PENDING_SOURCE6); + irqarray3_csr.rmwf(utra::irqarray3::EV_PENDING_SOURCE6, bar); + let mut baz = irqarray3_csr.zf(utra::irqarray3::EV_PENDING_SOURCE6, bar); + baz |= irqarray3_csr.ms(utra::irqarray3::EV_PENDING_SOURCE6, 1); + irqarray3_csr.wfo(utra::irqarray3::EV_PENDING_SOURCE6, baz); + let bar = irqarray3_csr.rf(utra::irqarray3::EV_PENDING_SOURCE7); + irqarray3_csr.rmwf(utra::irqarray3::EV_PENDING_SOURCE7, bar); + let mut baz = irqarray3_csr.zf(utra::irqarray3::EV_PENDING_SOURCE7, bar); + baz |= irqarray3_csr.ms(utra::irqarray3::EV_PENDING_SOURCE7, 1); + irqarray3_csr.wfo(utra::irqarray3::EV_PENDING_SOURCE7, baz); + let bar = irqarray3_csr.rf(utra::irqarray3::EV_PENDING_SOURCE8); + irqarray3_csr.rmwf(utra::irqarray3::EV_PENDING_SOURCE8, bar); + let mut baz = irqarray3_csr.zf(utra::irqarray3::EV_PENDING_SOURCE8, bar); + baz |= irqarray3_csr.ms(utra::irqarray3::EV_PENDING_SOURCE8, 1); + irqarray3_csr.wfo(utra::irqarray3::EV_PENDING_SOURCE8, baz); + let bar = irqarray3_csr.rf(utra::irqarray3::EV_PENDING_SOURCE9); + irqarray3_csr.rmwf(utra::irqarray3::EV_PENDING_SOURCE9, bar); + let mut baz = irqarray3_csr.zf(utra::irqarray3::EV_PENDING_SOURCE9, bar); + baz |= irqarray3_csr.ms(utra::irqarray3::EV_PENDING_SOURCE9, 1); + irqarray3_csr.wfo(utra::irqarray3::EV_PENDING_SOURCE9, baz); + let bar = irqarray3_csr.rf(utra::irqarray3::EV_PENDING_SOURCE10); + irqarray3_csr.rmwf(utra::irqarray3::EV_PENDING_SOURCE10, bar); + let mut baz = irqarray3_csr.zf(utra::irqarray3::EV_PENDING_SOURCE10, bar); + baz |= irqarray3_csr.ms(utra::irqarray3::EV_PENDING_SOURCE10, 1); + irqarray3_csr.wfo(utra::irqarray3::EV_PENDING_SOURCE10, baz); + let bar = irqarray3_csr.rf(utra::irqarray3::EV_PENDING_SOURCE11); + irqarray3_csr.rmwf(utra::irqarray3::EV_PENDING_SOURCE11, bar); + let mut baz = irqarray3_csr.zf(utra::irqarray3::EV_PENDING_SOURCE11, bar); + baz |= irqarray3_csr.ms(utra::irqarray3::EV_PENDING_SOURCE11, 1); + irqarray3_csr.wfo(utra::irqarray3::EV_PENDING_SOURCE11, baz); + let bar = irqarray3_csr.rf(utra::irqarray3::EV_PENDING_SOURCE12); + irqarray3_csr.rmwf(utra::irqarray3::EV_PENDING_SOURCE12, bar); + let mut baz = irqarray3_csr.zf(utra::irqarray3::EV_PENDING_SOURCE12, bar); + baz |= irqarray3_csr.ms(utra::irqarray3::EV_PENDING_SOURCE12, 1); + irqarray3_csr.wfo(utra::irqarray3::EV_PENDING_SOURCE12, baz); + let bar = irqarray3_csr.rf(utra::irqarray3::EV_PENDING_SOURCE13); + irqarray3_csr.rmwf(utra::irqarray3::EV_PENDING_SOURCE13, bar); + let mut baz = irqarray3_csr.zf(utra::irqarray3::EV_PENDING_SOURCE13, bar); + baz |= irqarray3_csr.ms(utra::irqarray3::EV_PENDING_SOURCE13, 1); + irqarray3_csr.wfo(utra::irqarray3::EV_PENDING_SOURCE13, baz); + let bar = irqarray3_csr.rf(utra::irqarray3::EV_PENDING_SOURCE14); + irqarray3_csr.rmwf(utra::irqarray3::EV_PENDING_SOURCE14, bar); + let mut baz = irqarray3_csr.zf(utra::irqarray3::EV_PENDING_SOURCE14, bar); + baz |= irqarray3_csr.ms(utra::irqarray3::EV_PENDING_SOURCE14, 1); + irqarray3_csr.wfo(utra::irqarray3::EV_PENDING_SOURCE14, baz); + let bar = irqarray3_csr.rf(utra::irqarray3::EV_PENDING_SOURCE15); + irqarray3_csr.rmwf(utra::irqarray3::EV_PENDING_SOURCE15, bar); + let mut baz = irqarray3_csr.zf(utra::irqarray3::EV_PENDING_SOURCE15, bar); + baz |= irqarray3_csr.ms(utra::irqarray3::EV_PENDING_SOURCE15, 1); + irqarray3_csr.wfo(utra::irqarray3::EV_PENDING_SOURCE15, baz); + let bar = irqarray3_csr.rf(utra::irqarray3::EV_PENDING_SOURCE16); + irqarray3_csr.rmwf(utra::irqarray3::EV_PENDING_SOURCE16, bar); + let mut baz = irqarray3_csr.zf(utra::irqarray3::EV_PENDING_SOURCE16, bar); + baz |= irqarray3_csr.ms(utra::irqarray3::EV_PENDING_SOURCE16, 1); + irqarray3_csr.wfo(utra::irqarray3::EV_PENDING_SOURCE16, baz); + let bar = irqarray3_csr.rf(utra::irqarray3::EV_PENDING_SOURCE17); + irqarray3_csr.rmwf(utra::irqarray3::EV_PENDING_SOURCE17, bar); + let mut baz = irqarray3_csr.zf(utra::irqarray3::EV_PENDING_SOURCE17, bar); + baz |= irqarray3_csr.ms(utra::irqarray3::EV_PENDING_SOURCE17, 1); + irqarray3_csr.wfo(utra::irqarray3::EV_PENDING_SOURCE17, baz); + let bar = irqarray3_csr.rf(utra::irqarray3::EV_PENDING_SOURCE18); + irqarray3_csr.rmwf(utra::irqarray3::EV_PENDING_SOURCE18, bar); + let mut baz = irqarray3_csr.zf(utra::irqarray3::EV_PENDING_SOURCE18, bar); + baz |= irqarray3_csr.ms(utra::irqarray3::EV_PENDING_SOURCE18, 1); + irqarray3_csr.wfo(utra::irqarray3::EV_PENDING_SOURCE18, baz); + let bar = irqarray3_csr.rf(utra::irqarray3::EV_PENDING_SOURCE19); + irqarray3_csr.rmwf(utra::irqarray3::EV_PENDING_SOURCE19, bar); + let mut baz = irqarray3_csr.zf(utra::irqarray3::EV_PENDING_SOURCE19, bar); + baz |= irqarray3_csr.ms(utra::irqarray3::EV_PENDING_SOURCE19, 1); + irqarray3_csr.wfo(utra::irqarray3::EV_PENDING_SOURCE19, baz); + + let foo = irqarray3_csr.r(utra::irqarray3::EV_ENABLE); + irqarray3_csr.wo(utra::irqarray3::EV_ENABLE, foo); + let bar = irqarray3_csr.rf(utra::irqarray3::EV_ENABLE_SOURCE0); + irqarray3_csr.rmwf(utra::irqarray3::EV_ENABLE_SOURCE0, bar); + let mut baz = irqarray3_csr.zf(utra::irqarray3::EV_ENABLE_SOURCE0, bar); + baz |= irqarray3_csr.ms(utra::irqarray3::EV_ENABLE_SOURCE0, 1); + irqarray3_csr.wfo(utra::irqarray3::EV_ENABLE_SOURCE0, baz); + let bar = irqarray3_csr.rf(utra::irqarray3::EV_ENABLE_SOURCE1); + irqarray3_csr.rmwf(utra::irqarray3::EV_ENABLE_SOURCE1, bar); + let mut baz = irqarray3_csr.zf(utra::irqarray3::EV_ENABLE_SOURCE1, bar); + baz |= irqarray3_csr.ms(utra::irqarray3::EV_ENABLE_SOURCE1, 1); + irqarray3_csr.wfo(utra::irqarray3::EV_ENABLE_SOURCE1, baz); + let bar = irqarray3_csr.rf(utra::irqarray3::EV_ENABLE_SOURCE2); + irqarray3_csr.rmwf(utra::irqarray3::EV_ENABLE_SOURCE2, bar); + let mut baz = irqarray3_csr.zf(utra::irqarray3::EV_ENABLE_SOURCE2, bar); + baz |= irqarray3_csr.ms(utra::irqarray3::EV_ENABLE_SOURCE2, 1); + irqarray3_csr.wfo(utra::irqarray3::EV_ENABLE_SOURCE2, baz); + let bar = irqarray3_csr.rf(utra::irqarray3::EV_ENABLE_SOURCE3); + irqarray3_csr.rmwf(utra::irqarray3::EV_ENABLE_SOURCE3, bar); + let mut baz = irqarray3_csr.zf(utra::irqarray3::EV_ENABLE_SOURCE3, bar); + baz |= irqarray3_csr.ms(utra::irqarray3::EV_ENABLE_SOURCE3, 1); + irqarray3_csr.wfo(utra::irqarray3::EV_ENABLE_SOURCE3, baz); + let bar = irqarray3_csr.rf(utra::irqarray3::EV_ENABLE_SOURCE4); + irqarray3_csr.rmwf(utra::irqarray3::EV_ENABLE_SOURCE4, bar); + let mut baz = irqarray3_csr.zf(utra::irqarray3::EV_ENABLE_SOURCE4, bar); + baz |= irqarray3_csr.ms(utra::irqarray3::EV_ENABLE_SOURCE4, 1); + irqarray3_csr.wfo(utra::irqarray3::EV_ENABLE_SOURCE4, baz); + let bar = irqarray3_csr.rf(utra::irqarray3::EV_ENABLE_SOURCE5); + irqarray3_csr.rmwf(utra::irqarray3::EV_ENABLE_SOURCE5, bar); + let mut baz = irqarray3_csr.zf(utra::irqarray3::EV_ENABLE_SOURCE5, bar); + baz |= irqarray3_csr.ms(utra::irqarray3::EV_ENABLE_SOURCE5, 1); + irqarray3_csr.wfo(utra::irqarray3::EV_ENABLE_SOURCE5, baz); + let bar = irqarray3_csr.rf(utra::irqarray3::EV_ENABLE_SOURCE6); + irqarray3_csr.rmwf(utra::irqarray3::EV_ENABLE_SOURCE6, bar); + let mut baz = irqarray3_csr.zf(utra::irqarray3::EV_ENABLE_SOURCE6, bar); + baz |= irqarray3_csr.ms(utra::irqarray3::EV_ENABLE_SOURCE6, 1); + irqarray3_csr.wfo(utra::irqarray3::EV_ENABLE_SOURCE6, baz); + let bar = irqarray3_csr.rf(utra::irqarray3::EV_ENABLE_SOURCE7); + irqarray3_csr.rmwf(utra::irqarray3::EV_ENABLE_SOURCE7, bar); + let mut baz = irqarray3_csr.zf(utra::irqarray3::EV_ENABLE_SOURCE7, bar); + baz |= irqarray3_csr.ms(utra::irqarray3::EV_ENABLE_SOURCE7, 1); + irqarray3_csr.wfo(utra::irqarray3::EV_ENABLE_SOURCE7, baz); + let bar = irqarray3_csr.rf(utra::irqarray3::EV_ENABLE_SOURCE8); + irqarray3_csr.rmwf(utra::irqarray3::EV_ENABLE_SOURCE8, bar); + let mut baz = irqarray3_csr.zf(utra::irqarray3::EV_ENABLE_SOURCE8, bar); + baz |= irqarray3_csr.ms(utra::irqarray3::EV_ENABLE_SOURCE8, 1); + irqarray3_csr.wfo(utra::irqarray3::EV_ENABLE_SOURCE8, baz); + let bar = irqarray3_csr.rf(utra::irqarray3::EV_ENABLE_SOURCE9); + irqarray3_csr.rmwf(utra::irqarray3::EV_ENABLE_SOURCE9, bar); + let mut baz = irqarray3_csr.zf(utra::irqarray3::EV_ENABLE_SOURCE9, bar); + baz |= irqarray3_csr.ms(utra::irqarray3::EV_ENABLE_SOURCE9, 1); + irqarray3_csr.wfo(utra::irqarray3::EV_ENABLE_SOURCE9, baz); + let bar = irqarray3_csr.rf(utra::irqarray3::EV_ENABLE_SOURCE10); + irqarray3_csr.rmwf(utra::irqarray3::EV_ENABLE_SOURCE10, bar); + let mut baz = irqarray3_csr.zf(utra::irqarray3::EV_ENABLE_SOURCE10, bar); + baz |= irqarray3_csr.ms(utra::irqarray3::EV_ENABLE_SOURCE10, 1); + irqarray3_csr.wfo(utra::irqarray3::EV_ENABLE_SOURCE10, baz); + let bar = irqarray3_csr.rf(utra::irqarray3::EV_ENABLE_SOURCE11); + irqarray3_csr.rmwf(utra::irqarray3::EV_ENABLE_SOURCE11, bar); + let mut baz = irqarray3_csr.zf(utra::irqarray3::EV_ENABLE_SOURCE11, bar); + baz |= irqarray3_csr.ms(utra::irqarray3::EV_ENABLE_SOURCE11, 1); + irqarray3_csr.wfo(utra::irqarray3::EV_ENABLE_SOURCE11, baz); + let bar = irqarray3_csr.rf(utra::irqarray3::EV_ENABLE_SOURCE12); + irqarray3_csr.rmwf(utra::irqarray3::EV_ENABLE_SOURCE12, bar); + let mut baz = irqarray3_csr.zf(utra::irqarray3::EV_ENABLE_SOURCE12, bar); + baz |= irqarray3_csr.ms(utra::irqarray3::EV_ENABLE_SOURCE12, 1); + irqarray3_csr.wfo(utra::irqarray3::EV_ENABLE_SOURCE12, baz); + let bar = irqarray3_csr.rf(utra::irqarray3::EV_ENABLE_SOURCE13); + irqarray3_csr.rmwf(utra::irqarray3::EV_ENABLE_SOURCE13, bar); + let mut baz = irqarray3_csr.zf(utra::irqarray3::EV_ENABLE_SOURCE13, bar); + baz |= irqarray3_csr.ms(utra::irqarray3::EV_ENABLE_SOURCE13, 1); + irqarray3_csr.wfo(utra::irqarray3::EV_ENABLE_SOURCE13, baz); + let bar = irqarray3_csr.rf(utra::irqarray3::EV_ENABLE_SOURCE14); + irqarray3_csr.rmwf(utra::irqarray3::EV_ENABLE_SOURCE14, bar); + let mut baz = irqarray3_csr.zf(utra::irqarray3::EV_ENABLE_SOURCE14, bar); + baz |= irqarray3_csr.ms(utra::irqarray3::EV_ENABLE_SOURCE14, 1); + irqarray3_csr.wfo(utra::irqarray3::EV_ENABLE_SOURCE14, baz); + let bar = irqarray3_csr.rf(utra::irqarray3::EV_ENABLE_SOURCE15); + irqarray3_csr.rmwf(utra::irqarray3::EV_ENABLE_SOURCE15, bar); + let mut baz = irqarray3_csr.zf(utra::irqarray3::EV_ENABLE_SOURCE15, bar); + baz |= irqarray3_csr.ms(utra::irqarray3::EV_ENABLE_SOURCE15, 1); + irqarray3_csr.wfo(utra::irqarray3::EV_ENABLE_SOURCE15, baz); + let bar = irqarray3_csr.rf(utra::irqarray3::EV_ENABLE_SOURCE16); + irqarray3_csr.rmwf(utra::irqarray3::EV_ENABLE_SOURCE16, bar); + let mut baz = irqarray3_csr.zf(utra::irqarray3::EV_ENABLE_SOURCE16, bar); + baz |= irqarray3_csr.ms(utra::irqarray3::EV_ENABLE_SOURCE16, 1); + irqarray3_csr.wfo(utra::irqarray3::EV_ENABLE_SOURCE16, baz); + let bar = irqarray3_csr.rf(utra::irqarray3::EV_ENABLE_SOURCE17); + irqarray3_csr.rmwf(utra::irqarray3::EV_ENABLE_SOURCE17, bar); + let mut baz = irqarray3_csr.zf(utra::irqarray3::EV_ENABLE_SOURCE17, bar); + baz |= irqarray3_csr.ms(utra::irqarray3::EV_ENABLE_SOURCE17, 1); + irqarray3_csr.wfo(utra::irqarray3::EV_ENABLE_SOURCE17, baz); + let bar = irqarray3_csr.rf(utra::irqarray3::EV_ENABLE_SOURCE18); + irqarray3_csr.rmwf(utra::irqarray3::EV_ENABLE_SOURCE18, bar); + let mut baz = irqarray3_csr.zf(utra::irqarray3::EV_ENABLE_SOURCE18, bar); + baz |= irqarray3_csr.ms(utra::irqarray3::EV_ENABLE_SOURCE18, 1); + irqarray3_csr.wfo(utra::irqarray3::EV_ENABLE_SOURCE18, baz); + let bar = irqarray3_csr.rf(utra::irqarray3::EV_ENABLE_SOURCE19); + irqarray3_csr.rmwf(utra::irqarray3::EV_ENABLE_SOURCE19, bar); + let mut baz = irqarray3_csr.zf(utra::irqarray3::EV_ENABLE_SOURCE19, bar); + baz |= irqarray3_csr.ms(utra::irqarray3::EV_ENABLE_SOURCE19, 1); + irqarray3_csr.wfo(utra::irqarray3::EV_ENABLE_SOURCE19, baz); + } + + #[test] + #[ignore] + fn compile_check_irqarray4_csr() { + use super::*; + let mut irqarray4_csr = CSR::new(HW_IRQARRAY4_BASE as *mut u32); + + let foo = irqarray4_csr.r(utra::irqarray4::EV_SOFT); + irqarray4_csr.wo(utra::irqarray4::EV_SOFT, foo); + let bar = irqarray4_csr.rf(utra::irqarray4::EV_SOFT_TRIGGER); + irqarray4_csr.rmwf(utra::irqarray4::EV_SOFT_TRIGGER, bar); + let mut baz = irqarray4_csr.zf(utra::irqarray4::EV_SOFT_TRIGGER, bar); + baz |= irqarray4_csr.ms(utra::irqarray4::EV_SOFT_TRIGGER, 1); + irqarray4_csr.wfo(utra::irqarray4::EV_SOFT_TRIGGER, baz); + + let foo = irqarray4_csr.r(utra::irqarray4::EV_STATUS); + irqarray4_csr.wo(utra::irqarray4::EV_STATUS, foo); + let bar = irqarray4_csr.rf(utra::irqarray4::EV_STATUS_SOURCE0); + irqarray4_csr.rmwf(utra::irqarray4::EV_STATUS_SOURCE0, bar); + let mut baz = irqarray4_csr.zf(utra::irqarray4::EV_STATUS_SOURCE0, bar); + baz |= irqarray4_csr.ms(utra::irqarray4::EV_STATUS_SOURCE0, 1); + irqarray4_csr.wfo(utra::irqarray4::EV_STATUS_SOURCE0, baz); + let bar = irqarray4_csr.rf(utra::irqarray4::EV_STATUS_SOURCE1); + irqarray4_csr.rmwf(utra::irqarray4::EV_STATUS_SOURCE1, bar); + let mut baz = irqarray4_csr.zf(utra::irqarray4::EV_STATUS_SOURCE1, bar); + baz |= irqarray4_csr.ms(utra::irqarray4::EV_STATUS_SOURCE1, 1); + irqarray4_csr.wfo(utra::irqarray4::EV_STATUS_SOURCE1, baz); + let bar = irqarray4_csr.rf(utra::irqarray4::EV_STATUS_SOURCE2); + irqarray4_csr.rmwf(utra::irqarray4::EV_STATUS_SOURCE2, bar); + let mut baz = irqarray4_csr.zf(utra::irqarray4::EV_STATUS_SOURCE2, bar); + baz |= irqarray4_csr.ms(utra::irqarray4::EV_STATUS_SOURCE2, 1); + irqarray4_csr.wfo(utra::irqarray4::EV_STATUS_SOURCE2, baz); + let bar = irqarray4_csr.rf(utra::irqarray4::EV_STATUS_SOURCE3); + irqarray4_csr.rmwf(utra::irqarray4::EV_STATUS_SOURCE3, bar); + let mut baz = irqarray4_csr.zf(utra::irqarray4::EV_STATUS_SOURCE3, bar); + baz |= irqarray4_csr.ms(utra::irqarray4::EV_STATUS_SOURCE3, 1); + irqarray4_csr.wfo(utra::irqarray4::EV_STATUS_SOURCE3, baz); + let bar = irqarray4_csr.rf(utra::irqarray4::EV_STATUS_SOURCE4); + irqarray4_csr.rmwf(utra::irqarray4::EV_STATUS_SOURCE4, bar); + let mut baz = irqarray4_csr.zf(utra::irqarray4::EV_STATUS_SOURCE4, bar); + baz |= irqarray4_csr.ms(utra::irqarray4::EV_STATUS_SOURCE4, 1); + irqarray4_csr.wfo(utra::irqarray4::EV_STATUS_SOURCE4, baz); + let bar = irqarray4_csr.rf(utra::irqarray4::EV_STATUS_SOURCE5); + irqarray4_csr.rmwf(utra::irqarray4::EV_STATUS_SOURCE5, bar); + let mut baz = irqarray4_csr.zf(utra::irqarray4::EV_STATUS_SOURCE5, bar); + baz |= irqarray4_csr.ms(utra::irqarray4::EV_STATUS_SOURCE5, 1); + irqarray4_csr.wfo(utra::irqarray4::EV_STATUS_SOURCE5, baz); + let bar = irqarray4_csr.rf(utra::irqarray4::EV_STATUS_SOURCE6); + irqarray4_csr.rmwf(utra::irqarray4::EV_STATUS_SOURCE6, bar); + let mut baz = irqarray4_csr.zf(utra::irqarray4::EV_STATUS_SOURCE6, bar); + baz |= irqarray4_csr.ms(utra::irqarray4::EV_STATUS_SOURCE6, 1); + irqarray4_csr.wfo(utra::irqarray4::EV_STATUS_SOURCE6, baz); + let bar = irqarray4_csr.rf(utra::irqarray4::EV_STATUS_SOURCE7); + irqarray4_csr.rmwf(utra::irqarray4::EV_STATUS_SOURCE7, bar); + let mut baz = irqarray4_csr.zf(utra::irqarray4::EV_STATUS_SOURCE7, bar); + baz |= irqarray4_csr.ms(utra::irqarray4::EV_STATUS_SOURCE7, 1); + irqarray4_csr.wfo(utra::irqarray4::EV_STATUS_SOURCE7, baz); + let bar = irqarray4_csr.rf(utra::irqarray4::EV_STATUS_SOURCE8); + irqarray4_csr.rmwf(utra::irqarray4::EV_STATUS_SOURCE8, bar); + let mut baz = irqarray4_csr.zf(utra::irqarray4::EV_STATUS_SOURCE8, bar); + baz |= irqarray4_csr.ms(utra::irqarray4::EV_STATUS_SOURCE8, 1); + irqarray4_csr.wfo(utra::irqarray4::EV_STATUS_SOURCE8, baz); + let bar = irqarray4_csr.rf(utra::irqarray4::EV_STATUS_SOURCE9); + irqarray4_csr.rmwf(utra::irqarray4::EV_STATUS_SOURCE9, bar); + let mut baz = irqarray4_csr.zf(utra::irqarray4::EV_STATUS_SOURCE9, bar); + baz |= irqarray4_csr.ms(utra::irqarray4::EV_STATUS_SOURCE9, 1); + irqarray4_csr.wfo(utra::irqarray4::EV_STATUS_SOURCE9, baz); + let bar = irqarray4_csr.rf(utra::irqarray4::EV_STATUS_SOURCE10); + irqarray4_csr.rmwf(utra::irqarray4::EV_STATUS_SOURCE10, bar); + let mut baz = irqarray4_csr.zf(utra::irqarray4::EV_STATUS_SOURCE10, bar); + baz |= irqarray4_csr.ms(utra::irqarray4::EV_STATUS_SOURCE10, 1); + irqarray4_csr.wfo(utra::irqarray4::EV_STATUS_SOURCE10, baz); + let bar = irqarray4_csr.rf(utra::irqarray4::EV_STATUS_SOURCE11); + irqarray4_csr.rmwf(utra::irqarray4::EV_STATUS_SOURCE11, bar); + let mut baz = irqarray4_csr.zf(utra::irqarray4::EV_STATUS_SOURCE11, bar); + baz |= irqarray4_csr.ms(utra::irqarray4::EV_STATUS_SOURCE11, 1); + irqarray4_csr.wfo(utra::irqarray4::EV_STATUS_SOURCE11, baz); + let bar = irqarray4_csr.rf(utra::irqarray4::EV_STATUS_SOURCE12); + irqarray4_csr.rmwf(utra::irqarray4::EV_STATUS_SOURCE12, bar); + let mut baz = irqarray4_csr.zf(utra::irqarray4::EV_STATUS_SOURCE12, bar); + baz |= irqarray4_csr.ms(utra::irqarray4::EV_STATUS_SOURCE12, 1); + irqarray4_csr.wfo(utra::irqarray4::EV_STATUS_SOURCE12, baz); + let bar = irqarray4_csr.rf(utra::irqarray4::EV_STATUS_SOURCE13); + irqarray4_csr.rmwf(utra::irqarray4::EV_STATUS_SOURCE13, bar); + let mut baz = irqarray4_csr.zf(utra::irqarray4::EV_STATUS_SOURCE13, bar); + baz |= irqarray4_csr.ms(utra::irqarray4::EV_STATUS_SOURCE13, 1); + irqarray4_csr.wfo(utra::irqarray4::EV_STATUS_SOURCE13, baz); + let bar = irqarray4_csr.rf(utra::irqarray4::EV_STATUS_SOURCE14); + irqarray4_csr.rmwf(utra::irqarray4::EV_STATUS_SOURCE14, bar); + let mut baz = irqarray4_csr.zf(utra::irqarray4::EV_STATUS_SOURCE14, bar); + baz |= irqarray4_csr.ms(utra::irqarray4::EV_STATUS_SOURCE14, 1); + irqarray4_csr.wfo(utra::irqarray4::EV_STATUS_SOURCE14, baz); + let bar = irqarray4_csr.rf(utra::irqarray4::EV_STATUS_SOURCE15); + irqarray4_csr.rmwf(utra::irqarray4::EV_STATUS_SOURCE15, bar); + let mut baz = irqarray4_csr.zf(utra::irqarray4::EV_STATUS_SOURCE15, bar); + baz |= irqarray4_csr.ms(utra::irqarray4::EV_STATUS_SOURCE15, 1); + irqarray4_csr.wfo(utra::irqarray4::EV_STATUS_SOURCE15, baz); + let bar = irqarray4_csr.rf(utra::irqarray4::EV_STATUS_SOURCE16); + irqarray4_csr.rmwf(utra::irqarray4::EV_STATUS_SOURCE16, bar); + let mut baz = irqarray4_csr.zf(utra::irqarray4::EV_STATUS_SOURCE16, bar); + baz |= irqarray4_csr.ms(utra::irqarray4::EV_STATUS_SOURCE16, 1); + irqarray4_csr.wfo(utra::irqarray4::EV_STATUS_SOURCE16, baz); + let bar = irqarray4_csr.rf(utra::irqarray4::EV_STATUS_SOURCE17); + irqarray4_csr.rmwf(utra::irqarray4::EV_STATUS_SOURCE17, bar); + let mut baz = irqarray4_csr.zf(utra::irqarray4::EV_STATUS_SOURCE17, bar); + baz |= irqarray4_csr.ms(utra::irqarray4::EV_STATUS_SOURCE17, 1); + irqarray4_csr.wfo(utra::irqarray4::EV_STATUS_SOURCE17, baz); + let bar = irqarray4_csr.rf(utra::irqarray4::EV_STATUS_SOURCE18); + irqarray4_csr.rmwf(utra::irqarray4::EV_STATUS_SOURCE18, bar); + let mut baz = irqarray4_csr.zf(utra::irqarray4::EV_STATUS_SOURCE18, bar); + baz |= irqarray4_csr.ms(utra::irqarray4::EV_STATUS_SOURCE18, 1); + irqarray4_csr.wfo(utra::irqarray4::EV_STATUS_SOURCE18, baz); + let bar = irqarray4_csr.rf(utra::irqarray4::EV_STATUS_SOURCE19); + irqarray4_csr.rmwf(utra::irqarray4::EV_STATUS_SOURCE19, bar); + let mut baz = irqarray4_csr.zf(utra::irqarray4::EV_STATUS_SOURCE19, bar); + baz |= irqarray4_csr.ms(utra::irqarray4::EV_STATUS_SOURCE19, 1); + irqarray4_csr.wfo(utra::irqarray4::EV_STATUS_SOURCE19, baz); + + let foo = irqarray4_csr.r(utra::irqarray4::EV_PENDING); + irqarray4_csr.wo(utra::irqarray4::EV_PENDING, foo); + let bar = irqarray4_csr.rf(utra::irqarray4::EV_PENDING_SOURCE0); + irqarray4_csr.rmwf(utra::irqarray4::EV_PENDING_SOURCE0, bar); + let mut baz = irqarray4_csr.zf(utra::irqarray4::EV_PENDING_SOURCE0, bar); + baz |= irqarray4_csr.ms(utra::irqarray4::EV_PENDING_SOURCE0, 1); + irqarray4_csr.wfo(utra::irqarray4::EV_PENDING_SOURCE0, baz); + let bar = irqarray4_csr.rf(utra::irqarray4::EV_PENDING_SOURCE1); + irqarray4_csr.rmwf(utra::irqarray4::EV_PENDING_SOURCE1, bar); + let mut baz = irqarray4_csr.zf(utra::irqarray4::EV_PENDING_SOURCE1, bar); + baz |= irqarray4_csr.ms(utra::irqarray4::EV_PENDING_SOURCE1, 1); + irqarray4_csr.wfo(utra::irqarray4::EV_PENDING_SOURCE1, baz); + let bar = irqarray4_csr.rf(utra::irqarray4::EV_PENDING_SOURCE2); + irqarray4_csr.rmwf(utra::irqarray4::EV_PENDING_SOURCE2, bar); + let mut baz = irqarray4_csr.zf(utra::irqarray4::EV_PENDING_SOURCE2, bar); + baz |= irqarray4_csr.ms(utra::irqarray4::EV_PENDING_SOURCE2, 1); + irqarray4_csr.wfo(utra::irqarray4::EV_PENDING_SOURCE2, baz); + let bar = irqarray4_csr.rf(utra::irqarray4::EV_PENDING_SOURCE3); + irqarray4_csr.rmwf(utra::irqarray4::EV_PENDING_SOURCE3, bar); + let mut baz = irqarray4_csr.zf(utra::irqarray4::EV_PENDING_SOURCE3, bar); + baz |= irqarray4_csr.ms(utra::irqarray4::EV_PENDING_SOURCE3, 1); + irqarray4_csr.wfo(utra::irqarray4::EV_PENDING_SOURCE3, baz); + let bar = irqarray4_csr.rf(utra::irqarray4::EV_PENDING_SOURCE4); + irqarray4_csr.rmwf(utra::irqarray4::EV_PENDING_SOURCE4, bar); + let mut baz = irqarray4_csr.zf(utra::irqarray4::EV_PENDING_SOURCE4, bar); + baz |= irqarray4_csr.ms(utra::irqarray4::EV_PENDING_SOURCE4, 1); + irqarray4_csr.wfo(utra::irqarray4::EV_PENDING_SOURCE4, baz); + let bar = irqarray4_csr.rf(utra::irqarray4::EV_PENDING_SOURCE5); + irqarray4_csr.rmwf(utra::irqarray4::EV_PENDING_SOURCE5, bar); + let mut baz = irqarray4_csr.zf(utra::irqarray4::EV_PENDING_SOURCE5, bar); + baz |= irqarray4_csr.ms(utra::irqarray4::EV_PENDING_SOURCE5, 1); + irqarray4_csr.wfo(utra::irqarray4::EV_PENDING_SOURCE5, baz); + let bar = irqarray4_csr.rf(utra::irqarray4::EV_PENDING_SOURCE6); + irqarray4_csr.rmwf(utra::irqarray4::EV_PENDING_SOURCE6, bar); + let mut baz = irqarray4_csr.zf(utra::irqarray4::EV_PENDING_SOURCE6, bar); + baz |= irqarray4_csr.ms(utra::irqarray4::EV_PENDING_SOURCE6, 1); + irqarray4_csr.wfo(utra::irqarray4::EV_PENDING_SOURCE6, baz); + let bar = irqarray4_csr.rf(utra::irqarray4::EV_PENDING_SOURCE7); + irqarray4_csr.rmwf(utra::irqarray4::EV_PENDING_SOURCE7, bar); + let mut baz = irqarray4_csr.zf(utra::irqarray4::EV_PENDING_SOURCE7, bar); + baz |= irqarray4_csr.ms(utra::irqarray4::EV_PENDING_SOURCE7, 1); + irqarray4_csr.wfo(utra::irqarray4::EV_PENDING_SOURCE7, baz); + let bar = irqarray4_csr.rf(utra::irqarray4::EV_PENDING_SOURCE8); + irqarray4_csr.rmwf(utra::irqarray4::EV_PENDING_SOURCE8, bar); + let mut baz = irqarray4_csr.zf(utra::irqarray4::EV_PENDING_SOURCE8, bar); + baz |= irqarray4_csr.ms(utra::irqarray4::EV_PENDING_SOURCE8, 1); + irqarray4_csr.wfo(utra::irqarray4::EV_PENDING_SOURCE8, baz); + let bar = irqarray4_csr.rf(utra::irqarray4::EV_PENDING_SOURCE9); + irqarray4_csr.rmwf(utra::irqarray4::EV_PENDING_SOURCE9, bar); + let mut baz = irqarray4_csr.zf(utra::irqarray4::EV_PENDING_SOURCE9, bar); + baz |= irqarray4_csr.ms(utra::irqarray4::EV_PENDING_SOURCE9, 1); + irqarray4_csr.wfo(utra::irqarray4::EV_PENDING_SOURCE9, baz); + let bar = irqarray4_csr.rf(utra::irqarray4::EV_PENDING_SOURCE10); + irqarray4_csr.rmwf(utra::irqarray4::EV_PENDING_SOURCE10, bar); + let mut baz = irqarray4_csr.zf(utra::irqarray4::EV_PENDING_SOURCE10, bar); + baz |= irqarray4_csr.ms(utra::irqarray4::EV_PENDING_SOURCE10, 1); + irqarray4_csr.wfo(utra::irqarray4::EV_PENDING_SOURCE10, baz); + let bar = irqarray4_csr.rf(utra::irqarray4::EV_PENDING_SOURCE11); + irqarray4_csr.rmwf(utra::irqarray4::EV_PENDING_SOURCE11, bar); + let mut baz = irqarray4_csr.zf(utra::irqarray4::EV_PENDING_SOURCE11, bar); + baz |= irqarray4_csr.ms(utra::irqarray4::EV_PENDING_SOURCE11, 1); + irqarray4_csr.wfo(utra::irqarray4::EV_PENDING_SOURCE11, baz); + let bar = irqarray4_csr.rf(utra::irqarray4::EV_PENDING_SOURCE12); + irqarray4_csr.rmwf(utra::irqarray4::EV_PENDING_SOURCE12, bar); + let mut baz = irqarray4_csr.zf(utra::irqarray4::EV_PENDING_SOURCE12, bar); + baz |= irqarray4_csr.ms(utra::irqarray4::EV_PENDING_SOURCE12, 1); + irqarray4_csr.wfo(utra::irqarray4::EV_PENDING_SOURCE12, baz); + let bar = irqarray4_csr.rf(utra::irqarray4::EV_PENDING_SOURCE13); + irqarray4_csr.rmwf(utra::irqarray4::EV_PENDING_SOURCE13, bar); + let mut baz = irqarray4_csr.zf(utra::irqarray4::EV_PENDING_SOURCE13, bar); + baz |= irqarray4_csr.ms(utra::irqarray4::EV_PENDING_SOURCE13, 1); + irqarray4_csr.wfo(utra::irqarray4::EV_PENDING_SOURCE13, baz); + let bar = irqarray4_csr.rf(utra::irqarray4::EV_PENDING_SOURCE14); + irqarray4_csr.rmwf(utra::irqarray4::EV_PENDING_SOURCE14, bar); + let mut baz = irqarray4_csr.zf(utra::irqarray4::EV_PENDING_SOURCE14, bar); + baz |= irqarray4_csr.ms(utra::irqarray4::EV_PENDING_SOURCE14, 1); + irqarray4_csr.wfo(utra::irqarray4::EV_PENDING_SOURCE14, baz); + let bar = irqarray4_csr.rf(utra::irqarray4::EV_PENDING_SOURCE15); + irqarray4_csr.rmwf(utra::irqarray4::EV_PENDING_SOURCE15, bar); + let mut baz = irqarray4_csr.zf(utra::irqarray4::EV_PENDING_SOURCE15, bar); + baz |= irqarray4_csr.ms(utra::irqarray4::EV_PENDING_SOURCE15, 1); + irqarray4_csr.wfo(utra::irqarray4::EV_PENDING_SOURCE15, baz); + let bar = irqarray4_csr.rf(utra::irqarray4::EV_PENDING_SOURCE16); + irqarray4_csr.rmwf(utra::irqarray4::EV_PENDING_SOURCE16, bar); + let mut baz = irqarray4_csr.zf(utra::irqarray4::EV_PENDING_SOURCE16, bar); + baz |= irqarray4_csr.ms(utra::irqarray4::EV_PENDING_SOURCE16, 1); + irqarray4_csr.wfo(utra::irqarray4::EV_PENDING_SOURCE16, baz); + let bar = irqarray4_csr.rf(utra::irqarray4::EV_PENDING_SOURCE17); + irqarray4_csr.rmwf(utra::irqarray4::EV_PENDING_SOURCE17, bar); + let mut baz = irqarray4_csr.zf(utra::irqarray4::EV_PENDING_SOURCE17, bar); + baz |= irqarray4_csr.ms(utra::irqarray4::EV_PENDING_SOURCE17, 1); + irqarray4_csr.wfo(utra::irqarray4::EV_PENDING_SOURCE17, baz); + let bar = irqarray4_csr.rf(utra::irqarray4::EV_PENDING_SOURCE18); + irqarray4_csr.rmwf(utra::irqarray4::EV_PENDING_SOURCE18, bar); + let mut baz = irqarray4_csr.zf(utra::irqarray4::EV_PENDING_SOURCE18, bar); + baz |= irqarray4_csr.ms(utra::irqarray4::EV_PENDING_SOURCE18, 1); + irqarray4_csr.wfo(utra::irqarray4::EV_PENDING_SOURCE18, baz); + let bar = irqarray4_csr.rf(utra::irqarray4::EV_PENDING_SOURCE19); + irqarray4_csr.rmwf(utra::irqarray4::EV_PENDING_SOURCE19, bar); + let mut baz = irqarray4_csr.zf(utra::irqarray4::EV_PENDING_SOURCE19, bar); + baz |= irqarray4_csr.ms(utra::irqarray4::EV_PENDING_SOURCE19, 1); + irqarray4_csr.wfo(utra::irqarray4::EV_PENDING_SOURCE19, baz); + + let foo = irqarray4_csr.r(utra::irqarray4::EV_ENABLE); + irqarray4_csr.wo(utra::irqarray4::EV_ENABLE, foo); + let bar = irqarray4_csr.rf(utra::irqarray4::EV_ENABLE_SOURCE0); + irqarray4_csr.rmwf(utra::irqarray4::EV_ENABLE_SOURCE0, bar); + let mut baz = irqarray4_csr.zf(utra::irqarray4::EV_ENABLE_SOURCE0, bar); + baz |= irqarray4_csr.ms(utra::irqarray4::EV_ENABLE_SOURCE0, 1); + irqarray4_csr.wfo(utra::irqarray4::EV_ENABLE_SOURCE0, baz); + let bar = irqarray4_csr.rf(utra::irqarray4::EV_ENABLE_SOURCE1); + irqarray4_csr.rmwf(utra::irqarray4::EV_ENABLE_SOURCE1, bar); + let mut baz = irqarray4_csr.zf(utra::irqarray4::EV_ENABLE_SOURCE1, bar); + baz |= irqarray4_csr.ms(utra::irqarray4::EV_ENABLE_SOURCE1, 1); + irqarray4_csr.wfo(utra::irqarray4::EV_ENABLE_SOURCE1, baz); + let bar = irqarray4_csr.rf(utra::irqarray4::EV_ENABLE_SOURCE2); + irqarray4_csr.rmwf(utra::irqarray4::EV_ENABLE_SOURCE2, bar); + let mut baz = irqarray4_csr.zf(utra::irqarray4::EV_ENABLE_SOURCE2, bar); + baz |= irqarray4_csr.ms(utra::irqarray4::EV_ENABLE_SOURCE2, 1); + irqarray4_csr.wfo(utra::irqarray4::EV_ENABLE_SOURCE2, baz); + let bar = irqarray4_csr.rf(utra::irqarray4::EV_ENABLE_SOURCE3); + irqarray4_csr.rmwf(utra::irqarray4::EV_ENABLE_SOURCE3, bar); + let mut baz = irqarray4_csr.zf(utra::irqarray4::EV_ENABLE_SOURCE3, bar); + baz |= irqarray4_csr.ms(utra::irqarray4::EV_ENABLE_SOURCE3, 1); + irqarray4_csr.wfo(utra::irqarray4::EV_ENABLE_SOURCE3, baz); + let bar = irqarray4_csr.rf(utra::irqarray4::EV_ENABLE_SOURCE4); + irqarray4_csr.rmwf(utra::irqarray4::EV_ENABLE_SOURCE4, bar); + let mut baz = irqarray4_csr.zf(utra::irqarray4::EV_ENABLE_SOURCE4, bar); + baz |= irqarray4_csr.ms(utra::irqarray4::EV_ENABLE_SOURCE4, 1); + irqarray4_csr.wfo(utra::irqarray4::EV_ENABLE_SOURCE4, baz); + let bar = irqarray4_csr.rf(utra::irqarray4::EV_ENABLE_SOURCE5); + irqarray4_csr.rmwf(utra::irqarray4::EV_ENABLE_SOURCE5, bar); + let mut baz = irqarray4_csr.zf(utra::irqarray4::EV_ENABLE_SOURCE5, bar); + baz |= irqarray4_csr.ms(utra::irqarray4::EV_ENABLE_SOURCE5, 1); + irqarray4_csr.wfo(utra::irqarray4::EV_ENABLE_SOURCE5, baz); + let bar = irqarray4_csr.rf(utra::irqarray4::EV_ENABLE_SOURCE6); + irqarray4_csr.rmwf(utra::irqarray4::EV_ENABLE_SOURCE6, bar); + let mut baz = irqarray4_csr.zf(utra::irqarray4::EV_ENABLE_SOURCE6, bar); + baz |= irqarray4_csr.ms(utra::irqarray4::EV_ENABLE_SOURCE6, 1); + irqarray4_csr.wfo(utra::irqarray4::EV_ENABLE_SOURCE6, baz); + let bar = irqarray4_csr.rf(utra::irqarray4::EV_ENABLE_SOURCE7); + irqarray4_csr.rmwf(utra::irqarray4::EV_ENABLE_SOURCE7, bar); + let mut baz = irqarray4_csr.zf(utra::irqarray4::EV_ENABLE_SOURCE7, bar); + baz |= irqarray4_csr.ms(utra::irqarray4::EV_ENABLE_SOURCE7, 1); + irqarray4_csr.wfo(utra::irqarray4::EV_ENABLE_SOURCE7, baz); + let bar = irqarray4_csr.rf(utra::irqarray4::EV_ENABLE_SOURCE8); + irqarray4_csr.rmwf(utra::irqarray4::EV_ENABLE_SOURCE8, bar); + let mut baz = irqarray4_csr.zf(utra::irqarray4::EV_ENABLE_SOURCE8, bar); + baz |= irqarray4_csr.ms(utra::irqarray4::EV_ENABLE_SOURCE8, 1); + irqarray4_csr.wfo(utra::irqarray4::EV_ENABLE_SOURCE8, baz); + let bar = irqarray4_csr.rf(utra::irqarray4::EV_ENABLE_SOURCE9); + irqarray4_csr.rmwf(utra::irqarray4::EV_ENABLE_SOURCE9, bar); + let mut baz = irqarray4_csr.zf(utra::irqarray4::EV_ENABLE_SOURCE9, bar); + baz |= irqarray4_csr.ms(utra::irqarray4::EV_ENABLE_SOURCE9, 1); + irqarray4_csr.wfo(utra::irqarray4::EV_ENABLE_SOURCE9, baz); + let bar = irqarray4_csr.rf(utra::irqarray4::EV_ENABLE_SOURCE10); + irqarray4_csr.rmwf(utra::irqarray4::EV_ENABLE_SOURCE10, bar); + let mut baz = irqarray4_csr.zf(utra::irqarray4::EV_ENABLE_SOURCE10, bar); + baz |= irqarray4_csr.ms(utra::irqarray4::EV_ENABLE_SOURCE10, 1); + irqarray4_csr.wfo(utra::irqarray4::EV_ENABLE_SOURCE10, baz); + let bar = irqarray4_csr.rf(utra::irqarray4::EV_ENABLE_SOURCE11); + irqarray4_csr.rmwf(utra::irqarray4::EV_ENABLE_SOURCE11, bar); + let mut baz = irqarray4_csr.zf(utra::irqarray4::EV_ENABLE_SOURCE11, bar); + baz |= irqarray4_csr.ms(utra::irqarray4::EV_ENABLE_SOURCE11, 1); + irqarray4_csr.wfo(utra::irqarray4::EV_ENABLE_SOURCE11, baz); + let bar = irqarray4_csr.rf(utra::irqarray4::EV_ENABLE_SOURCE12); + irqarray4_csr.rmwf(utra::irqarray4::EV_ENABLE_SOURCE12, bar); + let mut baz = irqarray4_csr.zf(utra::irqarray4::EV_ENABLE_SOURCE12, bar); + baz |= irqarray4_csr.ms(utra::irqarray4::EV_ENABLE_SOURCE12, 1); + irqarray4_csr.wfo(utra::irqarray4::EV_ENABLE_SOURCE12, baz); + let bar = irqarray4_csr.rf(utra::irqarray4::EV_ENABLE_SOURCE13); + irqarray4_csr.rmwf(utra::irqarray4::EV_ENABLE_SOURCE13, bar); + let mut baz = irqarray4_csr.zf(utra::irqarray4::EV_ENABLE_SOURCE13, bar); + baz |= irqarray4_csr.ms(utra::irqarray4::EV_ENABLE_SOURCE13, 1); + irqarray4_csr.wfo(utra::irqarray4::EV_ENABLE_SOURCE13, baz); + let bar = irqarray4_csr.rf(utra::irqarray4::EV_ENABLE_SOURCE14); + irqarray4_csr.rmwf(utra::irqarray4::EV_ENABLE_SOURCE14, bar); + let mut baz = irqarray4_csr.zf(utra::irqarray4::EV_ENABLE_SOURCE14, bar); + baz |= irqarray4_csr.ms(utra::irqarray4::EV_ENABLE_SOURCE14, 1); + irqarray4_csr.wfo(utra::irqarray4::EV_ENABLE_SOURCE14, baz); + let bar = irqarray4_csr.rf(utra::irqarray4::EV_ENABLE_SOURCE15); + irqarray4_csr.rmwf(utra::irqarray4::EV_ENABLE_SOURCE15, bar); + let mut baz = irqarray4_csr.zf(utra::irqarray4::EV_ENABLE_SOURCE15, bar); + baz |= irqarray4_csr.ms(utra::irqarray4::EV_ENABLE_SOURCE15, 1); + irqarray4_csr.wfo(utra::irqarray4::EV_ENABLE_SOURCE15, baz); + let bar = irqarray4_csr.rf(utra::irqarray4::EV_ENABLE_SOURCE16); + irqarray4_csr.rmwf(utra::irqarray4::EV_ENABLE_SOURCE16, bar); + let mut baz = irqarray4_csr.zf(utra::irqarray4::EV_ENABLE_SOURCE16, bar); + baz |= irqarray4_csr.ms(utra::irqarray4::EV_ENABLE_SOURCE16, 1); + irqarray4_csr.wfo(utra::irqarray4::EV_ENABLE_SOURCE16, baz); + let bar = irqarray4_csr.rf(utra::irqarray4::EV_ENABLE_SOURCE17); + irqarray4_csr.rmwf(utra::irqarray4::EV_ENABLE_SOURCE17, bar); + let mut baz = irqarray4_csr.zf(utra::irqarray4::EV_ENABLE_SOURCE17, bar); + baz |= irqarray4_csr.ms(utra::irqarray4::EV_ENABLE_SOURCE17, 1); + irqarray4_csr.wfo(utra::irqarray4::EV_ENABLE_SOURCE17, baz); + let bar = irqarray4_csr.rf(utra::irqarray4::EV_ENABLE_SOURCE18); + irqarray4_csr.rmwf(utra::irqarray4::EV_ENABLE_SOURCE18, bar); + let mut baz = irqarray4_csr.zf(utra::irqarray4::EV_ENABLE_SOURCE18, bar); + baz |= irqarray4_csr.ms(utra::irqarray4::EV_ENABLE_SOURCE18, 1); + irqarray4_csr.wfo(utra::irqarray4::EV_ENABLE_SOURCE18, baz); + let bar = irqarray4_csr.rf(utra::irqarray4::EV_ENABLE_SOURCE19); + irqarray4_csr.rmwf(utra::irqarray4::EV_ENABLE_SOURCE19, bar); + let mut baz = irqarray4_csr.zf(utra::irqarray4::EV_ENABLE_SOURCE19, bar); + baz |= irqarray4_csr.ms(utra::irqarray4::EV_ENABLE_SOURCE19, 1); + irqarray4_csr.wfo(utra::irqarray4::EV_ENABLE_SOURCE19, baz); + } + + #[test] + #[ignore] + fn compile_check_irqarray5_csr() { + use super::*; + let mut irqarray5_csr = CSR::new(HW_IRQARRAY5_BASE as *mut u32); + + let foo = irqarray5_csr.r(utra::irqarray5::EV_SOFT); + irqarray5_csr.wo(utra::irqarray5::EV_SOFT, foo); + let bar = irqarray5_csr.rf(utra::irqarray5::EV_SOFT_TRIGGER); + irqarray5_csr.rmwf(utra::irqarray5::EV_SOFT_TRIGGER, bar); + let mut baz = irqarray5_csr.zf(utra::irqarray5::EV_SOFT_TRIGGER, bar); + baz |= irqarray5_csr.ms(utra::irqarray5::EV_SOFT_TRIGGER, 1); + irqarray5_csr.wfo(utra::irqarray5::EV_SOFT_TRIGGER, baz); + + let foo = irqarray5_csr.r(utra::irqarray5::EV_STATUS); + irqarray5_csr.wo(utra::irqarray5::EV_STATUS, foo); + let bar = irqarray5_csr.rf(utra::irqarray5::EV_STATUS_SOURCE0); + irqarray5_csr.rmwf(utra::irqarray5::EV_STATUS_SOURCE0, bar); + let mut baz = irqarray5_csr.zf(utra::irqarray5::EV_STATUS_SOURCE0, bar); + baz |= irqarray5_csr.ms(utra::irqarray5::EV_STATUS_SOURCE0, 1); + irqarray5_csr.wfo(utra::irqarray5::EV_STATUS_SOURCE0, baz); + let bar = irqarray5_csr.rf(utra::irqarray5::EV_STATUS_SOURCE1); + irqarray5_csr.rmwf(utra::irqarray5::EV_STATUS_SOURCE1, bar); + let mut baz = irqarray5_csr.zf(utra::irqarray5::EV_STATUS_SOURCE1, bar); + baz |= irqarray5_csr.ms(utra::irqarray5::EV_STATUS_SOURCE1, 1); + irqarray5_csr.wfo(utra::irqarray5::EV_STATUS_SOURCE1, baz); + let bar = irqarray5_csr.rf(utra::irqarray5::EV_STATUS_SOURCE2); + irqarray5_csr.rmwf(utra::irqarray5::EV_STATUS_SOURCE2, bar); + let mut baz = irqarray5_csr.zf(utra::irqarray5::EV_STATUS_SOURCE2, bar); + baz |= irqarray5_csr.ms(utra::irqarray5::EV_STATUS_SOURCE2, 1); + irqarray5_csr.wfo(utra::irqarray5::EV_STATUS_SOURCE2, baz); + let bar = irqarray5_csr.rf(utra::irqarray5::EV_STATUS_SOURCE3); + irqarray5_csr.rmwf(utra::irqarray5::EV_STATUS_SOURCE3, bar); + let mut baz = irqarray5_csr.zf(utra::irqarray5::EV_STATUS_SOURCE3, bar); + baz |= irqarray5_csr.ms(utra::irqarray5::EV_STATUS_SOURCE3, 1); + irqarray5_csr.wfo(utra::irqarray5::EV_STATUS_SOURCE3, baz); + let bar = irqarray5_csr.rf(utra::irqarray5::EV_STATUS_SOURCE4); + irqarray5_csr.rmwf(utra::irqarray5::EV_STATUS_SOURCE4, bar); + let mut baz = irqarray5_csr.zf(utra::irqarray5::EV_STATUS_SOURCE4, bar); + baz |= irqarray5_csr.ms(utra::irqarray5::EV_STATUS_SOURCE4, 1); + irqarray5_csr.wfo(utra::irqarray5::EV_STATUS_SOURCE4, baz); + let bar = irqarray5_csr.rf(utra::irqarray5::EV_STATUS_SOURCE5); + irqarray5_csr.rmwf(utra::irqarray5::EV_STATUS_SOURCE5, bar); + let mut baz = irqarray5_csr.zf(utra::irqarray5::EV_STATUS_SOURCE5, bar); + baz |= irqarray5_csr.ms(utra::irqarray5::EV_STATUS_SOURCE5, 1); + irqarray5_csr.wfo(utra::irqarray5::EV_STATUS_SOURCE5, baz); + let bar = irqarray5_csr.rf(utra::irqarray5::EV_STATUS_SOURCE6); + irqarray5_csr.rmwf(utra::irqarray5::EV_STATUS_SOURCE6, bar); + let mut baz = irqarray5_csr.zf(utra::irqarray5::EV_STATUS_SOURCE6, bar); + baz |= irqarray5_csr.ms(utra::irqarray5::EV_STATUS_SOURCE6, 1); + irqarray5_csr.wfo(utra::irqarray5::EV_STATUS_SOURCE6, baz); + let bar = irqarray5_csr.rf(utra::irqarray5::EV_STATUS_SOURCE7); + irqarray5_csr.rmwf(utra::irqarray5::EV_STATUS_SOURCE7, bar); + let mut baz = irqarray5_csr.zf(utra::irqarray5::EV_STATUS_SOURCE7, bar); + baz |= irqarray5_csr.ms(utra::irqarray5::EV_STATUS_SOURCE7, 1); + irqarray5_csr.wfo(utra::irqarray5::EV_STATUS_SOURCE7, baz); + let bar = irqarray5_csr.rf(utra::irqarray5::EV_STATUS_SOURCE8); + irqarray5_csr.rmwf(utra::irqarray5::EV_STATUS_SOURCE8, bar); + let mut baz = irqarray5_csr.zf(utra::irqarray5::EV_STATUS_SOURCE8, bar); + baz |= irqarray5_csr.ms(utra::irqarray5::EV_STATUS_SOURCE8, 1); + irqarray5_csr.wfo(utra::irqarray5::EV_STATUS_SOURCE8, baz); + let bar = irqarray5_csr.rf(utra::irqarray5::EV_STATUS_SOURCE9); + irqarray5_csr.rmwf(utra::irqarray5::EV_STATUS_SOURCE9, bar); + let mut baz = irqarray5_csr.zf(utra::irqarray5::EV_STATUS_SOURCE9, bar); + baz |= irqarray5_csr.ms(utra::irqarray5::EV_STATUS_SOURCE9, 1); + irqarray5_csr.wfo(utra::irqarray5::EV_STATUS_SOURCE9, baz); + let bar = irqarray5_csr.rf(utra::irqarray5::EV_STATUS_SOURCE10); + irqarray5_csr.rmwf(utra::irqarray5::EV_STATUS_SOURCE10, bar); + let mut baz = irqarray5_csr.zf(utra::irqarray5::EV_STATUS_SOURCE10, bar); + baz |= irqarray5_csr.ms(utra::irqarray5::EV_STATUS_SOURCE10, 1); + irqarray5_csr.wfo(utra::irqarray5::EV_STATUS_SOURCE10, baz); + let bar = irqarray5_csr.rf(utra::irqarray5::EV_STATUS_SOURCE11); + irqarray5_csr.rmwf(utra::irqarray5::EV_STATUS_SOURCE11, bar); + let mut baz = irqarray5_csr.zf(utra::irqarray5::EV_STATUS_SOURCE11, bar); + baz |= irqarray5_csr.ms(utra::irqarray5::EV_STATUS_SOURCE11, 1); + irqarray5_csr.wfo(utra::irqarray5::EV_STATUS_SOURCE11, baz); + let bar = irqarray5_csr.rf(utra::irqarray5::EV_STATUS_SOURCE12); + irqarray5_csr.rmwf(utra::irqarray5::EV_STATUS_SOURCE12, bar); + let mut baz = irqarray5_csr.zf(utra::irqarray5::EV_STATUS_SOURCE12, bar); + baz |= irqarray5_csr.ms(utra::irqarray5::EV_STATUS_SOURCE12, 1); + irqarray5_csr.wfo(utra::irqarray5::EV_STATUS_SOURCE12, baz); + let bar = irqarray5_csr.rf(utra::irqarray5::EV_STATUS_SOURCE13); + irqarray5_csr.rmwf(utra::irqarray5::EV_STATUS_SOURCE13, bar); + let mut baz = irqarray5_csr.zf(utra::irqarray5::EV_STATUS_SOURCE13, bar); + baz |= irqarray5_csr.ms(utra::irqarray5::EV_STATUS_SOURCE13, 1); + irqarray5_csr.wfo(utra::irqarray5::EV_STATUS_SOURCE13, baz); + let bar = irqarray5_csr.rf(utra::irqarray5::EV_STATUS_SOURCE14); + irqarray5_csr.rmwf(utra::irqarray5::EV_STATUS_SOURCE14, bar); + let mut baz = irqarray5_csr.zf(utra::irqarray5::EV_STATUS_SOURCE14, bar); + baz |= irqarray5_csr.ms(utra::irqarray5::EV_STATUS_SOURCE14, 1); + irqarray5_csr.wfo(utra::irqarray5::EV_STATUS_SOURCE14, baz); + let bar = irqarray5_csr.rf(utra::irqarray5::EV_STATUS_SOURCE15); + irqarray5_csr.rmwf(utra::irqarray5::EV_STATUS_SOURCE15, bar); + let mut baz = irqarray5_csr.zf(utra::irqarray5::EV_STATUS_SOURCE15, bar); + baz |= irqarray5_csr.ms(utra::irqarray5::EV_STATUS_SOURCE15, 1); + irqarray5_csr.wfo(utra::irqarray5::EV_STATUS_SOURCE15, baz); + let bar = irqarray5_csr.rf(utra::irqarray5::EV_STATUS_SOURCE16); + irqarray5_csr.rmwf(utra::irqarray5::EV_STATUS_SOURCE16, bar); + let mut baz = irqarray5_csr.zf(utra::irqarray5::EV_STATUS_SOURCE16, bar); + baz |= irqarray5_csr.ms(utra::irqarray5::EV_STATUS_SOURCE16, 1); + irqarray5_csr.wfo(utra::irqarray5::EV_STATUS_SOURCE16, baz); + let bar = irqarray5_csr.rf(utra::irqarray5::EV_STATUS_SOURCE17); + irqarray5_csr.rmwf(utra::irqarray5::EV_STATUS_SOURCE17, bar); + let mut baz = irqarray5_csr.zf(utra::irqarray5::EV_STATUS_SOURCE17, bar); + baz |= irqarray5_csr.ms(utra::irqarray5::EV_STATUS_SOURCE17, 1); + irqarray5_csr.wfo(utra::irqarray5::EV_STATUS_SOURCE17, baz); + let bar = irqarray5_csr.rf(utra::irqarray5::EV_STATUS_SOURCE18); + irqarray5_csr.rmwf(utra::irqarray5::EV_STATUS_SOURCE18, bar); + let mut baz = irqarray5_csr.zf(utra::irqarray5::EV_STATUS_SOURCE18, bar); + baz |= irqarray5_csr.ms(utra::irqarray5::EV_STATUS_SOURCE18, 1); + irqarray5_csr.wfo(utra::irqarray5::EV_STATUS_SOURCE18, baz); + let bar = irqarray5_csr.rf(utra::irqarray5::EV_STATUS_SOURCE19); + irqarray5_csr.rmwf(utra::irqarray5::EV_STATUS_SOURCE19, bar); + let mut baz = irqarray5_csr.zf(utra::irqarray5::EV_STATUS_SOURCE19, bar); + baz |= irqarray5_csr.ms(utra::irqarray5::EV_STATUS_SOURCE19, 1); + irqarray5_csr.wfo(utra::irqarray5::EV_STATUS_SOURCE19, baz); + + let foo = irqarray5_csr.r(utra::irqarray5::EV_PENDING); + irqarray5_csr.wo(utra::irqarray5::EV_PENDING, foo); + let bar = irqarray5_csr.rf(utra::irqarray5::EV_PENDING_SOURCE0); + irqarray5_csr.rmwf(utra::irqarray5::EV_PENDING_SOURCE0, bar); + let mut baz = irqarray5_csr.zf(utra::irqarray5::EV_PENDING_SOURCE0, bar); + baz |= irqarray5_csr.ms(utra::irqarray5::EV_PENDING_SOURCE0, 1); + irqarray5_csr.wfo(utra::irqarray5::EV_PENDING_SOURCE0, baz); + let bar = irqarray5_csr.rf(utra::irqarray5::EV_PENDING_SOURCE1); + irqarray5_csr.rmwf(utra::irqarray5::EV_PENDING_SOURCE1, bar); + let mut baz = irqarray5_csr.zf(utra::irqarray5::EV_PENDING_SOURCE1, bar); + baz |= irqarray5_csr.ms(utra::irqarray5::EV_PENDING_SOURCE1, 1); + irqarray5_csr.wfo(utra::irqarray5::EV_PENDING_SOURCE1, baz); + let bar = irqarray5_csr.rf(utra::irqarray5::EV_PENDING_SOURCE2); + irqarray5_csr.rmwf(utra::irqarray5::EV_PENDING_SOURCE2, bar); + let mut baz = irqarray5_csr.zf(utra::irqarray5::EV_PENDING_SOURCE2, bar); + baz |= irqarray5_csr.ms(utra::irqarray5::EV_PENDING_SOURCE2, 1); + irqarray5_csr.wfo(utra::irqarray5::EV_PENDING_SOURCE2, baz); + let bar = irqarray5_csr.rf(utra::irqarray5::EV_PENDING_SOURCE3); + irqarray5_csr.rmwf(utra::irqarray5::EV_PENDING_SOURCE3, bar); + let mut baz = irqarray5_csr.zf(utra::irqarray5::EV_PENDING_SOURCE3, bar); + baz |= irqarray5_csr.ms(utra::irqarray5::EV_PENDING_SOURCE3, 1); + irqarray5_csr.wfo(utra::irqarray5::EV_PENDING_SOURCE3, baz); + let bar = irqarray5_csr.rf(utra::irqarray5::EV_PENDING_SOURCE4); + irqarray5_csr.rmwf(utra::irqarray5::EV_PENDING_SOURCE4, bar); + let mut baz = irqarray5_csr.zf(utra::irqarray5::EV_PENDING_SOURCE4, bar); + baz |= irqarray5_csr.ms(utra::irqarray5::EV_PENDING_SOURCE4, 1); + irqarray5_csr.wfo(utra::irqarray5::EV_PENDING_SOURCE4, baz); + let bar = irqarray5_csr.rf(utra::irqarray5::EV_PENDING_SOURCE5); + irqarray5_csr.rmwf(utra::irqarray5::EV_PENDING_SOURCE5, bar); + let mut baz = irqarray5_csr.zf(utra::irqarray5::EV_PENDING_SOURCE5, bar); + baz |= irqarray5_csr.ms(utra::irqarray5::EV_PENDING_SOURCE5, 1); + irqarray5_csr.wfo(utra::irqarray5::EV_PENDING_SOURCE5, baz); + let bar = irqarray5_csr.rf(utra::irqarray5::EV_PENDING_SOURCE6); + irqarray5_csr.rmwf(utra::irqarray5::EV_PENDING_SOURCE6, bar); + let mut baz = irqarray5_csr.zf(utra::irqarray5::EV_PENDING_SOURCE6, bar); + baz |= irqarray5_csr.ms(utra::irqarray5::EV_PENDING_SOURCE6, 1); + irqarray5_csr.wfo(utra::irqarray5::EV_PENDING_SOURCE6, baz); + let bar = irqarray5_csr.rf(utra::irqarray5::EV_PENDING_SOURCE7); + irqarray5_csr.rmwf(utra::irqarray5::EV_PENDING_SOURCE7, bar); + let mut baz = irqarray5_csr.zf(utra::irqarray5::EV_PENDING_SOURCE7, bar); + baz |= irqarray5_csr.ms(utra::irqarray5::EV_PENDING_SOURCE7, 1); + irqarray5_csr.wfo(utra::irqarray5::EV_PENDING_SOURCE7, baz); + let bar = irqarray5_csr.rf(utra::irqarray5::EV_PENDING_SOURCE8); + irqarray5_csr.rmwf(utra::irqarray5::EV_PENDING_SOURCE8, bar); + let mut baz = irqarray5_csr.zf(utra::irqarray5::EV_PENDING_SOURCE8, bar); + baz |= irqarray5_csr.ms(utra::irqarray5::EV_PENDING_SOURCE8, 1); + irqarray5_csr.wfo(utra::irqarray5::EV_PENDING_SOURCE8, baz); + let bar = irqarray5_csr.rf(utra::irqarray5::EV_PENDING_SOURCE9); + irqarray5_csr.rmwf(utra::irqarray5::EV_PENDING_SOURCE9, bar); + let mut baz = irqarray5_csr.zf(utra::irqarray5::EV_PENDING_SOURCE9, bar); + baz |= irqarray5_csr.ms(utra::irqarray5::EV_PENDING_SOURCE9, 1); + irqarray5_csr.wfo(utra::irqarray5::EV_PENDING_SOURCE9, baz); + let bar = irqarray5_csr.rf(utra::irqarray5::EV_PENDING_SOURCE10); + irqarray5_csr.rmwf(utra::irqarray5::EV_PENDING_SOURCE10, bar); + let mut baz = irqarray5_csr.zf(utra::irqarray5::EV_PENDING_SOURCE10, bar); + baz |= irqarray5_csr.ms(utra::irqarray5::EV_PENDING_SOURCE10, 1); + irqarray5_csr.wfo(utra::irqarray5::EV_PENDING_SOURCE10, baz); + let bar = irqarray5_csr.rf(utra::irqarray5::EV_PENDING_SOURCE11); + irqarray5_csr.rmwf(utra::irqarray5::EV_PENDING_SOURCE11, bar); + let mut baz = irqarray5_csr.zf(utra::irqarray5::EV_PENDING_SOURCE11, bar); + baz |= irqarray5_csr.ms(utra::irqarray5::EV_PENDING_SOURCE11, 1); + irqarray5_csr.wfo(utra::irqarray5::EV_PENDING_SOURCE11, baz); + let bar = irqarray5_csr.rf(utra::irqarray5::EV_PENDING_SOURCE12); + irqarray5_csr.rmwf(utra::irqarray5::EV_PENDING_SOURCE12, bar); + let mut baz = irqarray5_csr.zf(utra::irqarray5::EV_PENDING_SOURCE12, bar); + baz |= irqarray5_csr.ms(utra::irqarray5::EV_PENDING_SOURCE12, 1); + irqarray5_csr.wfo(utra::irqarray5::EV_PENDING_SOURCE12, baz); + let bar = irqarray5_csr.rf(utra::irqarray5::EV_PENDING_SOURCE13); + irqarray5_csr.rmwf(utra::irqarray5::EV_PENDING_SOURCE13, bar); + let mut baz = irqarray5_csr.zf(utra::irqarray5::EV_PENDING_SOURCE13, bar); + baz |= irqarray5_csr.ms(utra::irqarray5::EV_PENDING_SOURCE13, 1); + irqarray5_csr.wfo(utra::irqarray5::EV_PENDING_SOURCE13, baz); + let bar = irqarray5_csr.rf(utra::irqarray5::EV_PENDING_SOURCE14); + irqarray5_csr.rmwf(utra::irqarray5::EV_PENDING_SOURCE14, bar); + let mut baz = irqarray5_csr.zf(utra::irqarray5::EV_PENDING_SOURCE14, bar); + baz |= irqarray5_csr.ms(utra::irqarray5::EV_PENDING_SOURCE14, 1); + irqarray5_csr.wfo(utra::irqarray5::EV_PENDING_SOURCE14, baz); + let bar = irqarray5_csr.rf(utra::irqarray5::EV_PENDING_SOURCE15); + irqarray5_csr.rmwf(utra::irqarray5::EV_PENDING_SOURCE15, bar); + let mut baz = irqarray5_csr.zf(utra::irqarray5::EV_PENDING_SOURCE15, bar); + baz |= irqarray5_csr.ms(utra::irqarray5::EV_PENDING_SOURCE15, 1); + irqarray5_csr.wfo(utra::irqarray5::EV_PENDING_SOURCE15, baz); + let bar = irqarray5_csr.rf(utra::irqarray5::EV_PENDING_SOURCE16); + irqarray5_csr.rmwf(utra::irqarray5::EV_PENDING_SOURCE16, bar); + let mut baz = irqarray5_csr.zf(utra::irqarray5::EV_PENDING_SOURCE16, bar); + baz |= irqarray5_csr.ms(utra::irqarray5::EV_PENDING_SOURCE16, 1); + irqarray5_csr.wfo(utra::irqarray5::EV_PENDING_SOURCE16, baz); + let bar = irqarray5_csr.rf(utra::irqarray5::EV_PENDING_SOURCE17); + irqarray5_csr.rmwf(utra::irqarray5::EV_PENDING_SOURCE17, bar); + let mut baz = irqarray5_csr.zf(utra::irqarray5::EV_PENDING_SOURCE17, bar); + baz |= irqarray5_csr.ms(utra::irqarray5::EV_PENDING_SOURCE17, 1); + irqarray5_csr.wfo(utra::irqarray5::EV_PENDING_SOURCE17, baz); + let bar = irqarray5_csr.rf(utra::irqarray5::EV_PENDING_SOURCE18); + irqarray5_csr.rmwf(utra::irqarray5::EV_PENDING_SOURCE18, bar); + let mut baz = irqarray5_csr.zf(utra::irqarray5::EV_PENDING_SOURCE18, bar); + baz |= irqarray5_csr.ms(utra::irqarray5::EV_PENDING_SOURCE18, 1); + irqarray5_csr.wfo(utra::irqarray5::EV_PENDING_SOURCE18, baz); + let bar = irqarray5_csr.rf(utra::irqarray5::EV_PENDING_SOURCE19); + irqarray5_csr.rmwf(utra::irqarray5::EV_PENDING_SOURCE19, bar); + let mut baz = irqarray5_csr.zf(utra::irqarray5::EV_PENDING_SOURCE19, bar); + baz |= irqarray5_csr.ms(utra::irqarray5::EV_PENDING_SOURCE19, 1); + irqarray5_csr.wfo(utra::irqarray5::EV_PENDING_SOURCE19, baz); + + let foo = irqarray5_csr.r(utra::irqarray5::EV_ENABLE); + irqarray5_csr.wo(utra::irqarray5::EV_ENABLE, foo); + let bar = irqarray5_csr.rf(utra::irqarray5::EV_ENABLE_SOURCE0); + irqarray5_csr.rmwf(utra::irqarray5::EV_ENABLE_SOURCE0, bar); + let mut baz = irqarray5_csr.zf(utra::irqarray5::EV_ENABLE_SOURCE0, bar); + baz |= irqarray5_csr.ms(utra::irqarray5::EV_ENABLE_SOURCE0, 1); + irqarray5_csr.wfo(utra::irqarray5::EV_ENABLE_SOURCE0, baz); + let bar = irqarray5_csr.rf(utra::irqarray5::EV_ENABLE_SOURCE1); + irqarray5_csr.rmwf(utra::irqarray5::EV_ENABLE_SOURCE1, bar); + let mut baz = irqarray5_csr.zf(utra::irqarray5::EV_ENABLE_SOURCE1, bar); + baz |= irqarray5_csr.ms(utra::irqarray5::EV_ENABLE_SOURCE1, 1); + irqarray5_csr.wfo(utra::irqarray5::EV_ENABLE_SOURCE1, baz); + let bar = irqarray5_csr.rf(utra::irqarray5::EV_ENABLE_SOURCE2); + irqarray5_csr.rmwf(utra::irqarray5::EV_ENABLE_SOURCE2, bar); + let mut baz = irqarray5_csr.zf(utra::irqarray5::EV_ENABLE_SOURCE2, bar); + baz |= irqarray5_csr.ms(utra::irqarray5::EV_ENABLE_SOURCE2, 1); + irqarray5_csr.wfo(utra::irqarray5::EV_ENABLE_SOURCE2, baz); + let bar = irqarray5_csr.rf(utra::irqarray5::EV_ENABLE_SOURCE3); + irqarray5_csr.rmwf(utra::irqarray5::EV_ENABLE_SOURCE3, bar); + let mut baz = irqarray5_csr.zf(utra::irqarray5::EV_ENABLE_SOURCE3, bar); + baz |= irqarray5_csr.ms(utra::irqarray5::EV_ENABLE_SOURCE3, 1); + irqarray5_csr.wfo(utra::irqarray5::EV_ENABLE_SOURCE3, baz); + let bar = irqarray5_csr.rf(utra::irqarray5::EV_ENABLE_SOURCE4); + irqarray5_csr.rmwf(utra::irqarray5::EV_ENABLE_SOURCE4, bar); + let mut baz = irqarray5_csr.zf(utra::irqarray5::EV_ENABLE_SOURCE4, bar); + baz |= irqarray5_csr.ms(utra::irqarray5::EV_ENABLE_SOURCE4, 1); + irqarray5_csr.wfo(utra::irqarray5::EV_ENABLE_SOURCE4, baz); + let bar = irqarray5_csr.rf(utra::irqarray5::EV_ENABLE_SOURCE5); + irqarray5_csr.rmwf(utra::irqarray5::EV_ENABLE_SOURCE5, bar); + let mut baz = irqarray5_csr.zf(utra::irqarray5::EV_ENABLE_SOURCE5, bar); + baz |= irqarray5_csr.ms(utra::irqarray5::EV_ENABLE_SOURCE5, 1); + irqarray5_csr.wfo(utra::irqarray5::EV_ENABLE_SOURCE5, baz); + let bar = irqarray5_csr.rf(utra::irqarray5::EV_ENABLE_SOURCE6); + irqarray5_csr.rmwf(utra::irqarray5::EV_ENABLE_SOURCE6, bar); + let mut baz = irqarray5_csr.zf(utra::irqarray5::EV_ENABLE_SOURCE6, bar); + baz |= irqarray5_csr.ms(utra::irqarray5::EV_ENABLE_SOURCE6, 1); + irqarray5_csr.wfo(utra::irqarray5::EV_ENABLE_SOURCE6, baz); + let bar = irqarray5_csr.rf(utra::irqarray5::EV_ENABLE_SOURCE7); + irqarray5_csr.rmwf(utra::irqarray5::EV_ENABLE_SOURCE7, bar); + let mut baz = irqarray5_csr.zf(utra::irqarray5::EV_ENABLE_SOURCE7, bar); + baz |= irqarray5_csr.ms(utra::irqarray5::EV_ENABLE_SOURCE7, 1); + irqarray5_csr.wfo(utra::irqarray5::EV_ENABLE_SOURCE7, baz); + let bar = irqarray5_csr.rf(utra::irqarray5::EV_ENABLE_SOURCE8); + irqarray5_csr.rmwf(utra::irqarray5::EV_ENABLE_SOURCE8, bar); + let mut baz = irqarray5_csr.zf(utra::irqarray5::EV_ENABLE_SOURCE8, bar); + baz |= irqarray5_csr.ms(utra::irqarray5::EV_ENABLE_SOURCE8, 1); + irqarray5_csr.wfo(utra::irqarray5::EV_ENABLE_SOURCE8, baz); + let bar = irqarray5_csr.rf(utra::irqarray5::EV_ENABLE_SOURCE9); + irqarray5_csr.rmwf(utra::irqarray5::EV_ENABLE_SOURCE9, bar); + let mut baz = irqarray5_csr.zf(utra::irqarray5::EV_ENABLE_SOURCE9, bar); + baz |= irqarray5_csr.ms(utra::irqarray5::EV_ENABLE_SOURCE9, 1); + irqarray5_csr.wfo(utra::irqarray5::EV_ENABLE_SOURCE9, baz); + let bar = irqarray5_csr.rf(utra::irqarray5::EV_ENABLE_SOURCE10); + irqarray5_csr.rmwf(utra::irqarray5::EV_ENABLE_SOURCE10, bar); + let mut baz = irqarray5_csr.zf(utra::irqarray5::EV_ENABLE_SOURCE10, bar); + baz |= irqarray5_csr.ms(utra::irqarray5::EV_ENABLE_SOURCE10, 1); + irqarray5_csr.wfo(utra::irqarray5::EV_ENABLE_SOURCE10, baz); + let bar = irqarray5_csr.rf(utra::irqarray5::EV_ENABLE_SOURCE11); + irqarray5_csr.rmwf(utra::irqarray5::EV_ENABLE_SOURCE11, bar); + let mut baz = irqarray5_csr.zf(utra::irqarray5::EV_ENABLE_SOURCE11, bar); + baz |= irqarray5_csr.ms(utra::irqarray5::EV_ENABLE_SOURCE11, 1); + irqarray5_csr.wfo(utra::irqarray5::EV_ENABLE_SOURCE11, baz); + let bar = irqarray5_csr.rf(utra::irqarray5::EV_ENABLE_SOURCE12); + irqarray5_csr.rmwf(utra::irqarray5::EV_ENABLE_SOURCE12, bar); + let mut baz = irqarray5_csr.zf(utra::irqarray5::EV_ENABLE_SOURCE12, bar); + baz |= irqarray5_csr.ms(utra::irqarray5::EV_ENABLE_SOURCE12, 1); + irqarray5_csr.wfo(utra::irqarray5::EV_ENABLE_SOURCE12, baz); + let bar = irqarray5_csr.rf(utra::irqarray5::EV_ENABLE_SOURCE13); + irqarray5_csr.rmwf(utra::irqarray5::EV_ENABLE_SOURCE13, bar); + let mut baz = irqarray5_csr.zf(utra::irqarray5::EV_ENABLE_SOURCE13, bar); + baz |= irqarray5_csr.ms(utra::irqarray5::EV_ENABLE_SOURCE13, 1); + irqarray5_csr.wfo(utra::irqarray5::EV_ENABLE_SOURCE13, baz); + let bar = irqarray5_csr.rf(utra::irqarray5::EV_ENABLE_SOURCE14); + irqarray5_csr.rmwf(utra::irqarray5::EV_ENABLE_SOURCE14, bar); + let mut baz = irqarray5_csr.zf(utra::irqarray5::EV_ENABLE_SOURCE14, bar); + baz |= irqarray5_csr.ms(utra::irqarray5::EV_ENABLE_SOURCE14, 1); + irqarray5_csr.wfo(utra::irqarray5::EV_ENABLE_SOURCE14, baz); + let bar = irqarray5_csr.rf(utra::irqarray5::EV_ENABLE_SOURCE15); + irqarray5_csr.rmwf(utra::irqarray5::EV_ENABLE_SOURCE15, bar); + let mut baz = irqarray5_csr.zf(utra::irqarray5::EV_ENABLE_SOURCE15, bar); + baz |= irqarray5_csr.ms(utra::irqarray5::EV_ENABLE_SOURCE15, 1); + irqarray5_csr.wfo(utra::irqarray5::EV_ENABLE_SOURCE15, baz); + let bar = irqarray5_csr.rf(utra::irqarray5::EV_ENABLE_SOURCE16); + irqarray5_csr.rmwf(utra::irqarray5::EV_ENABLE_SOURCE16, bar); + let mut baz = irqarray5_csr.zf(utra::irqarray5::EV_ENABLE_SOURCE16, bar); + baz |= irqarray5_csr.ms(utra::irqarray5::EV_ENABLE_SOURCE16, 1); + irqarray5_csr.wfo(utra::irqarray5::EV_ENABLE_SOURCE16, baz); + let bar = irqarray5_csr.rf(utra::irqarray5::EV_ENABLE_SOURCE17); + irqarray5_csr.rmwf(utra::irqarray5::EV_ENABLE_SOURCE17, bar); + let mut baz = irqarray5_csr.zf(utra::irqarray5::EV_ENABLE_SOURCE17, bar); + baz |= irqarray5_csr.ms(utra::irqarray5::EV_ENABLE_SOURCE17, 1); + irqarray5_csr.wfo(utra::irqarray5::EV_ENABLE_SOURCE17, baz); + let bar = irqarray5_csr.rf(utra::irqarray5::EV_ENABLE_SOURCE18); + irqarray5_csr.rmwf(utra::irqarray5::EV_ENABLE_SOURCE18, bar); + let mut baz = irqarray5_csr.zf(utra::irqarray5::EV_ENABLE_SOURCE18, bar); + baz |= irqarray5_csr.ms(utra::irqarray5::EV_ENABLE_SOURCE18, 1); + irqarray5_csr.wfo(utra::irqarray5::EV_ENABLE_SOURCE18, baz); + let bar = irqarray5_csr.rf(utra::irqarray5::EV_ENABLE_SOURCE19); + irqarray5_csr.rmwf(utra::irqarray5::EV_ENABLE_SOURCE19, bar); + let mut baz = irqarray5_csr.zf(utra::irqarray5::EV_ENABLE_SOURCE19, bar); + baz |= irqarray5_csr.ms(utra::irqarray5::EV_ENABLE_SOURCE19, 1); + irqarray5_csr.wfo(utra::irqarray5::EV_ENABLE_SOURCE19, baz); + } + + #[test] + #[ignore] + fn compile_check_irqarray6_csr() { + use super::*; + let mut irqarray6_csr = CSR::new(HW_IRQARRAY6_BASE as *mut u32); + + let foo = irqarray6_csr.r(utra::irqarray6::EV_SOFT); + irqarray6_csr.wo(utra::irqarray6::EV_SOFT, foo); + let bar = irqarray6_csr.rf(utra::irqarray6::EV_SOFT_TRIGGER); + irqarray6_csr.rmwf(utra::irqarray6::EV_SOFT_TRIGGER, bar); + let mut baz = irqarray6_csr.zf(utra::irqarray6::EV_SOFT_TRIGGER, bar); + baz |= irqarray6_csr.ms(utra::irqarray6::EV_SOFT_TRIGGER, 1); + irqarray6_csr.wfo(utra::irqarray6::EV_SOFT_TRIGGER, baz); + + let foo = irqarray6_csr.r(utra::irqarray6::EV_STATUS); + irqarray6_csr.wo(utra::irqarray6::EV_STATUS, foo); + let bar = irqarray6_csr.rf(utra::irqarray6::EV_STATUS_SOURCE0); + irqarray6_csr.rmwf(utra::irqarray6::EV_STATUS_SOURCE0, bar); + let mut baz = irqarray6_csr.zf(utra::irqarray6::EV_STATUS_SOURCE0, bar); + baz |= irqarray6_csr.ms(utra::irqarray6::EV_STATUS_SOURCE0, 1); + irqarray6_csr.wfo(utra::irqarray6::EV_STATUS_SOURCE0, baz); + let bar = irqarray6_csr.rf(utra::irqarray6::EV_STATUS_SOURCE1); + irqarray6_csr.rmwf(utra::irqarray6::EV_STATUS_SOURCE1, bar); + let mut baz = irqarray6_csr.zf(utra::irqarray6::EV_STATUS_SOURCE1, bar); + baz |= irqarray6_csr.ms(utra::irqarray6::EV_STATUS_SOURCE1, 1); + irqarray6_csr.wfo(utra::irqarray6::EV_STATUS_SOURCE1, baz); + let bar = irqarray6_csr.rf(utra::irqarray6::EV_STATUS_SOURCE2); + irqarray6_csr.rmwf(utra::irqarray6::EV_STATUS_SOURCE2, bar); + let mut baz = irqarray6_csr.zf(utra::irqarray6::EV_STATUS_SOURCE2, bar); + baz |= irqarray6_csr.ms(utra::irqarray6::EV_STATUS_SOURCE2, 1); + irqarray6_csr.wfo(utra::irqarray6::EV_STATUS_SOURCE2, baz); + let bar = irqarray6_csr.rf(utra::irqarray6::EV_STATUS_SOURCE3); + irqarray6_csr.rmwf(utra::irqarray6::EV_STATUS_SOURCE3, bar); + let mut baz = irqarray6_csr.zf(utra::irqarray6::EV_STATUS_SOURCE3, bar); + baz |= irqarray6_csr.ms(utra::irqarray6::EV_STATUS_SOURCE3, 1); + irqarray6_csr.wfo(utra::irqarray6::EV_STATUS_SOURCE3, baz); + let bar = irqarray6_csr.rf(utra::irqarray6::EV_STATUS_SOURCE4); + irqarray6_csr.rmwf(utra::irqarray6::EV_STATUS_SOURCE4, bar); + let mut baz = irqarray6_csr.zf(utra::irqarray6::EV_STATUS_SOURCE4, bar); + baz |= irqarray6_csr.ms(utra::irqarray6::EV_STATUS_SOURCE4, 1); + irqarray6_csr.wfo(utra::irqarray6::EV_STATUS_SOURCE4, baz); + let bar = irqarray6_csr.rf(utra::irqarray6::EV_STATUS_SOURCE5); + irqarray6_csr.rmwf(utra::irqarray6::EV_STATUS_SOURCE5, bar); + let mut baz = irqarray6_csr.zf(utra::irqarray6::EV_STATUS_SOURCE5, bar); + baz |= irqarray6_csr.ms(utra::irqarray6::EV_STATUS_SOURCE5, 1); + irqarray6_csr.wfo(utra::irqarray6::EV_STATUS_SOURCE5, baz); + let bar = irqarray6_csr.rf(utra::irqarray6::EV_STATUS_SOURCE6); + irqarray6_csr.rmwf(utra::irqarray6::EV_STATUS_SOURCE6, bar); + let mut baz = irqarray6_csr.zf(utra::irqarray6::EV_STATUS_SOURCE6, bar); + baz |= irqarray6_csr.ms(utra::irqarray6::EV_STATUS_SOURCE6, 1); + irqarray6_csr.wfo(utra::irqarray6::EV_STATUS_SOURCE6, baz); + let bar = irqarray6_csr.rf(utra::irqarray6::EV_STATUS_SOURCE7); + irqarray6_csr.rmwf(utra::irqarray6::EV_STATUS_SOURCE7, bar); + let mut baz = irqarray6_csr.zf(utra::irqarray6::EV_STATUS_SOURCE7, bar); + baz |= irqarray6_csr.ms(utra::irqarray6::EV_STATUS_SOURCE7, 1); + irqarray6_csr.wfo(utra::irqarray6::EV_STATUS_SOURCE7, baz); + let bar = irqarray6_csr.rf(utra::irqarray6::EV_STATUS_SOURCE8); + irqarray6_csr.rmwf(utra::irqarray6::EV_STATUS_SOURCE8, bar); + let mut baz = irqarray6_csr.zf(utra::irqarray6::EV_STATUS_SOURCE8, bar); + baz |= irqarray6_csr.ms(utra::irqarray6::EV_STATUS_SOURCE8, 1); + irqarray6_csr.wfo(utra::irqarray6::EV_STATUS_SOURCE8, baz); + let bar = irqarray6_csr.rf(utra::irqarray6::EV_STATUS_SOURCE9); + irqarray6_csr.rmwf(utra::irqarray6::EV_STATUS_SOURCE9, bar); + let mut baz = irqarray6_csr.zf(utra::irqarray6::EV_STATUS_SOURCE9, bar); + baz |= irqarray6_csr.ms(utra::irqarray6::EV_STATUS_SOURCE9, 1); + irqarray6_csr.wfo(utra::irqarray6::EV_STATUS_SOURCE9, baz); + let bar = irqarray6_csr.rf(utra::irqarray6::EV_STATUS_SOURCE10); + irqarray6_csr.rmwf(utra::irqarray6::EV_STATUS_SOURCE10, bar); + let mut baz = irqarray6_csr.zf(utra::irqarray6::EV_STATUS_SOURCE10, bar); + baz |= irqarray6_csr.ms(utra::irqarray6::EV_STATUS_SOURCE10, 1); + irqarray6_csr.wfo(utra::irqarray6::EV_STATUS_SOURCE10, baz); + let bar = irqarray6_csr.rf(utra::irqarray6::EV_STATUS_SOURCE11); + irqarray6_csr.rmwf(utra::irqarray6::EV_STATUS_SOURCE11, bar); + let mut baz = irqarray6_csr.zf(utra::irqarray6::EV_STATUS_SOURCE11, bar); + baz |= irqarray6_csr.ms(utra::irqarray6::EV_STATUS_SOURCE11, 1); + irqarray6_csr.wfo(utra::irqarray6::EV_STATUS_SOURCE11, baz); + let bar = irqarray6_csr.rf(utra::irqarray6::EV_STATUS_SOURCE12); + irqarray6_csr.rmwf(utra::irqarray6::EV_STATUS_SOURCE12, bar); + let mut baz = irqarray6_csr.zf(utra::irqarray6::EV_STATUS_SOURCE12, bar); + baz |= irqarray6_csr.ms(utra::irqarray6::EV_STATUS_SOURCE12, 1); + irqarray6_csr.wfo(utra::irqarray6::EV_STATUS_SOURCE12, baz); + let bar = irqarray6_csr.rf(utra::irqarray6::EV_STATUS_SOURCE13); + irqarray6_csr.rmwf(utra::irqarray6::EV_STATUS_SOURCE13, bar); + let mut baz = irqarray6_csr.zf(utra::irqarray6::EV_STATUS_SOURCE13, bar); + baz |= irqarray6_csr.ms(utra::irqarray6::EV_STATUS_SOURCE13, 1); + irqarray6_csr.wfo(utra::irqarray6::EV_STATUS_SOURCE13, baz); + let bar = irqarray6_csr.rf(utra::irqarray6::EV_STATUS_SOURCE14); + irqarray6_csr.rmwf(utra::irqarray6::EV_STATUS_SOURCE14, bar); + let mut baz = irqarray6_csr.zf(utra::irqarray6::EV_STATUS_SOURCE14, bar); + baz |= irqarray6_csr.ms(utra::irqarray6::EV_STATUS_SOURCE14, 1); + irqarray6_csr.wfo(utra::irqarray6::EV_STATUS_SOURCE14, baz); + let bar = irqarray6_csr.rf(utra::irqarray6::EV_STATUS_SOURCE15); + irqarray6_csr.rmwf(utra::irqarray6::EV_STATUS_SOURCE15, bar); + let mut baz = irqarray6_csr.zf(utra::irqarray6::EV_STATUS_SOURCE15, bar); + baz |= irqarray6_csr.ms(utra::irqarray6::EV_STATUS_SOURCE15, 1); + irqarray6_csr.wfo(utra::irqarray6::EV_STATUS_SOURCE15, baz); + let bar = irqarray6_csr.rf(utra::irqarray6::EV_STATUS_SOURCE16); + irqarray6_csr.rmwf(utra::irqarray6::EV_STATUS_SOURCE16, bar); + let mut baz = irqarray6_csr.zf(utra::irqarray6::EV_STATUS_SOURCE16, bar); + baz |= irqarray6_csr.ms(utra::irqarray6::EV_STATUS_SOURCE16, 1); + irqarray6_csr.wfo(utra::irqarray6::EV_STATUS_SOURCE16, baz); + let bar = irqarray6_csr.rf(utra::irqarray6::EV_STATUS_SOURCE17); + irqarray6_csr.rmwf(utra::irqarray6::EV_STATUS_SOURCE17, bar); + let mut baz = irqarray6_csr.zf(utra::irqarray6::EV_STATUS_SOURCE17, bar); + baz |= irqarray6_csr.ms(utra::irqarray6::EV_STATUS_SOURCE17, 1); + irqarray6_csr.wfo(utra::irqarray6::EV_STATUS_SOURCE17, baz); + let bar = irqarray6_csr.rf(utra::irqarray6::EV_STATUS_SOURCE18); + irqarray6_csr.rmwf(utra::irqarray6::EV_STATUS_SOURCE18, bar); + let mut baz = irqarray6_csr.zf(utra::irqarray6::EV_STATUS_SOURCE18, bar); + baz |= irqarray6_csr.ms(utra::irqarray6::EV_STATUS_SOURCE18, 1); + irqarray6_csr.wfo(utra::irqarray6::EV_STATUS_SOURCE18, baz); + let bar = irqarray6_csr.rf(utra::irqarray6::EV_STATUS_SOURCE19); + irqarray6_csr.rmwf(utra::irqarray6::EV_STATUS_SOURCE19, bar); + let mut baz = irqarray6_csr.zf(utra::irqarray6::EV_STATUS_SOURCE19, bar); + baz |= irqarray6_csr.ms(utra::irqarray6::EV_STATUS_SOURCE19, 1); + irqarray6_csr.wfo(utra::irqarray6::EV_STATUS_SOURCE19, baz); + + let foo = irqarray6_csr.r(utra::irqarray6::EV_PENDING); + irqarray6_csr.wo(utra::irqarray6::EV_PENDING, foo); + let bar = irqarray6_csr.rf(utra::irqarray6::EV_PENDING_SOURCE0); + irqarray6_csr.rmwf(utra::irqarray6::EV_PENDING_SOURCE0, bar); + let mut baz = irqarray6_csr.zf(utra::irqarray6::EV_PENDING_SOURCE0, bar); + baz |= irqarray6_csr.ms(utra::irqarray6::EV_PENDING_SOURCE0, 1); + irqarray6_csr.wfo(utra::irqarray6::EV_PENDING_SOURCE0, baz); + let bar = irqarray6_csr.rf(utra::irqarray6::EV_PENDING_SOURCE1); + irqarray6_csr.rmwf(utra::irqarray6::EV_PENDING_SOURCE1, bar); + let mut baz = irqarray6_csr.zf(utra::irqarray6::EV_PENDING_SOURCE1, bar); + baz |= irqarray6_csr.ms(utra::irqarray6::EV_PENDING_SOURCE1, 1); + irqarray6_csr.wfo(utra::irqarray6::EV_PENDING_SOURCE1, baz); + let bar = irqarray6_csr.rf(utra::irqarray6::EV_PENDING_SOURCE2); + irqarray6_csr.rmwf(utra::irqarray6::EV_PENDING_SOURCE2, bar); + let mut baz = irqarray6_csr.zf(utra::irqarray6::EV_PENDING_SOURCE2, bar); + baz |= irqarray6_csr.ms(utra::irqarray6::EV_PENDING_SOURCE2, 1); + irqarray6_csr.wfo(utra::irqarray6::EV_PENDING_SOURCE2, baz); + let bar = irqarray6_csr.rf(utra::irqarray6::EV_PENDING_SOURCE3); + irqarray6_csr.rmwf(utra::irqarray6::EV_PENDING_SOURCE3, bar); + let mut baz = irqarray6_csr.zf(utra::irqarray6::EV_PENDING_SOURCE3, bar); + baz |= irqarray6_csr.ms(utra::irqarray6::EV_PENDING_SOURCE3, 1); + irqarray6_csr.wfo(utra::irqarray6::EV_PENDING_SOURCE3, baz); + let bar = irqarray6_csr.rf(utra::irqarray6::EV_PENDING_SOURCE4); + irqarray6_csr.rmwf(utra::irqarray6::EV_PENDING_SOURCE4, bar); + let mut baz = irqarray6_csr.zf(utra::irqarray6::EV_PENDING_SOURCE4, bar); + baz |= irqarray6_csr.ms(utra::irqarray6::EV_PENDING_SOURCE4, 1); + irqarray6_csr.wfo(utra::irqarray6::EV_PENDING_SOURCE4, baz); + let bar = irqarray6_csr.rf(utra::irqarray6::EV_PENDING_SOURCE5); + irqarray6_csr.rmwf(utra::irqarray6::EV_PENDING_SOURCE5, bar); + let mut baz = irqarray6_csr.zf(utra::irqarray6::EV_PENDING_SOURCE5, bar); + baz |= irqarray6_csr.ms(utra::irqarray6::EV_PENDING_SOURCE5, 1); + irqarray6_csr.wfo(utra::irqarray6::EV_PENDING_SOURCE5, baz); + let bar = irqarray6_csr.rf(utra::irqarray6::EV_PENDING_SOURCE6); + irqarray6_csr.rmwf(utra::irqarray6::EV_PENDING_SOURCE6, bar); + let mut baz = irqarray6_csr.zf(utra::irqarray6::EV_PENDING_SOURCE6, bar); + baz |= irqarray6_csr.ms(utra::irqarray6::EV_PENDING_SOURCE6, 1); + irqarray6_csr.wfo(utra::irqarray6::EV_PENDING_SOURCE6, baz); + let bar = irqarray6_csr.rf(utra::irqarray6::EV_PENDING_SOURCE7); + irqarray6_csr.rmwf(utra::irqarray6::EV_PENDING_SOURCE7, bar); + let mut baz = irqarray6_csr.zf(utra::irqarray6::EV_PENDING_SOURCE7, bar); + baz |= irqarray6_csr.ms(utra::irqarray6::EV_PENDING_SOURCE7, 1); + irqarray6_csr.wfo(utra::irqarray6::EV_PENDING_SOURCE7, baz); + let bar = irqarray6_csr.rf(utra::irqarray6::EV_PENDING_SOURCE8); + irqarray6_csr.rmwf(utra::irqarray6::EV_PENDING_SOURCE8, bar); + let mut baz = irqarray6_csr.zf(utra::irqarray6::EV_PENDING_SOURCE8, bar); + baz |= irqarray6_csr.ms(utra::irqarray6::EV_PENDING_SOURCE8, 1); + irqarray6_csr.wfo(utra::irqarray6::EV_PENDING_SOURCE8, baz); + let bar = irqarray6_csr.rf(utra::irqarray6::EV_PENDING_SOURCE9); + irqarray6_csr.rmwf(utra::irqarray6::EV_PENDING_SOURCE9, bar); + let mut baz = irqarray6_csr.zf(utra::irqarray6::EV_PENDING_SOURCE9, bar); + baz |= irqarray6_csr.ms(utra::irqarray6::EV_PENDING_SOURCE9, 1); + irqarray6_csr.wfo(utra::irqarray6::EV_PENDING_SOURCE9, baz); + let bar = irqarray6_csr.rf(utra::irqarray6::EV_PENDING_SOURCE10); + irqarray6_csr.rmwf(utra::irqarray6::EV_PENDING_SOURCE10, bar); + let mut baz = irqarray6_csr.zf(utra::irqarray6::EV_PENDING_SOURCE10, bar); + baz |= irqarray6_csr.ms(utra::irqarray6::EV_PENDING_SOURCE10, 1); + irqarray6_csr.wfo(utra::irqarray6::EV_PENDING_SOURCE10, baz); + let bar = irqarray6_csr.rf(utra::irqarray6::EV_PENDING_SOURCE11); + irqarray6_csr.rmwf(utra::irqarray6::EV_PENDING_SOURCE11, bar); + let mut baz = irqarray6_csr.zf(utra::irqarray6::EV_PENDING_SOURCE11, bar); + baz |= irqarray6_csr.ms(utra::irqarray6::EV_PENDING_SOURCE11, 1); + irqarray6_csr.wfo(utra::irqarray6::EV_PENDING_SOURCE11, baz); + let bar = irqarray6_csr.rf(utra::irqarray6::EV_PENDING_SOURCE12); + irqarray6_csr.rmwf(utra::irqarray6::EV_PENDING_SOURCE12, bar); + let mut baz = irqarray6_csr.zf(utra::irqarray6::EV_PENDING_SOURCE12, bar); + baz |= irqarray6_csr.ms(utra::irqarray6::EV_PENDING_SOURCE12, 1); + irqarray6_csr.wfo(utra::irqarray6::EV_PENDING_SOURCE12, baz); + let bar = irqarray6_csr.rf(utra::irqarray6::EV_PENDING_SOURCE13); + irqarray6_csr.rmwf(utra::irqarray6::EV_PENDING_SOURCE13, bar); + let mut baz = irqarray6_csr.zf(utra::irqarray6::EV_PENDING_SOURCE13, bar); + baz |= irqarray6_csr.ms(utra::irqarray6::EV_PENDING_SOURCE13, 1); + irqarray6_csr.wfo(utra::irqarray6::EV_PENDING_SOURCE13, baz); + let bar = irqarray6_csr.rf(utra::irqarray6::EV_PENDING_SOURCE14); + irqarray6_csr.rmwf(utra::irqarray6::EV_PENDING_SOURCE14, bar); + let mut baz = irqarray6_csr.zf(utra::irqarray6::EV_PENDING_SOURCE14, bar); + baz |= irqarray6_csr.ms(utra::irqarray6::EV_PENDING_SOURCE14, 1); + irqarray6_csr.wfo(utra::irqarray6::EV_PENDING_SOURCE14, baz); + let bar = irqarray6_csr.rf(utra::irqarray6::EV_PENDING_SOURCE15); + irqarray6_csr.rmwf(utra::irqarray6::EV_PENDING_SOURCE15, bar); + let mut baz = irqarray6_csr.zf(utra::irqarray6::EV_PENDING_SOURCE15, bar); + baz |= irqarray6_csr.ms(utra::irqarray6::EV_PENDING_SOURCE15, 1); + irqarray6_csr.wfo(utra::irqarray6::EV_PENDING_SOURCE15, baz); + let bar = irqarray6_csr.rf(utra::irqarray6::EV_PENDING_SOURCE16); + irqarray6_csr.rmwf(utra::irqarray6::EV_PENDING_SOURCE16, bar); + let mut baz = irqarray6_csr.zf(utra::irqarray6::EV_PENDING_SOURCE16, bar); + baz |= irqarray6_csr.ms(utra::irqarray6::EV_PENDING_SOURCE16, 1); + irqarray6_csr.wfo(utra::irqarray6::EV_PENDING_SOURCE16, baz); + let bar = irqarray6_csr.rf(utra::irqarray6::EV_PENDING_SOURCE17); + irqarray6_csr.rmwf(utra::irqarray6::EV_PENDING_SOURCE17, bar); + let mut baz = irqarray6_csr.zf(utra::irqarray6::EV_PENDING_SOURCE17, bar); + baz |= irqarray6_csr.ms(utra::irqarray6::EV_PENDING_SOURCE17, 1); + irqarray6_csr.wfo(utra::irqarray6::EV_PENDING_SOURCE17, baz); + let bar = irqarray6_csr.rf(utra::irqarray6::EV_PENDING_SOURCE18); + irqarray6_csr.rmwf(utra::irqarray6::EV_PENDING_SOURCE18, bar); + let mut baz = irqarray6_csr.zf(utra::irqarray6::EV_PENDING_SOURCE18, bar); + baz |= irqarray6_csr.ms(utra::irqarray6::EV_PENDING_SOURCE18, 1); + irqarray6_csr.wfo(utra::irqarray6::EV_PENDING_SOURCE18, baz); + let bar = irqarray6_csr.rf(utra::irqarray6::EV_PENDING_SOURCE19); + irqarray6_csr.rmwf(utra::irqarray6::EV_PENDING_SOURCE19, bar); + let mut baz = irqarray6_csr.zf(utra::irqarray6::EV_PENDING_SOURCE19, bar); + baz |= irqarray6_csr.ms(utra::irqarray6::EV_PENDING_SOURCE19, 1); + irqarray6_csr.wfo(utra::irqarray6::EV_PENDING_SOURCE19, baz); + + let foo = irqarray6_csr.r(utra::irqarray6::EV_ENABLE); + irqarray6_csr.wo(utra::irqarray6::EV_ENABLE, foo); + let bar = irqarray6_csr.rf(utra::irqarray6::EV_ENABLE_SOURCE0); + irqarray6_csr.rmwf(utra::irqarray6::EV_ENABLE_SOURCE0, bar); + let mut baz = irqarray6_csr.zf(utra::irqarray6::EV_ENABLE_SOURCE0, bar); + baz |= irqarray6_csr.ms(utra::irqarray6::EV_ENABLE_SOURCE0, 1); + irqarray6_csr.wfo(utra::irqarray6::EV_ENABLE_SOURCE0, baz); + let bar = irqarray6_csr.rf(utra::irqarray6::EV_ENABLE_SOURCE1); + irqarray6_csr.rmwf(utra::irqarray6::EV_ENABLE_SOURCE1, bar); + let mut baz = irqarray6_csr.zf(utra::irqarray6::EV_ENABLE_SOURCE1, bar); + baz |= irqarray6_csr.ms(utra::irqarray6::EV_ENABLE_SOURCE1, 1); + irqarray6_csr.wfo(utra::irqarray6::EV_ENABLE_SOURCE1, baz); + let bar = irqarray6_csr.rf(utra::irqarray6::EV_ENABLE_SOURCE2); + irqarray6_csr.rmwf(utra::irqarray6::EV_ENABLE_SOURCE2, bar); + let mut baz = irqarray6_csr.zf(utra::irqarray6::EV_ENABLE_SOURCE2, bar); + baz |= irqarray6_csr.ms(utra::irqarray6::EV_ENABLE_SOURCE2, 1); + irqarray6_csr.wfo(utra::irqarray6::EV_ENABLE_SOURCE2, baz); + let bar = irqarray6_csr.rf(utra::irqarray6::EV_ENABLE_SOURCE3); + irqarray6_csr.rmwf(utra::irqarray6::EV_ENABLE_SOURCE3, bar); + let mut baz = irqarray6_csr.zf(utra::irqarray6::EV_ENABLE_SOURCE3, bar); + baz |= irqarray6_csr.ms(utra::irqarray6::EV_ENABLE_SOURCE3, 1); + irqarray6_csr.wfo(utra::irqarray6::EV_ENABLE_SOURCE3, baz); + let bar = irqarray6_csr.rf(utra::irqarray6::EV_ENABLE_SOURCE4); + irqarray6_csr.rmwf(utra::irqarray6::EV_ENABLE_SOURCE4, bar); + let mut baz = irqarray6_csr.zf(utra::irqarray6::EV_ENABLE_SOURCE4, bar); + baz |= irqarray6_csr.ms(utra::irqarray6::EV_ENABLE_SOURCE4, 1); + irqarray6_csr.wfo(utra::irqarray6::EV_ENABLE_SOURCE4, baz); + let bar = irqarray6_csr.rf(utra::irqarray6::EV_ENABLE_SOURCE5); + irqarray6_csr.rmwf(utra::irqarray6::EV_ENABLE_SOURCE5, bar); + let mut baz = irqarray6_csr.zf(utra::irqarray6::EV_ENABLE_SOURCE5, bar); + baz |= irqarray6_csr.ms(utra::irqarray6::EV_ENABLE_SOURCE5, 1); + irqarray6_csr.wfo(utra::irqarray6::EV_ENABLE_SOURCE5, baz); + let bar = irqarray6_csr.rf(utra::irqarray6::EV_ENABLE_SOURCE6); + irqarray6_csr.rmwf(utra::irqarray6::EV_ENABLE_SOURCE6, bar); + let mut baz = irqarray6_csr.zf(utra::irqarray6::EV_ENABLE_SOURCE6, bar); + baz |= irqarray6_csr.ms(utra::irqarray6::EV_ENABLE_SOURCE6, 1); + irqarray6_csr.wfo(utra::irqarray6::EV_ENABLE_SOURCE6, baz); + let bar = irqarray6_csr.rf(utra::irqarray6::EV_ENABLE_SOURCE7); + irqarray6_csr.rmwf(utra::irqarray6::EV_ENABLE_SOURCE7, bar); + let mut baz = irqarray6_csr.zf(utra::irqarray6::EV_ENABLE_SOURCE7, bar); + baz |= irqarray6_csr.ms(utra::irqarray6::EV_ENABLE_SOURCE7, 1); + irqarray6_csr.wfo(utra::irqarray6::EV_ENABLE_SOURCE7, baz); + let bar = irqarray6_csr.rf(utra::irqarray6::EV_ENABLE_SOURCE8); + irqarray6_csr.rmwf(utra::irqarray6::EV_ENABLE_SOURCE8, bar); + let mut baz = irqarray6_csr.zf(utra::irqarray6::EV_ENABLE_SOURCE8, bar); + baz |= irqarray6_csr.ms(utra::irqarray6::EV_ENABLE_SOURCE8, 1); + irqarray6_csr.wfo(utra::irqarray6::EV_ENABLE_SOURCE8, baz); + let bar = irqarray6_csr.rf(utra::irqarray6::EV_ENABLE_SOURCE9); + irqarray6_csr.rmwf(utra::irqarray6::EV_ENABLE_SOURCE9, bar); + let mut baz = irqarray6_csr.zf(utra::irqarray6::EV_ENABLE_SOURCE9, bar); + baz |= irqarray6_csr.ms(utra::irqarray6::EV_ENABLE_SOURCE9, 1); + irqarray6_csr.wfo(utra::irqarray6::EV_ENABLE_SOURCE9, baz); + let bar = irqarray6_csr.rf(utra::irqarray6::EV_ENABLE_SOURCE10); + irqarray6_csr.rmwf(utra::irqarray6::EV_ENABLE_SOURCE10, bar); + let mut baz = irqarray6_csr.zf(utra::irqarray6::EV_ENABLE_SOURCE10, bar); + baz |= irqarray6_csr.ms(utra::irqarray6::EV_ENABLE_SOURCE10, 1); + irqarray6_csr.wfo(utra::irqarray6::EV_ENABLE_SOURCE10, baz); + let bar = irqarray6_csr.rf(utra::irqarray6::EV_ENABLE_SOURCE11); + irqarray6_csr.rmwf(utra::irqarray6::EV_ENABLE_SOURCE11, bar); + let mut baz = irqarray6_csr.zf(utra::irqarray6::EV_ENABLE_SOURCE11, bar); + baz |= irqarray6_csr.ms(utra::irqarray6::EV_ENABLE_SOURCE11, 1); + irqarray6_csr.wfo(utra::irqarray6::EV_ENABLE_SOURCE11, baz); + let bar = irqarray6_csr.rf(utra::irqarray6::EV_ENABLE_SOURCE12); + irqarray6_csr.rmwf(utra::irqarray6::EV_ENABLE_SOURCE12, bar); + let mut baz = irqarray6_csr.zf(utra::irqarray6::EV_ENABLE_SOURCE12, bar); + baz |= irqarray6_csr.ms(utra::irqarray6::EV_ENABLE_SOURCE12, 1); + irqarray6_csr.wfo(utra::irqarray6::EV_ENABLE_SOURCE12, baz); + let bar = irqarray6_csr.rf(utra::irqarray6::EV_ENABLE_SOURCE13); + irqarray6_csr.rmwf(utra::irqarray6::EV_ENABLE_SOURCE13, bar); + let mut baz = irqarray6_csr.zf(utra::irqarray6::EV_ENABLE_SOURCE13, bar); + baz |= irqarray6_csr.ms(utra::irqarray6::EV_ENABLE_SOURCE13, 1); + irqarray6_csr.wfo(utra::irqarray6::EV_ENABLE_SOURCE13, baz); + let bar = irqarray6_csr.rf(utra::irqarray6::EV_ENABLE_SOURCE14); + irqarray6_csr.rmwf(utra::irqarray6::EV_ENABLE_SOURCE14, bar); + let mut baz = irqarray6_csr.zf(utra::irqarray6::EV_ENABLE_SOURCE14, bar); + baz |= irqarray6_csr.ms(utra::irqarray6::EV_ENABLE_SOURCE14, 1); + irqarray6_csr.wfo(utra::irqarray6::EV_ENABLE_SOURCE14, baz); + let bar = irqarray6_csr.rf(utra::irqarray6::EV_ENABLE_SOURCE15); + irqarray6_csr.rmwf(utra::irqarray6::EV_ENABLE_SOURCE15, bar); + let mut baz = irqarray6_csr.zf(utra::irqarray6::EV_ENABLE_SOURCE15, bar); + baz |= irqarray6_csr.ms(utra::irqarray6::EV_ENABLE_SOURCE15, 1); + irqarray6_csr.wfo(utra::irqarray6::EV_ENABLE_SOURCE15, baz); + let bar = irqarray6_csr.rf(utra::irqarray6::EV_ENABLE_SOURCE16); + irqarray6_csr.rmwf(utra::irqarray6::EV_ENABLE_SOURCE16, bar); + let mut baz = irqarray6_csr.zf(utra::irqarray6::EV_ENABLE_SOURCE16, bar); + baz |= irqarray6_csr.ms(utra::irqarray6::EV_ENABLE_SOURCE16, 1); + irqarray6_csr.wfo(utra::irqarray6::EV_ENABLE_SOURCE16, baz); + let bar = irqarray6_csr.rf(utra::irqarray6::EV_ENABLE_SOURCE17); + irqarray6_csr.rmwf(utra::irqarray6::EV_ENABLE_SOURCE17, bar); + let mut baz = irqarray6_csr.zf(utra::irqarray6::EV_ENABLE_SOURCE17, bar); + baz |= irqarray6_csr.ms(utra::irqarray6::EV_ENABLE_SOURCE17, 1); + irqarray6_csr.wfo(utra::irqarray6::EV_ENABLE_SOURCE17, baz); + let bar = irqarray6_csr.rf(utra::irqarray6::EV_ENABLE_SOURCE18); + irqarray6_csr.rmwf(utra::irqarray6::EV_ENABLE_SOURCE18, bar); + let mut baz = irqarray6_csr.zf(utra::irqarray6::EV_ENABLE_SOURCE18, bar); + baz |= irqarray6_csr.ms(utra::irqarray6::EV_ENABLE_SOURCE18, 1); + irqarray6_csr.wfo(utra::irqarray6::EV_ENABLE_SOURCE18, baz); + let bar = irqarray6_csr.rf(utra::irqarray6::EV_ENABLE_SOURCE19); + irqarray6_csr.rmwf(utra::irqarray6::EV_ENABLE_SOURCE19, bar); + let mut baz = irqarray6_csr.zf(utra::irqarray6::EV_ENABLE_SOURCE19, bar); + baz |= irqarray6_csr.ms(utra::irqarray6::EV_ENABLE_SOURCE19, 1); + irqarray6_csr.wfo(utra::irqarray6::EV_ENABLE_SOURCE19, baz); + } + + #[test] + #[ignore] + fn compile_check_irqarray7_csr() { + use super::*; + let mut irqarray7_csr = CSR::new(HW_IRQARRAY7_BASE as *mut u32); + + let foo = irqarray7_csr.r(utra::irqarray7::EV_SOFT); + irqarray7_csr.wo(utra::irqarray7::EV_SOFT, foo); + let bar = irqarray7_csr.rf(utra::irqarray7::EV_SOFT_TRIGGER); + irqarray7_csr.rmwf(utra::irqarray7::EV_SOFT_TRIGGER, bar); + let mut baz = irqarray7_csr.zf(utra::irqarray7::EV_SOFT_TRIGGER, bar); + baz |= irqarray7_csr.ms(utra::irqarray7::EV_SOFT_TRIGGER, 1); + irqarray7_csr.wfo(utra::irqarray7::EV_SOFT_TRIGGER, baz); + + let foo = irqarray7_csr.r(utra::irqarray7::EV_STATUS); + irqarray7_csr.wo(utra::irqarray7::EV_STATUS, foo); + let bar = irqarray7_csr.rf(utra::irqarray7::EV_STATUS_SOURCE0); + irqarray7_csr.rmwf(utra::irqarray7::EV_STATUS_SOURCE0, bar); + let mut baz = irqarray7_csr.zf(utra::irqarray7::EV_STATUS_SOURCE0, bar); + baz |= irqarray7_csr.ms(utra::irqarray7::EV_STATUS_SOURCE0, 1); + irqarray7_csr.wfo(utra::irqarray7::EV_STATUS_SOURCE0, baz); + let bar = irqarray7_csr.rf(utra::irqarray7::EV_STATUS_SOURCE1); + irqarray7_csr.rmwf(utra::irqarray7::EV_STATUS_SOURCE1, bar); + let mut baz = irqarray7_csr.zf(utra::irqarray7::EV_STATUS_SOURCE1, bar); + baz |= irqarray7_csr.ms(utra::irqarray7::EV_STATUS_SOURCE1, 1); + irqarray7_csr.wfo(utra::irqarray7::EV_STATUS_SOURCE1, baz); + let bar = irqarray7_csr.rf(utra::irqarray7::EV_STATUS_SOURCE2); + irqarray7_csr.rmwf(utra::irqarray7::EV_STATUS_SOURCE2, bar); + let mut baz = irqarray7_csr.zf(utra::irqarray7::EV_STATUS_SOURCE2, bar); + baz |= irqarray7_csr.ms(utra::irqarray7::EV_STATUS_SOURCE2, 1); + irqarray7_csr.wfo(utra::irqarray7::EV_STATUS_SOURCE2, baz); + let bar = irqarray7_csr.rf(utra::irqarray7::EV_STATUS_SOURCE3); + irqarray7_csr.rmwf(utra::irqarray7::EV_STATUS_SOURCE3, bar); + let mut baz = irqarray7_csr.zf(utra::irqarray7::EV_STATUS_SOURCE3, bar); + baz |= irqarray7_csr.ms(utra::irqarray7::EV_STATUS_SOURCE3, 1); + irqarray7_csr.wfo(utra::irqarray7::EV_STATUS_SOURCE3, baz); + let bar = irqarray7_csr.rf(utra::irqarray7::EV_STATUS_SOURCE4); + irqarray7_csr.rmwf(utra::irqarray7::EV_STATUS_SOURCE4, bar); + let mut baz = irqarray7_csr.zf(utra::irqarray7::EV_STATUS_SOURCE4, bar); + baz |= irqarray7_csr.ms(utra::irqarray7::EV_STATUS_SOURCE4, 1); + irqarray7_csr.wfo(utra::irqarray7::EV_STATUS_SOURCE4, baz); + let bar = irqarray7_csr.rf(utra::irqarray7::EV_STATUS_SOURCE5); + irqarray7_csr.rmwf(utra::irqarray7::EV_STATUS_SOURCE5, bar); + let mut baz = irqarray7_csr.zf(utra::irqarray7::EV_STATUS_SOURCE5, bar); + baz |= irqarray7_csr.ms(utra::irqarray7::EV_STATUS_SOURCE5, 1); + irqarray7_csr.wfo(utra::irqarray7::EV_STATUS_SOURCE5, baz); + let bar = irqarray7_csr.rf(utra::irqarray7::EV_STATUS_SOURCE6); + irqarray7_csr.rmwf(utra::irqarray7::EV_STATUS_SOURCE6, bar); + let mut baz = irqarray7_csr.zf(utra::irqarray7::EV_STATUS_SOURCE6, bar); + baz |= irqarray7_csr.ms(utra::irqarray7::EV_STATUS_SOURCE6, 1); + irqarray7_csr.wfo(utra::irqarray7::EV_STATUS_SOURCE6, baz); + let bar = irqarray7_csr.rf(utra::irqarray7::EV_STATUS_SOURCE7); + irqarray7_csr.rmwf(utra::irqarray7::EV_STATUS_SOURCE7, bar); + let mut baz = irqarray7_csr.zf(utra::irqarray7::EV_STATUS_SOURCE7, bar); + baz |= irqarray7_csr.ms(utra::irqarray7::EV_STATUS_SOURCE7, 1); + irqarray7_csr.wfo(utra::irqarray7::EV_STATUS_SOURCE7, baz); + let bar = irqarray7_csr.rf(utra::irqarray7::EV_STATUS_SOURCE8); + irqarray7_csr.rmwf(utra::irqarray7::EV_STATUS_SOURCE8, bar); + let mut baz = irqarray7_csr.zf(utra::irqarray7::EV_STATUS_SOURCE8, bar); + baz |= irqarray7_csr.ms(utra::irqarray7::EV_STATUS_SOURCE8, 1); + irqarray7_csr.wfo(utra::irqarray7::EV_STATUS_SOURCE8, baz); + let bar = irqarray7_csr.rf(utra::irqarray7::EV_STATUS_SOURCE9); + irqarray7_csr.rmwf(utra::irqarray7::EV_STATUS_SOURCE9, bar); + let mut baz = irqarray7_csr.zf(utra::irqarray7::EV_STATUS_SOURCE9, bar); + baz |= irqarray7_csr.ms(utra::irqarray7::EV_STATUS_SOURCE9, 1); + irqarray7_csr.wfo(utra::irqarray7::EV_STATUS_SOURCE9, baz); + let bar = irqarray7_csr.rf(utra::irqarray7::EV_STATUS_SOURCE10); + irqarray7_csr.rmwf(utra::irqarray7::EV_STATUS_SOURCE10, bar); + let mut baz = irqarray7_csr.zf(utra::irqarray7::EV_STATUS_SOURCE10, bar); + baz |= irqarray7_csr.ms(utra::irqarray7::EV_STATUS_SOURCE10, 1); + irqarray7_csr.wfo(utra::irqarray7::EV_STATUS_SOURCE10, baz); + let bar = irqarray7_csr.rf(utra::irqarray7::EV_STATUS_SOURCE11); + irqarray7_csr.rmwf(utra::irqarray7::EV_STATUS_SOURCE11, bar); + let mut baz = irqarray7_csr.zf(utra::irqarray7::EV_STATUS_SOURCE11, bar); + baz |= irqarray7_csr.ms(utra::irqarray7::EV_STATUS_SOURCE11, 1); + irqarray7_csr.wfo(utra::irqarray7::EV_STATUS_SOURCE11, baz); + let bar = irqarray7_csr.rf(utra::irqarray7::EV_STATUS_SOURCE12); + irqarray7_csr.rmwf(utra::irqarray7::EV_STATUS_SOURCE12, bar); + let mut baz = irqarray7_csr.zf(utra::irqarray7::EV_STATUS_SOURCE12, bar); + baz |= irqarray7_csr.ms(utra::irqarray7::EV_STATUS_SOURCE12, 1); + irqarray7_csr.wfo(utra::irqarray7::EV_STATUS_SOURCE12, baz); + let bar = irqarray7_csr.rf(utra::irqarray7::EV_STATUS_SOURCE13); + irqarray7_csr.rmwf(utra::irqarray7::EV_STATUS_SOURCE13, bar); + let mut baz = irqarray7_csr.zf(utra::irqarray7::EV_STATUS_SOURCE13, bar); + baz |= irqarray7_csr.ms(utra::irqarray7::EV_STATUS_SOURCE13, 1); + irqarray7_csr.wfo(utra::irqarray7::EV_STATUS_SOURCE13, baz); + let bar = irqarray7_csr.rf(utra::irqarray7::EV_STATUS_SOURCE14); + irqarray7_csr.rmwf(utra::irqarray7::EV_STATUS_SOURCE14, bar); + let mut baz = irqarray7_csr.zf(utra::irqarray7::EV_STATUS_SOURCE14, bar); + baz |= irqarray7_csr.ms(utra::irqarray7::EV_STATUS_SOURCE14, 1); + irqarray7_csr.wfo(utra::irqarray7::EV_STATUS_SOURCE14, baz); + let bar = irqarray7_csr.rf(utra::irqarray7::EV_STATUS_SOURCE15); + irqarray7_csr.rmwf(utra::irqarray7::EV_STATUS_SOURCE15, bar); + let mut baz = irqarray7_csr.zf(utra::irqarray7::EV_STATUS_SOURCE15, bar); + baz |= irqarray7_csr.ms(utra::irqarray7::EV_STATUS_SOURCE15, 1); + irqarray7_csr.wfo(utra::irqarray7::EV_STATUS_SOURCE15, baz); + let bar = irqarray7_csr.rf(utra::irqarray7::EV_STATUS_SOURCE16); + irqarray7_csr.rmwf(utra::irqarray7::EV_STATUS_SOURCE16, bar); + let mut baz = irqarray7_csr.zf(utra::irqarray7::EV_STATUS_SOURCE16, bar); + baz |= irqarray7_csr.ms(utra::irqarray7::EV_STATUS_SOURCE16, 1); + irqarray7_csr.wfo(utra::irqarray7::EV_STATUS_SOURCE16, baz); + let bar = irqarray7_csr.rf(utra::irqarray7::EV_STATUS_SOURCE17); + irqarray7_csr.rmwf(utra::irqarray7::EV_STATUS_SOURCE17, bar); + let mut baz = irqarray7_csr.zf(utra::irqarray7::EV_STATUS_SOURCE17, bar); + baz |= irqarray7_csr.ms(utra::irqarray7::EV_STATUS_SOURCE17, 1); + irqarray7_csr.wfo(utra::irqarray7::EV_STATUS_SOURCE17, baz); + let bar = irqarray7_csr.rf(utra::irqarray7::EV_STATUS_SOURCE18); + irqarray7_csr.rmwf(utra::irqarray7::EV_STATUS_SOURCE18, bar); + let mut baz = irqarray7_csr.zf(utra::irqarray7::EV_STATUS_SOURCE18, bar); + baz |= irqarray7_csr.ms(utra::irqarray7::EV_STATUS_SOURCE18, 1); + irqarray7_csr.wfo(utra::irqarray7::EV_STATUS_SOURCE18, baz); + let bar = irqarray7_csr.rf(utra::irqarray7::EV_STATUS_SOURCE19); + irqarray7_csr.rmwf(utra::irqarray7::EV_STATUS_SOURCE19, bar); + let mut baz = irqarray7_csr.zf(utra::irqarray7::EV_STATUS_SOURCE19, bar); + baz |= irqarray7_csr.ms(utra::irqarray7::EV_STATUS_SOURCE19, 1); + irqarray7_csr.wfo(utra::irqarray7::EV_STATUS_SOURCE19, baz); + + let foo = irqarray7_csr.r(utra::irqarray7::EV_PENDING); + irqarray7_csr.wo(utra::irqarray7::EV_PENDING, foo); + let bar = irqarray7_csr.rf(utra::irqarray7::EV_PENDING_SOURCE0); + irqarray7_csr.rmwf(utra::irqarray7::EV_PENDING_SOURCE0, bar); + let mut baz = irqarray7_csr.zf(utra::irqarray7::EV_PENDING_SOURCE0, bar); + baz |= irqarray7_csr.ms(utra::irqarray7::EV_PENDING_SOURCE0, 1); + irqarray7_csr.wfo(utra::irqarray7::EV_PENDING_SOURCE0, baz); + let bar = irqarray7_csr.rf(utra::irqarray7::EV_PENDING_SOURCE1); + irqarray7_csr.rmwf(utra::irqarray7::EV_PENDING_SOURCE1, bar); + let mut baz = irqarray7_csr.zf(utra::irqarray7::EV_PENDING_SOURCE1, bar); + baz |= irqarray7_csr.ms(utra::irqarray7::EV_PENDING_SOURCE1, 1); + irqarray7_csr.wfo(utra::irqarray7::EV_PENDING_SOURCE1, baz); + let bar = irqarray7_csr.rf(utra::irqarray7::EV_PENDING_SOURCE2); + irqarray7_csr.rmwf(utra::irqarray7::EV_PENDING_SOURCE2, bar); + let mut baz = irqarray7_csr.zf(utra::irqarray7::EV_PENDING_SOURCE2, bar); + baz |= irqarray7_csr.ms(utra::irqarray7::EV_PENDING_SOURCE2, 1); + irqarray7_csr.wfo(utra::irqarray7::EV_PENDING_SOURCE2, baz); + let bar = irqarray7_csr.rf(utra::irqarray7::EV_PENDING_SOURCE3); + irqarray7_csr.rmwf(utra::irqarray7::EV_PENDING_SOURCE3, bar); + let mut baz = irqarray7_csr.zf(utra::irqarray7::EV_PENDING_SOURCE3, bar); + baz |= irqarray7_csr.ms(utra::irqarray7::EV_PENDING_SOURCE3, 1); + irqarray7_csr.wfo(utra::irqarray7::EV_PENDING_SOURCE3, baz); + let bar = irqarray7_csr.rf(utra::irqarray7::EV_PENDING_SOURCE4); + irqarray7_csr.rmwf(utra::irqarray7::EV_PENDING_SOURCE4, bar); + let mut baz = irqarray7_csr.zf(utra::irqarray7::EV_PENDING_SOURCE4, bar); + baz |= irqarray7_csr.ms(utra::irqarray7::EV_PENDING_SOURCE4, 1); + irqarray7_csr.wfo(utra::irqarray7::EV_PENDING_SOURCE4, baz); + let bar = irqarray7_csr.rf(utra::irqarray7::EV_PENDING_SOURCE5); + irqarray7_csr.rmwf(utra::irqarray7::EV_PENDING_SOURCE5, bar); + let mut baz = irqarray7_csr.zf(utra::irqarray7::EV_PENDING_SOURCE5, bar); + baz |= irqarray7_csr.ms(utra::irqarray7::EV_PENDING_SOURCE5, 1); + irqarray7_csr.wfo(utra::irqarray7::EV_PENDING_SOURCE5, baz); + let bar = irqarray7_csr.rf(utra::irqarray7::EV_PENDING_SOURCE6); + irqarray7_csr.rmwf(utra::irqarray7::EV_PENDING_SOURCE6, bar); + let mut baz = irqarray7_csr.zf(utra::irqarray7::EV_PENDING_SOURCE6, bar); + baz |= irqarray7_csr.ms(utra::irqarray7::EV_PENDING_SOURCE6, 1); + irqarray7_csr.wfo(utra::irqarray7::EV_PENDING_SOURCE6, baz); + let bar = irqarray7_csr.rf(utra::irqarray7::EV_PENDING_SOURCE7); + irqarray7_csr.rmwf(utra::irqarray7::EV_PENDING_SOURCE7, bar); + let mut baz = irqarray7_csr.zf(utra::irqarray7::EV_PENDING_SOURCE7, bar); + baz |= irqarray7_csr.ms(utra::irqarray7::EV_PENDING_SOURCE7, 1); + irqarray7_csr.wfo(utra::irqarray7::EV_PENDING_SOURCE7, baz); + let bar = irqarray7_csr.rf(utra::irqarray7::EV_PENDING_SOURCE8); + irqarray7_csr.rmwf(utra::irqarray7::EV_PENDING_SOURCE8, bar); + let mut baz = irqarray7_csr.zf(utra::irqarray7::EV_PENDING_SOURCE8, bar); + baz |= irqarray7_csr.ms(utra::irqarray7::EV_PENDING_SOURCE8, 1); + irqarray7_csr.wfo(utra::irqarray7::EV_PENDING_SOURCE8, baz); + let bar = irqarray7_csr.rf(utra::irqarray7::EV_PENDING_SOURCE9); + irqarray7_csr.rmwf(utra::irqarray7::EV_PENDING_SOURCE9, bar); + let mut baz = irqarray7_csr.zf(utra::irqarray7::EV_PENDING_SOURCE9, bar); + baz |= irqarray7_csr.ms(utra::irqarray7::EV_PENDING_SOURCE9, 1); + irqarray7_csr.wfo(utra::irqarray7::EV_PENDING_SOURCE9, baz); + let bar = irqarray7_csr.rf(utra::irqarray7::EV_PENDING_SOURCE10); + irqarray7_csr.rmwf(utra::irqarray7::EV_PENDING_SOURCE10, bar); + let mut baz = irqarray7_csr.zf(utra::irqarray7::EV_PENDING_SOURCE10, bar); + baz |= irqarray7_csr.ms(utra::irqarray7::EV_PENDING_SOURCE10, 1); + irqarray7_csr.wfo(utra::irqarray7::EV_PENDING_SOURCE10, baz); + let bar = irqarray7_csr.rf(utra::irqarray7::EV_PENDING_SOURCE11); + irqarray7_csr.rmwf(utra::irqarray7::EV_PENDING_SOURCE11, bar); + let mut baz = irqarray7_csr.zf(utra::irqarray7::EV_PENDING_SOURCE11, bar); + baz |= irqarray7_csr.ms(utra::irqarray7::EV_PENDING_SOURCE11, 1); + irqarray7_csr.wfo(utra::irqarray7::EV_PENDING_SOURCE11, baz); + let bar = irqarray7_csr.rf(utra::irqarray7::EV_PENDING_SOURCE12); + irqarray7_csr.rmwf(utra::irqarray7::EV_PENDING_SOURCE12, bar); + let mut baz = irqarray7_csr.zf(utra::irqarray7::EV_PENDING_SOURCE12, bar); + baz |= irqarray7_csr.ms(utra::irqarray7::EV_PENDING_SOURCE12, 1); + irqarray7_csr.wfo(utra::irqarray7::EV_PENDING_SOURCE12, baz); + let bar = irqarray7_csr.rf(utra::irqarray7::EV_PENDING_SOURCE13); + irqarray7_csr.rmwf(utra::irqarray7::EV_PENDING_SOURCE13, bar); + let mut baz = irqarray7_csr.zf(utra::irqarray7::EV_PENDING_SOURCE13, bar); + baz |= irqarray7_csr.ms(utra::irqarray7::EV_PENDING_SOURCE13, 1); + irqarray7_csr.wfo(utra::irqarray7::EV_PENDING_SOURCE13, baz); + let bar = irqarray7_csr.rf(utra::irqarray7::EV_PENDING_SOURCE14); + irqarray7_csr.rmwf(utra::irqarray7::EV_PENDING_SOURCE14, bar); + let mut baz = irqarray7_csr.zf(utra::irqarray7::EV_PENDING_SOURCE14, bar); + baz |= irqarray7_csr.ms(utra::irqarray7::EV_PENDING_SOURCE14, 1); + irqarray7_csr.wfo(utra::irqarray7::EV_PENDING_SOURCE14, baz); + let bar = irqarray7_csr.rf(utra::irqarray7::EV_PENDING_SOURCE15); + irqarray7_csr.rmwf(utra::irqarray7::EV_PENDING_SOURCE15, bar); + let mut baz = irqarray7_csr.zf(utra::irqarray7::EV_PENDING_SOURCE15, bar); + baz |= irqarray7_csr.ms(utra::irqarray7::EV_PENDING_SOURCE15, 1); + irqarray7_csr.wfo(utra::irqarray7::EV_PENDING_SOURCE15, baz); + let bar = irqarray7_csr.rf(utra::irqarray7::EV_PENDING_SOURCE16); + irqarray7_csr.rmwf(utra::irqarray7::EV_PENDING_SOURCE16, bar); + let mut baz = irqarray7_csr.zf(utra::irqarray7::EV_PENDING_SOURCE16, bar); + baz |= irqarray7_csr.ms(utra::irqarray7::EV_PENDING_SOURCE16, 1); + irqarray7_csr.wfo(utra::irqarray7::EV_PENDING_SOURCE16, baz); + let bar = irqarray7_csr.rf(utra::irqarray7::EV_PENDING_SOURCE17); + irqarray7_csr.rmwf(utra::irqarray7::EV_PENDING_SOURCE17, bar); + let mut baz = irqarray7_csr.zf(utra::irqarray7::EV_PENDING_SOURCE17, bar); + baz |= irqarray7_csr.ms(utra::irqarray7::EV_PENDING_SOURCE17, 1); + irqarray7_csr.wfo(utra::irqarray7::EV_PENDING_SOURCE17, baz); + let bar = irqarray7_csr.rf(utra::irqarray7::EV_PENDING_SOURCE18); + irqarray7_csr.rmwf(utra::irqarray7::EV_PENDING_SOURCE18, bar); + let mut baz = irqarray7_csr.zf(utra::irqarray7::EV_PENDING_SOURCE18, bar); + baz |= irqarray7_csr.ms(utra::irqarray7::EV_PENDING_SOURCE18, 1); + irqarray7_csr.wfo(utra::irqarray7::EV_PENDING_SOURCE18, baz); + let bar = irqarray7_csr.rf(utra::irqarray7::EV_PENDING_SOURCE19); + irqarray7_csr.rmwf(utra::irqarray7::EV_PENDING_SOURCE19, bar); + let mut baz = irqarray7_csr.zf(utra::irqarray7::EV_PENDING_SOURCE19, bar); + baz |= irqarray7_csr.ms(utra::irqarray7::EV_PENDING_SOURCE19, 1); + irqarray7_csr.wfo(utra::irqarray7::EV_PENDING_SOURCE19, baz); + + let foo = irqarray7_csr.r(utra::irqarray7::EV_ENABLE); + irqarray7_csr.wo(utra::irqarray7::EV_ENABLE, foo); + let bar = irqarray7_csr.rf(utra::irqarray7::EV_ENABLE_SOURCE0); + irqarray7_csr.rmwf(utra::irqarray7::EV_ENABLE_SOURCE0, bar); + let mut baz = irqarray7_csr.zf(utra::irqarray7::EV_ENABLE_SOURCE0, bar); + baz |= irqarray7_csr.ms(utra::irqarray7::EV_ENABLE_SOURCE0, 1); + irqarray7_csr.wfo(utra::irqarray7::EV_ENABLE_SOURCE0, baz); + let bar = irqarray7_csr.rf(utra::irqarray7::EV_ENABLE_SOURCE1); + irqarray7_csr.rmwf(utra::irqarray7::EV_ENABLE_SOURCE1, bar); + let mut baz = irqarray7_csr.zf(utra::irqarray7::EV_ENABLE_SOURCE1, bar); + baz |= irqarray7_csr.ms(utra::irqarray7::EV_ENABLE_SOURCE1, 1); + irqarray7_csr.wfo(utra::irqarray7::EV_ENABLE_SOURCE1, baz); + let bar = irqarray7_csr.rf(utra::irqarray7::EV_ENABLE_SOURCE2); + irqarray7_csr.rmwf(utra::irqarray7::EV_ENABLE_SOURCE2, bar); + let mut baz = irqarray7_csr.zf(utra::irqarray7::EV_ENABLE_SOURCE2, bar); + baz |= irqarray7_csr.ms(utra::irqarray7::EV_ENABLE_SOURCE2, 1); + irqarray7_csr.wfo(utra::irqarray7::EV_ENABLE_SOURCE2, baz); + let bar = irqarray7_csr.rf(utra::irqarray7::EV_ENABLE_SOURCE3); + irqarray7_csr.rmwf(utra::irqarray7::EV_ENABLE_SOURCE3, bar); + let mut baz = irqarray7_csr.zf(utra::irqarray7::EV_ENABLE_SOURCE3, bar); + baz |= irqarray7_csr.ms(utra::irqarray7::EV_ENABLE_SOURCE3, 1); + irqarray7_csr.wfo(utra::irqarray7::EV_ENABLE_SOURCE3, baz); + let bar = irqarray7_csr.rf(utra::irqarray7::EV_ENABLE_SOURCE4); + irqarray7_csr.rmwf(utra::irqarray7::EV_ENABLE_SOURCE4, bar); + let mut baz = irqarray7_csr.zf(utra::irqarray7::EV_ENABLE_SOURCE4, bar); + baz |= irqarray7_csr.ms(utra::irqarray7::EV_ENABLE_SOURCE4, 1); + irqarray7_csr.wfo(utra::irqarray7::EV_ENABLE_SOURCE4, baz); + let bar = irqarray7_csr.rf(utra::irqarray7::EV_ENABLE_SOURCE5); + irqarray7_csr.rmwf(utra::irqarray7::EV_ENABLE_SOURCE5, bar); + let mut baz = irqarray7_csr.zf(utra::irqarray7::EV_ENABLE_SOURCE5, bar); + baz |= irqarray7_csr.ms(utra::irqarray7::EV_ENABLE_SOURCE5, 1); + irqarray7_csr.wfo(utra::irqarray7::EV_ENABLE_SOURCE5, baz); + let bar = irqarray7_csr.rf(utra::irqarray7::EV_ENABLE_SOURCE6); + irqarray7_csr.rmwf(utra::irqarray7::EV_ENABLE_SOURCE6, bar); + let mut baz = irqarray7_csr.zf(utra::irqarray7::EV_ENABLE_SOURCE6, bar); + baz |= irqarray7_csr.ms(utra::irqarray7::EV_ENABLE_SOURCE6, 1); + irqarray7_csr.wfo(utra::irqarray7::EV_ENABLE_SOURCE6, baz); + let bar = irqarray7_csr.rf(utra::irqarray7::EV_ENABLE_SOURCE7); + irqarray7_csr.rmwf(utra::irqarray7::EV_ENABLE_SOURCE7, bar); + let mut baz = irqarray7_csr.zf(utra::irqarray7::EV_ENABLE_SOURCE7, bar); + baz |= irqarray7_csr.ms(utra::irqarray7::EV_ENABLE_SOURCE7, 1); + irqarray7_csr.wfo(utra::irqarray7::EV_ENABLE_SOURCE7, baz); + let bar = irqarray7_csr.rf(utra::irqarray7::EV_ENABLE_SOURCE8); + irqarray7_csr.rmwf(utra::irqarray7::EV_ENABLE_SOURCE8, bar); + let mut baz = irqarray7_csr.zf(utra::irqarray7::EV_ENABLE_SOURCE8, bar); + baz |= irqarray7_csr.ms(utra::irqarray7::EV_ENABLE_SOURCE8, 1); + irqarray7_csr.wfo(utra::irqarray7::EV_ENABLE_SOURCE8, baz); + let bar = irqarray7_csr.rf(utra::irqarray7::EV_ENABLE_SOURCE9); + irqarray7_csr.rmwf(utra::irqarray7::EV_ENABLE_SOURCE9, bar); + let mut baz = irqarray7_csr.zf(utra::irqarray7::EV_ENABLE_SOURCE9, bar); + baz |= irqarray7_csr.ms(utra::irqarray7::EV_ENABLE_SOURCE9, 1); + irqarray7_csr.wfo(utra::irqarray7::EV_ENABLE_SOURCE9, baz); + let bar = irqarray7_csr.rf(utra::irqarray7::EV_ENABLE_SOURCE10); + irqarray7_csr.rmwf(utra::irqarray7::EV_ENABLE_SOURCE10, bar); + let mut baz = irqarray7_csr.zf(utra::irqarray7::EV_ENABLE_SOURCE10, bar); + baz |= irqarray7_csr.ms(utra::irqarray7::EV_ENABLE_SOURCE10, 1); + irqarray7_csr.wfo(utra::irqarray7::EV_ENABLE_SOURCE10, baz); + let bar = irqarray7_csr.rf(utra::irqarray7::EV_ENABLE_SOURCE11); + irqarray7_csr.rmwf(utra::irqarray7::EV_ENABLE_SOURCE11, bar); + let mut baz = irqarray7_csr.zf(utra::irqarray7::EV_ENABLE_SOURCE11, bar); + baz |= irqarray7_csr.ms(utra::irqarray7::EV_ENABLE_SOURCE11, 1); + irqarray7_csr.wfo(utra::irqarray7::EV_ENABLE_SOURCE11, baz); + let bar = irqarray7_csr.rf(utra::irqarray7::EV_ENABLE_SOURCE12); + irqarray7_csr.rmwf(utra::irqarray7::EV_ENABLE_SOURCE12, bar); + let mut baz = irqarray7_csr.zf(utra::irqarray7::EV_ENABLE_SOURCE12, bar); + baz |= irqarray7_csr.ms(utra::irqarray7::EV_ENABLE_SOURCE12, 1); + irqarray7_csr.wfo(utra::irqarray7::EV_ENABLE_SOURCE12, baz); + let bar = irqarray7_csr.rf(utra::irqarray7::EV_ENABLE_SOURCE13); + irqarray7_csr.rmwf(utra::irqarray7::EV_ENABLE_SOURCE13, bar); + let mut baz = irqarray7_csr.zf(utra::irqarray7::EV_ENABLE_SOURCE13, bar); + baz |= irqarray7_csr.ms(utra::irqarray7::EV_ENABLE_SOURCE13, 1); + irqarray7_csr.wfo(utra::irqarray7::EV_ENABLE_SOURCE13, baz); + let bar = irqarray7_csr.rf(utra::irqarray7::EV_ENABLE_SOURCE14); + irqarray7_csr.rmwf(utra::irqarray7::EV_ENABLE_SOURCE14, bar); + let mut baz = irqarray7_csr.zf(utra::irqarray7::EV_ENABLE_SOURCE14, bar); + baz |= irqarray7_csr.ms(utra::irqarray7::EV_ENABLE_SOURCE14, 1); + irqarray7_csr.wfo(utra::irqarray7::EV_ENABLE_SOURCE14, baz); + let bar = irqarray7_csr.rf(utra::irqarray7::EV_ENABLE_SOURCE15); + irqarray7_csr.rmwf(utra::irqarray7::EV_ENABLE_SOURCE15, bar); + let mut baz = irqarray7_csr.zf(utra::irqarray7::EV_ENABLE_SOURCE15, bar); + baz |= irqarray7_csr.ms(utra::irqarray7::EV_ENABLE_SOURCE15, 1); + irqarray7_csr.wfo(utra::irqarray7::EV_ENABLE_SOURCE15, baz); + let bar = irqarray7_csr.rf(utra::irqarray7::EV_ENABLE_SOURCE16); + irqarray7_csr.rmwf(utra::irqarray7::EV_ENABLE_SOURCE16, bar); + let mut baz = irqarray7_csr.zf(utra::irqarray7::EV_ENABLE_SOURCE16, bar); + baz |= irqarray7_csr.ms(utra::irqarray7::EV_ENABLE_SOURCE16, 1); + irqarray7_csr.wfo(utra::irqarray7::EV_ENABLE_SOURCE16, baz); + let bar = irqarray7_csr.rf(utra::irqarray7::EV_ENABLE_SOURCE17); + irqarray7_csr.rmwf(utra::irqarray7::EV_ENABLE_SOURCE17, bar); + let mut baz = irqarray7_csr.zf(utra::irqarray7::EV_ENABLE_SOURCE17, bar); + baz |= irqarray7_csr.ms(utra::irqarray7::EV_ENABLE_SOURCE17, 1); + irqarray7_csr.wfo(utra::irqarray7::EV_ENABLE_SOURCE17, baz); + let bar = irqarray7_csr.rf(utra::irqarray7::EV_ENABLE_SOURCE18); + irqarray7_csr.rmwf(utra::irqarray7::EV_ENABLE_SOURCE18, bar); + let mut baz = irqarray7_csr.zf(utra::irqarray7::EV_ENABLE_SOURCE18, bar); + baz |= irqarray7_csr.ms(utra::irqarray7::EV_ENABLE_SOURCE18, 1); + irqarray7_csr.wfo(utra::irqarray7::EV_ENABLE_SOURCE18, baz); + let bar = irqarray7_csr.rf(utra::irqarray7::EV_ENABLE_SOURCE19); + irqarray7_csr.rmwf(utra::irqarray7::EV_ENABLE_SOURCE19, bar); + let mut baz = irqarray7_csr.zf(utra::irqarray7::EV_ENABLE_SOURCE19, bar); + baz |= irqarray7_csr.ms(utra::irqarray7::EV_ENABLE_SOURCE19, 1); + irqarray7_csr.wfo(utra::irqarray7::EV_ENABLE_SOURCE19, baz); + } + + #[test] + #[ignore] + fn compile_check_irqarray8_csr() { + use super::*; + let mut irqarray8_csr = CSR::new(HW_IRQARRAY8_BASE as *mut u32); + + let foo = irqarray8_csr.r(utra::irqarray8::EV_SOFT); + irqarray8_csr.wo(utra::irqarray8::EV_SOFT, foo); + let bar = irqarray8_csr.rf(utra::irqarray8::EV_SOFT_TRIGGER); + irqarray8_csr.rmwf(utra::irqarray8::EV_SOFT_TRIGGER, bar); + let mut baz = irqarray8_csr.zf(utra::irqarray8::EV_SOFT_TRIGGER, bar); + baz |= irqarray8_csr.ms(utra::irqarray8::EV_SOFT_TRIGGER, 1); + irqarray8_csr.wfo(utra::irqarray8::EV_SOFT_TRIGGER, baz); + + let foo = irqarray8_csr.r(utra::irqarray8::EV_STATUS); + irqarray8_csr.wo(utra::irqarray8::EV_STATUS, foo); + let bar = irqarray8_csr.rf(utra::irqarray8::EV_STATUS_SOURCE0); + irqarray8_csr.rmwf(utra::irqarray8::EV_STATUS_SOURCE0, bar); + let mut baz = irqarray8_csr.zf(utra::irqarray8::EV_STATUS_SOURCE0, bar); + baz |= irqarray8_csr.ms(utra::irqarray8::EV_STATUS_SOURCE0, 1); + irqarray8_csr.wfo(utra::irqarray8::EV_STATUS_SOURCE0, baz); + let bar = irqarray8_csr.rf(utra::irqarray8::EV_STATUS_SOURCE1); + irqarray8_csr.rmwf(utra::irqarray8::EV_STATUS_SOURCE1, bar); + let mut baz = irqarray8_csr.zf(utra::irqarray8::EV_STATUS_SOURCE1, bar); + baz |= irqarray8_csr.ms(utra::irqarray8::EV_STATUS_SOURCE1, 1); + irqarray8_csr.wfo(utra::irqarray8::EV_STATUS_SOURCE1, baz); + let bar = irqarray8_csr.rf(utra::irqarray8::EV_STATUS_SOURCE2); + irqarray8_csr.rmwf(utra::irqarray8::EV_STATUS_SOURCE2, bar); + let mut baz = irqarray8_csr.zf(utra::irqarray8::EV_STATUS_SOURCE2, bar); + baz |= irqarray8_csr.ms(utra::irqarray8::EV_STATUS_SOURCE2, 1); + irqarray8_csr.wfo(utra::irqarray8::EV_STATUS_SOURCE2, baz); + let bar = irqarray8_csr.rf(utra::irqarray8::EV_STATUS_SOURCE3); + irqarray8_csr.rmwf(utra::irqarray8::EV_STATUS_SOURCE3, bar); + let mut baz = irqarray8_csr.zf(utra::irqarray8::EV_STATUS_SOURCE3, bar); + baz |= irqarray8_csr.ms(utra::irqarray8::EV_STATUS_SOURCE3, 1); + irqarray8_csr.wfo(utra::irqarray8::EV_STATUS_SOURCE3, baz); + let bar = irqarray8_csr.rf(utra::irqarray8::EV_STATUS_SOURCE4); + irqarray8_csr.rmwf(utra::irqarray8::EV_STATUS_SOURCE4, bar); + let mut baz = irqarray8_csr.zf(utra::irqarray8::EV_STATUS_SOURCE4, bar); + baz |= irqarray8_csr.ms(utra::irqarray8::EV_STATUS_SOURCE4, 1); + irqarray8_csr.wfo(utra::irqarray8::EV_STATUS_SOURCE4, baz); + let bar = irqarray8_csr.rf(utra::irqarray8::EV_STATUS_SOURCE5); + irqarray8_csr.rmwf(utra::irqarray8::EV_STATUS_SOURCE5, bar); + let mut baz = irqarray8_csr.zf(utra::irqarray8::EV_STATUS_SOURCE5, bar); + baz |= irqarray8_csr.ms(utra::irqarray8::EV_STATUS_SOURCE5, 1); + irqarray8_csr.wfo(utra::irqarray8::EV_STATUS_SOURCE5, baz); + let bar = irqarray8_csr.rf(utra::irqarray8::EV_STATUS_SOURCE6); + irqarray8_csr.rmwf(utra::irqarray8::EV_STATUS_SOURCE6, bar); + let mut baz = irqarray8_csr.zf(utra::irqarray8::EV_STATUS_SOURCE6, bar); + baz |= irqarray8_csr.ms(utra::irqarray8::EV_STATUS_SOURCE6, 1); + irqarray8_csr.wfo(utra::irqarray8::EV_STATUS_SOURCE6, baz); + let bar = irqarray8_csr.rf(utra::irqarray8::EV_STATUS_SOURCE7); + irqarray8_csr.rmwf(utra::irqarray8::EV_STATUS_SOURCE7, bar); + let mut baz = irqarray8_csr.zf(utra::irqarray8::EV_STATUS_SOURCE7, bar); + baz |= irqarray8_csr.ms(utra::irqarray8::EV_STATUS_SOURCE7, 1); + irqarray8_csr.wfo(utra::irqarray8::EV_STATUS_SOURCE7, baz); + let bar = irqarray8_csr.rf(utra::irqarray8::EV_STATUS_SOURCE8); + irqarray8_csr.rmwf(utra::irqarray8::EV_STATUS_SOURCE8, bar); + let mut baz = irqarray8_csr.zf(utra::irqarray8::EV_STATUS_SOURCE8, bar); + baz |= irqarray8_csr.ms(utra::irqarray8::EV_STATUS_SOURCE8, 1); + irqarray8_csr.wfo(utra::irqarray8::EV_STATUS_SOURCE8, baz); + let bar = irqarray8_csr.rf(utra::irqarray8::EV_STATUS_SOURCE9); + irqarray8_csr.rmwf(utra::irqarray8::EV_STATUS_SOURCE9, bar); + let mut baz = irqarray8_csr.zf(utra::irqarray8::EV_STATUS_SOURCE9, bar); + baz |= irqarray8_csr.ms(utra::irqarray8::EV_STATUS_SOURCE9, 1); + irqarray8_csr.wfo(utra::irqarray8::EV_STATUS_SOURCE9, baz); + let bar = irqarray8_csr.rf(utra::irqarray8::EV_STATUS_SOURCE10); + irqarray8_csr.rmwf(utra::irqarray8::EV_STATUS_SOURCE10, bar); + let mut baz = irqarray8_csr.zf(utra::irqarray8::EV_STATUS_SOURCE10, bar); + baz |= irqarray8_csr.ms(utra::irqarray8::EV_STATUS_SOURCE10, 1); + irqarray8_csr.wfo(utra::irqarray8::EV_STATUS_SOURCE10, baz); + let bar = irqarray8_csr.rf(utra::irqarray8::EV_STATUS_SOURCE11); + irqarray8_csr.rmwf(utra::irqarray8::EV_STATUS_SOURCE11, bar); + let mut baz = irqarray8_csr.zf(utra::irqarray8::EV_STATUS_SOURCE11, bar); + baz |= irqarray8_csr.ms(utra::irqarray8::EV_STATUS_SOURCE11, 1); + irqarray8_csr.wfo(utra::irqarray8::EV_STATUS_SOURCE11, baz); + let bar = irqarray8_csr.rf(utra::irqarray8::EV_STATUS_SOURCE12); + irqarray8_csr.rmwf(utra::irqarray8::EV_STATUS_SOURCE12, bar); + let mut baz = irqarray8_csr.zf(utra::irqarray8::EV_STATUS_SOURCE12, bar); + baz |= irqarray8_csr.ms(utra::irqarray8::EV_STATUS_SOURCE12, 1); + irqarray8_csr.wfo(utra::irqarray8::EV_STATUS_SOURCE12, baz); + let bar = irqarray8_csr.rf(utra::irqarray8::EV_STATUS_SOURCE13); + irqarray8_csr.rmwf(utra::irqarray8::EV_STATUS_SOURCE13, bar); + let mut baz = irqarray8_csr.zf(utra::irqarray8::EV_STATUS_SOURCE13, bar); + baz |= irqarray8_csr.ms(utra::irqarray8::EV_STATUS_SOURCE13, 1); + irqarray8_csr.wfo(utra::irqarray8::EV_STATUS_SOURCE13, baz); + let bar = irqarray8_csr.rf(utra::irqarray8::EV_STATUS_SOURCE14); + irqarray8_csr.rmwf(utra::irqarray8::EV_STATUS_SOURCE14, bar); + let mut baz = irqarray8_csr.zf(utra::irqarray8::EV_STATUS_SOURCE14, bar); + baz |= irqarray8_csr.ms(utra::irqarray8::EV_STATUS_SOURCE14, 1); + irqarray8_csr.wfo(utra::irqarray8::EV_STATUS_SOURCE14, baz); + let bar = irqarray8_csr.rf(utra::irqarray8::EV_STATUS_SOURCE15); + irqarray8_csr.rmwf(utra::irqarray8::EV_STATUS_SOURCE15, bar); + let mut baz = irqarray8_csr.zf(utra::irqarray8::EV_STATUS_SOURCE15, bar); + baz |= irqarray8_csr.ms(utra::irqarray8::EV_STATUS_SOURCE15, 1); + irqarray8_csr.wfo(utra::irqarray8::EV_STATUS_SOURCE15, baz); + let bar = irqarray8_csr.rf(utra::irqarray8::EV_STATUS_SOURCE16); + irqarray8_csr.rmwf(utra::irqarray8::EV_STATUS_SOURCE16, bar); + let mut baz = irqarray8_csr.zf(utra::irqarray8::EV_STATUS_SOURCE16, bar); + baz |= irqarray8_csr.ms(utra::irqarray8::EV_STATUS_SOURCE16, 1); + irqarray8_csr.wfo(utra::irqarray8::EV_STATUS_SOURCE16, baz); + let bar = irqarray8_csr.rf(utra::irqarray8::EV_STATUS_SOURCE17); + irqarray8_csr.rmwf(utra::irqarray8::EV_STATUS_SOURCE17, bar); + let mut baz = irqarray8_csr.zf(utra::irqarray8::EV_STATUS_SOURCE17, bar); + baz |= irqarray8_csr.ms(utra::irqarray8::EV_STATUS_SOURCE17, 1); + irqarray8_csr.wfo(utra::irqarray8::EV_STATUS_SOURCE17, baz); + let bar = irqarray8_csr.rf(utra::irqarray8::EV_STATUS_SOURCE18); + irqarray8_csr.rmwf(utra::irqarray8::EV_STATUS_SOURCE18, bar); + let mut baz = irqarray8_csr.zf(utra::irqarray8::EV_STATUS_SOURCE18, bar); + baz |= irqarray8_csr.ms(utra::irqarray8::EV_STATUS_SOURCE18, 1); + irqarray8_csr.wfo(utra::irqarray8::EV_STATUS_SOURCE18, baz); + let bar = irqarray8_csr.rf(utra::irqarray8::EV_STATUS_SOURCE19); + irqarray8_csr.rmwf(utra::irqarray8::EV_STATUS_SOURCE19, bar); + let mut baz = irqarray8_csr.zf(utra::irqarray8::EV_STATUS_SOURCE19, bar); + baz |= irqarray8_csr.ms(utra::irqarray8::EV_STATUS_SOURCE19, 1); + irqarray8_csr.wfo(utra::irqarray8::EV_STATUS_SOURCE19, baz); + + let foo = irqarray8_csr.r(utra::irqarray8::EV_PENDING); + irqarray8_csr.wo(utra::irqarray8::EV_PENDING, foo); + let bar = irqarray8_csr.rf(utra::irqarray8::EV_PENDING_SOURCE0); + irqarray8_csr.rmwf(utra::irqarray8::EV_PENDING_SOURCE0, bar); + let mut baz = irqarray8_csr.zf(utra::irqarray8::EV_PENDING_SOURCE0, bar); + baz |= irqarray8_csr.ms(utra::irqarray8::EV_PENDING_SOURCE0, 1); + irqarray8_csr.wfo(utra::irqarray8::EV_PENDING_SOURCE0, baz); + let bar = irqarray8_csr.rf(utra::irqarray8::EV_PENDING_SOURCE1); + irqarray8_csr.rmwf(utra::irqarray8::EV_PENDING_SOURCE1, bar); + let mut baz = irqarray8_csr.zf(utra::irqarray8::EV_PENDING_SOURCE1, bar); + baz |= irqarray8_csr.ms(utra::irqarray8::EV_PENDING_SOURCE1, 1); + irqarray8_csr.wfo(utra::irqarray8::EV_PENDING_SOURCE1, baz); + let bar = irqarray8_csr.rf(utra::irqarray8::EV_PENDING_SOURCE2); + irqarray8_csr.rmwf(utra::irqarray8::EV_PENDING_SOURCE2, bar); + let mut baz = irqarray8_csr.zf(utra::irqarray8::EV_PENDING_SOURCE2, bar); + baz |= irqarray8_csr.ms(utra::irqarray8::EV_PENDING_SOURCE2, 1); + irqarray8_csr.wfo(utra::irqarray8::EV_PENDING_SOURCE2, baz); + let bar = irqarray8_csr.rf(utra::irqarray8::EV_PENDING_SOURCE3); + irqarray8_csr.rmwf(utra::irqarray8::EV_PENDING_SOURCE3, bar); + let mut baz = irqarray8_csr.zf(utra::irqarray8::EV_PENDING_SOURCE3, bar); + baz |= irqarray8_csr.ms(utra::irqarray8::EV_PENDING_SOURCE3, 1); + irqarray8_csr.wfo(utra::irqarray8::EV_PENDING_SOURCE3, baz); + let bar = irqarray8_csr.rf(utra::irqarray8::EV_PENDING_SOURCE4); + irqarray8_csr.rmwf(utra::irqarray8::EV_PENDING_SOURCE4, bar); + let mut baz = irqarray8_csr.zf(utra::irqarray8::EV_PENDING_SOURCE4, bar); + baz |= irqarray8_csr.ms(utra::irqarray8::EV_PENDING_SOURCE4, 1); + irqarray8_csr.wfo(utra::irqarray8::EV_PENDING_SOURCE4, baz); + let bar = irqarray8_csr.rf(utra::irqarray8::EV_PENDING_SOURCE5); + irqarray8_csr.rmwf(utra::irqarray8::EV_PENDING_SOURCE5, bar); + let mut baz = irqarray8_csr.zf(utra::irqarray8::EV_PENDING_SOURCE5, bar); + baz |= irqarray8_csr.ms(utra::irqarray8::EV_PENDING_SOURCE5, 1); + irqarray8_csr.wfo(utra::irqarray8::EV_PENDING_SOURCE5, baz); + let bar = irqarray8_csr.rf(utra::irqarray8::EV_PENDING_SOURCE6); + irqarray8_csr.rmwf(utra::irqarray8::EV_PENDING_SOURCE6, bar); + let mut baz = irqarray8_csr.zf(utra::irqarray8::EV_PENDING_SOURCE6, bar); + baz |= irqarray8_csr.ms(utra::irqarray8::EV_PENDING_SOURCE6, 1); + irqarray8_csr.wfo(utra::irqarray8::EV_PENDING_SOURCE6, baz); + let bar = irqarray8_csr.rf(utra::irqarray8::EV_PENDING_SOURCE7); + irqarray8_csr.rmwf(utra::irqarray8::EV_PENDING_SOURCE7, bar); + let mut baz = irqarray8_csr.zf(utra::irqarray8::EV_PENDING_SOURCE7, bar); + baz |= irqarray8_csr.ms(utra::irqarray8::EV_PENDING_SOURCE7, 1); + irqarray8_csr.wfo(utra::irqarray8::EV_PENDING_SOURCE7, baz); + let bar = irqarray8_csr.rf(utra::irqarray8::EV_PENDING_SOURCE8); + irqarray8_csr.rmwf(utra::irqarray8::EV_PENDING_SOURCE8, bar); + let mut baz = irqarray8_csr.zf(utra::irqarray8::EV_PENDING_SOURCE8, bar); + baz |= irqarray8_csr.ms(utra::irqarray8::EV_PENDING_SOURCE8, 1); + irqarray8_csr.wfo(utra::irqarray8::EV_PENDING_SOURCE8, baz); + let bar = irqarray8_csr.rf(utra::irqarray8::EV_PENDING_SOURCE9); + irqarray8_csr.rmwf(utra::irqarray8::EV_PENDING_SOURCE9, bar); + let mut baz = irqarray8_csr.zf(utra::irqarray8::EV_PENDING_SOURCE9, bar); + baz |= irqarray8_csr.ms(utra::irqarray8::EV_PENDING_SOURCE9, 1); + irqarray8_csr.wfo(utra::irqarray8::EV_PENDING_SOURCE9, baz); + let bar = irqarray8_csr.rf(utra::irqarray8::EV_PENDING_SOURCE10); + irqarray8_csr.rmwf(utra::irqarray8::EV_PENDING_SOURCE10, bar); + let mut baz = irqarray8_csr.zf(utra::irqarray8::EV_PENDING_SOURCE10, bar); + baz |= irqarray8_csr.ms(utra::irqarray8::EV_PENDING_SOURCE10, 1); + irqarray8_csr.wfo(utra::irqarray8::EV_PENDING_SOURCE10, baz); + let bar = irqarray8_csr.rf(utra::irqarray8::EV_PENDING_SOURCE11); + irqarray8_csr.rmwf(utra::irqarray8::EV_PENDING_SOURCE11, bar); + let mut baz = irqarray8_csr.zf(utra::irqarray8::EV_PENDING_SOURCE11, bar); + baz |= irqarray8_csr.ms(utra::irqarray8::EV_PENDING_SOURCE11, 1); + irqarray8_csr.wfo(utra::irqarray8::EV_PENDING_SOURCE11, baz); + let bar = irqarray8_csr.rf(utra::irqarray8::EV_PENDING_SOURCE12); + irqarray8_csr.rmwf(utra::irqarray8::EV_PENDING_SOURCE12, bar); + let mut baz = irqarray8_csr.zf(utra::irqarray8::EV_PENDING_SOURCE12, bar); + baz |= irqarray8_csr.ms(utra::irqarray8::EV_PENDING_SOURCE12, 1); + irqarray8_csr.wfo(utra::irqarray8::EV_PENDING_SOURCE12, baz); + let bar = irqarray8_csr.rf(utra::irqarray8::EV_PENDING_SOURCE13); + irqarray8_csr.rmwf(utra::irqarray8::EV_PENDING_SOURCE13, bar); + let mut baz = irqarray8_csr.zf(utra::irqarray8::EV_PENDING_SOURCE13, bar); + baz |= irqarray8_csr.ms(utra::irqarray8::EV_PENDING_SOURCE13, 1); + irqarray8_csr.wfo(utra::irqarray8::EV_PENDING_SOURCE13, baz); + let bar = irqarray8_csr.rf(utra::irqarray8::EV_PENDING_SOURCE14); + irqarray8_csr.rmwf(utra::irqarray8::EV_PENDING_SOURCE14, bar); + let mut baz = irqarray8_csr.zf(utra::irqarray8::EV_PENDING_SOURCE14, bar); + baz |= irqarray8_csr.ms(utra::irqarray8::EV_PENDING_SOURCE14, 1); + irqarray8_csr.wfo(utra::irqarray8::EV_PENDING_SOURCE14, baz); + let bar = irqarray8_csr.rf(utra::irqarray8::EV_PENDING_SOURCE15); + irqarray8_csr.rmwf(utra::irqarray8::EV_PENDING_SOURCE15, bar); + let mut baz = irqarray8_csr.zf(utra::irqarray8::EV_PENDING_SOURCE15, bar); + baz |= irqarray8_csr.ms(utra::irqarray8::EV_PENDING_SOURCE15, 1); + irqarray8_csr.wfo(utra::irqarray8::EV_PENDING_SOURCE15, baz); + let bar = irqarray8_csr.rf(utra::irqarray8::EV_PENDING_SOURCE16); + irqarray8_csr.rmwf(utra::irqarray8::EV_PENDING_SOURCE16, bar); + let mut baz = irqarray8_csr.zf(utra::irqarray8::EV_PENDING_SOURCE16, bar); + baz |= irqarray8_csr.ms(utra::irqarray8::EV_PENDING_SOURCE16, 1); + irqarray8_csr.wfo(utra::irqarray8::EV_PENDING_SOURCE16, baz); + let bar = irqarray8_csr.rf(utra::irqarray8::EV_PENDING_SOURCE17); + irqarray8_csr.rmwf(utra::irqarray8::EV_PENDING_SOURCE17, bar); + let mut baz = irqarray8_csr.zf(utra::irqarray8::EV_PENDING_SOURCE17, bar); + baz |= irqarray8_csr.ms(utra::irqarray8::EV_PENDING_SOURCE17, 1); + irqarray8_csr.wfo(utra::irqarray8::EV_PENDING_SOURCE17, baz); + let bar = irqarray8_csr.rf(utra::irqarray8::EV_PENDING_SOURCE18); + irqarray8_csr.rmwf(utra::irqarray8::EV_PENDING_SOURCE18, bar); + let mut baz = irqarray8_csr.zf(utra::irqarray8::EV_PENDING_SOURCE18, bar); + baz |= irqarray8_csr.ms(utra::irqarray8::EV_PENDING_SOURCE18, 1); + irqarray8_csr.wfo(utra::irqarray8::EV_PENDING_SOURCE18, baz); + let bar = irqarray8_csr.rf(utra::irqarray8::EV_PENDING_SOURCE19); + irqarray8_csr.rmwf(utra::irqarray8::EV_PENDING_SOURCE19, bar); + let mut baz = irqarray8_csr.zf(utra::irqarray8::EV_PENDING_SOURCE19, bar); + baz |= irqarray8_csr.ms(utra::irqarray8::EV_PENDING_SOURCE19, 1); + irqarray8_csr.wfo(utra::irqarray8::EV_PENDING_SOURCE19, baz); + + let foo = irqarray8_csr.r(utra::irqarray8::EV_ENABLE); + irqarray8_csr.wo(utra::irqarray8::EV_ENABLE, foo); + let bar = irqarray8_csr.rf(utra::irqarray8::EV_ENABLE_SOURCE0); + irqarray8_csr.rmwf(utra::irqarray8::EV_ENABLE_SOURCE0, bar); + let mut baz = irqarray8_csr.zf(utra::irqarray8::EV_ENABLE_SOURCE0, bar); + baz |= irqarray8_csr.ms(utra::irqarray8::EV_ENABLE_SOURCE0, 1); + irqarray8_csr.wfo(utra::irqarray8::EV_ENABLE_SOURCE0, baz); + let bar = irqarray8_csr.rf(utra::irqarray8::EV_ENABLE_SOURCE1); + irqarray8_csr.rmwf(utra::irqarray8::EV_ENABLE_SOURCE1, bar); + let mut baz = irqarray8_csr.zf(utra::irqarray8::EV_ENABLE_SOURCE1, bar); + baz |= irqarray8_csr.ms(utra::irqarray8::EV_ENABLE_SOURCE1, 1); + irqarray8_csr.wfo(utra::irqarray8::EV_ENABLE_SOURCE1, baz); + let bar = irqarray8_csr.rf(utra::irqarray8::EV_ENABLE_SOURCE2); + irqarray8_csr.rmwf(utra::irqarray8::EV_ENABLE_SOURCE2, bar); + let mut baz = irqarray8_csr.zf(utra::irqarray8::EV_ENABLE_SOURCE2, bar); + baz |= irqarray8_csr.ms(utra::irqarray8::EV_ENABLE_SOURCE2, 1); + irqarray8_csr.wfo(utra::irqarray8::EV_ENABLE_SOURCE2, baz); + let bar = irqarray8_csr.rf(utra::irqarray8::EV_ENABLE_SOURCE3); + irqarray8_csr.rmwf(utra::irqarray8::EV_ENABLE_SOURCE3, bar); + let mut baz = irqarray8_csr.zf(utra::irqarray8::EV_ENABLE_SOURCE3, bar); + baz |= irqarray8_csr.ms(utra::irqarray8::EV_ENABLE_SOURCE3, 1); + irqarray8_csr.wfo(utra::irqarray8::EV_ENABLE_SOURCE3, baz); + let bar = irqarray8_csr.rf(utra::irqarray8::EV_ENABLE_SOURCE4); + irqarray8_csr.rmwf(utra::irqarray8::EV_ENABLE_SOURCE4, bar); + let mut baz = irqarray8_csr.zf(utra::irqarray8::EV_ENABLE_SOURCE4, bar); + baz |= irqarray8_csr.ms(utra::irqarray8::EV_ENABLE_SOURCE4, 1); + irqarray8_csr.wfo(utra::irqarray8::EV_ENABLE_SOURCE4, baz); + let bar = irqarray8_csr.rf(utra::irqarray8::EV_ENABLE_SOURCE5); + irqarray8_csr.rmwf(utra::irqarray8::EV_ENABLE_SOURCE5, bar); + let mut baz = irqarray8_csr.zf(utra::irqarray8::EV_ENABLE_SOURCE5, bar); + baz |= irqarray8_csr.ms(utra::irqarray8::EV_ENABLE_SOURCE5, 1); + irqarray8_csr.wfo(utra::irqarray8::EV_ENABLE_SOURCE5, baz); + let bar = irqarray8_csr.rf(utra::irqarray8::EV_ENABLE_SOURCE6); + irqarray8_csr.rmwf(utra::irqarray8::EV_ENABLE_SOURCE6, bar); + let mut baz = irqarray8_csr.zf(utra::irqarray8::EV_ENABLE_SOURCE6, bar); + baz |= irqarray8_csr.ms(utra::irqarray8::EV_ENABLE_SOURCE6, 1); + irqarray8_csr.wfo(utra::irqarray8::EV_ENABLE_SOURCE6, baz); + let bar = irqarray8_csr.rf(utra::irqarray8::EV_ENABLE_SOURCE7); + irqarray8_csr.rmwf(utra::irqarray8::EV_ENABLE_SOURCE7, bar); + let mut baz = irqarray8_csr.zf(utra::irqarray8::EV_ENABLE_SOURCE7, bar); + baz |= irqarray8_csr.ms(utra::irqarray8::EV_ENABLE_SOURCE7, 1); + irqarray8_csr.wfo(utra::irqarray8::EV_ENABLE_SOURCE7, baz); + let bar = irqarray8_csr.rf(utra::irqarray8::EV_ENABLE_SOURCE8); + irqarray8_csr.rmwf(utra::irqarray8::EV_ENABLE_SOURCE8, bar); + let mut baz = irqarray8_csr.zf(utra::irqarray8::EV_ENABLE_SOURCE8, bar); + baz |= irqarray8_csr.ms(utra::irqarray8::EV_ENABLE_SOURCE8, 1); + irqarray8_csr.wfo(utra::irqarray8::EV_ENABLE_SOURCE8, baz); + let bar = irqarray8_csr.rf(utra::irqarray8::EV_ENABLE_SOURCE9); + irqarray8_csr.rmwf(utra::irqarray8::EV_ENABLE_SOURCE9, bar); + let mut baz = irqarray8_csr.zf(utra::irqarray8::EV_ENABLE_SOURCE9, bar); + baz |= irqarray8_csr.ms(utra::irqarray8::EV_ENABLE_SOURCE9, 1); + irqarray8_csr.wfo(utra::irqarray8::EV_ENABLE_SOURCE9, baz); + let bar = irqarray8_csr.rf(utra::irqarray8::EV_ENABLE_SOURCE10); + irqarray8_csr.rmwf(utra::irqarray8::EV_ENABLE_SOURCE10, bar); + let mut baz = irqarray8_csr.zf(utra::irqarray8::EV_ENABLE_SOURCE10, bar); + baz |= irqarray8_csr.ms(utra::irqarray8::EV_ENABLE_SOURCE10, 1); + irqarray8_csr.wfo(utra::irqarray8::EV_ENABLE_SOURCE10, baz); + let bar = irqarray8_csr.rf(utra::irqarray8::EV_ENABLE_SOURCE11); + irqarray8_csr.rmwf(utra::irqarray8::EV_ENABLE_SOURCE11, bar); + let mut baz = irqarray8_csr.zf(utra::irqarray8::EV_ENABLE_SOURCE11, bar); + baz |= irqarray8_csr.ms(utra::irqarray8::EV_ENABLE_SOURCE11, 1); + irqarray8_csr.wfo(utra::irqarray8::EV_ENABLE_SOURCE11, baz); + let bar = irqarray8_csr.rf(utra::irqarray8::EV_ENABLE_SOURCE12); + irqarray8_csr.rmwf(utra::irqarray8::EV_ENABLE_SOURCE12, bar); + let mut baz = irqarray8_csr.zf(utra::irqarray8::EV_ENABLE_SOURCE12, bar); + baz |= irqarray8_csr.ms(utra::irqarray8::EV_ENABLE_SOURCE12, 1); + irqarray8_csr.wfo(utra::irqarray8::EV_ENABLE_SOURCE12, baz); + let bar = irqarray8_csr.rf(utra::irqarray8::EV_ENABLE_SOURCE13); + irqarray8_csr.rmwf(utra::irqarray8::EV_ENABLE_SOURCE13, bar); + let mut baz = irqarray8_csr.zf(utra::irqarray8::EV_ENABLE_SOURCE13, bar); + baz |= irqarray8_csr.ms(utra::irqarray8::EV_ENABLE_SOURCE13, 1); + irqarray8_csr.wfo(utra::irqarray8::EV_ENABLE_SOURCE13, baz); + let bar = irqarray8_csr.rf(utra::irqarray8::EV_ENABLE_SOURCE14); + irqarray8_csr.rmwf(utra::irqarray8::EV_ENABLE_SOURCE14, bar); + let mut baz = irqarray8_csr.zf(utra::irqarray8::EV_ENABLE_SOURCE14, bar); + baz |= irqarray8_csr.ms(utra::irqarray8::EV_ENABLE_SOURCE14, 1); + irqarray8_csr.wfo(utra::irqarray8::EV_ENABLE_SOURCE14, baz); + let bar = irqarray8_csr.rf(utra::irqarray8::EV_ENABLE_SOURCE15); + irqarray8_csr.rmwf(utra::irqarray8::EV_ENABLE_SOURCE15, bar); + let mut baz = irqarray8_csr.zf(utra::irqarray8::EV_ENABLE_SOURCE15, bar); + baz |= irqarray8_csr.ms(utra::irqarray8::EV_ENABLE_SOURCE15, 1); + irqarray8_csr.wfo(utra::irqarray8::EV_ENABLE_SOURCE15, baz); + let bar = irqarray8_csr.rf(utra::irqarray8::EV_ENABLE_SOURCE16); + irqarray8_csr.rmwf(utra::irqarray8::EV_ENABLE_SOURCE16, bar); + let mut baz = irqarray8_csr.zf(utra::irqarray8::EV_ENABLE_SOURCE16, bar); + baz |= irqarray8_csr.ms(utra::irqarray8::EV_ENABLE_SOURCE16, 1); + irqarray8_csr.wfo(utra::irqarray8::EV_ENABLE_SOURCE16, baz); + let bar = irqarray8_csr.rf(utra::irqarray8::EV_ENABLE_SOURCE17); + irqarray8_csr.rmwf(utra::irqarray8::EV_ENABLE_SOURCE17, bar); + let mut baz = irqarray8_csr.zf(utra::irqarray8::EV_ENABLE_SOURCE17, bar); + baz |= irqarray8_csr.ms(utra::irqarray8::EV_ENABLE_SOURCE17, 1); + irqarray8_csr.wfo(utra::irqarray8::EV_ENABLE_SOURCE17, baz); + let bar = irqarray8_csr.rf(utra::irqarray8::EV_ENABLE_SOURCE18); + irqarray8_csr.rmwf(utra::irqarray8::EV_ENABLE_SOURCE18, bar); + let mut baz = irqarray8_csr.zf(utra::irqarray8::EV_ENABLE_SOURCE18, bar); + baz |= irqarray8_csr.ms(utra::irqarray8::EV_ENABLE_SOURCE18, 1); + irqarray8_csr.wfo(utra::irqarray8::EV_ENABLE_SOURCE18, baz); + let bar = irqarray8_csr.rf(utra::irqarray8::EV_ENABLE_SOURCE19); + irqarray8_csr.rmwf(utra::irqarray8::EV_ENABLE_SOURCE19, bar); + let mut baz = irqarray8_csr.zf(utra::irqarray8::EV_ENABLE_SOURCE19, bar); + baz |= irqarray8_csr.ms(utra::irqarray8::EV_ENABLE_SOURCE19, 1); + irqarray8_csr.wfo(utra::irqarray8::EV_ENABLE_SOURCE19, baz); + } + + #[test] + #[ignore] + fn compile_check_irqarray9_csr() { + use super::*; + let mut irqarray9_csr = CSR::new(HW_IRQARRAY9_BASE as *mut u32); + + let foo = irqarray9_csr.r(utra::irqarray9::EV_SOFT); + irqarray9_csr.wo(utra::irqarray9::EV_SOFT, foo); + let bar = irqarray9_csr.rf(utra::irqarray9::EV_SOFT_TRIGGER); + irqarray9_csr.rmwf(utra::irqarray9::EV_SOFT_TRIGGER, bar); + let mut baz = irqarray9_csr.zf(utra::irqarray9::EV_SOFT_TRIGGER, bar); + baz |= irqarray9_csr.ms(utra::irqarray9::EV_SOFT_TRIGGER, 1); + irqarray9_csr.wfo(utra::irqarray9::EV_SOFT_TRIGGER, baz); + + let foo = irqarray9_csr.r(utra::irqarray9::EV_STATUS); + irqarray9_csr.wo(utra::irqarray9::EV_STATUS, foo); + let bar = irqarray9_csr.rf(utra::irqarray9::EV_STATUS_SOURCE0); + irqarray9_csr.rmwf(utra::irqarray9::EV_STATUS_SOURCE0, bar); + let mut baz = irqarray9_csr.zf(utra::irqarray9::EV_STATUS_SOURCE0, bar); + baz |= irqarray9_csr.ms(utra::irqarray9::EV_STATUS_SOURCE0, 1); + irqarray9_csr.wfo(utra::irqarray9::EV_STATUS_SOURCE0, baz); + let bar = irqarray9_csr.rf(utra::irqarray9::EV_STATUS_SOURCE1); + irqarray9_csr.rmwf(utra::irqarray9::EV_STATUS_SOURCE1, bar); + let mut baz = irqarray9_csr.zf(utra::irqarray9::EV_STATUS_SOURCE1, bar); + baz |= irqarray9_csr.ms(utra::irqarray9::EV_STATUS_SOURCE1, 1); + irqarray9_csr.wfo(utra::irqarray9::EV_STATUS_SOURCE1, baz); + let bar = irqarray9_csr.rf(utra::irqarray9::EV_STATUS_SOURCE2); + irqarray9_csr.rmwf(utra::irqarray9::EV_STATUS_SOURCE2, bar); + let mut baz = irqarray9_csr.zf(utra::irqarray9::EV_STATUS_SOURCE2, bar); + baz |= irqarray9_csr.ms(utra::irqarray9::EV_STATUS_SOURCE2, 1); + irqarray9_csr.wfo(utra::irqarray9::EV_STATUS_SOURCE2, baz); + let bar = irqarray9_csr.rf(utra::irqarray9::EV_STATUS_SOURCE3); + irqarray9_csr.rmwf(utra::irqarray9::EV_STATUS_SOURCE3, bar); + let mut baz = irqarray9_csr.zf(utra::irqarray9::EV_STATUS_SOURCE3, bar); + baz |= irqarray9_csr.ms(utra::irqarray9::EV_STATUS_SOURCE3, 1); + irqarray9_csr.wfo(utra::irqarray9::EV_STATUS_SOURCE3, baz); + let bar = irqarray9_csr.rf(utra::irqarray9::EV_STATUS_SOURCE4); + irqarray9_csr.rmwf(utra::irqarray9::EV_STATUS_SOURCE4, bar); + let mut baz = irqarray9_csr.zf(utra::irqarray9::EV_STATUS_SOURCE4, bar); + baz |= irqarray9_csr.ms(utra::irqarray9::EV_STATUS_SOURCE4, 1); + irqarray9_csr.wfo(utra::irqarray9::EV_STATUS_SOURCE4, baz); + let bar = irqarray9_csr.rf(utra::irqarray9::EV_STATUS_SOURCE5); + irqarray9_csr.rmwf(utra::irqarray9::EV_STATUS_SOURCE5, bar); + let mut baz = irqarray9_csr.zf(utra::irqarray9::EV_STATUS_SOURCE5, bar); + baz |= irqarray9_csr.ms(utra::irqarray9::EV_STATUS_SOURCE5, 1); + irqarray9_csr.wfo(utra::irqarray9::EV_STATUS_SOURCE5, baz); + let bar = irqarray9_csr.rf(utra::irqarray9::EV_STATUS_SOURCE6); + irqarray9_csr.rmwf(utra::irqarray9::EV_STATUS_SOURCE6, bar); + let mut baz = irqarray9_csr.zf(utra::irqarray9::EV_STATUS_SOURCE6, bar); + baz |= irqarray9_csr.ms(utra::irqarray9::EV_STATUS_SOURCE6, 1); + irqarray9_csr.wfo(utra::irqarray9::EV_STATUS_SOURCE6, baz); + let bar = irqarray9_csr.rf(utra::irqarray9::EV_STATUS_SOURCE7); + irqarray9_csr.rmwf(utra::irqarray9::EV_STATUS_SOURCE7, bar); + let mut baz = irqarray9_csr.zf(utra::irqarray9::EV_STATUS_SOURCE7, bar); + baz |= irqarray9_csr.ms(utra::irqarray9::EV_STATUS_SOURCE7, 1); + irqarray9_csr.wfo(utra::irqarray9::EV_STATUS_SOURCE7, baz); + let bar = irqarray9_csr.rf(utra::irqarray9::EV_STATUS_SOURCE8); + irqarray9_csr.rmwf(utra::irqarray9::EV_STATUS_SOURCE8, bar); + let mut baz = irqarray9_csr.zf(utra::irqarray9::EV_STATUS_SOURCE8, bar); + baz |= irqarray9_csr.ms(utra::irqarray9::EV_STATUS_SOURCE8, 1); + irqarray9_csr.wfo(utra::irqarray9::EV_STATUS_SOURCE8, baz); + let bar = irqarray9_csr.rf(utra::irqarray9::EV_STATUS_SOURCE9); + irqarray9_csr.rmwf(utra::irqarray9::EV_STATUS_SOURCE9, bar); + let mut baz = irqarray9_csr.zf(utra::irqarray9::EV_STATUS_SOURCE9, bar); + baz |= irqarray9_csr.ms(utra::irqarray9::EV_STATUS_SOURCE9, 1); + irqarray9_csr.wfo(utra::irqarray9::EV_STATUS_SOURCE9, baz); + let bar = irqarray9_csr.rf(utra::irqarray9::EV_STATUS_SOURCE10); + irqarray9_csr.rmwf(utra::irqarray9::EV_STATUS_SOURCE10, bar); + let mut baz = irqarray9_csr.zf(utra::irqarray9::EV_STATUS_SOURCE10, bar); + baz |= irqarray9_csr.ms(utra::irqarray9::EV_STATUS_SOURCE10, 1); + irqarray9_csr.wfo(utra::irqarray9::EV_STATUS_SOURCE10, baz); + let bar = irqarray9_csr.rf(utra::irqarray9::EV_STATUS_SOURCE11); + irqarray9_csr.rmwf(utra::irqarray9::EV_STATUS_SOURCE11, bar); + let mut baz = irqarray9_csr.zf(utra::irqarray9::EV_STATUS_SOURCE11, bar); + baz |= irqarray9_csr.ms(utra::irqarray9::EV_STATUS_SOURCE11, 1); + irqarray9_csr.wfo(utra::irqarray9::EV_STATUS_SOURCE11, baz); + let bar = irqarray9_csr.rf(utra::irqarray9::EV_STATUS_SOURCE12); + irqarray9_csr.rmwf(utra::irqarray9::EV_STATUS_SOURCE12, bar); + let mut baz = irqarray9_csr.zf(utra::irqarray9::EV_STATUS_SOURCE12, bar); + baz |= irqarray9_csr.ms(utra::irqarray9::EV_STATUS_SOURCE12, 1); + irqarray9_csr.wfo(utra::irqarray9::EV_STATUS_SOURCE12, baz); + let bar = irqarray9_csr.rf(utra::irqarray9::EV_STATUS_SOURCE13); + irqarray9_csr.rmwf(utra::irqarray9::EV_STATUS_SOURCE13, bar); + let mut baz = irqarray9_csr.zf(utra::irqarray9::EV_STATUS_SOURCE13, bar); + baz |= irqarray9_csr.ms(utra::irqarray9::EV_STATUS_SOURCE13, 1); + irqarray9_csr.wfo(utra::irqarray9::EV_STATUS_SOURCE13, baz); + let bar = irqarray9_csr.rf(utra::irqarray9::EV_STATUS_SOURCE14); + irqarray9_csr.rmwf(utra::irqarray9::EV_STATUS_SOURCE14, bar); + let mut baz = irqarray9_csr.zf(utra::irqarray9::EV_STATUS_SOURCE14, bar); + baz |= irqarray9_csr.ms(utra::irqarray9::EV_STATUS_SOURCE14, 1); + irqarray9_csr.wfo(utra::irqarray9::EV_STATUS_SOURCE14, baz); + let bar = irqarray9_csr.rf(utra::irqarray9::EV_STATUS_SOURCE15); + irqarray9_csr.rmwf(utra::irqarray9::EV_STATUS_SOURCE15, bar); + let mut baz = irqarray9_csr.zf(utra::irqarray9::EV_STATUS_SOURCE15, bar); + baz |= irqarray9_csr.ms(utra::irqarray9::EV_STATUS_SOURCE15, 1); + irqarray9_csr.wfo(utra::irqarray9::EV_STATUS_SOURCE15, baz); + let bar = irqarray9_csr.rf(utra::irqarray9::EV_STATUS_SOURCE16); + irqarray9_csr.rmwf(utra::irqarray9::EV_STATUS_SOURCE16, bar); + let mut baz = irqarray9_csr.zf(utra::irqarray9::EV_STATUS_SOURCE16, bar); + baz |= irqarray9_csr.ms(utra::irqarray9::EV_STATUS_SOURCE16, 1); + irqarray9_csr.wfo(utra::irqarray9::EV_STATUS_SOURCE16, baz); + let bar = irqarray9_csr.rf(utra::irqarray9::EV_STATUS_SOURCE17); + irqarray9_csr.rmwf(utra::irqarray9::EV_STATUS_SOURCE17, bar); + let mut baz = irqarray9_csr.zf(utra::irqarray9::EV_STATUS_SOURCE17, bar); + baz |= irqarray9_csr.ms(utra::irqarray9::EV_STATUS_SOURCE17, 1); + irqarray9_csr.wfo(utra::irqarray9::EV_STATUS_SOURCE17, baz); + let bar = irqarray9_csr.rf(utra::irqarray9::EV_STATUS_SOURCE18); + irqarray9_csr.rmwf(utra::irqarray9::EV_STATUS_SOURCE18, bar); + let mut baz = irqarray9_csr.zf(utra::irqarray9::EV_STATUS_SOURCE18, bar); + baz |= irqarray9_csr.ms(utra::irqarray9::EV_STATUS_SOURCE18, 1); + irqarray9_csr.wfo(utra::irqarray9::EV_STATUS_SOURCE18, baz); + let bar = irqarray9_csr.rf(utra::irqarray9::EV_STATUS_SOURCE19); + irqarray9_csr.rmwf(utra::irqarray9::EV_STATUS_SOURCE19, bar); + let mut baz = irqarray9_csr.zf(utra::irqarray9::EV_STATUS_SOURCE19, bar); + baz |= irqarray9_csr.ms(utra::irqarray9::EV_STATUS_SOURCE19, 1); + irqarray9_csr.wfo(utra::irqarray9::EV_STATUS_SOURCE19, baz); + + let foo = irqarray9_csr.r(utra::irqarray9::EV_PENDING); + irqarray9_csr.wo(utra::irqarray9::EV_PENDING, foo); + let bar = irqarray9_csr.rf(utra::irqarray9::EV_PENDING_SOURCE0); + irqarray9_csr.rmwf(utra::irqarray9::EV_PENDING_SOURCE0, bar); + let mut baz = irqarray9_csr.zf(utra::irqarray9::EV_PENDING_SOURCE0, bar); + baz |= irqarray9_csr.ms(utra::irqarray9::EV_PENDING_SOURCE0, 1); + irqarray9_csr.wfo(utra::irqarray9::EV_PENDING_SOURCE0, baz); + let bar = irqarray9_csr.rf(utra::irqarray9::EV_PENDING_SOURCE1); + irqarray9_csr.rmwf(utra::irqarray9::EV_PENDING_SOURCE1, bar); + let mut baz = irqarray9_csr.zf(utra::irqarray9::EV_PENDING_SOURCE1, bar); + baz |= irqarray9_csr.ms(utra::irqarray9::EV_PENDING_SOURCE1, 1); + irqarray9_csr.wfo(utra::irqarray9::EV_PENDING_SOURCE1, baz); + let bar = irqarray9_csr.rf(utra::irqarray9::EV_PENDING_SOURCE2); + irqarray9_csr.rmwf(utra::irqarray9::EV_PENDING_SOURCE2, bar); + let mut baz = irqarray9_csr.zf(utra::irqarray9::EV_PENDING_SOURCE2, bar); + baz |= irqarray9_csr.ms(utra::irqarray9::EV_PENDING_SOURCE2, 1); + irqarray9_csr.wfo(utra::irqarray9::EV_PENDING_SOURCE2, baz); + let bar = irqarray9_csr.rf(utra::irqarray9::EV_PENDING_SOURCE3); + irqarray9_csr.rmwf(utra::irqarray9::EV_PENDING_SOURCE3, bar); + let mut baz = irqarray9_csr.zf(utra::irqarray9::EV_PENDING_SOURCE3, bar); + baz |= irqarray9_csr.ms(utra::irqarray9::EV_PENDING_SOURCE3, 1); + irqarray9_csr.wfo(utra::irqarray9::EV_PENDING_SOURCE3, baz); + let bar = irqarray9_csr.rf(utra::irqarray9::EV_PENDING_SOURCE4); + irqarray9_csr.rmwf(utra::irqarray9::EV_PENDING_SOURCE4, bar); + let mut baz = irqarray9_csr.zf(utra::irqarray9::EV_PENDING_SOURCE4, bar); + baz |= irqarray9_csr.ms(utra::irqarray9::EV_PENDING_SOURCE4, 1); + irqarray9_csr.wfo(utra::irqarray9::EV_PENDING_SOURCE4, baz); + let bar = irqarray9_csr.rf(utra::irqarray9::EV_PENDING_SOURCE5); + irqarray9_csr.rmwf(utra::irqarray9::EV_PENDING_SOURCE5, bar); + let mut baz = irqarray9_csr.zf(utra::irqarray9::EV_PENDING_SOURCE5, bar); + baz |= irqarray9_csr.ms(utra::irqarray9::EV_PENDING_SOURCE5, 1); + irqarray9_csr.wfo(utra::irqarray9::EV_PENDING_SOURCE5, baz); + let bar = irqarray9_csr.rf(utra::irqarray9::EV_PENDING_SOURCE6); + irqarray9_csr.rmwf(utra::irqarray9::EV_PENDING_SOURCE6, bar); + let mut baz = irqarray9_csr.zf(utra::irqarray9::EV_PENDING_SOURCE6, bar); + baz |= irqarray9_csr.ms(utra::irqarray9::EV_PENDING_SOURCE6, 1); + irqarray9_csr.wfo(utra::irqarray9::EV_PENDING_SOURCE6, baz); + let bar = irqarray9_csr.rf(utra::irqarray9::EV_PENDING_SOURCE7); + irqarray9_csr.rmwf(utra::irqarray9::EV_PENDING_SOURCE7, bar); + let mut baz = irqarray9_csr.zf(utra::irqarray9::EV_PENDING_SOURCE7, bar); + baz |= irqarray9_csr.ms(utra::irqarray9::EV_PENDING_SOURCE7, 1); + irqarray9_csr.wfo(utra::irqarray9::EV_PENDING_SOURCE7, baz); + let bar = irqarray9_csr.rf(utra::irqarray9::EV_PENDING_SOURCE8); + irqarray9_csr.rmwf(utra::irqarray9::EV_PENDING_SOURCE8, bar); + let mut baz = irqarray9_csr.zf(utra::irqarray9::EV_PENDING_SOURCE8, bar); + baz |= irqarray9_csr.ms(utra::irqarray9::EV_PENDING_SOURCE8, 1); + irqarray9_csr.wfo(utra::irqarray9::EV_PENDING_SOURCE8, baz); + let bar = irqarray9_csr.rf(utra::irqarray9::EV_PENDING_SOURCE9); + irqarray9_csr.rmwf(utra::irqarray9::EV_PENDING_SOURCE9, bar); + let mut baz = irqarray9_csr.zf(utra::irqarray9::EV_PENDING_SOURCE9, bar); + baz |= irqarray9_csr.ms(utra::irqarray9::EV_PENDING_SOURCE9, 1); + irqarray9_csr.wfo(utra::irqarray9::EV_PENDING_SOURCE9, baz); + let bar = irqarray9_csr.rf(utra::irqarray9::EV_PENDING_SOURCE10); + irqarray9_csr.rmwf(utra::irqarray9::EV_PENDING_SOURCE10, bar); + let mut baz = irqarray9_csr.zf(utra::irqarray9::EV_PENDING_SOURCE10, bar); + baz |= irqarray9_csr.ms(utra::irqarray9::EV_PENDING_SOURCE10, 1); + irqarray9_csr.wfo(utra::irqarray9::EV_PENDING_SOURCE10, baz); + let bar = irqarray9_csr.rf(utra::irqarray9::EV_PENDING_SOURCE11); + irqarray9_csr.rmwf(utra::irqarray9::EV_PENDING_SOURCE11, bar); + let mut baz = irqarray9_csr.zf(utra::irqarray9::EV_PENDING_SOURCE11, bar); + baz |= irqarray9_csr.ms(utra::irqarray9::EV_PENDING_SOURCE11, 1); + irqarray9_csr.wfo(utra::irqarray9::EV_PENDING_SOURCE11, baz); + let bar = irqarray9_csr.rf(utra::irqarray9::EV_PENDING_SOURCE12); + irqarray9_csr.rmwf(utra::irqarray9::EV_PENDING_SOURCE12, bar); + let mut baz = irqarray9_csr.zf(utra::irqarray9::EV_PENDING_SOURCE12, bar); + baz |= irqarray9_csr.ms(utra::irqarray9::EV_PENDING_SOURCE12, 1); + irqarray9_csr.wfo(utra::irqarray9::EV_PENDING_SOURCE12, baz); + let bar = irqarray9_csr.rf(utra::irqarray9::EV_PENDING_SOURCE13); + irqarray9_csr.rmwf(utra::irqarray9::EV_PENDING_SOURCE13, bar); + let mut baz = irqarray9_csr.zf(utra::irqarray9::EV_PENDING_SOURCE13, bar); + baz |= irqarray9_csr.ms(utra::irqarray9::EV_PENDING_SOURCE13, 1); + irqarray9_csr.wfo(utra::irqarray9::EV_PENDING_SOURCE13, baz); + let bar = irqarray9_csr.rf(utra::irqarray9::EV_PENDING_SOURCE14); + irqarray9_csr.rmwf(utra::irqarray9::EV_PENDING_SOURCE14, bar); + let mut baz = irqarray9_csr.zf(utra::irqarray9::EV_PENDING_SOURCE14, bar); + baz |= irqarray9_csr.ms(utra::irqarray9::EV_PENDING_SOURCE14, 1); + irqarray9_csr.wfo(utra::irqarray9::EV_PENDING_SOURCE14, baz); + let bar = irqarray9_csr.rf(utra::irqarray9::EV_PENDING_SOURCE15); + irqarray9_csr.rmwf(utra::irqarray9::EV_PENDING_SOURCE15, bar); + let mut baz = irqarray9_csr.zf(utra::irqarray9::EV_PENDING_SOURCE15, bar); + baz |= irqarray9_csr.ms(utra::irqarray9::EV_PENDING_SOURCE15, 1); + irqarray9_csr.wfo(utra::irqarray9::EV_PENDING_SOURCE15, baz); + let bar = irqarray9_csr.rf(utra::irqarray9::EV_PENDING_SOURCE16); + irqarray9_csr.rmwf(utra::irqarray9::EV_PENDING_SOURCE16, bar); + let mut baz = irqarray9_csr.zf(utra::irqarray9::EV_PENDING_SOURCE16, bar); + baz |= irqarray9_csr.ms(utra::irqarray9::EV_PENDING_SOURCE16, 1); + irqarray9_csr.wfo(utra::irqarray9::EV_PENDING_SOURCE16, baz); + let bar = irqarray9_csr.rf(utra::irqarray9::EV_PENDING_SOURCE17); + irqarray9_csr.rmwf(utra::irqarray9::EV_PENDING_SOURCE17, bar); + let mut baz = irqarray9_csr.zf(utra::irqarray9::EV_PENDING_SOURCE17, bar); + baz |= irqarray9_csr.ms(utra::irqarray9::EV_PENDING_SOURCE17, 1); + irqarray9_csr.wfo(utra::irqarray9::EV_PENDING_SOURCE17, baz); + let bar = irqarray9_csr.rf(utra::irqarray9::EV_PENDING_SOURCE18); + irqarray9_csr.rmwf(utra::irqarray9::EV_PENDING_SOURCE18, bar); + let mut baz = irqarray9_csr.zf(utra::irqarray9::EV_PENDING_SOURCE18, bar); + baz |= irqarray9_csr.ms(utra::irqarray9::EV_PENDING_SOURCE18, 1); + irqarray9_csr.wfo(utra::irqarray9::EV_PENDING_SOURCE18, baz); + let bar = irqarray9_csr.rf(utra::irqarray9::EV_PENDING_SOURCE19); + irqarray9_csr.rmwf(utra::irqarray9::EV_PENDING_SOURCE19, bar); + let mut baz = irqarray9_csr.zf(utra::irqarray9::EV_PENDING_SOURCE19, bar); + baz |= irqarray9_csr.ms(utra::irqarray9::EV_PENDING_SOURCE19, 1); + irqarray9_csr.wfo(utra::irqarray9::EV_PENDING_SOURCE19, baz); + + let foo = irqarray9_csr.r(utra::irqarray9::EV_ENABLE); + irqarray9_csr.wo(utra::irqarray9::EV_ENABLE, foo); + let bar = irqarray9_csr.rf(utra::irqarray9::EV_ENABLE_SOURCE0); + irqarray9_csr.rmwf(utra::irqarray9::EV_ENABLE_SOURCE0, bar); + let mut baz = irqarray9_csr.zf(utra::irqarray9::EV_ENABLE_SOURCE0, bar); + baz |= irqarray9_csr.ms(utra::irqarray9::EV_ENABLE_SOURCE0, 1); + irqarray9_csr.wfo(utra::irqarray9::EV_ENABLE_SOURCE0, baz); + let bar = irqarray9_csr.rf(utra::irqarray9::EV_ENABLE_SOURCE1); + irqarray9_csr.rmwf(utra::irqarray9::EV_ENABLE_SOURCE1, bar); + let mut baz = irqarray9_csr.zf(utra::irqarray9::EV_ENABLE_SOURCE1, bar); + baz |= irqarray9_csr.ms(utra::irqarray9::EV_ENABLE_SOURCE1, 1); + irqarray9_csr.wfo(utra::irqarray9::EV_ENABLE_SOURCE1, baz); + let bar = irqarray9_csr.rf(utra::irqarray9::EV_ENABLE_SOURCE2); + irqarray9_csr.rmwf(utra::irqarray9::EV_ENABLE_SOURCE2, bar); + let mut baz = irqarray9_csr.zf(utra::irqarray9::EV_ENABLE_SOURCE2, bar); + baz |= irqarray9_csr.ms(utra::irqarray9::EV_ENABLE_SOURCE2, 1); + irqarray9_csr.wfo(utra::irqarray9::EV_ENABLE_SOURCE2, baz); + let bar = irqarray9_csr.rf(utra::irqarray9::EV_ENABLE_SOURCE3); + irqarray9_csr.rmwf(utra::irqarray9::EV_ENABLE_SOURCE3, bar); + let mut baz = irqarray9_csr.zf(utra::irqarray9::EV_ENABLE_SOURCE3, bar); + baz |= irqarray9_csr.ms(utra::irqarray9::EV_ENABLE_SOURCE3, 1); + irqarray9_csr.wfo(utra::irqarray9::EV_ENABLE_SOURCE3, baz); + let bar = irqarray9_csr.rf(utra::irqarray9::EV_ENABLE_SOURCE4); + irqarray9_csr.rmwf(utra::irqarray9::EV_ENABLE_SOURCE4, bar); + let mut baz = irqarray9_csr.zf(utra::irqarray9::EV_ENABLE_SOURCE4, bar); + baz |= irqarray9_csr.ms(utra::irqarray9::EV_ENABLE_SOURCE4, 1); + irqarray9_csr.wfo(utra::irqarray9::EV_ENABLE_SOURCE4, baz); + let bar = irqarray9_csr.rf(utra::irqarray9::EV_ENABLE_SOURCE5); + irqarray9_csr.rmwf(utra::irqarray9::EV_ENABLE_SOURCE5, bar); + let mut baz = irqarray9_csr.zf(utra::irqarray9::EV_ENABLE_SOURCE5, bar); + baz |= irqarray9_csr.ms(utra::irqarray9::EV_ENABLE_SOURCE5, 1); + irqarray9_csr.wfo(utra::irqarray9::EV_ENABLE_SOURCE5, baz); + let bar = irqarray9_csr.rf(utra::irqarray9::EV_ENABLE_SOURCE6); + irqarray9_csr.rmwf(utra::irqarray9::EV_ENABLE_SOURCE6, bar); + let mut baz = irqarray9_csr.zf(utra::irqarray9::EV_ENABLE_SOURCE6, bar); + baz |= irqarray9_csr.ms(utra::irqarray9::EV_ENABLE_SOURCE6, 1); + irqarray9_csr.wfo(utra::irqarray9::EV_ENABLE_SOURCE6, baz); + let bar = irqarray9_csr.rf(utra::irqarray9::EV_ENABLE_SOURCE7); + irqarray9_csr.rmwf(utra::irqarray9::EV_ENABLE_SOURCE7, bar); + let mut baz = irqarray9_csr.zf(utra::irqarray9::EV_ENABLE_SOURCE7, bar); + baz |= irqarray9_csr.ms(utra::irqarray9::EV_ENABLE_SOURCE7, 1); + irqarray9_csr.wfo(utra::irqarray9::EV_ENABLE_SOURCE7, baz); + let bar = irqarray9_csr.rf(utra::irqarray9::EV_ENABLE_SOURCE8); + irqarray9_csr.rmwf(utra::irqarray9::EV_ENABLE_SOURCE8, bar); + let mut baz = irqarray9_csr.zf(utra::irqarray9::EV_ENABLE_SOURCE8, bar); + baz |= irqarray9_csr.ms(utra::irqarray9::EV_ENABLE_SOURCE8, 1); + irqarray9_csr.wfo(utra::irqarray9::EV_ENABLE_SOURCE8, baz); + let bar = irqarray9_csr.rf(utra::irqarray9::EV_ENABLE_SOURCE9); + irqarray9_csr.rmwf(utra::irqarray9::EV_ENABLE_SOURCE9, bar); + let mut baz = irqarray9_csr.zf(utra::irqarray9::EV_ENABLE_SOURCE9, bar); + baz |= irqarray9_csr.ms(utra::irqarray9::EV_ENABLE_SOURCE9, 1); + irqarray9_csr.wfo(utra::irqarray9::EV_ENABLE_SOURCE9, baz); + let bar = irqarray9_csr.rf(utra::irqarray9::EV_ENABLE_SOURCE10); + irqarray9_csr.rmwf(utra::irqarray9::EV_ENABLE_SOURCE10, bar); + let mut baz = irqarray9_csr.zf(utra::irqarray9::EV_ENABLE_SOURCE10, bar); + baz |= irqarray9_csr.ms(utra::irqarray9::EV_ENABLE_SOURCE10, 1); + irqarray9_csr.wfo(utra::irqarray9::EV_ENABLE_SOURCE10, baz); + let bar = irqarray9_csr.rf(utra::irqarray9::EV_ENABLE_SOURCE11); + irqarray9_csr.rmwf(utra::irqarray9::EV_ENABLE_SOURCE11, bar); + let mut baz = irqarray9_csr.zf(utra::irqarray9::EV_ENABLE_SOURCE11, bar); + baz |= irqarray9_csr.ms(utra::irqarray9::EV_ENABLE_SOURCE11, 1); + irqarray9_csr.wfo(utra::irqarray9::EV_ENABLE_SOURCE11, baz); + let bar = irqarray9_csr.rf(utra::irqarray9::EV_ENABLE_SOURCE12); + irqarray9_csr.rmwf(utra::irqarray9::EV_ENABLE_SOURCE12, bar); + let mut baz = irqarray9_csr.zf(utra::irqarray9::EV_ENABLE_SOURCE12, bar); + baz |= irqarray9_csr.ms(utra::irqarray9::EV_ENABLE_SOURCE12, 1); + irqarray9_csr.wfo(utra::irqarray9::EV_ENABLE_SOURCE12, baz); + let bar = irqarray9_csr.rf(utra::irqarray9::EV_ENABLE_SOURCE13); + irqarray9_csr.rmwf(utra::irqarray9::EV_ENABLE_SOURCE13, bar); + let mut baz = irqarray9_csr.zf(utra::irqarray9::EV_ENABLE_SOURCE13, bar); + baz |= irqarray9_csr.ms(utra::irqarray9::EV_ENABLE_SOURCE13, 1); + irqarray9_csr.wfo(utra::irqarray9::EV_ENABLE_SOURCE13, baz); + let bar = irqarray9_csr.rf(utra::irqarray9::EV_ENABLE_SOURCE14); + irqarray9_csr.rmwf(utra::irqarray9::EV_ENABLE_SOURCE14, bar); + let mut baz = irqarray9_csr.zf(utra::irqarray9::EV_ENABLE_SOURCE14, bar); + baz |= irqarray9_csr.ms(utra::irqarray9::EV_ENABLE_SOURCE14, 1); + irqarray9_csr.wfo(utra::irqarray9::EV_ENABLE_SOURCE14, baz); + let bar = irqarray9_csr.rf(utra::irqarray9::EV_ENABLE_SOURCE15); + irqarray9_csr.rmwf(utra::irqarray9::EV_ENABLE_SOURCE15, bar); + let mut baz = irqarray9_csr.zf(utra::irqarray9::EV_ENABLE_SOURCE15, bar); + baz |= irqarray9_csr.ms(utra::irqarray9::EV_ENABLE_SOURCE15, 1); + irqarray9_csr.wfo(utra::irqarray9::EV_ENABLE_SOURCE15, baz); + let bar = irqarray9_csr.rf(utra::irqarray9::EV_ENABLE_SOURCE16); + irqarray9_csr.rmwf(utra::irqarray9::EV_ENABLE_SOURCE16, bar); + let mut baz = irqarray9_csr.zf(utra::irqarray9::EV_ENABLE_SOURCE16, bar); + baz |= irqarray9_csr.ms(utra::irqarray9::EV_ENABLE_SOURCE16, 1); + irqarray9_csr.wfo(utra::irqarray9::EV_ENABLE_SOURCE16, baz); + let bar = irqarray9_csr.rf(utra::irqarray9::EV_ENABLE_SOURCE17); + irqarray9_csr.rmwf(utra::irqarray9::EV_ENABLE_SOURCE17, bar); + let mut baz = irqarray9_csr.zf(utra::irqarray9::EV_ENABLE_SOURCE17, bar); + baz |= irqarray9_csr.ms(utra::irqarray9::EV_ENABLE_SOURCE17, 1); + irqarray9_csr.wfo(utra::irqarray9::EV_ENABLE_SOURCE17, baz); + let bar = irqarray9_csr.rf(utra::irqarray9::EV_ENABLE_SOURCE18); + irqarray9_csr.rmwf(utra::irqarray9::EV_ENABLE_SOURCE18, bar); + let mut baz = irqarray9_csr.zf(utra::irqarray9::EV_ENABLE_SOURCE18, bar); + baz |= irqarray9_csr.ms(utra::irqarray9::EV_ENABLE_SOURCE18, 1); + irqarray9_csr.wfo(utra::irqarray9::EV_ENABLE_SOURCE18, baz); + let bar = irqarray9_csr.rf(utra::irqarray9::EV_ENABLE_SOURCE19); + irqarray9_csr.rmwf(utra::irqarray9::EV_ENABLE_SOURCE19, bar); + let mut baz = irqarray9_csr.zf(utra::irqarray9::EV_ENABLE_SOURCE19, bar); + baz |= irqarray9_csr.ms(utra::irqarray9::EV_ENABLE_SOURCE19, 1); + irqarray9_csr.wfo(utra::irqarray9::EV_ENABLE_SOURCE19, baz); + } + + #[test] + #[ignore] + fn compile_check_mailbox_csr() { + use super::*; + let mut mailbox_csr = CSR::new(HW_MAILBOX_BASE as *mut u32); + + let foo = mailbox_csr.r(utra::mailbox::WDATA); + mailbox_csr.wo(utra::mailbox::WDATA, foo); + let bar = mailbox_csr.rf(utra::mailbox::WDATA_WDATA); + mailbox_csr.rmwf(utra::mailbox::WDATA_WDATA, bar); + let mut baz = mailbox_csr.zf(utra::mailbox::WDATA_WDATA, bar); + baz |= mailbox_csr.ms(utra::mailbox::WDATA_WDATA, 1); + mailbox_csr.wfo(utra::mailbox::WDATA_WDATA, baz); + + let foo = mailbox_csr.r(utra::mailbox::RDATA); + mailbox_csr.wo(utra::mailbox::RDATA, foo); + let bar = mailbox_csr.rf(utra::mailbox::RDATA_RDATA); + mailbox_csr.rmwf(utra::mailbox::RDATA_RDATA, bar); + let mut baz = mailbox_csr.zf(utra::mailbox::RDATA_RDATA, bar); + baz |= mailbox_csr.ms(utra::mailbox::RDATA_RDATA, 1); + mailbox_csr.wfo(utra::mailbox::RDATA_RDATA, baz); + + let foo = mailbox_csr.r(utra::mailbox::EV_STATUS); + mailbox_csr.wo(utra::mailbox::EV_STATUS, foo); + let bar = mailbox_csr.rf(utra::mailbox::EV_STATUS_AVAILABLE); + mailbox_csr.rmwf(utra::mailbox::EV_STATUS_AVAILABLE, bar); + let mut baz = mailbox_csr.zf(utra::mailbox::EV_STATUS_AVAILABLE, bar); + baz |= mailbox_csr.ms(utra::mailbox::EV_STATUS_AVAILABLE, 1); + mailbox_csr.wfo(utra::mailbox::EV_STATUS_AVAILABLE, baz); + let bar = mailbox_csr.rf(utra::mailbox::EV_STATUS_ABORT_INIT); + mailbox_csr.rmwf(utra::mailbox::EV_STATUS_ABORT_INIT, bar); + let mut baz = mailbox_csr.zf(utra::mailbox::EV_STATUS_ABORT_INIT, bar); + baz |= mailbox_csr.ms(utra::mailbox::EV_STATUS_ABORT_INIT, 1); + mailbox_csr.wfo(utra::mailbox::EV_STATUS_ABORT_INIT, baz); + let bar = mailbox_csr.rf(utra::mailbox::EV_STATUS_ABORT_DONE); + mailbox_csr.rmwf(utra::mailbox::EV_STATUS_ABORT_DONE, bar); + let mut baz = mailbox_csr.zf(utra::mailbox::EV_STATUS_ABORT_DONE, bar); + baz |= mailbox_csr.ms(utra::mailbox::EV_STATUS_ABORT_DONE, 1); + mailbox_csr.wfo(utra::mailbox::EV_STATUS_ABORT_DONE, baz); + let bar = mailbox_csr.rf(utra::mailbox::EV_STATUS_ERROR); + mailbox_csr.rmwf(utra::mailbox::EV_STATUS_ERROR, bar); + let mut baz = mailbox_csr.zf(utra::mailbox::EV_STATUS_ERROR, bar); + baz |= mailbox_csr.ms(utra::mailbox::EV_STATUS_ERROR, 1); + mailbox_csr.wfo(utra::mailbox::EV_STATUS_ERROR, baz); + + let foo = mailbox_csr.r(utra::mailbox::EV_PENDING); + mailbox_csr.wo(utra::mailbox::EV_PENDING, foo); + let bar = mailbox_csr.rf(utra::mailbox::EV_PENDING_AVAILABLE); + mailbox_csr.rmwf(utra::mailbox::EV_PENDING_AVAILABLE, bar); + let mut baz = mailbox_csr.zf(utra::mailbox::EV_PENDING_AVAILABLE, bar); + baz |= mailbox_csr.ms(utra::mailbox::EV_PENDING_AVAILABLE, 1); + mailbox_csr.wfo(utra::mailbox::EV_PENDING_AVAILABLE, baz); + let bar = mailbox_csr.rf(utra::mailbox::EV_PENDING_ABORT_INIT); + mailbox_csr.rmwf(utra::mailbox::EV_PENDING_ABORT_INIT, bar); + let mut baz = mailbox_csr.zf(utra::mailbox::EV_PENDING_ABORT_INIT, bar); + baz |= mailbox_csr.ms(utra::mailbox::EV_PENDING_ABORT_INIT, 1); + mailbox_csr.wfo(utra::mailbox::EV_PENDING_ABORT_INIT, baz); + let bar = mailbox_csr.rf(utra::mailbox::EV_PENDING_ABORT_DONE); + mailbox_csr.rmwf(utra::mailbox::EV_PENDING_ABORT_DONE, bar); + let mut baz = mailbox_csr.zf(utra::mailbox::EV_PENDING_ABORT_DONE, bar); + baz |= mailbox_csr.ms(utra::mailbox::EV_PENDING_ABORT_DONE, 1); + mailbox_csr.wfo(utra::mailbox::EV_PENDING_ABORT_DONE, baz); + let bar = mailbox_csr.rf(utra::mailbox::EV_PENDING_ERROR); + mailbox_csr.rmwf(utra::mailbox::EV_PENDING_ERROR, bar); + let mut baz = mailbox_csr.zf(utra::mailbox::EV_PENDING_ERROR, bar); + baz |= mailbox_csr.ms(utra::mailbox::EV_PENDING_ERROR, 1); + mailbox_csr.wfo(utra::mailbox::EV_PENDING_ERROR, baz); + + let foo = mailbox_csr.r(utra::mailbox::EV_ENABLE); + mailbox_csr.wo(utra::mailbox::EV_ENABLE, foo); + let bar = mailbox_csr.rf(utra::mailbox::EV_ENABLE_AVAILABLE); + mailbox_csr.rmwf(utra::mailbox::EV_ENABLE_AVAILABLE, bar); + let mut baz = mailbox_csr.zf(utra::mailbox::EV_ENABLE_AVAILABLE, bar); + baz |= mailbox_csr.ms(utra::mailbox::EV_ENABLE_AVAILABLE, 1); + mailbox_csr.wfo(utra::mailbox::EV_ENABLE_AVAILABLE, baz); + let bar = mailbox_csr.rf(utra::mailbox::EV_ENABLE_ABORT_INIT); + mailbox_csr.rmwf(utra::mailbox::EV_ENABLE_ABORT_INIT, bar); + let mut baz = mailbox_csr.zf(utra::mailbox::EV_ENABLE_ABORT_INIT, bar); + baz |= mailbox_csr.ms(utra::mailbox::EV_ENABLE_ABORT_INIT, 1); + mailbox_csr.wfo(utra::mailbox::EV_ENABLE_ABORT_INIT, baz); + let bar = mailbox_csr.rf(utra::mailbox::EV_ENABLE_ABORT_DONE); + mailbox_csr.rmwf(utra::mailbox::EV_ENABLE_ABORT_DONE, bar); + let mut baz = mailbox_csr.zf(utra::mailbox::EV_ENABLE_ABORT_DONE, bar); + baz |= mailbox_csr.ms(utra::mailbox::EV_ENABLE_ABORT_DONE, 1); + mailbox_csr.wfo(utra::mailbox::EV_ENABLE_ABORT_DONE, baz); + let bar = mailbox_csr.rf(utra::mailbox::EV_ENABLE_ERROR); + mailbox_csr.rmwf(utra::mailbox::EV_ENABLE_ERROR, bar); + let mut baz = mailbox_csr.zf(utra::mailbox::EV_ENABLE_ERROR, bar); + baz |= mailbox_csr.ms(utra::mailbox::EV_ENABLE_ERROR, 1); + mailbox_csr.wfo(utra::mailbox::EV_ENABLE_ERROR, baz); + + let foo = mailbox_csr.r(utra::mailbox::STATUS); + mailbox_csr.wo(utra::mailbox::STATUS, foo); + let bar = mailbox_csr.rf(utra::mailbox::STATUS_RX_WORDS); + mailbox_csr.rmwf(utra::mailbox::STATUS_RX_WORDS, bar); + let mut baz = mailbox_csr.zf(utra::mailbox::STATUS_RX_WORDS, bar); + baz |= mailbox_csr.ms(utra::mailbox::STATUS_RX_WORDS, 1); + mailbox_csr.wfo(utra::mailbox::STATUS_RX_WORDS, baz); + let bar = mailbox_csr.rf(utra::mailbox::STATUS_TX_WORDS); + mailbox_csr.rmwf(utra::mailbox::STATUS_TX_WORDS, bar); + let mut baz = mailbox_csr.zf(utra::mailbox::STATUS_TX_WORDS, bar); + baz |= mailbox_csr.ms(utra::mailbox::STATUS_TX_WORDS, 1); + mailbox_csr.wfo(utra::mailbox::STATUS_TX_WORDS, baz); + let bar = mailbox_csr.rf(utra::mailbox::STATUS_ABORT_IN_PROGRESS); + mailbox_csr.rmwf(utra::mailbox::STATUS_ABORT_IN_PROGRESS, bar); + let mut baz = mailbox_csr.zf(utra::mailbox::STATUS_ABORT_IN_PROGRESS, bar); + baz |= mailbox_csr.ms(utra::mailbox::STATUS_ABORT_IN_PROGRESS, 1); + mailbox_csr.wfo(utra::mailbox::STATUS_ABORT_IN_PROGRESS, baz); + let bar = mailbox_csr.rf(utra::mailbox::STATUS_ABORT_ACK); + mailbox_csr.rmwf(utra::mailbox::STATUS_ABORT_ACK, bar); + let mut baz = mailbox_csr.zf(utra::mailbox::STATUS_ABORT_ACK, bar); + baz |= mailbox_csr.ms(utra::mailbox::STATUS_ABORT_ACK, 1); + mailbox_csr.wfo(utra::mailbox::STATUS_ABORT_ACK, baz); + let bar = mailbox_csr.rf(utra::mailbox::STATUS_TX_ERR); + mailbox_csr.rmwf(utra::mailbox::STATUS_TX_ERR, bar); + let mut baz = mailbox_csr.zf(utra::mailbox::STATUS_TX_ERR, bar); + baz |= mailbox_csr.ms(utra::mailbox::STATUS_TX_ERR, 1); + mailbox_csr.wfo(utra::mailbox::STATUS_TX_ERR, baz); + let bar = mailbox_csr.rf(utra::mailbox::STATUS_RX_ERR); + mailbox_csr.rmwf(utra::mailbox::STATUS_RX_ERR, bar); + let mut baz = mailbox_csr.zf(utra::mailbox::STATUS_RX_ERR, bar); + baz |= mailbox_csr.ms(utra::mailbox::STATUS_RX_ERR, 1); + mailbox_csr.wfo(utra::mailbox::STATUS_RX_ERR, baz); + + let foo = mailbox_csr.r(utra::mailbox::CONTROL); + mailbox_csr.wo(utra::mailbox::CONTROL, foo); + let bar = mailbox_csr.rf(utra::mailbox::CONTROL_ABORT); + mailbox_csr.rmwf(utra::mailbox::CONTROL_ABORT, bar); + let mut baz = mailbox_csr.zf(utra::mailbox::CONTROL_ABORT, bar); + baz |= mailbox_csr.ms(utra::mailbox::CONTROL_ABORT, 1); + mailbox_csr.wfo(utra::mailbox::CONTROL_ABORT, baz); + + let foo = mailbox_csr.r(utra::mailbox::DONE); + mailbox_csr.wo(utra::mailbox::DONE, foo); + let bar = mailbox_csr.rf(utra::mailbox::DONE_DONE); + mailbox_csr.rmwf(utra::mailbox::DONE_DONE, bar); + let mut baz = mailbox_csr.zf(utra::mailbox::DONE_DONE, bar); + baz |= mailbox_csr.ms(utra::mailbox::DONE_DONE, 1); + mailbox_csr.wfo(utra::mailbox::DONE_DONE, baz); + } + + #[test] + #[ignore] + fn compile_check_mb_client_csr() { + use super::*; + let mut mb_client_csr = CSR::new(HW_MB_CLIENT_BASE as *mut u32); + + let foo = mb_client_csr.r(utra::mb_client::WDATA); + mb_client_csr.wo(utra::mb_client::WDATA, foo); + let bar = mb_client_csr.rf(utra::mb_client::WDATA_WDATA); + mb_client_csr.rmwf(utra::mb_client::WDATA_WDATA, bar); + let mut baz = mb_client_csr.zf(utra::mb_client::WDATA_WDATA, bar); + baz |= mb_client_csr.ms(utra::mb_client::WDATA_WDATA, 1); + mb_client_csr.wfo(utra::mb_client::WDATA_WDATA, baz); + + let foo = mb_client_csr.r(utra::mb_client::RDATA); + mb_client_csr.wo(utra::mb_client::RDATA, foo); + let bar = mb_client_csr.rf(utra::mb_client::RDATA_RDATA); + mb_client_csr.rmwf(utra::mb_client::RDATA_RDATA, bar); + let mut baz = mb_client_csr.zf(utra::mb_client::RDATA_RDATA, bar); + baz |= mb_client_csr.ms(utra::mb_client::RDATA_RDATA, 1); + mb_client_csr.wfo(utra::mb_client::RDATA_RDATA, baz); + + let foo = mb_client_csr.r(utra::mb_client::EV_STATUS); + mb_client_csr.wo(utra::mb_client::EV_STATUS, foo); + let bar = mb_client_csr.rf(utra::mb_client::EV_STATUS_AVAILABLE); + mb_client_csr.rmwf(utra::mb_client::EV_STATUS_AVAILABLE, bar); + let mut baz = mb_client_csr.zf(utra::mb_client::EV_STATUS_AVAILABLE, bar); + baz |= mb_client_csr.ms(utra::mb_client::EV_STATUS_AVAILABLE, 1); + mb_client_csr.wfo(utra::mb_client::EV_STATUS_AVAILABLE, baz); + let bar = mb_client_csr.rf(utra::mb_client::EV_STATUS_ABORT_INIT); + mb_client_csr.rmwf(utra::mb_client::EV_STATUS_ABORT_INIT, bar); + let mut baz = mb_client_csr.zf(utra::mb_client::EV_STATUS_ABORT_INIT, bar); + baz |= mb_client_csr.ms(utra::mb_client::EV_STATUS_ABORT_INIT, 1); + mb_client_csr.wfo(utra::mb_client::EV_STATUS_ABORT_INIT, baz); + let bar = mb_client_csr.rf(utra::mb_client::EV_STATUS_ABORT_DONE); + mb_client_csr.rmwf(utra::mb_client::EV_STATUS_ABORT_DONE, bar); + let mut baz = mb_client_csr.zf(utra::mb_client::EV_STATUS_ABORT_DONE, bar); + baz |= mb_client_csr.ms(utra::mb_client::EV_STATUS_ABORT_DONE, 1); + mb_client_csr.wfo(utra::mb_client::EV_STATUS_ABORT_DONE, baz); + let bar = mb_client_csr.rf(utra::mb_client::EV_STATUS_ERROR); + mb_client_csr.rmwf(utra::mb_client::EV_STATUS_ERROR, bar); + let mut baz = mb_client_csr.zf(utra::mb_client::EV_STATUS_ERROR, bar); + baz |= mb_client_csr.ms(utra::mb_client::EV_STATUS_ERROR, 1); + mb_client_csr.wfo(utra::mb_client::EV_STATUS_ERROR, baz); + + let foo = mb_client_csr.r(utra::mb_client::EV_PENDING); + mb_client_csr.wo(utra::mb_client::EV_PENDING, foo); + let bar = mb_client_csr.rf(utra::mb_client::EV_PENDING_AVAILABLE); + mb_client_csr.rmwf(utra::mb_client::EV_PENDING_AVAILABLE, bar); + let mut baz = mb_client_csr.zf(utra::mb_client::EV_PENDING_AVAILABLE, bar); + baz |= mb_client_csr.ms(utra::mb_client::EV_PENDING_AVAILABLE, 1); + mb_client_csr.wfo(utra::mb_client::EV_PENDING_AVAILABLE, baz); + let bar = mb_client_csr.rf(utra::mb_client::EV_PENDING_ABORT_INIT); + mb_client_csr.rmwf(utra::mb_client::EV_PENDING_ABORT_INIT, bar); + let mut baz = mb_client_csr.zf(utra::mb_client::EV_PENDING_ABORT_INIT, bar); + baz |= mb_client_csr.ms(utra::mb_client::EV_PENDING_ABORT_INIT, 1); + mb_client_csr.wfo(utra::mb_client::EV_PENDING_ABORT_INIT, baz); + let bar = mb_client_csr.rf(utra::mb_client::EV_PENDING_ABORT_DONE); + mb_client_csr.rmwf(utra::mb_client::EV_PENDING_ABORT_DONE, bar); + let mut baz = mb_client_csr.zf(utra::mb_client::EV_PENDING_ABORT_DONE, bar); + baz |= mb_client_csr.ms(utra::mb_client::EV_PENDING_ABORT_DONE, 1); + mb_client_csr.wfo(utra::mb_client::EV_PENDING_ABORT_DONE, baz); + let bar = mb_client_csr.rf(utra::mb_client::EV_PENDING_ERROR); + mb_client_csr.rmwf(utra::mb_client::EV_PENDING_ERROR, bar); + let mut baz = mb_client_csr.zf(utra::mb_client::EV_PENDING_ERROR, bar); + baz |= mb_client_csr.ms(utra::mb_client::EV_PENDING_ERROR, 1); + mb_client_csr.wfo(utra::mb_client::EV_PENDING_ERROR, baz); + + let foo = mb_client_csr.r(utra::mb_client::EV_ENABLE); + mb_client_csr.wo(utra::mb_client::EV_ENABLE, foo); + let bar = mb_client_csr.rf(utra::mb_client::EV_ENABLE_AVAILABLE); + mb_client_csr.rmwf(utra::mb_client::EV_ENABLE_AVAILABLE, bar); + let mut baz = mb_client_csr.zf(utra::mb_client::EV_ENABLE_AVAILABLE, bar); + baz |= mb_client_csr.ms(utra::mb_client::EV_ENABLE_AVAILABLE, 1); + mb_client_csr.wfo(utra::mb_client::EV_ENABLE_AVAILABLE, baz); + let bar = mb_client_csr.rf(utra::mb_client::EV_ENABLE_ABORT_INIT); + mb_client_csr.rmwf(utra::mb_client::EV_ENABLE_ABORT_INIT, bar); + let mut baz = mb_client_csr.zf(utra::mb_client::EV_ENABLE_ABORT_INIT, bar); + baz |= mb_client_csr.ms(utra::mb_client::EV_ENABLE_ABORT_INIT, 1); + mb_client_csr.wfo(utra::mb_client::EV_ENABLE_ABORT_INIT, baz); + let bar = mb_client_csr.rf(utra::mb_client::EV_ENABLE_ABORT_DONE); + mb_client_csr.rmwf(utra::mb_client::EV_ENABLE_ABORT_DONE, bar); + let mut baz = mb_client_csr.zf(utra::mb_client::EV_ENABLE_ABORT_DONE, bar); + baz |= mb_client_csr.ms(utra::mb_client::EV_ENABLE_ABORT_DONE, 1); + mb_client_csr.wfo(utra::mb_client::EV_ENABLE_ABORT_DONE, baz); + let bar = mb_client_csr.rf(utra::mb_client::EV_ENABLE_ERROR); + mb_client_csr.rmwf(utra::mb_client::EV_ENABLE_ERROR, bar); + let mut baz = mb_client_csr.zf(utra::mb_client::EV_ENABLE_ERROR, bar); + baz |= mb_client_csr.ms(utra::mb_client::EV_ENABLE_ERROR, 1); + mb_client_csr.wfo(utra::mb_client::EV_ENABLE_ERROR, baz); + + let foo = mb_client_csr.r(utra::mb_client::STATUS); + mb_client_csr.wo(utra::mb_client::STATUS, foo); + let bar = mb_client_csr.rf(utra::mb_client::STATUS_RX_AVAIL); + mb_client_csr.rmwf(utra::mb_client::STATUS_RX_AVAIL, bar); + let mut baz = mb_client_csr.zf(utra::mb_client::STATUS_RX_AVAIL, bar); + baz |= mb_client_csr.ms(utra::mb_client::STATUS_RX_AVAIL, 1); + mb_client_csr.wfo(utra::mb_client::STATUS_RX_AVAIL, baz); + let bar = mb_client_csr.rf(utra::mb_client::STATUS_TX_FREE); + mb_client_csr.rmwf(utra::mb_client::STATUS_TX_FREE, bar); + let mut baz = mb_client_csr.zf(utra::mb_client::STATUS_TX_FREE, bar); + baz |= mb_client_csr.ms(utra::mb_client::STATUS_TX_FREE, 1); + mb_client_csr.wfo(utra::mb_client::STATUS_TX_FREE, baz); + let bar = mb_client_csr.rf(utra::mb_client::STATUS_ABORT_IN_PROGRESS); + mb_client_csr.rmwf(utra::mb_client::STATUS_ABORT_IN_PROGRESS, bar); + let mut baz = mb_client_csr.zf(utra::mb_client::STATUS_ABORT_IN_PROGRESS, bar); + baz |= mb_client_csr.ms(utra::mb_client::STATUS_ABORT_IN_PROGRESS, 1); + mb_client_csr.wfo(utra::mb_client::STATUS_ABORT_IN_PROGRESS, baz); + let bar = mb_client_csr.rf(utra::mb_client::STATUS_ABORT_ACK); + mb_client_csr.rmwf(utra::mb_client::STATUS_ABORT_ACK, bar); + let mut baz = mb_client_csr.zf(utra::mb_client::STATUS_ABORT_ACK, bar); + baz |= mb_client_csr.ms(utra::mb_client::STATUS_ABORT_ACK, 1); + mb_client_csr.wfo(utra::mb_client::STATUS_ABORT_ACK, baz); + let bar = mb_client_csr.rf(utra::mb_client::STATUS_TX_ERR); + mb_client_csr.rmwf(utra::mb_client::STATUS_TX_ERR, bar); + let mut baz = mb_client_csr.zf(utra::mb_client::STATUS_TX_ERR, bar); + baz |= mb_client_csr.ms(utra::mb_client::STATUS_TX_ERR, 1); + mb_client_csr.wfo(utra::mb_client::STATUS_TX_ERR, baz); + let bar = mb_client_csr.rf(utra::mb_client::STATUS_RX_ERR); + mb_client_csr.rmwf(utra::mb_client::STATUS_RX_ERR, bar); + let mut baz = mb_client_csr.zf(utra::mb_client::STATUS_RX_ERR, bar); + baz |= mb_client_csr.ms(utra::mb_client::STATUS_RX_ERR, 1); + mb_client_csr.wfo(utra::mb_client::STATUS_RX_ERR, baz); + + let foo = mb_client_csr.r(utra::mb_client::CONTROL); + mb_client_csr.wo(utra::mb_client::CONTROL, foo); + let bar = mb_client_csr.rf(utra::mb_client::CONTROL_ABORT); + mb_client_csr.rmwf(utra::mb_client::CONTROL_ABORT, bar); + let mut baz = mb_client_csr.zf(utra::mb_client::CONTROL_ABORT, bar); + baz |= mb_client_csr.ms(utra::mb_client::CONTROL_ABORT, 1); + mb_client_csr.wfo(utra::mb_client::CONTROL_ABORT, baz); + + let foo = mb_client_csr.r(utra::mb_client::DONE); + mb_client_csr.wo(utra::mb_client::DONE, foo); + let bar = mb_client_csr.rf(utra::mb_client::DONE_DONE); + mb_client_csr.rmwf(utra::mb_client::DONE_DONE, bar); + let mut baz = mb_client_csr.zf(utra::mb_client::DONE_DONE, bar); + baz |= mb_client_csr.ms(utra::mb_client::DONE_DONE, 1); + mb_client_csr.wfo(utra::mb_client::DONE_DONE, baz); + } + + #[test] + #[ignore] + fn compile_check_resetvalue_csr() { + use super::*; + let mut resetvalue_csr = CSR::new(HW_RESETVALUE_BASE as *mut u32); + + let foo = resetvalue_csr.r(utra::resetvalue::PC); + resetvalue_csr.wo(utra::resetvalue::PC, foo); + let bar = resetvalue_csr.rf(utra::resetvalue::PC_PC); + resetvalue_csr.rmwf(utra::resetvalue::PC_PC, bar); + let mut baz = resetvalue_csr.zf(utra::resetvalue::PC_PC, bar); + baz |= resetvalue_csr.ms(utra::resetvalue::PC_PC, 1); + resetvalue_csr.wfo(utra::resetvalue::PC_PC, baz); + } + + #[test] + #[ignore] + fn compile_check_ticktimer_csr() { + use super::*; + let mut ticktimer_csr = CSR::new(HW_TICKTIMER_BASE as *mut u32); + + let foo = ticktimer_csr.r(utra::ticktimer::CONTROL); + ticktimer_csr.wo(utra::ticktimer::CONTROL, foo); + let bar = ticktimer_csr.rf(utra::ticktimer::CONTROL_RESET); + ticktimer_csr.rmwf(utra::ticktimer::CONTROL_RESET, bar); + let mut baz = ticktimer_csr.zf(utra::ticktimer::CONTROL_RESET, bar); + baz |= ticktimer_csr.ms(utra::ticktimer::CONTROL_RESET, 1); + ticktimer_csr.wfo(utra::ticktimer::CONTROL_RESET, baz); + + let foo = ticktimer_csr.r(utra::ticktimer::TIME1); + ticktimer_csr.wo(utra::ticktimer::TIME1, foo); + let bar = ticktimer_csr.rf(utra::ticktimer::TIME1_TIME); + ticktimer_csr.rmwf(utra::ticktimer::TIME1_TIME, bar); + let mut baz = ticktimer_csr.zf(utra::ticktimer::TIME1_TIME, bar); + baz |= ticktimer_csr.ms(utra::ticktimer::TIME1_TIME, 1); + ticktimer_csr.wfo(utra::ticktimer::TIME1_TIME, baz); + + let foo = ticktimer_csr.r(utra::ticktimer::TIME0); + ticktimer_csr.wo(utra::ticktimer::TIME0, foo); + let bar = ticktimer_csr.rf(utra::ticktimer::TIME0_TIME); + ticktimer_csr.rmwf(utra::ticktimer::TIME0_TIME, bar); + let mut baz = ticktimer_csr.zf(utra::ticktimer::TIME0_TIME, bar); + baz |= ticktimer_csr.ms(utra::ticktimer::TIME0_TIME, 1); + ticktimer_csr.wfo(utra::ticktimer::TIME0_TIME, baz); + + let foo = ticktimer_csr.r(utra::ticktimer::MSLEEP_TARGET1); + ticktimer_csr.wo(utra::ticktimer::MSLEEP_TARGET1, foo); + let bar = ticktimer_csr.rf(utra::ticktimer::MSLEEP_TARGET1_MSLEEP_TARGET); + ticktimer_csr.rmwf(utra::ticktimer::MSLEEP_TARGET1_MSLEEP_TARGET, bar); + let mut baz = ticktimer_csr.zf(utra::ticktimer::MSLEEP_TARGET1_MSLEEP_TARGET, bar); + baz |= ticktimer_csr.ms(utra::ticktimer::MSLEEP_TARGET1_MSLEEP_TARGET, 1); + ticktimer_csr.wfo(utra::ticktimer::MSLEEP_TARGET1_MSLEEP_TARGET, baz); + + let foo = ticktimer_csr.r(utra::ticktimer::MSLEEP_TARGET0); + ticktimer_csr.wo(utra::ticktimer::MSLEEP_TARGET0, foo); + let bar = ticktimer_csr.rf(utra::ticktimer::MSLEEP_TARGET0_MSLEEP_TARGET); + ticktimer_csr.rmwf(utra::ticktimer::MSLEEP_TARGET0_MSLEEP_TARGET, bar); + let mut baz = ticktimer_csr.zf(utra::ticktimer::MSLEEP_TARGET0_MSLEEP_TARGET, bar); + baz |= ticktimer_csr.ms(utra::ticktimer::MSLEEP_TARGET0_MSLEEP_TARGET, 1); + ticktimer_csr.wfo(utra::ticktimer::MSLEEP_TARGET0_MSLEEP_TARGET, baz); + + let foo = ticktimer_csr.r(utra::ticktimer::EV_STATUS); + ticktimer_csr.wo(utra::ticktimer::EV_STATUS, foo); + let bar = ticktimer_csr.rf(utra::ticktimer::EV_STATUS_ALARM); + ticktimer_csr.rmwf(utra::ticktimer::EV_STATUS_ALARM, bar); + let mut baz = ticktimer_csr.zf(utra::ticktimer::EV_STATUS_ALARM, bar); + baz |= ticktimer_csr.ms(utra::ticktimer::EV_STATUS_ALARM, 1); + ticktimer_csr.wfo(utra::ticktimer::EV_STATUS_ALARM, baz); + + let foo = ticktimer_csr.r(utra::ticktimer::EV_PENDING); + ticktimer_csr.wo(utra::ticktimer::EV_PENDING, foo); + let bar = ticktimer_csr.rf(utra::ticktimer::EV_PENDING_ALARM); + ticktimer_csr.rmwf(utra::ticktimer::EV_PENDING_ALARM, bar); + let mut baz = ticktimer_csr.zf(utra::ticktimer::EV_PENDING_ALARM, bar); + baz |= ticktimer_csr.ms(utra::ticktimer::EV_PENDING_ALARM, 1); + ticktimer_csr.wfo(utra::ticktimer::EV_PENDING_ALARM, baz); + + let foo = ticktimer_csr.r(utra::ticktimer::EV_ENABLE); + ticktimer_csr.wo(utra::ticktimer::EV_ENABLE, foo); + let bar = ticktimer_csr.rf(utra::ticktimer::EV_ENABLE_ALARM); + ticktimer_csr.rmwf(utra::ticktimer::EV_ENABLE_ALARM, bar); + let mut baz = ticktimer_csr.zf(utra::ticktimer::EV_ENABLE_ALARM, bar); + baz |= ticktimer_csr.ms(utra::ticktimer::EV_ENABLE_ALARM, 1); + ticktimer_csr.wfo(utra::ticktimer::EV_ENABLE_ALARM, baz); + + let foo = ticktimer_csr.r(utra::ticktimer::CLOCKS_PER_TICK); + ticktimer_csr.wo(utra::ticktimer::CLOCKS_PER_TICK, foo); + let bar = ticktimer_csr.rf(utra::ticktimer::CLOCKS_PER_TICK_CLOCKS_PER_TICK); + ticktimer_csr.rmwf(utra::ticktimer::CLOCKS_PER_TICK_CLOCKS_PER_TICK, bar); + let mut baz = ticktimer_csr.zf(utra::ticktimer::CLOCKS_PER_TICK_CLOCKS_PER_TICK, bar); + baz |= ticktimer_csr.ms(utra::ticktimer::CLOCKS_PER_TICK_CLOCKS_PER_TICK, 1); + ticktimer_csr.wfo(utra::ticktimer::CLOCKS_PER_TICK_CLOCKS_PER_TICK, baz); + } + + #[test] + #[ignore] + fn compile_check_pl230_csr() { + use super::*; + let mut pl230_csr = CSR::new(HW_PL230_BASE as *mut u32); + + let foo = pl230_csr.r(utra::pl230::STATUS); + pl230_csr.wo(utra::pl230::STATUS, foo); + let bar = pl230_csr.rf(utra::pl230::STATUS_TEST_STATUS); + pl230_csr.rmwf(utra::pl230::STATUS_TEST_STATUS, bar); + let mut baz = pl230_csr.zf(utra::pl230::STATUS_TEST_STATUS, bar); + baz |= pl230_csr.ms(utra::pl230::STATUS_TEST_STATUS, 1); + pl230_csr.wfo(utra::pl230::STATUS_TEST_STATUS, baz); + let bar = pl230_csr.rf(utra::pl230::STATUS_CHNLS_MINUS1); + pl230_csr.rmwf(utra::pl230::STATUS_CHNLS_MINUS1, bar); + let mut baz = pl230_csr.zf(utra::pl230::STATUS_CHNLS_MINUS1, bar); + baz |= pl230_csr.ms(utra::pl230::STATUS_CHNLS_MINUS1, 1); + pl230_csr.wfo(utra::pl230::STATUS_CHNLS_MINUS1, baz); + let bar = pl230_csr.rf(utra::pl230::STATUS_STATE); + pl230_csr.rmwf(utra::pl230::STATUS_STATE, bar); + let mut baz = pl230_csr.zf(utra::pl230::STATUS_STATE, bar); + baz |= pl230_csr.ms(utra::pl230::STATUS_STATE, 1); + pl230_csr.wfo(utra::pl230::STATUS_STATE, baz); + let bar = pl230_csr.rf(utra::pl230::STATUS_MASTER_ENABLE); + pl230_csr.rmwf(utra::pl230::STATUS_MASTER_ENABLE, bar); + let mut baz = pl230_csr.zf(utra::pl230::STATUS_MASTER_ENABLE, bar); + baz |= pl230_csr.ms(utra::pl230::STATUS_MASTER_ENABLE, 1); + pl230_csr.wfo(utra::pl230::STATUS_MASTER_ENABLE, baz); + + let foo = pl230_csr.r(utra::pl230::CFG); + pl230_csr.wo(utra::pl230::CFG, foo); + let bar = pl230_csr.rf(utra::pl230::CFG_CHNL_PROT_CTRL); + pl230_csr.rmwf(utra::pl230::CFG_CHNL_PROT_CTRL, bar); + let mut baz = pl230_csr.zf(utra::pl230::CFG_CHNL_PROT_CTRL, bar); + baz |= pl230_csr.ms(utra::pl230::CFG_CHNL_PROT_CTRL, 1); + pl230_csr.wfo(utra::pl230::CFG_CHNL_PROT_CTRL, baz); + let bar = pl230_csr.rf(utra::pl230::CFG_MASTER_ENABLE); + pl230_csr.rmwf(utra::pl230::CFG_MASTER_ENABLE, bar); + let mut baz = pl230_csr.zf(utra::pl230::CFG_MASTER_ENABLE, bar); + baz |= pl230_csr.ms(utra::pl230::CFG_MASTER_ENABLE, 1); + pl230_csr.wfo(utra::pl230::CFG_MASTER_ENABLE, baz); + + let foo = pl230_csr.r(utra::pl230::CTRLBASEPTR); + pl230_csr.wo(utra::pl230::CTRLBASEPTR, foo); + let bar = pl230_csr.rf(utra::pl230::CTRLBASEPTR_CTRL_BASE_PTR); + pl230_csr.rmwf(utra::pl230::CTRLBASEPTR_CTRL_BASE_PTR, bar); + let mut baz = pl230_csr.zf(utra::pl230::CTRLBASEPTR_CTRL_BASE_PTR, bar); + baz |= pl230_csr.ms(utra::pl230::CTRLBASEPTR_CTRL_BASE_PTR, 1); + pl230_csr.wfo(utra::pl230::CTRLBASEPTR_CTRL_BASE_PTR, baz); + + let foo = pl230_csr.r(utra::pl230::ALTCTRLBASEPTR); + pl230_csr.wo(utra::pl230::ALTCTRLBASEPTR, foo); + let bar = pl230_csr.rf(utra::pl230::ALTCTRLBASEPTR_ALT_CTRL_BASE_PTR); + pl230_csr.rmwf(utra::pl230::ALTCTRLBASEPTR_ALT_CTRL_BASE_PTR, bar); + let mut baz = pl230_csr.zf(utra::pl230::ALTCTRLBASEPTR_ALT_CTRL_BASE_PTR, bar); + baz |= pl230_csr.ms(utra::pl230::ALTCTRLBASEPTR_ALT_CTRL_BASE_PTR, 1); + pl230_csr.wfo(utra::pl230::ALTCTRLBASEPTR_ALT_CTRL_BASE_PTR, baz); + + let foo = pl230_csr.r(utra::pl230::DMA_WAITONREQ_STATUS); + pl230_csr.wo(utra::pl230::DMA_WAITONREQ_STATUS, foo); + let bar = pl230_csr.rf(utra::pl230::DMA_WAITONREQ_STATUS_DMA_WAITONREQ_STATUS); + pl230_csr.rmwf(utra::pl230::DMA_WAITONREQ_STATUS_DMA_WAITONREQ_STATUS, bar); + let mut baz = pl230_csr.zf(utra::pl230::DMA_WAITONREQ_STATUS_DMA_WAITONREQ_STATUS, bar); + baz |= pl230_csr.ms(utra::pl230::DMA_WAITONREQ_STATUS_DMA_WAITONREQ_STATUS, 1); + pl230_csr.wfo(utra::pl230::DMA_WAITONREQ_STATUS_DMA_WAITONREQ_STATUS, baz); + + let foo = pl230_csr.r(utra::pl230::CHNLSWREQUEST); + pl230_csr.wo(utra::pl230::CHNLSWREQUEST, foo); + let bar = pl230_csr.rf(utra::pl230::CHNLSWREQUEST_CHNL_SW_REQUEST); + pl230_csr.rmwf(utra::pl230::CHNLSWREQUEST_CHNL_SW_REQUEST, bar); + let mut baz = pl230_csr.zf(utra::pl230::CHNLSWREQUEST_CHNL_SW_REQUEST, bar); + baz |= pl230_csr.ms(utra::pl230::CHNLSWREQUEST_CHNL_SW_REQUEST, 1); + pl230_csr.wfo(utra::pl230::CHNLSWREQUEST_CHNL_SW_REQUEST, baz); + + let foo = pl230_csr.r(utra::pl230::CHNLUSEBURSTSET); + pl230_csr.wo(utra::pl230::CHNLUSEBURSTSET, foo); + let bar = pl230_csr.rf(utra::pl230::CHNLUSEBURSTSET_CHNL_USEBURST_SET); + pl230_csr.rmwf(utra::pl230::CHNLUSEBURSTSET_CHNL_USEBURST_SET, bar); + let mut baz = pl230_csr.zf(utra::pl230::CHNLUSEBURSTSET_CHNL_USEBURST_SET, bar); + baz |= pl230_csr.ms(utra::pl230::CHNLUSEBURSTSET_CHNL_USEBURST_SET, 1); + pl230_csr.wfo(utra::pl230::CHNLUSEBURSTSET_CHNL_USEBURST_SET, baz); + + let foo = pl230_csr.r(utra::pl230::CHNLUSEBURSTCLR); + pl230_csr.wo(utra::pl230::CHNLUSEBURSTCLR, foo); + let bar = pl230_csr.rf(utra::pl230::CHNLUSEBURSTCLR_CHNL_USEBURST_CLR); + pl230_csr.rmwf(utra::pl230::CHNLUSEBURSTCLR_CHNL_USEBURST_CLR, bar); + let mut baz = pl230_csr.zf(utra::pl230::CHNLUSEBURSTCLR_CHNL_USEBURST_CLR, bar); + baz |= pl230_csr.ms(utra::pl230::CHNLUSEBURSTCLR_CHNL_USEBURST_CLR, 1); + pl230_csr.wfo(utra::pl230::CHNLUSEBURSTCLR_CHNL_USEBURST_CLR, baz); + + let foo = pl230_csr.r(utra::pl230::CHNLREQMASKSET); + pl230_csr.wo(utra::pl230::CHNLREQMASKSET, foo); + let bar = pl230_csr.rf(utra::pl230::CHNLREQMASKSET_CHNL_REQ_MASK_SET); + pl230_csr.rmwf(utra::pl230::CHNLREQMASKSET_CHNL_REQ_MASK_SET, bar); + let mut baz = pl230_csr.zf(utra::pl230::CHNLREQMASKSET_CHNL_REQ_MASK_SET, bar); + baz |= pl230_csr.ms(utra::pl230::CHNLREQMASKSET_CHNL_REQ_MASK_SET, 1); + pl230_csr.wfo(utra::pl230::CHNLREQMASKSET_CHNL_REQ_MASK_SET, baz); + + let foo = pl230_csr.r(utra::pl230::CHNLREQMASKCLR); + pl230_csr.wo(utra::pl230::CHNLREQMASKCLR, foo); + let bar = pl230_csr.rf(utra::pl230::CHNLREQMASKCLR_CHNL_REQ_MASK_CLR); + pl230_csr.rmwf(utra::pl230::CHNLREQMASKCLR_CHNL_REQ_MASK_CLR, bar); + let mut baz = pl230_csr.zf(utra::pl230::CHNLREQMASKCLR_CHNL_REQ_MASK_CLR, bar); + baz |= pl230_csr.ms(utra::pl230::CHNLREQMASKCLR_CHNL_REQ_MASK_CLR, 1); + pl230_csr.wfo(utra::pl230::CHNLREQMASKCLR_CHNL_REQ_MASK_CLR, baz); + + let foo = pl230_csr.r(utra::pl230::CHNLENABLESET); + pl230_csr.wo(utra::pl230::CHNLENABLESET, foo); + let bar = pl230_csr.rf(utra::pl230::CHNLENABLESET_CHNL_ENABLE_SET); + pl230_csr.rmwf(utra::pl230::CHNLENABLESET_CHNL_ENABLE_SET, bar); + let mut baz = pl230_csr.zf(utra::pl230::CHNLENABLESET_CHNL_ENABLE_SET, bar); + baz |= pl230_csr.ms(utra::pl230::CHNLENABLESET_CHNL_ENABLE_SET, 1); + pl230_csr.wfo(utra::pl230::CHNLENABLESET_CHNL_ENABLE_SET, baz); + + let foo = pl230_csr.r(utra::pl230::CHNLENABLECLR); + pl230_csr.wo(utra::pl230::CHNLENABLECLR, foo); + let bar = pl230_csr.rf(utra::pl230::CHNLENABLECLR_CHNL_ENABLE_CLR); + pl230_csr.rmwf(utra::pl230::CHNLENABLECLR_CHNL_ENABLE_CLR, bar); + let mut baz = pl230_csr.zf(utra::pl230::CHNLENABLECLR_CHNL_ENABLE_CLR, bar); + baz |= pl230_csr.ms(utra::pl230::CHNLENABLECLR_CHNL_ENABLE_CLR, 1); + pl230_csr.wfo(utra::pl230::CHNLENABLECLR_CHNL_ENABLE_CLR, baz); + + let foo = pl230_csr.r(utra::pl230::CHNLPRIALTSET); + pl230_csr.wo(utra::pl230::CHNLPRIALTSET, foo); + let bar = pl230_csr.rf(utra::pl230::CHNLPRIALTSET_CHNL_PRI_ALT_SET); + pl230_csr.rmwf(utra::pl230::CHNLPRIALTSET_CHNL_PRI_ALT_SET, bar); + let mut baz = pl230_csr.zf(utra::pl230::CHNLPRIALTSET_CHNL_PRI_ALT_SET, bar); + baz |= pl230_csr.ms(utra::pl230::CHNLPRIALTSET_CHNL_PRI_ALT_SET, 1); + pl230_csr.wfo(utra::pl230::CHNLPRIALTSET_CHNL_PRI_ALT_SET, baz); + + let foo = pl230_csr.r(utra::pl230::CHNLPRIALTCLR); + pl230_csr.wo(utra::pl230::CHNLPRIALTCLR, foo); + let bar = pl230_csr.rf(utra::pl230::CHNLPRIALTCLR_CHNL_PRI_ALT_CLR); + pl230_csr.rmwf(utra::pl230::CHNLPRIALTCLR_CHNL_PRI_ALT_CLR, bar); + let mut baz = pl230_csr.zf(utra::pl230::CHNLPRIALTCLR_CHNL_PRI_ALT_CLR, bar); + baz |= pl230_csr.ms(utra::pl230::CHNLPRIALTCLR_CHNL_PRI_ALT_CLR, 1); + pl230_csr.wfo(utra::pl230::CHNLPRIALTCLR_CHNL_PRI_ALT_CLR, baz); + + let foo = pl230_csr.r(utra::pl230::CHNLPRIORITYSET); + pl230_csr.wo(utra::pl230::CHNLPRIORITYSET, foo); + let bar = pl230_csr.rf(utra::pl230::CHNLPRIORITYSET_CHNL_PRIORITY_SET); + pl230_csr.rmwf(utra::pl230::CHNLPRIORITYSET_CHNL_PRIORITY_SET, bar); + let mut baz = pl230_csr.zf(utra::pl230::CHNLPRIORITYSET_CHNL_PRIORITY_SET, bar); + baz |= pl230_csr.ms(utra::pl230::CHNLPRIORITYSET_CHNL_PRIORITY_SET, 1); + pl230_csr.wfo(utra::pl230::CHNLPRIORITYSET_CHNL_PRIORITY_SET, baz); + + let foo = pl230_csr.r(utra::pl230::CHNLPRIORITYCLR); + pl230_csr.wo(utra::pl230::CHNLPRIORITYCLR, foo); + let bar = pl230_csr.rf(utra::pl230::CHNLPRIORITYCLR_CHNL_PRIORITY_CLR); + pl230_csr.rmwf(utra::pl230::CHNLPRIORITYCLR_CHNL_PRIORITY_CLR, bar); + let mut baz = pl230_csr.zf(utra::pl230::CHNLPRIORITYCLR_CHNL_PRIORITY_CLR, bar); + baz |= pl230_csr.ms(utra::pl230::CHNLPRIORITYCLR_CHNL_PRIORITY_CLR, 1); + pl230_csr.wfo(utra::pl230::CHNLPRIORITYCLR_CHNL_PRIORITY_CLR, baz); + + let foo = pl230_csr.r(utra::pl230::ERRCLR); + pl230_csr.wo(utra::pl230::ERRCLR, foo); + let bar = pl230_csr.rf(utra::pl230::ERRCLR_ERR_CLR); + pl230_csr.rmwf(utra::pl230::ERRCLR_ERR_CLR, bar); + let mut baz = pl230_csr.zf(utra::pl230::ERRCLR_ERR_CLR, bar); + baz |= pl230_csr.ms(utra::pl230::ERRCLR_ERR_CLR, 1); + pl230_csr.wfo(utra::pl230::ERRCLR_ERR_CLR, baz); + + let foo = pl230_csr.r(utra::pl230::PERIPH_ID_0); + pl230_csr.wo(utra::pl230::PERIPH_ID_0, foo); + let bar = pl230_csr.rf(utra::pl230::PERIPH_ID_0_PART_NUMBER_LSB); + pl230_csr.rmwf(utra::pl230::PERIPH_ID_0_PART_NUMBER_LSB, bar); + let mut baz = pl230_csr.zf(utra::pl230::PERIPH_ID_0_PART_NUMBER_LSB, bar); + baz |= pl230_csr.ms(utra::pl230::PERIPH_ID_0_PART_NUMBER_LSB, 1); + pl230_csr.wfo(utra::pl230::PERIPH_ID_0_PART_NUMBER_LSB, baz); + + let foo = pl230_csr.r(utra::pl230::PERIPH_ID_1); + pl230_csr.wo(utra::pl230::PERIPH_ID_1, foo); + let bar = pl230_csr.rf(utra::pl230::PERIPH_ID_1_PART_NUMBER_MSB); + pl230_csr.rmwf(utra::pl230::PERIPH_ID_1_PART_NUMBER_MSB, bar); + let mut baz = pl230_csr.zf(utra::pl230::PERIPH_ID_1_PART_NUMBER_MSB, bar); + baz |= pl230_csr.ms(utra::pl230::PERIPH_ID_1_PART_NUMBER_MSB, 1); + pl230_csr.wfo(utra::pl230::PERIPH_ID_1_PART_NUMBER_MSB, baz); + let bar = pl230_csr.rf(utra::pl230::PERIPH_ID_1_JEP106_LSB); + pl230_csr.rmwf(utra::pl230::PERIPH_ID_1_JEP106_LSB, bar); + let mut baz = pl230_csr.zf(utra::pl230::PERIPH_ID_1_JEP106_LSB, bar); + baz |= pl230_csr.ms(utra::pl230::PERIPH_ID_1_JEP106_LSB, 1); + pl230_csr.wfo(utra::pl230::PERIPH_ID_1_JEP106_LSB, baz); + + let foo = pl230_csr.r(utra::pl230::PERIPH_ID_2); + pl230_csr.wo(utra::pl230::PERIPH_ID_2, foo); + let bar = pl230_csr.rf(utra::pl230::PERIPH_ID_2_JEP106_MSB); + pl230_csr.rmwf(utra::pl230::PERIPH_ID_2_JEP106_MSB, bar); + let mut baz = pl230_csr.zf(utra::pl230::PERIPH_ID_2_JEP106_MSB, bar); + baz |= pl230_csr.ms(utra::pl230::PERIPH_ID_2_JEP106_MSB, 1); + pl230_csr.wfo(utra::pl230::PERIPH_ID_2_JEP106_MSB, baz); + let bar = pl230_csr.rf(utra::pl230::PERIPH_ID_2_JEDEC_USED); + pl230_csr.rmwf(utra::pl230::PERIPH_ID_2_JEDEC_USED, bar); + let mut baz = pl230_csr.zf(utra::pl230::PERIPH_ID_2_JEDEC_USED, bar); + baz |= pl230_csr.ms(utra::pl230::PERIPH_ID_2_JEDEC_USED, 1); + pl230_csr.wfo(utra::pl230::PERIPH_ID_2_JEDEC_USED, baz); + let bar = pl230_csr.rf(utra::pl230::PERIPH_ID_2_REVISION); + pl230_csr.rmwf(utra::pl230::PERIPH_ID_2_REVISION, bar); + let mut baz = pl230_csr.zf(utra::pl230::PERIPH_ID_2_REVISION, bar); + baz |= pl230_csr.ms(utra::pl230::PERIPH_ID_2_REVISION, 1); + pl230_csr.wfo(utra::pl230::PERIPH_ID_2_REVISION, baz); + } + + #[test] + #[ignore] + fn compile_check_aes_csr() { + use super::*; + let mut aes_csr = CSR::new(HW_AES_BASE as *mut u32); + + let foo = aes_csr.r(utra::aes::SFR_CRFUNC); + aes_csr.wo(utra::aes::SFR_CRFUNC, foo); + let bar = aes_csr.rf(utra::aes::SFR_CRFUNC_SFR_CRFUNC); + aes_csr.rmwf(utra::aes::SFR_CRFUNC_SFR_CRFUNC, bar); + let mut baz = aes_csr.zf(utra::aes::SFR_CRFUNC_SFR_CRFUNC, bar); + baz |= aes_csr.ms(utra::aes::SFR_CRFUNC_SFR_CRFUNC, 1); + aes_csr.wfo(utra::aes::SFR_CRFUNC_SFR_CRFUNC, baz); + + let foo = aes_csr.r(utra::aes::SFR_AR); + aes_csr.wo(utra::aes::SFR_AR, foo); + let bar = aes_csr.rf(utra::aes::SFR_AR_SFR_AR); + aes_csr.rmwf(utra::aes::SFR_AR_SFR_AR, bar); + let mut baz = aes_csr.zf(utra::aes::SFR_AR_SFR_AR, bar); + baz |= aes_csr.ms(utra::aes::SFR_AR_SFR_AR, 1); + aes_csr.wfo(utra::aes::SFR_AR_SFR_AR, baz); + + let foo = aes_csr.r(utra::aes::SFR_SRMFSM); + aes_csr.wo(utra::aes::SFR_SRMFSM, foo); + let bar = aes_csr.rf(utra::aes::SFR_SRMFSM_SFR_SRMFSM); + aes_csr.rmwf(utra::aes::SFR_SRMFSM_SFR_SRMFSM, bar); + let mut baz = aes_csr.zf(utra::aes::SFR_SRMFSM_SFR_SRMFSM, bar); + baz |= aes_csr.ms(utra::aes::SFR_SRMFSM_SFR_SRMFSM, 1); + aes_csr.wfo(utra::aes::SFR_SRMFSM_SFR_SRMFSM, baz); + + let foo = aes_csr.r(utra::aes::SFR_FR); + aes_csr.wo(utra::aes::SFR_FR, foo); + let bar = aes_csr.rf(utra::aes::SFR_FR_MFSM_DONE); + aes_csr.rmwf(utra::aes::SFR_FR_MFSM_DONE, bar); + let mut baz = aes_csr.zf(utra::aes::SFR_FR_MFSM_DONE, bar); + baz |= aes_csr.ms(utra::aes::SFR_FR_MFSM_DONE, 1); + aes_csr.wfo(utra::aes::SFR_FR_MFSM_DONE, baz); + let bar = aes_csr.rf(utra::aes::SFR_FR_ACORE_DONE); + aes_csr.rmwf(utra::aes::SFR_FR_ACORE_DONE, bar); + let mut baz = aes_csr.zf(utra::aes::SFR_FR_ACORE_DONE, bar); + baz |= aes_csr.ms(utra::aes::SFR_FR_ACORE_DONE, 1); + aes_csr.wfo(utra::aes::SFR_FR_ACORE_DONE, baz); + let bar = aes_csr.rf(utra::aes::SFR_FR_CHNLO_DONE); + aes_csr.rmwf(utra::aes::SFR_FR_CHNLO_DONE, bar); + let mut baz = aes_csr.zf(utra::aes::SFR_FR_CHNLO_DONE, bar); + baz |= aes_csr.ms(utra::aes::SFR_FR_CHNLO_DONE, 1); + aes_csr.wfo(utra::aes::SFR_FR_CHNLO_DONE, baz); + let bar = aes_csr.rf(utra::aes::SFR_FR_CHNLI_DONE); + aes_csr.rmwf(utra::aes::SFR_FR_CHNLI_DONE, bar); + let mut baz = aes_csr.zf(utra::aes::SFR_FR_CHNLI_DONE, bar); + baz |= aes_csr.ms(utra::aes::SFR_FR_CHNLI_DONE, 1); + aes_csr.wfo(utra::aes::SFR_FR_CHNLI_DONE, baz); + + let foo = aes_csr.r(utra::aes::SFR_OPT); + aes_csr.wo(utra::aes::SFR_OPT, foo); + let bar = aes_csr.rf(utra::aes::SFR_OPT_OPT_KLEN0); + aes_csr.rmwf(utra::aes::SFR_OPT_OPT_KLEN0, bar); + let mut baz = aes_csr.zf(utra::aes::SFR_OPT_OPT_KLEN0, bar); + baz |= aes_csr.ms(utra::aes::SFR_OPT_OPT_KLEN0, 1); + aes_csr.wfo(utra::aes::SFR_OPT_OPT_KLEN0, baz); + let bar = aes_csr.rf(utra::aes::SFR_OPT_OPT_MODE0); + aes_csr.rmwf(utra::aes::SFR_OPT_OPT_MODE0, bar); + let mut baz = aes_csr.zf(utra::aes::SFR_OPT_OPT_MODE0, bar); + baz |= aes_csr.ms(utra::aes::SFR_OPT_OPT_MODE0, 1); + aes_csr.wfo(utra::aes::SFR_OPT_OPT_MODE0, baz); + let bar = aes_csr.rf(utra::aes::SFR_OPT_OPT_IFSTART0); + aes_csr.rmwf(utra::aes::SFR_OPT_OPT_IFSTART0, bar); + let mut baz = aes_csr.zf(utra::aes::SFR_OPT_OPT_IFSTART0, bar); + baz |= aes_csr.ms(utra::aes::SFR_OPT_OPT_IFSTART0, 1); + aes_csr.wfo(utra::aes::SFR_OPT_OPT_IFSTART0, baz); + + let foo = aes_csr.r(utra::aes::SFR_OPT1); + aes_csr.wo(utra::aes::SFR_OPT1, foo); + let bar = aes_csr.rf(utra::aes::SFR_OPT1_SFR_OPT1); + aes_csr.rmwf(utra::aes::SFR_OPT1_SFR_OPT1, bar); + let mut baz = aes_csr.zf(utra::aes::SFR_OPT1_SFR_OPT1, bar); + baz |= aes_csr.ms(utra::aes::SFR_OPT1_SFR_OPT1, 1); + aes_csr.wfo(utra::aes::SFR_OPT1_SFR_OPT1, baz); + + let foo = aes_csr.r(utra::aes::SFR_SEGPTR_PTRID_IV); + aes_csr.wo(utra::aes::SFR_SEGPTR_PTRID_IV, foo); + let bar = aes_csr.rf(utra::aes::SFR_SEGPTR_PTRID_IV_PTRID_IV); + aes_csr.rmwf(utra::aes::SFR_SEGPTR_PTRID_IV_PTRID_IV, bar); + let mut baz = aes_csr.zf(utra::aes::SFR_SEGPTR_PTRID_IV_PTRID_IV, bar); + baz |= aes_csr.ms(utra::aes::SFR_SEGPTR_PTRID_IV_PTRID_IV, 1); + aes_csr.wfo(utra::aes::SFR_SEGPTR_PTRID_IV_PTRID_IV, baz); + + let foo = aes_csr.r(utra::aes::SFR_SEGPTR_PTRID_AKEY); + aes_csr.wo(utra::aes::SFR_SEGPTR_PTRID_AKEY, foo); + let bar = aes_csr.rf(utra::aes::SFR_SEGPTR_PTRID_AKEY_PTRID_AKEY); + aes_csr.rmwf(utra::aes::SFR_SEGPTR_PTRID_AKEY_PTRID_AKEY, bar); + let mut baz = aes_csr.zf(utra::aes::SFR_SEGPTR_PTRID_AKEY_PTRID_AKEY, bar); + baz |= aes_csr.ms(utra::aes::SFR_SEGPTR_PTRID_AKEY_PTRID_AKEY, 1); + aes_csr.wfo(utra::aes::SFR_SEGPTR_PTRID_AKEY_PTRID_AKEY, baz); + + let foo = aes_csr.r(utra::aes::SFR_SEGPTR_PTRID_AIB); + aes_csr.wo(utra::aes::SFR_SEGPTR_PTRID_AIB, foo); + let bar = aes_csr.rf(utra::aes::SFR_SEGPTR_PTRID_AIB_PTRID_AIB); + aes_csr.rmwf(utra::aes::SFR_SEGPTR_PTRID_AIB_PTRID_AIB, bar); + let mut baz = aes_csr.zf(utra::aes::SFR_SEGPTR_PTRID_AIB_PTRID_AIB, bar); + baz |= aes_csr.ms(utra::aes::SFR_SEGPTR_PTRID_AIB_PTRID_AIB, 1); + aes_csr.wfo(utra::aes::SFR_SEGPTR_PTRID_AIB_PTRID_AIB, baz); + + let foo = aes_csr.r(utra::aes::SFR_SEGPTR_PTRID_AOB); + aes_csr.wo(utra::aes::SFR_SEGPTR_PTRID_AOB, foo); + let bar = aes_csr.rf(utra::aes::SFR_SEGPTR_PTRID_AOB_PTRID_AOB); + aes_csr.rmwf(utra::aes::SFR_SEGPTR_PTRID_AOB_PTRID_AOB, bar); + let mut baz = aes_csr.zf(utra::aes::SFR_SEGPTR_PTRID_AOB_PTRID_AOB, bar); + baz |= aes_csr.ms(utra::aes::SFR_SEGPTR_PTRID_AOB_PTRID_AOB, 1); + aes_csr.wfo(utra::aes::SFR_SEGPTR_PTRID_AOB_PTRID_AOB, baz); + } + + #[test] + #[ignore] + fn compile_check_combohash_csr() { + use super::*; + let mut combohash_csr = CSR::new(HW_COMBOHASH_BASE as *mut u32); + + let foo = combohash_csr.r(utra::combohash::SFR_CRFUNC); + combohash_csr.wo(utra::combohash::SFR_CRFUNC, foo); + let bar = combohash_csr.rf(utra::combohash::SFR_CRFUNC_CR_FUNC); + combohash_csr.rmwf(utra::combohash::SFR_CRFUNC_CR_FUNC, bar); + let mut baz = combohash_csr.zf(utra::combohash::SFR_CRFUNC_CR_FUNC, bar); + baz |= combohash_csr.ms(utra::combohash::SFR_CRFUNC_CR_FUNC, 1); + combohash_csr.wfo(utra::combohash::SFR_CRFUNC_CR_FUNC, baz); + + let foo = combohash_csr.r(utra::combohash::SFR_AR); + combohash_csr.wo(utra::combohash::SFR_AR, foo); + let bar = combohash_csr.rf(utra::combohash::SFR_AR_SFR_AR); + combohash_csr.rmwf(utra::combohash::SFR_AR_SFR_AR, bar); + let mut baz = combohash_csr.zf(utra::combohash::SFR_AR_SFR_AR, bar); + baz |= combohash_csr.ms(utra::combohash::SFR_AR_SFR_AR, 1); + combohash_csr.wfo(utra::combohash::SFR_AR_SFR_AR, baz); + + let foo = combohash_csr.r(utra::combohash::SFR_SRMFSM); + combohash_csr.wo(utra::combohash::SFR_SRMFSM, foo); + let bar = combohash_csr.rf(utra::combohash::SFR_SRMFSM_MFSM); + combohash_csr.rmwf(utra::combohash::SFR_SRMFSM_MFSM, bar); + let mut baz = combohash_csr.zf(utra::combohash::SFR_SRMFSM_MFSM, bar); + baz |= combohash_csr.ms(utra::combohash::SFR_SRMFSM_MFSM, 1); + combohash_csr.wfo(utra::combohash::SFR_SRMFSM_MFSM, baz); + + let foo = combohash_csr.r(utra::combohash::SFR_FR); + combohash_csr.wo(utra::combohash::SFR_FR, foo); + let bar = combohash_csr.rf(utra::combohash::SFR_FR_MFSM_DONE); + combohash_csr.rmwf(utra::combohash::SFR_FR_MFSM_DONE, bar); + let mut baz = combohash_csr.zf(utra::combohash::SFR_FR_MFSM_DONE, bar); + baz |= combohash_csr.ms(utra::combohash::SFR_FR_MFSM_DONE, 1); + combohash_csr.wfo(utra::combohash::SFR_FR_MFSM_DONE, baz); + let bar = combohash_csr.rf(utra::combohash::SFR_FR_HASH_DONE); + combohash_csr.rmwf(utra::combohash::SFR_FR_HASH_DONE, bar); + let mut baz = combohash_csr.zf(utra::combohash::SFR_FR_HASH_DONE, bar); + baz |= combohash_csr.ms(utra::combohash::SFR_FR_HASH_DONE, 1); + combohash_csr.wfo(utra::combohash::SFR_FR_HASH_DONE, baz); + let bar = combohash_csr.rf(utra::combohash::SFR_FR_CHNLO_DONE); + combohash_csr.rmwf(utra::combohash::SFR_FR_CHNLO_DONE, bar); + let mut baz = combohash_csr.zf(utra::combohash::SFR_FR_CHNLO_DONE, bar); + baz |= combohash_csr.ms(utra::combohash::SFR_FR_CHNLO_DONE, 1); + combohash_csr.wfo(utra::combohash::SFR_FR_CHNLO_DONE, baz); + let bar = combohash_csr.rf(utra::combohash::SFR_FR_CHNLI_DONE); + combohash_csr.rmwf(utra::combohash::SFR_FR_CHNLI_DONE, bar); + let mut baz = combohash_csr.zf(utra::combohash::SFR_FR_CHNLI_DONE, bar); + baz |= combohash_csr.ms(utra::combohash::SFR_FR_CHNLI_DONE, 1); + combohash_csr.wfo(utra::combohash::SFR_FR_CHNLI_DONE, baz); + + let foo = combohash_csr.r(utra::combohash::SFR_OPT1); + combohash_csr.wo(utra::combohash::SFR_OPT1, foo); + let bar = combohash_csr.rf(utra::combohash::SFR_OPT1_CR_OPT_HASHCNT); + combohash_csr.rmwf(utra::combohash::SFR_OPT1_CR_OPT_HASHCNT, bar); + let mut baz = combohash_csr.zf(utra::combohash::SFR_OPT1_CR_OPT_HASHCNT, bar); + baz |= combohash_csr.ms(utra::combohash::SFR_OPT1_CR_OPT_HASHCNT, 1); + combohash_csr.wfo(utra::combohash::SFR_OPT1_CR_OPT_HASHCNT, baz); + + let foo = combohash_csr.r(utra::combohash::SFR_OPT2); + combohash_csr.wo(utra::combohash::SFR_OPT2, foo); + let bar = combohash_csr.rf(utra::combohash::SFR_OPT2_CR_OPT_SCRTCHK); + combohash_csr.rmwf(utra::combohash::SFR_OPT2_CR_OPT_SCRTCHK, bar); + let mut baz = combohash_csr.zf(utra::combohash::SFR_OPT2_CR_OPT_SCRTCHK, bar); + baz |= combohash_csr.ms(utra::combohash::SFR_OPT2_CR_OPT_SCRTCHK, 1); + combohash_csr.wfo(utra::combohash::SFR_OPT2_CR_OPT_SCRTCHK, baz); + let bar = combohash_csr.rf(utra::combohash::SFR_OPT2_CR_OPT_IFSOB); + combohash_csr.rmwf(utra::combohash::SFR_OPT2_CR_OPT_IFSOB, bar); + let mut baz = combohash_csr.zf(utra::combohash::SFR_OPT2_CR_OPT_IFSOB, bar); + baz |= combohash_csr.ms(utra::combohash::SFR_OPT2_CR_OPT_IFSOB, 1); + combohash_csr.wfo(utra::combohash::SFR_OPT2_CR_OPT_IFSOB, baz); + let bar = combohash_csr.rf(utra::combohash::SFR_OPT2_CR_OPT_IFSTART); + combohash_csr.rmwf(utra::combohash::SFR_OPT2_CR_OPT_IFSTART, bar); + let mut baz = combohash_csr.zf(utra::combohash::SFR_OPT2_CR_OPT_IFSTART, bar); + baz |= combohash_csr.ms(utra::combohash::SFR_OPT2_CR_OPT_IFSTART, 1); + combohash_csr.wfo(utra::combohash::SFR_OPT2_CR_OPT_IFSTART, baz); + + let foo = combohash_csr.r(utra::combohash::SFR_SEGPTR_SEGID_LKEY); + combohash_csr.wo(utra::combohash::SFR_SEGPTR_SEGID_LKEY, foo); + let bar = combohash_csr.rf(utra::combohash::SFR_SEGPTR_SEGID_LKEY_SEGID_LKEY); + combohash_csr.rmwf(utra::combohash::SFR_SEGPTR_SEGID_LKEY_SEGID_LKEY, bar); + let mut baz = combohash_csr.zf(utra::combohash::SFR_SEGPTR_SEGID_LKEY_SEGID_LKEY, bar); + baz |= combohash_csr.ms(utra::combohash::SFR_SEGPTR_SEGID_LKEY_SEGID_LKEY, 1); + combohash_csr.wfo(utra::combohash::SFR_SEGPTR_SEGID_LKEY_SEGID_LKEY, baz); + + let foo = combohash_csr.r(utra::combohash::SFR_SEGPTR_SEGID_KEY); + combohash_csr.wo(utra::combohash::SFR_SEGPTR_SEGID_KEY, foo); + let bar = combohash_csr.rf(utra::combohash::SFR_SEGPTR_SEGID_KEY_SEGID_KEY); + combohash_csr.rmwf(utra::combohash::SFR_SEGPTR_SEGID_KEY_SEGID_KEY, bar); + let mut baz = combohash_csr.zf(utra::combohash::SFR_SEGPTR_SEGID_KEY_SEGID_KEY, bar); + baz |= combohash_csr.ms(utra::combohash::SFR_SEGPTR_SEGID_KEY_SEGID_KEY, 1); + combohash_csr.wfo(utra::combohash::SFR_SEGPTR_SEGID_KEY_SEGID_KEY, baz); + + let foo = combohash_csr.r(utra::combohash::SFR_SEGPTR_SEGID_SCRT); + combohash_csr.wo(utra::combohash::SFR_SEGPTR_SEGID_SCRT, foo); + let bar = combohash_csr.rf(utra::combohash::SFR_SEGPTR_SEGID_SCRT_SEGID_SCRT); + combohash_csr.rmwf(utra::combohash::SFR_SEGPTR_SEGID_SCRT_SEGID_SCRT, bar); + let mut baz = combohash_csr.zf(utra::combohash::SFR_SEGPTR_SEGID_SCRT_SEGID_SCRT, bar); + baz |= combohash_csr.ms(utra::combohash::SFR_SEGPTR_SEGID_SCRT_SEGID_SCRT, 1); + combohash_csr.wfo(utra::combohash::SFR_SEGPTR_SEGID_SCRT_SEGID_SCRT, baz); + + let foo = combohash_csr.r(utra::combohash::SFR_SEGPTR_SEGID_MSG); + combohash_csr.wo(utra::combohash::SFR_SEGPTR_SEGID_MSG, foo); + let bar = combohash_csr.rf(utra::combohash::SFR_SEGPTR_SEGID_MSG_SEGID_MSG); + combohash_csr.rmwf(utra::combohash::SFR_SEGPTR_SEGID_MSG_SEGID_MSG, bar); + let mut baz = combohash_csr.zf(utra::combohash::SFR_SEGPTR_SEGID_MSG_SEGID_MSG, bar); + baz |= combohash_csr.ms(utra::combohash::SFR_SEGPTR_SEGID_MSG_SEGID_MSG, 1); + combohash_csr.wfo(utra::combohash::SFR_SEGPTR_SEGID_MSG_SEGID_MSG, baz); + + let foo = combohash_csr.r(utra::combohash::SFR_SEGPTR_SEGID_HOUT); + combohash_csr.wo(utra::combohash::SFR_SEGPTR_SEGID_HOUT, foo); + let bar = combohash_csr.rf(utra::combohash::SFR_SEGPTR_SEGID_HOUT_SEGID_HOUT); + combohash_csr.rmwf(utra::combohash::SFR_SEGPTR_SEGID_HOUT_SEGID_HOUT, bar); + let mut baz = combohash_csr.zf(utra::combohash::SFR_SEGPTR_SEGID_HOUT_SEGID_HOUT, bar); + baz |= combohash_csr.ms(utra::combohash::SFR_SEGPTR_SEGID_HOUT_SEGID_HOUT, 1); + combohash_csr.wfo(utra::combohash::SFR_SEGPTR_SEGID_HOUT_SEGID_HOUT, baz); + + let foo = combohash_csr.r(utra::combohash::SFR_SEGPTR_SEGID_SOB); + combohash_csr.wo(utra::combohash::SFR_SEGPTR_SEGID_SOB, foo); + let bar = combohash_csr.rf(utra::combohash::SFR_SEGPTR_SEGID_SOB_SEGID_SOB); + combohash_csr.rmwf(utra::combohash::SFR_SEGPTR_SEGID_SOB_SEGID_SOB, bar); + let mut baz = combohash_csr.zf(utra::combohash::SFR_SEGPTR_SEGID_SOB_SEGID_SOB, bar); + baz |= combohash_csr.ms(utra::combohash::SFR_SEGPTR_SEGID_SOB_SEGID_SOB, 1); + combohash_csr.wfo(utra::combohash::SFR_SEGPTR_SEGID_SOB_SEGID_SOB, baz); + } + + #[test] + #[ignore] + fn compile_check_pke_csr() { + use super::*; + let mut pke_csr = CSR::new(HW_PKE_BASE as *mut u32); + + let foo = pke_csr.r(utra::pke::SFR_CRFUNC); + pke_csr.wo(utra::pke::SFR_CRFUNC, foo); + let bar = pke_csr.rf(utra::pke::SFR_CRFUNC_SFR_CRFUNC); + pke_csr.rmwf(utra::pke::SFR_CRFUNC_SFR_CRFUNC, bar); + let mut baz = pke_csr.zf(utra::pke::SFR_CRFUNC_SFR_CRFUNC, bar); + baz |= pke_csr.ms(utra::pke::SFR_CRFUNC_SFR_CRFUNC, 1); + pke_csr.wfo(utra::pke::SFR_CRFUNC_SFR_CRFUNC, baz); + + let foo = pke_csr.r(utra::pke::SFR_AR); + pke_csr.wo(utra::pke::SFR_AR, foo); + let bar = pke_csr.rf(utra::pke::SFR_AR_SFR_AR); + pke_csr.rmwf(utra::pke::SFR_AR_SFR_AR, bar); + let mut baz = pke_csr.zf(utra::pke::SFR_AR_SFR_AR, bar); + baz |= pke_csr.ms(utra::pke::SFR_AR_SFR_AR, 1); + pke_csr.wfo(utra::pke::SFR_AR_SFR_AR, baz); + + let foo = pke_csr.r(utra::pke::SFR_SRMFSM); + pke_csr.wo(utra::pke::SFR_SRMFSM, foo); + let bar = pke_csr.rf(utra::pke::SFR_SRMFSM_MFSM); + pke_csr.rmwf(utra::pke::SFR_SRMFSM_MFSM, bar); + let mut baz = pke_csr.zf(utra::pke::SFR_SRMFSM_MFSM, bar); + baz |= pke_csr.ms(utra::pke::SFR_SRMFSM_MFSM, 1); + pke_csr.wfo(utra::pke::SFR_SRMFSM_MFSM, baz); + let bar = pke_csr.rf(utra::pke::SFR_SRMFSM_MODINVREADY); + pke_csr.rmwf(utra::pke::SFR_SRMFSM_MODINVREADY, bar); + let mut baz = pke_csr.zf(utra::pke::SFR_SRMFSM_MODINVREADY, bar); + baz |= pke_csr.ms(utra::pke::SFR_SRMFSM_MODINVREADY, 1); + pke_csr.wfo(utra::pke::SFR_SRMFSM_MODINVREADY, baz); + + let foo = pke_csr.r(utra::pke::SFR_FR); + pke_csr.wo(utra::pke::SFR_FR, foo); + let bar = pke_csr.rf(utra::pke::SFR_FR_MFSM_DONE); + pke_csr.rmwf(utra::pke::SFR_FR_MFSM_DONE, bar); + let mut baz = pke_csr.zf(utra::pke::SFR_FR_MFSM_DONE, bar); + baz |= pke_csr.ms(utra::pke::SFR_FR_MFSM_DONE, 1); + pke_csr.wfo(utra::pke::SFR_FR_MFSM_DONE, baz); + let bar = pke_csr.rf(utra::pke::SFR_FR_PCORE_DONE); + pke_csr.rmwf(utra::pke::SFR_FR_PCORE_DONE, bar); + let mut baz = pke_csr.zf(utra::pke::SFR_FR_PCORE_DONE, bar); + baz |= pke_csr.ms(utra::pke::SFR_FR_PCORE_DONE, 1); + pke_csr.wfo(utra::pke::SFR_FR_PCORE_DONE, baz); + let bar = pke_csr.rf(utra::pke::SFR_FR_CHNLO_DONE); + pke_csr.rmwf(utra::pke::SFR_FR_CHNLO_DONE, bar); + let mut baz = pke_csr.zf(utra::pke::SFR_FR_CHNLO_DONE, bar); + baz |= pke_csr.ms(utra::pke::SFR_FR_CHNLO_DONE, 1); + pke_csr.wfo(utra::pke::SFR_FR_CHNLO_DONE, baz); + let bar = pke_csr.rf(utra::pke::SFR_FR_CHNLI_DONE); + pke_csr.rmwf(utra::pke::SFR_FR_CHNLI_DONE, bar); + let mut baz = pke_csr.zf(utra::pke::SFR_FR_CHNLI_DONE, bar); + baz |= pke_csr.ms(utra::pke::SFR_FR_CHNLI_DONE, 1); + pke_csr.wfo(utra::pke::SFR_FR_CHNLI_DONE, baz); + let bar = pke_csr.rf(utra::pke::SFR_FR_CHNLX_DONE); + pke_csr.rmwf(utra::pke::SFR_FR_CHNLX_DONE, bar); + let mut baz = pke_csr.zf(utra::pke::SFR_FR_CHNLX_DONE, bar); + baz |= pke_csr.ms(utra::pke::SFR_FR_CHNLX_DONE, 1); + pke_csr.wfo(utra::pke::SFR_FR_CHNLX_DONE, baz); + + let foo = pke_csr.r(utra::pke::SFR_OPTNW); + pke_csr.wo(utra::pke::SFR_OPTNW, foo); + let bar = pke_csr.rf(utra::pke::SFR_OPTNW_SFR_OPTNW); + pke_csr.rmwf(utra::pke::SFR_OPTNW_SFR_OPTNW, bar); + let mut baz = pke_csr.zf(utra::pke::SFR_OPTNW_SFR_OPTNW, bar); + baz |= pke_csr.ms(utra::pke::SFR_OPTNW_SFR_OPTNW, 1); + pke_csr.wfo(utra::pke::SFR_OPTNW_SFR_OPTNW, baz); + + let foo = pke_csr.r(utra::pke::SFR_OPTEW); + pke_csr.wo(utra::pke::SFR_OPTEW, foo); + let bar = pke_csr.rf(utra::pke::SFR_OPTEW_SFR_OPTEW); + pke_csr.rmwf(utra::pke::SFR_OPTEW_SFR_OPTEW, bar); + let mut baz = pke_csr.zf(utra::pke::SFR_OPTEW_SFR_OPTEW, bar); + baz |= pke_csr.ms(utra::pke::SFR_OPTEW_SFR_OPTEW, 1); + pke_csr.wfo(utra::pke::SFR_OPTEW_SFR_OPTEW, baz); + + let foo = pke_csr.r(utra::pke::SFR_OPTMASK); + pke_csr.wo(utra::pke::SFR_OPTMASK, foo); + let bar = pke_csr.rf(utra::pke::SFR_OPTMASK_SFR_OPTMASK); + pke_csr.rmwf(utra::pke::SFR_OPTMASK_SFR_OPTMASK, bar); + let mut baz = pke_csr.zf(utra::pke::SFR_OPTMASK_SFR_OPTMASK, bar); + baz |= pke_csr.ms(utra::pke::SFR_OPTMASK_SFR_OPTMASK, 1); + pke_csr.wfo(utra::pke::SFR_OPTMASK_SFR_OPTMASK, baz); + + let foo = pke_csr.r(utra::pke::SFR_SEGPTR_PTRID_PCON); + pke_csr.wo(utra::pke::SFR_SEGPTR_PTRID_PCON, foo); + let bar = pke_csr.rf(utra::pke::SFR_SEGPTR_PTRID_PCON_PTRID_PCON); + pke_csr.rmwf(utra::pke::SFR_SEGPTR_PTRID_PCON_PTRID_PCON, bar); + let mut baz = pke_csr.zf(utra::pke::SFR_SEGPTR_PTRID_PCON_PTRID_PCON, bar); + baz |= pke_csr.ms(utra::pke::SFR_SEGPTR_PTRID_PCON_PTRID_PCON, 1); + pke_csr.wfo(utra::pke::SFR_SEGPTR_PTRID_PCON_PTRID_PCON, baz); + + let foo = pke_csr.r(utra::pke::SFR_SEGPTR_PTRID_PIB0); + pke_csr.wo(utra::pke::SFR_SEGPTR_PTRID_PIB0, foo); + let bar = pke_csr.rf(utra::pke::SFR_SEGPTR_PTRID_PIB0_PTRID_PIB0); + pke_csr.rmwf(utra::pke::SFR_SEGPTR_PTRID_PIB0_PTRID_PIB0, bar); + let mut baz = pke_csr.zf(utra::pke::SFR_SEGPTR_PTRID_PIB0_PTRID_PIB0, bar); + baz |= pke_csr.ms(utra::pke::SFR_SEGPTR_PTRID_PIB0_PTRID_PIB0, 1); + pke_csr.wfo(utra::pke::SFR_SEGPTR_PTRID_PIB0_PTRID_PIB0, baz); + + let foo = pke_csr.r(utra::pke::SFR_SEGPTR_PTRID_PIB1); + pke_csr.wo(utra::pke::SFR_SEGPTR_PTRID_PIB1, foo); + let bar = pke_csr.rf(utra::pke::SFR_SEGPTR_PTRID_PIB1_PTRID_PIB1); + pke_csr.rmwf(utra::pke::SFR_SEGPTR_PTRID_PIB1_PTRID_PIB1, bar); + let mut baz = pke_csr.zf(utra::pke::SFR_SEGPTR_PTRID_PIB1_PTRID_PIB1, bar); + baz |= pke_csr.ms(utra::pke::SFR_SEGPTR_PTRID_PIB1_PTRID_PIB1, 1); + pke_csr.wfo(utra::pke::SFR_SEGPTR_PTRID_PIB1_PTRID_PIB1, baz); + + let foo = pke_csr.r(utra::pke::SFR_SEGPTR_PTRID_PKB); + pke_csr.wo(utra::pke::SFR_SEGPTR_PTRID_PKB, foo); + let bar = pke_csr.rf(utra::pke::SFR_SEGPTR_PTRID_PKB_PTRID_PKB); + pke_csr.rmwf(utra::pke::SFR_SEGPTR_PTRID_PKB_PTRID_PKB, bar); + let mut baz = pke_csr.zf(utra::pke::SFR_SEGPTR_PTRID_PKB_PTRID_PKB, bar); + baz |= pke_csr.ms(utra::pke::SFR_SEGPTR_PTRID_PKB_PTRID_PKB, 1); + pke_csr.wfo(utra::pke::SFR_SEGPTR_PTRID_PKB_PTRID_PKB, baz); + + let foo = pke_csr.r(utra::pke::SFR_SEGPTR_PTRID_POB); + pke_csr.wo(utra::pke::SFR_SEGPTR_PTRID_POB, foo); + let bar = pke_csr.rf(utra::pke::SFR_SEGPTR_PTRID_POB_PTRID_POB); + pke_csr.rmwf(utra::pke::SFR_SEGPTR_PTRID_POB_PTRID_POB, bar); + let mut baz = pke_csr.zf(utra::pke::SFR_SEGPTR_PTRID_POB_PTRID_POB, bar); + baz |= pke_csr.ms(utra::pke::SFR_SEGPTR_PTRID_POB_PTRID_POB, 1); + pke_csr.wfo(utra::pke::SFR_SEGPTR_PTRID_POB_PTRID_POB, baz); + } + + #[test] + #[ignore] + fn compile_check_scedma_csr() { + use super::*; + let mut scedma_csr = CSR::new(HW_SCEDMA_BASE as *mut u32); + + let foo = scedma_csr.r(utra::scedma::SFR_SCHSTART_AR); + scedma_csr.wo(utra::scedma::SFR_SCHSTART_AR, foo); + let bar = scedma_csr.rf(utra::scedma::SFR_SCHSTART_AR_SFR_SCHSTART_AR); + scedma_csr.rmwf(utra::scedma::SFR_SCHSTART_AR_SFR_SCHSTART_AR, bar); + let mut baz = scedma_csr.zf(utra::scedma::SFR_SCHSTART_AR_SFR_SCHSTART_AR, bar); + baz |= scedma_csr.ms(utra::scedma::SFR_SCHSTART_AR_SFR_SCHSTART_AR, 1); + scedma_csr.wfo(utra::scedma::SFR_SCHSTART_AR_SFR_SCHSTART_AR, baz); + + let foo = scedma_csr.r(utra::scedma::SFR_XCH_FUNC); + scedma_csr.wo(utra::scedma::SFR_XCH_FUNC, foo); + let bar = scedma_csr.rf(utra::scedma::SFR_XCH_FUNC_SFR_XCH_FUNC); + scedma_csr.rmwf(utra::scedma::SFR_XCH_FUNC_SFR_XCH_FUNC, bar); + let mut baz = scedma_csr.zf(utra::scedma::SFR_XCH_FUNC_SFR_XCH_FUNC, bar); + baz |= scedma_csr.ms(utra::scedma::SFR_XCH_FUNC_SFR_XCH_FUNC, 1); + scedma_csr.wfo(utra::scedma::SFR_XCH_FUNC_SFR_XCH_FUNC, baz); + + let foo = scedma_csr.r(utra::scedma::SFR_XCH_OPT); + scedma_csr.wo(utra::scedma::SFR_XCH_OPT, foo); + let bar = scedma_csr.rf(utra::scedma::SFR_XCH_OPT_SFR_XCH_OPT); + scedma_csr.rmwf(utra::scedma::SFR_XCH_OPT_SFR_XCH_OPT, bar); + let mut baz = scedma_csr.zf(utra::scedma::SFR_XCH_OPT_SFR_XCH_OPT, bar); + baz |= scedma_csr.ms(utra::scedma::SFR_XCH_OPT_SFR_XCH_OPT, 1); + scedma_csr.wfo(utra::scedma::SFR_XCH_OPT_SFR_XCH_OPT, baz); + + let foo = scedma_csr.r(utra::scedma::SFR_XCH_AXSTART); + scedma_csr.wo(utra::scedma::SFR_XCH_AXSTART, foo); + let bar = scedma_csr.rf(utra::scedma::SFR_XCH_AXSTART_SFR_XCH_AXSTART); + scedma_csr.rmwf(utra::scedma::SFR_XCH_AXSTART_SFR_XCH_AXSTART, bar); + let mut baz = scedma_csr.zf(utra::scedma::SFR_XCH_AXSTART_SFR_XCH_AXSTART, bar); + baz |= scedma_csr.ms(utra::scedma::SFR_XCH_AXSTART_SFR_XCH_AXSTART, 1); + scedma_csr.wfo(utra::scedma::SFR_XCH_AXSTART_SFR_XCH_AXSTART, baz); + + let foo = scedma_csr.r(utra::scedma::SFR_XCH_SEGID); + scedma_csr.wo(utra::scedma::SFR_XCH_SEGID, foo); + let bar = scedma_csr.rf(utra::scedma::SFR_XCH_SEGID_SFR_XCH_SEGID); + scedma_csr.rmwf(utra::scedma::SFR_XCH_SEGID_SFR_XCH_SEGID, bar); + let mut baz = scedma_csr.zf(utra::scedma::SFR_XCH_SEGID_SFR_XCH_SEGID, bar); + baz |= scedma_csr.ms(utra::scedma::SFR_XCH_SEGID_SFR_XCH_SEGID, 1); + scedma_csr.wfo(utra::scedma::SFR_XCH_SEGID_SFR_XCH_SEGID, baz); + + let foo = scedma_csr.r(utra::scedma::SFR_XCH_SEGSTART); + scedma_csr.wo(utra::scedma::SFR_XCH_SEGSTART, foo); + let bar = scedma_csr.rf(utra::scedma::SFR_XCH_SEGSTART_XCHCR_SEGSTART); + scedma_csr.rmwf(utra::scedma::SFR_XCH_SEGSTART_XCHCR_SEGSTART, bar); + let mut baz = scedma_csr.zf(utra::scedma::SFR_XCH_SEGSTART_XCHCR_SEGSTART, bar); + baz |= scedma_csr.ms(utra::scedma::SFR_XCH_SEGSTART_XCHCR_SEGSTART, 1); + scedma_csr.wfo(utra::scedma::SFR_XCH_SEGSTART_XCHCR_SEGSTART, baz); + + let foo = scedma_csr.r(utra::scedma::SFR_XCH_TRANSIZE); + scedma_csr.wo(utra::scedma::SFR_XCH_TRANSIZE, foo); + let bar = scedma_csr.rf(utra::scedma::SFR_XCH_TRANSIZE_XCHCR_TRANSIZE); + scedma_csr.rmwf(utra::scedma::SFR_XCH_TRANSIZE_XCHCR_TRANSIZE, bar); + let mut baz = scedma_csr.zf(utra::scedma::SFR_XCH_TRANSIZE_XCHCR_TRANSIZE, bar); + baz |= scedma_csr.ms(utra::scedma::SFR_XCH_TRANSIZE_XCHCR_TRANSIZE, 1); + scedma_csr.wfo(utra::scedma::SFR_XCH_TRANSIZE_XCHCR_TRANSIZE, baz); + + let foo = scedma_csr.r(utra::scedma::SFR_SCH_FUNC); + scedma_csr.wo(utra::scedma::SFR_SCH_FUNC, foo); + let bar = scedma_csr.rf(utra::scedma::SFR_SCH_FUNC_SFR_SCH_FUNC); + scedma_csr.rmwf(utra::scedma::SFR_SCH_FUNC_SFR_SCH_FUNC, bar); + let mut baz = scedma_csr.zf(utra::scedma::SFR_SCH_FUNC_SFR_SCH_FUNC, bar); + baz |= scedma_csr.ms(utra::scedma::SFR_SCH_FUNC_SFR_SCH_FUNC, 1); + scedma_csr.wfo(utra::scedma::SFR_SCH_FUNC_SFR_SCH_FUNC, baz); + + let foo = scedma_csr.r(utra::scedma::SFR_SCH_OPT); + scedma_csr.wo(utra::scedma::SFR_SCH_OPT, foo); + let bar = scedma_csr.rf(utra::scedma::SFR_SCH_OPT_SFR_SCH_OPT); + scedma_csr.rmwf(utra::scedma::SFR_SCH_OPT_SFR_SCH_OPT, bar); + let mut baz = scedma_csr.zf(utra::scedma::SFR_SCH_OPT_SFR_SCH_OPT, bar); + baz |= scedma_csr.ms(utra::scedma::SFR_SCH_OPT_SFR_SCH_OPT, 1); + scedma_csr.wfo(utra::scedma::SFR_SCH_OPT_SFR_SCH_OPT, baz); + + let foo = scedma_csr.r(utra::scedma::SFR_SCH_AXSTART); + scedma_csr.wo(utra::scedma::SFR_SCH_AXSTART, foo); + let bar = scedma_csr.rf(utra::scedma::SFR_SCH_AXSTART_SFR_SCH_AXSTART); + scedma_csr.rmwf(utra::scedma::SFR_SCH_AXSTART_SFR_SCH_AXSTART, bar); + let mut baz = scedma_csr.zf(utra::scedma::SFR_SCH_AXSTART_SFR_SCH_AXSTART, bar); + baz |= scedma_csr.ms(utra::scedma::SFR_SCH_AXSTART_SFR_SCH_AXSTART, 1); + scedma_csr.wfo(utra::scedma::SFR_SCH_AXSTART_SFR_SCH_AXSTART, baz); + + let foo = scedma_csr.r(utra::scedma::SFR_SCH_SEGID); + scedma_csr.wo(utra::scedma::SFR_SCH_SEGID, foo); + let bar = scedma_csr.rf(utra::scedma::SFR_SCH_SEGID_SFR_SCH_SEGID); + scedma_csr.rmwf(utra::scedma::SFR_SCH_SEGID_SFR_SCH_SEGID, bar); + let mut baz = scedma_csr.zf(utra::scedma::SFR_SCH_SEGID_SFR_SCH_SEGID, bar); + baz |= scedma_csr.ms(utra::scedma::SFR_SCH_SEGID_SFR_SCH_SEGID, 1); + scedma_csr.wfo(utra::scedma::SFR_SCH_SEGID_SFR_SCH_SEGID, baz); + + let foo = scedma_csr.r(utra::scedma::SFR_SCH_SEGSTART); + scedma_csr.wo(utra::scedma::SFR_SCH_SEGSTART, foo); + let bar = scedma_csr.rf(utra::scedma::SFR_SCH_SEGSTART_SCHCR_SEGSTART); + scedma_csr.rmwf(utra::scedma::SFR_SCH_SEGSTART_SCHCR_SEGSTART, bar); + let mut baz = scedma_csr.zf(utra::scedma::SFR_SCH_SEGSTART_SCHCR_SEGSTART, bar); + baz |= scedma_csr.ms(utra::scedma::SFR_SCH_SEGSTART_SCHCR_SEGSTART, 1); + scedma_csr.wfo(utra::scedma::SFR_SCH_SEGSTART_SCHCR_SEGSTART, baz); + + let foo = scedma_csr.r(utra::scedma::SFR_SCH_TRANSIZE); + scedma_csr.wo(utra::scedma::SFR_SCH_TRANSIZE, foo); + let bar = scedma_csr.rf(utra::scedma::SFR_SCH_TRANSIZE_SCHCR_TRANSIZE); + scedma_csr.rmwf(utra::scedma::SFR_SCH_TRANSIZE_SCHCR_TRANSIZE, bar); + let mut baz = scedma_csr.zf(utra::scedma::SFR_SCH_TRANSIZE_SCHCR_TRANSIZE, bar); + baz |= scedma_csr.ms(utra::scedma::SFR_SCH_TRANSIZE_SCHCR_TRANSIZE, 1); + scedma_csr.wfo(utra::scedma::SFR_SCH_TRANSIZE_SCHCR_TRANSIZE, baz); + + let foo = scedma_csr.r(utra::scedma::SFR_ICH_OPT); + scedma_csr.wo(utra::scedma::SFR_ICH_OPT, foo); + let bar = scedma_csr.rf(utra::scedma::SFR_ICH_OPT_SFR_ICH_OPT); + scedma_csr.rmwf(utra::scedma::SFR_ICH_OPT_SFR_ICH_OPT, bar); + let mut baz = scedma_csr.zf(utra::scedma::SFR_ICH_OPT_SFR_ICH_OPT, bar); + baz |= scedma_csr.ms(utra::scedma::SFR_ICH_OPT_SFR_ICH_OPT, 1); + scedma_csr.wfo(utra::scedma::SFR_ICH_OPT_SFR_ICH_OPT, baz); + + let foo = scedma_csr.r(utra::scedma::SFR_ICH_SEGID); + scedma_csr.wo(utra::scedma::SFR_ICH_SEGID, foo); + let bar = scedma_csr.rf(utra::scedma::SFR_ICH_SEGID_SFR_ICH_SEGID); + scedma_csr.rmwf(utra::scedma::SFR_ICH_SEGID_SFR_ICH_SEGID, bar); + let mut baz = scedma_csr.zf(utra::scedma::SFR_ICH_SEGID_SFR_ICH_SEGID, bar); + baz |= scedma_csr.ms(utra::scedma::SFR_ICH_SEGID_SFR_ICH_SEGID, 1); + scedma_csr.wfo(utra::scedma::SFR_ICH_SEGID_SFR_ICH_SEGID, baz); + + let foo = scedma_csr.r(utra::scedma::SFR_ICH_RPSTART); + scedma_csr.wo(utra::scedma::SFR_ICH_RPSTART, foo); + let bar = scedma_csr.rf(utra::scedma::SFR_ICH_RPSTART_ICHCR_RPSTART); + scedma_csr.rmwf(utra::scedma::SFR_ICH_RPSTART_ICHCR_RPSTART, bar); + let mut baz = scedma_csr.zf(utra::scedma::SFR_ICH_RPSTART_ICHCR_RPSTART, bar); + baz |= scedma_csr.ms(utra::scedma::SFR_ICH_RPSTART_ICHCR_RPSTART, 1); + scedma_csr.wfo(utra::scedma::SFR_ICH_RPSTART_ICHCR_RPSTART, baz); + + let foo = scedma_csr.r(utra::scedma::SFR_ICH_WPSTART); + scedma_csr.wo(utra::scedma::SFR_ICH_WPSTART, foo); + let bar = scedma_csr.rf(utra::scedma::SFR_ICH_WPSTART_ICHCR_WPSTART); + scedma_csr.rmwf(utra::scedma::SFR_ICH_WPSTART_ICHCR_WPSTART, bar); + let mut baz = scedma_csr.zf(utra::scedma::SFR_ICH_WPSTART_ICHCR_WPSTART, bar); + baz |= scedma_csr.ms(utra::scedma::SFR_ICH_WPSTART_ICHCR_WPSTART, 1); + scedma_csr.wfo(utra::scedma::SFR_ICH_WPSTART_ICHCR_WPSTART, baz); + + let foo = scedma_csr.r(utra::scedma::SFR_ICH_TRANSIZE); + scedma_csr.wo(utra::scedma::SFR_ICH_TRANSIZE, foo); + let bar = scedma_csr.rf(utra::scedma::SFR_ICH_TRANSIZE_ICHCR_TRANSIZE); + scedma_csr.rmwf(utra::scedma::SFR_ICH_TRANSIZE_ICHCR_TRANSIZE, bar); + let mut baz = scedma_csr.zf(utra::scedma::SFR_ICH_TRANSIZE_ICHCR_TRANSIZE, bar); + baz |= scedma_csr.ms(utra::scedma::SFR_ICH_TRANSIZE_ICHCR_TRANSIZE, 1); + scedma_csr.wfo(utra::scedma::SFR_ICH_TRANSIZE_ICHCR_TRANSIZE, baz); + } + + #[test] + #[ignore] + fn compile_check_sce_glbsfr_csr() { + use super::*; + let mut sce_glbsfr_csr = CSR::new(HW_SCE_GLBSFR_BASE as *mut u32); + + let foo = sce_glbsfr_csr.r(utra::sce_glbsfr::SFR_SCEMODE); + sce_glbsfr_csr.wo(utra::sce_glbsfr::SFR_SCEMODE, foo); + let bar = sce_glbsfr_csr.rf(utra::sce_glbsfr::SFR_SCEMODE_CR_SCEMODE); + sce_glbsfr_csr.rmwf(utra::sce_glbsfr::SFR_SCEMODE_CR_SCEMODE, bar); + let mut baz = sce_glbsfr_csr.zf(utra::sce_glbsfr::SFR_SCEMODE_CR_SCEMODE, bar); + baz |= sce_glbsfr_csr.ms(utra::sce_glbsfr::SFR_SCEMODE_CR_SCEMODE, 1); + sce_glbsfr_csr.wfo(utra::sce_glbsfr::SFR_SCEMODE_CR_SCEMODE, baz); + + let foo = sce_glbsfr_csr.r(utra::sce_glbsfr::SFR_SUBEN); + sce_glbsfr_csr.wo(utra::sce_glbsfr::SFR_SUBEN, foo); + let bar = sce_glbsfr_csr.rf(utra::sce_glbsfr::SFR_SUBEN_CR_SUBEN); + sce_glbsfr_csr.rmwf(utra::sce_glbsfr::SFR_SUBEN_CR_SUBEN, bar); + let mut baz = sce_glbsfr_csr.zf(utra::sce_glbsfr::SFR_SUBEN_CR_SUBEN, bar); + baz |= sce_glbsfr_csr.ms(utra::sce_glbsfr::SFR_SUBEN_CR_SUBEN, 1); + sce_glbsfr_csr.wfo(utra::sce_glbsfr::SFR_SUBEN_CR_SUBEN, baz); + + let foo = sce_glbsfr_csr.r(utra::sce_glbsfr::SFR_AHBS); + sce_glbsfr_csr.wo(utra::sce_glbsfr::SFR_AHBS, foo); + let bar = sce_glbsfr_csr.rf(utra::sce_glbsfr::SFR_AHBS_CR_AHBSOPT); + sce_glbsfr_csr.rmwf(utra::sce_glbsfr::SFR_AHBS_CR_AHBSOPT, bar); + let mut baz = sce_glbsfr_csr.zf(utra::sce_glbsfr::SFR_AHBS_CR_AHBSOPT, bar); + baz |= sce_glbsfr_csr.ms(utra::sce_glbsfr::SFR_AHBS_CR_AHBSOPT, 1); + sce_glbsfr_csr.wfo(utra::sce_glbsfr::SFR_AHBS_CR_AHBSOPT, baz); + + let foo = sce_glbsfr_csr.r(utra::sce_glbsfr::SFR_SRBUSY); + sce_glbsfr_csr.wo(utra::sce_glbsfr::SFR_SRBUSY, foo); + let bar = sce_glbsfr_csr.rf(utra::sce_glbsfr::SFR_SRBUSY_SR_BUSY); + sce_glbsfr_csr.rmwf(utra::sce_glbsfr::SFR_SRBUSY_SR_BUSY, bar); + let mut baz = sce_glbsfr_csr.zf(utra::sce_glbsfr::SFR_SRBUSY_SR_BUSY, bar); + baz |= sce_glbsfr_csr.ms(utra::sce_glbsfr::SFR_SRBUSY_SR_BUSY, 1); + sce_glbsfr_csr.wfo(utra::sce_glbsfr::SFR_SRBUSY_SR_BUSY, baz); + + let foo = sce_glbsfr_csr.r(utra::sce_glbsfr::SFR_FRDONE); + sce_glbsfr_csr.wo(utra::sce_glbsfr::SFR_FRDONE, foo); + let bar = sce_glbsfr_csr.rf(utra::sce_glbsfr::SFR_FRDONE_FR_DONE); + sce_glbsfr_csr.rmwf(utra::sce_glbsfr::SFR_FRDONE_FR_DONE, bar); + let mut baz = sce_glbsfr_csr.zf(utra::sce_glbsfr::SFR_FRDONE_FR_DONE, bar); + baz |= sce_glbsfr_csr.ms(utra::sce_glbsfr::SFR_FRDONE_FR_DONE, 1); + sce_glbsfr_csr.wfo(utra::sce_glbsfr::SFR_FRDONE_FR_DONE, baz); + + let foo = sce_glbsfr_csr.r(utra::sce_glbsfr::SFR_FRERR); + sce_glbsfr_csr.wo(utra::sce_glbsfr::SFR_FRERR, foo); + let bar = sce_glbsfr_csr.rf(utra::sce_glbsfr::SFR_FRERR_FR_ERR); + sce_glbsfr_csr.rmwf(utra::sce_glbsfr::SFR_FRERR_FR_ERR, bar); + let mut baz = sce_glbsfr_csr.zf(utra::sce_glbsfr::SFR_FRERR_FR_ERR, bar); + baz |= sce_glbsfr_csr.ms(utra::sce_glbsfr::SFR_FRERR_FR_ERR, 1); + sce_glbsfr_csr.wfo(utra::sce_glbsfr::SFR_FRERR_FR_ERR, baz); + + let foo = sce_glbsfr_csr.r(utra::sce_glbsfr::SFR_ARCLR); + sce_glbsfr_csr.wo(utra::sce_glbsfr::SFR_ARCLR, foo); + let bar = sce_glbsfr_csr.rf(utra::sce_glbsfr::SFR_ARCLR_AR_CLRRAM); + sce_glbsfr_csr.rmwf(utra::sce_glbsfr::SFR_ARCLR_AR_CLRRAM, bar); + let mut baz = sce_glbsfr_csr.zf(utra::sce_glbsfr::SFR_ARCLR_AR_CLRRAM, bar); + baz |= sce_glbsfr_csr.ms(utra::sce_glbsfr::SFR_ARCLR_AR_CLRRAM, 1); + sce_glbsfr_csr.wfo(utra::sce_glbsfr::SFR_ARCLR_AR_CLRRAM, baz); + + let foo = sce_glbsfr_csr.r(utra::sce_glbsfr::SFR_TICKCYC); + sce_glbsfr_csr.wo(utra::sce_glbsfr::SFR_TICKCYC, foo); + let bar = sce_glbsfr_csr.rf(utra::sce_glbsfr::SFR_TICKCYC_SFR_TICKCYC); + sce_glbsfr_csr.rmwf(utra::sce_glbsfr::SFR_TICKCYC_SFR_TICKCYC, bar); + let mut baz = sce_glbsfr_csr.zf(utra::sce_glbsfr::SFR_TICKCYC_SFR_TICKCYC, bar); + baz |= sce_glbsfr_csr.ms(utra::sce_glbsfr::SFR_TICKCYC_SFR_TICKCYC, 1); + sce_glbsfr_csr.wfo(utra::sce_glbsfr::SFR_TICKCYC_SFR_TICKCYC, baz); + + let foo = sce_glbsfr_csr.r(utra::sce_glbsfr::SFR_TICKCNT); + sce_glbsfr_csr.wo(utra::sce_glbsfr::SFR_TICKCNT, foo); + let bar = sce_glbsfr_csr.rf(utra::sce_glbsfr::SFR_TICKCNT_SFR_TICKCNT); + sce_glbsfr_csr.rmwf(utra::sce_glbsfr::SFR_TICKCNT_SFR_TICKCNT, bar); + let mut baz = sce_glbsfr_csr.zf(utra::sce_glbsfr::SFR_TICKCNT_SFR_TICKCNT, bar); + baz |= sce_glbsfr_csr.ms(utra::sce_glbsfr::SFR_TICKCNT_SFR_TICKCNT, 1); + sce_glbsfr_csr.wfo(utra::sce_glbsfr::SFR_TICKCNT_SFR_TICKCNT, baz); + + let foo = sce_glbsfr_csr.r(utra::sce_glbsfr::SFR_FFEN); + sce_glbsfr_csr.wo(utra::sce_glbsfr::SFR_FFEN, foo); + let bar = sce_glbsfr_csr.rf(utra::sce_glbsfr::SFR_FFEN_CR_FFEN); + sce_glbsfr_csr.rmwf(utra::sce_glbsfr::SFR_FFEN_CR_FFEN, bar); + let mut baz = sce_glbsfr_csr.zf(utra::sce_glbsfr::SFR_FFEN_CR_FFEN, bar); + baz |= sce_glbsfr_csr.ms(utra::sce_glbsfr::SFR_FFEN_CR_FFEN, 1); + sce_glbsfr_csr.wfo(utra::sce_glbsfr::SFR_FFEN_CR_FFEN, baz); + + let foo = sce_glbsfr_csr.r(utra::sce_glbsfr::SFR_FFCLR); + sce_glbsfr_csr.wo(utra::sce_glbsfr::SFR_FFCLR, foo); + let bar = sce_glbsfr_csr.rf(utra::sce_glbsfr::SFR_FFCLR_AR_FFCLR); + sce_glbsfr_csr.rmwf(utra::sce_glbsfr::SFR_FFCLR_AR_FFCLR, bar); + let mut baz = sce_glbsfr_csr.zf(utra::sce_glbsfr::SFR_FFCLR_AR_FFCLR, bar); + baz |= sce_glbsfr_csr.ms(utra::sce_glbsfr::SFR_FFCLR_AR_FFCLR, 1); + sce_glbsfr_csr.wfo(utra::sce_glbsfr::SFR_FFCLR_AR_FFCLR, baz); + + let foo = sce_glbsfr_csr.r(utra::sce_glbsfr::SFR_FFCNT_SR_FF0); + sce_glbsfr_csr.wo(utra::sce_glbsfr::SFR_FFCNT_SR_FF0, foo); + let bar = sce_glbsfr_csr.rf(utra::sce_glbsfr::SFR_FFCNT_SR_FF0_SR_FF0); + sce_glbsfr_csr.rmwf(utra::sce_glbsfr::SFR_FFCNT_SR_FF0_SR_FF0, bar); + let mut baz = sce_glbsfr_csr.zf(utra::sce_glbsfr::SFR_FFCNT_SR_FF0_SR_FF0, bar); + baz |= sce_glbsfr_csr.ms(utra::sce_glbsfr::SFR_FFCNT_SR_FF0_SR_FF0, 1); + sce_glbsfr_csr.wfo(utra::sce_glbsfr::SFR_FFCNT_SR_FF0_SR_FF0, baz); + + let foo = sce_glbsfr_csr.r(utra::sce_glbsfr::SFR_FFCNT_SR_FF1); + sce_glbsfr_csr.wo(utra::sce_glbsfr::SFR_FFCNT_SR_FF1, foo); + let bar = sce_glbsfr_csr.rf(utra::sce_glbsfr::SFR_FFCNT_SR_FF1_SR_FF1); + sce_glbsfr_csr.rmwf(utra::sce_glbsfr::SFR_FFCNT_SR_FF1_SR_FF1, bar); + let mut baz = sce_glbsfr_csr.zf(utra::sce_glbsfr::SFR_FFCNT_SR_FF1_SR_FF1, bar); + baz |= sce_glbsfr_csr.ms(utra::sce_glbsfr::SFR_FFCNT_SR_FF1_SR_FF1, 1); + sce_glbsfr_csr.wfo(utra::sce_glbsfr::SFR_FFCNT_SR_FF1_SR_FF1, baz); + + let foo = sce_glbsfr_csr.r(utra::sce_glbsfr::SFR_FFCNT_SR_FF2); + sce_glbsfr_csr.wo(utra::sce_glbsfr::SFR_FFCNT_SR_FF2, foo); + let bar = sce_glbsfr_csr.rf(utra::sce_glbsfr::SFR_FFCNT_SR_FF2_SR_FF2); + sce_glbsfr_csr.rmwf(utra::sce_glbsfr::SFR_FFCNT_SR_FF2_SR_FF2, bar); + let mut baz = sce_glbsfr_csr.zf(utra::sce_glbsfr::SFR_FFCNT_SR_FF2_SR_FF2, bar); + baz |= sce_glbsfr_csr.ms(utra::sce_glbsfr::SFR_FFCNT_SR_FF2_SR_FF2, 1); + sce_glbsfr_csr.wfo(utra::sce_glbsfr::SFR_FFCNT_SR_FF2_SR_FF2, baz); + + let foo = sce_glbsfr_csr.r(utra::sce_glbsfr::SFR_FFCNT_SR_FF3); + sce_glbsfr_csr.wo(utra::sce_glbsfr::SFR_FFCNT_SR_FF3, foo); + let bar = sce_glbsfr_csr.rf(utra::sce_glbsfr::SFR_FFCNT_SR_FF3_SR_FF3); + sce_glbsfr_csr.rmwf(utra::sce_glbsfr::SFR_FFCNT_SR_FF3_SR_FF3, bar); + let mut baz = sce_glbsfr_csr.zf(utra::sce_glbsfr::SFR_FFCNT_SR_FF3_SR_FF3, bar); + baz |= sce_glbsfr_csr.ms(utra::sce_glbsfr::SFR_FFCNT_SR_FF3_SR_FF3, 1); + sce_glbsfr_csr.wfo(utra::sce_glbsfr::SFR_FFCNT_SR_FF3_SR_FF3, baz); + + let foo = sce_glbsfr_csr.r(utra::sce_glbsfr::SFR_FFCNT_SR_FF4); + sce_glbsfr_csr.wo(utra::sce_glbsfr::SFR_FFCNT_SR_FF4, foo); + let bar = sce_glbsfr_csr.rf(utra::sce_glbsfr::SFR_FFCNT_SR_FF4_SR_FF4); + sce_glbsfr_csr.rmwf(utra::sce_glbsfr::SFR_FFCNT_SR_FF4_SR_FF4, bar); + let mut baz = sce_glbsfr_csr.zf(utra::sce_glbsfr::SFR_FFCNT_SR_FF4_SR_FF4, bar); + baz |= sce_glbsfr_csr.ms(utra::sce_glbsfr::SFR_FFCNT_SR_FF4_SR_FF4, 1); + sce_glbsfr_csr.wfo(utra::sce_glbsfr::SFR_FFCNT_SR_FF4_SR_FF4, baz); + + let foo = sce_glbsfr_csr.r(utra::sce_glbsfr::SFR_FFCNT_SR_FF5); + sce_glbsfr_csr.wo(utra::sce_glbsfr::SFR_FFCNT_SR_FF5, foo); + let bar = sce_glbsfr_csr.rf(utra::sce_glbsfr::SFR_FFCNT_SR_FF5_SR_FF5); + sce_glbsfr_csr.rmwf(utra::sce_glbsfr::SFR_FFCNT_SR_FF5_SR_FF5, bar); + let mut baz = sce_glbsfr_csr.zf(utra::sce_glbsfr::SFR_FFCNT_SR_FF5_SR_FF5, bar); + baz |= sce_glbsfr_csr.ms(utra::sce_glbsfr::SFR_FFCNT_SR_FF5_SR_FF5, 1); + sce_glbsfr_csr.wfo(utra::sce_glbsfr::SFR_FFCNT_SR_FF5_SR_FF5, baz); + } + + #[test] + #[ignore] + fn compile_check_trng_csr() { + use super::*; + let mut trng_csr = CSR::new(HW_TRNG_BASE as *mut u32); + + let foo = trng_csr.r(utra::trng::SFR_CRFUNC); + trng_csr.wo(utra::trng::SFR_CRFUNC, foo); + let bar = trng_csr.rf(utra::trng::SFR_CRFUNC_CR_FUNC); + trng_csr.rmwf(utra::trng::SFR_CRFUNC_CR_FUNC, bar); + let mut baz = trng_csr.zf(utra::trng::SFR_CRFUNC_CR_FUNC, bar); + baz |= trng_csr.ms(utra::trng::SFR_CRFUNC_CR_FUNC, 1); + trng_csr.wfo(utra::trng::SFR_CRFUNC_CR_FUNC, baz); + + let foo = trng_csr.r(utra::trng::SFR_AR); + trng_csr.wo(utra::trng::SFR_AR, foo); + let bar = trng_csr.rf(utra::trng::SFR_AR_START); + trng_csr.rmwf(utra::trng::SFR_AR_START, bar); + let mut baz = trng_csr.zf(utra::trng::SFR_AR_START, bar); + baz |= trng_csr.ms(utra::trng::SFR_AR_START, 1); + trng_csr.wfo(utra::trng::SFR_AR_START, baz); + + let foo = trng_csr.r(utra::trng::SFR_SRMFSM); + trng_csr.wo(utra::trng::SFR_SRMFSM, foo); + let bar = trng_csr.rf(utra::trng::SFR_SRMFSM_MFSM); + trng_csr.rmwf(utra::trng::SFR_SRMFSM_MFSM, bar); + let mut baz = trng_csr.zf(utra::trng::SFR_SRMFSM_MFSM, bar); + baz |= trng_csr.ms(utra::trng::SFR_SRMFSM_MFSM, 1); + trng_csr.wfo(utra::trng::SFR_SRMFSM_MFSM, baz); + let bar = trng_csr.rf(utra::trng::SFR_SRMFSM_MODINVREADY); + trng_csr.rmwf(utra::trng::SFR_SRMFSM_MODINVREADY, bar); + let mut baz = trng_csr.zf(utra::trng::SFR_SRMFSM_MODINVREADY, bar); + baz |= trng_csr.ms(utra::trng::SFR_SRMFSM_MODINVREADY, 1); + trng_csr.wfo(utra::trng::SFR_SRMFSM_MODINVREADY, baz); + + let foo = trng_csr.r(utra::trng::SFR_FR); + trng_csr.wo(utra::trng::SFR_FR, foo); + let bar = trng_csr.rf(utra::trng::SFR_FR_MFSM_DONE); + trng_csr.rmwf(utra::trng::SFR_FR_MFSM_DONE, bar); + let mut baz = trng_csr.zf(utra::trng::SFR_FR_MFSM_DONE, bar); + baz |= trng_csr.ms(utra::trng::SFR_FR_MFSM_DONE, 1); + trng_csr.wfo(utra::trng::SFR_FR_MFSM_DONE, baz); + let bar = trng_csr.rf(utra::trng::SFR_FR_PCORE_DONE); + trng_csr.rmwf(utra::trng::SFR_FR_PCORE_DONE, bar); + let mut baz = trng_csr.zf(utra::trng::SFR_FR_PCORE_DONE, bar); + baz |= trng_csr.ms(utra::trng::SFR_FR_PCORE_DONE, 1); + trng_csr.wfo(utra::trng::SFR_FR_PCORE_DONE, baz); + let bar = trng_csr.rf(utra::trng::SFR_FR_CHNLO_DONE); + trng_csr.rmwf(utra::trng::SFR_FR_CHNLO_DONE, bar); + let mut baz = trng_csr.zf(utra::trng::SFR_FR_CHNLO_DONE, bar); + baz |= trng_csr.ms(utra::trng::SFR_FR_CHNLO_DONE, 1); + trng_csr.wfo(utra::trng::SFR_FR_CHNLO_DONE, baz); + let bar = trng_csr.rf(utra::trng::SFR_FR_CHNLI_DONE); + trng_csr.rmwf(utra::trng::SFR_FR_CHNLI_DONE, bar); + let mut baz = trng_csr.zf(utra::trng::SFR_FR_CHNLI_DONE, bar); + baz |= trng_csr.ms(utra::trng::SFR_FR_CHNLI_DONE, 1); + trng_csr.wfo(utra::trng::SFR_FR_CHNLI_DONE, baz); + let bar = trng_csr.rf(utra::trng::SFR_FR_CHNLX_DONE); + trng_csr.rmwf(utra::trng::SFR_FR_CHNLX_DONE, bar); + let mut baz = trng_csr.zf(utra::trng::SFR_FR_CHNLX_DONE, bar); + baz |= trng_csr.ms(utra::trng::SFR_FR_CHNLX_DONE, 1); + trng_csr.wfo(utra::trng::SFR_FR_CHNLX_DONE, baz); + + let foo = trng_csr.r(utra::trng::SFR_OPTNW); + trng_csr.wo(utra::trng::SFR_OPTNW, foo); + let bar = trng_csr.rf(utra::trng::SFR_OPTNW_OPT_NW); + trng_csr.rmwf(utra::trng::SFR_OPTNW_OPT_NW, bar); + let mut baz = trng_csr.zf(utra::trng::SFR_OPTNW_OPT_NW, bar); + baz |= trng_csr.ms(utra::trng::SFR_OPTNW_OPT_NW, 1); + trng_csr.wfo(utra::trng::SFR_OPTNW_OPT_NW, baz); + + let foo = trng_csr.r(utra::trng::SFR_OPTEW); + trng_csr.wo(utra::trng::SFR_OPTEW, foo); + let bar = trng_csr.rf(utra::trng::SFR_OPTEW_OPT_EW); + trng_csr.rmwf(utra::trng::SFR_OPTEW_OPT_EW, bar); + let mut baz = trng_csr.zf(utra::trng::SFR_OPTEW_OPT_EW, bar); + baz |= trng_csr.ms(utra::trng::SFR_OPTEW_OPT_EW, 1); + trng_csr.wfo(utra::trng::SFR_OPTEW_OPT_EW, baz); + + let foo = trng_csr.r(utra::trng::SFR_OPTMASK); + trng_csr.wo(utra::trng::SFR_OPTMASK, foo); + let bar = trng_csr.rf(utra::trng::SFR_OPTMASK_OPT_MASK); + trng_csr.rmwf(utra::trng::SFR_OPTMASK_OPT_MASK, bar); + let mut baz = trng_csr.zf(utra::trng::SFR_OPTMASK_OPT_MASK, bar); + baz |= trng_csr.ms(utra::trng::SFR_OPTMASK_OPT_MASK, 1); + trng_csr.wfo(utra::trng::SFR_OPTMASK_OPT_MASK, baz); + + let foo = trng_csr.r(utra::trng::SFR_SEGPTR_CR_SEGPTRSTART0); + trng_csr.wo(utra::trng::SFR_SEGPTR_CR_SEGPTRSTART0, foo); + let bar = trng_csr.rf(utra::trng::SFR_SEGPTR_CR_SEGPTRSTART0_CR_SEGPTRSTART0); + trng_csr.rmwf(utra::trng::SFR_SEGPTR_CR_SEGPTRSTART0_CR_SEGPTRSTART0, bar); + let mut baz = trng_csr.zf(utra::trng::SFR_SEGPTR_CR_SEGPTRSTART0_CR_SEGPTRSTART0, bar); + baz |= trng_csr.ms(utra::trng::SFR_SEGPTR_CR_SEGPTRSTART0_CR_SEGPTRSTART0, 1); + trng_csr.wfo(utra::trng::SFR_SEGPTR_CR_SEGPTRSTART0_CR_SEGPTRSTART0, baz); + + let foo = trng_csr.r(utra::trng::SFR_SEGPTR_CR_SEGPTRSTART1); + trng_csr.wo(utra::trng::SFR_SEGPTR_CR_SEGPTRSTART1, foo); + let bar = trng_csr.rf(utra::trng::SFR_SEGPTR_CR_SEGPTRSTART1_CR_SEGPTRSTART1); + trng_csr.rmwf(utra::trng::SFR_SEGPTR_CR_SEGPTRSTART1_CR_SEGPTRSTART1, bar); + let mut baz = trng_csr.zf(utra::trng::SFR_SEGPTR_CR_SEGPTRSTART1_CR_SEGPTRSTART1, bar); + baz |= trng_csr.ms(utra::trng::SFR_SEGPTR_CR_SEGPTRSTART1_CR_SEGPTRSTART1, 1); + trng_csr.wfo(utra::trng::SFR_SEGPTR_CR_SEGPTRSTART1_CR_SEGPTRSTART1, baz); + + let foo = trng_csr.r(utra::trng::SFR_SEGPTR_CR_SEGPTRSTART2); + trng_csr.wo(utra::trng::SFR_SEGPTR_CR_SEGPTRSTART2, foo); + let bar = trng_csr.rf(utra::trng::SFR_SEGPTR_CR_SEGPTRSTART2_CR_SEGPTRSTART2); + trng_csr.rmwf(utra::trng::SFR_SEGPTR_CR_SEGPTRSTART2_CR_SEGPTRSTART2, bar); + let mut baz = trng_csr.zf(utra::trng::SFR_SEGPTR_CR_SEGPTRSTART2_CR_SEGPTRSTART2, bar); + baz |= trng_csr.ms(utra::trng::SFR_SEGPTR_CR_SEGPTRSTART2_CR_SEGPTRSTART2, 1); + trng_csr.wfo(utra::trng::SFR_SEGPTR_CR_SEGPTRSTART2_CR_SEGPTRSTART2, baz); + + let foo = trng_csr.r(utra::trng::SFR_SEGPTR_CR_SEGPTRSTART3); + trng_csr.wo(utra::trng::SFR_SEGPTR_CR_SEGPTRSTART3, foo); + let bar = trng_csr.rf(utra::trng::SFR_SEGPTR_CR_SEGPTRSTART3_CR_SEGPTRSTART3); + trng_csr.rmwf(utra::trng::SFR_SEGPTR_CR_SEGPTRSTART3_CR_SEGPTRSTART3, bar); + let mut baz = trng_csr.zf(utra::trng::SFR_SEGPTR_CR_SEGPTRSTART3_CR_SEGPTRSTART3, bar); + baz |= trng_csr.ms(utra::trng::SFR_SEGPTR_CR_SEGPTRSTART3_CR_SEGPTRSTART3, 1); + trng_csr.wfo(utra::trng::SFR_SEGPTR_CR_SEGPTRSTART3_CR_SEGPTRSTART3, baz); + + let foo = trng_csr.r(utra::trng::SFR_SEGPTR_CR_SEGPTRSTART4); + trng_csr.wo(utra::trng::SFR_SEGPTR_CR_SEGPTRSTART4, foo); + let bar = trng_csr.rf(utra::trng::SFR_SEGPTR_CR_SEGPTRSTART4_CR_SEGPTRSTART4); + trng_csr.rmwf(utra::trng::SFR_SEGPTR_CR_SEGPTRSTART4_CR_SEGPTRSTART4, bar); + let mut baz = trng_csr.zf(utra::trng::SFR_SEGPTR_CR_SEGPTRSTART4_CR_SEGPTRSTART4, bar); + baz |= trng_csr.ms(utra::trng::SFR_SEGPTR_CR_SEGPTRSTART4_CR_SEGPTRSTART4, 1); + trng_csr.wfo(utra::trng::SFR_SEGPTR_CR_SEGPTRSTART4_CR_SEGPTRSTART4, baz); + } + + #[test] + #[ignore] + fn compile_check_alu_csr() { + use super::*; + let mut alu_csr = CSR::new(HW_ALU_BASE as *mut u32); + } + + #[test] + #[ignore] + fn compile_check_duart_csr() { + use super::*; + let mut duart_csr = CSR::new(HW_DUART_BASE as *mut u32); + + let foo = duart_csr.r(utra::duart::SFR_TXD); + duart_csr.wo(utra::duart::SFR_TXD, foo); + let bar = duart_csr.rf(utra::duart::SFR_TXD_SFR_TXD); + duart_csr.rmwf(utra::duart::SFR_TXD_SFR_TXD, bar); + let mut baz = duart_csr.zf(utra::duart::SFR_TXD_SFR_TXD, bar); + baz |= duart_csr.ms(utra::duart::SFR_TXD_SFR_TXD, 1); + duart_csr.wfo(utra::duart::SFR_TXD_SFR_TXD, baz); + + let foo = duart_csr.r(utra::duart::SFR_CR); + duart_csr.wo(utra::duart::SFR_CR, foo); + let bar = duart_csr.rf(utra::duart::SFR_CR_SFR_CR); + duart_csr.rmwf(utra::duart::SFR_CR_SFR_CR, bar); + let mut baz = duart_csr.zf(utra::duart::SFR_CR_SFR_CR, bar); + baz |= duart_csr.ms(utra::duart::SFR_CR_SFR_CR, 1); + duart_csr.wfo(utra::duart::SFR_CR_SFR_CR, baz); + + let foo = duart_csr.r(utra::duart::SFR_SR); + duart_csr.wo(utra::duart::SFR_SR, foo); + let bar = duart_csr.rf(utra::duart::SFR_SR_SFR_SR); + duart_csr.rmwf(utra::duart::SFR_SR_SFR_SR, bar); + let mut baz = duart_csr.zf(utra::duart::SFR_SR_SFR_SR, bar); + baz |= duart_csr.ms(utra::duart::SFR_SR_SFR_SR, 1); + duart_csr.wfo(utra::duart::SFR_SR_SFR_SR, baz); + + let foo = duart_csr.r(utra::duart::SFR_ETUC); + duart_csr.wo(utra::duart::SFR_ETUC, foo); + let bar = duart_csr.rf(utra::duart::SFR_ETUC_SFR_ETUC); + duart_csr.rmwf(utra::duart::SFR_ETUC_SFR_ETUC, bar); + let mut baz = duart_csr.zf(utra::duart::SFR_ETUC_SFR_ETUC, bar); + baz |= duart_csr.ms(utra::duart::SFR_ETUC_SFR_ETUC, 1); + duart_csr.wfo(utra::duart::SFR_ETUC_SFR_ETUC, baz); + } + + #[test] + #[ignore] + fn compile_check_wdg_intf_csr() { + use super::*; + let mut wdg_intf_csr = CSR::new(HW_WDG_INTF_BASE as *mut u32); + } + + #[test] + #[ignore] + fn compile_check_timer_intf_csr() { + use super::*; + let mut timer_intf_csr = CSR::new(HW_TIMER_INTF_BASE as *mut u32); + } + + #[test] + #[ignore] + fn compile_check_evc_csr() { + use super::*; + let mut evc_csr = CSR::new(HW_EVC_BASE as *mut u32); + + let foo = evc_csr.r(utra::evc::SFR_CM7EVSEL_CM7EVSEL0); + evc_csr.wo(utra::evc::SFR_CM7EVSEL_CM7EVSEL0, foo); + let bar = evc_csr.rf(utra::evc::SFR_CM7EVSEL_CM7EVSEL0_CM7EVSEL0); + evc_csr.rmwf(utra::evc::SFR_CM7EVSEL_CM7EVSEL0_CM7EVSEL0, bar); + let mut baz = evc_csr.zf(utra::evc::SFR_CM7EVSEL_CM7EVSEL0_CM7EVSEL0, bar); + baz |= evc_csr.ms(utra::evc::SFR_CM7EVSEL_CM7EVSEL0_CM7EVSEL0, 1); + evc_csr.wfo(utra::evc::SFR_CM7EVSEL_CM7EVSEL0_CM7EVSEL0, baz); + + let foo = evc_csr.r(utra::evc::SFR_CM7EVSEL_CM7EVSEL1); + evc_csr.wo(utra::evc::SFR_CM7EVSEL_CM7EVSEL1, foo); + let bar = evc_csr.rf(utra::evc::SFR_CM7EVSEL_CM7EVSEL1_CM7EVSEL1); + evc_csr.rmwf(utra::evc::SFR_CM7EVSEL_CM7EVSEL1_CM7EVSEL1, bar); + let mut baz = evc_csr.zf(utra::evc::SFR_CM7EVSEL_CM7EVSEL1_CM7EVSEL1, bar); + baz |= evc_csr.ms(utra::evc::SFR_CM7EVSEL_CM7EVSEL1_CM7EVSEL1, 1); + evc_csr.wfo(utra::evc::SFR_CM7EVSEL_CM7EVSEL1_CM7EVSEL1, baz); + + let foo = evc_csr.r(utra::evc::SFR_CM7EVSEL_CM7EVSEL2); + evc_csr.wo(utra::evc::SFR_CM7EVSEL_CM7EVSEL2, foo); + let bar = evc_csr.rf(utra::evc::SFR_CM7EVSEL_CM7EVSEL2_CM7EVSEL2); + evc_csr.rmwf(utra::evc::SFR_CM7EVSEL_CM7EVSEL2_CM7EVSEL2, bar); + let mut baz = evc_csr.zf(utra::evc::SFR_CM7EVSEL_CM7EVSEL2_CM7EVSEL2, bar); + baz |= evc_csr.ms(utra::evc::SFR_CM7EVSEL_CM7EVSEL2_CM7EVSEL2, 1); + evc_csr.wfo(utra::evc::SFR_CM7EVSEL_CM7EVSEL2_CM7EVSEL2, baz); + + let foo = evc_csr.r(utra::evc::SFR_CM7EVSEL_CM7EVSEL3); + evc_csr.wo(utra::evc::SFR_CM7EVSEL_CM7EVSEL3, foo); + let bar = evc_csr.rf(utra::evc::SFR_CM7EVSEL_CM7EVSEL3_CM7EVSEL3); + evc_csr.rmwf(utra::evc::SFR_CM7EVSEL_CM7EVSEL3_CM7EVSEL3, bar); + let mut baz = evc_csr.zf(utra::evc::SFR_CM7EVSEL_CM7EVSEL3_CM7EVSEL3, bar); + baz |= evc_csr.ms(utra::evc::SFR_CM7EVSEL_CM7EVSEL3_CM7EVSEL3, 1); + evc_csr.wfo(utra::evc::SFR_CM7EVSEL_CM7EVSEL3_CM7EVSEL3, baz); + + let foo = evc_csr.r(utra::evc::SFR_CM7EVSEL_CM7EVSEL4); + evc_csr.wo(utra::evc::SFR_CM7EVSEL_CM7EVSEL4, foo); + let bar = evc_csr.rf(utra::evc::SFR_CM7EVSEL_CM7EVSEL4_CM7EVSEL4); + evc_csr.rmwf(utra::evc::SFR_CM7EVSEL_CM7EVSEL4_CM7EVSEL4, bar); + let mut baz = evc_csr.zf(utra::evc::SFR_CM7EVSEL_CM7EVSEL4_CM7EVSEL4, bar); + baz |= evc_csr.ms(utra::evc::SFR_CM7EVSEL_CM7EVSEL4_CM7EVSEL4, 1); + evc_csr.wfo(utra::evc::SFR_CM7EVSEL_CM7EVSEL4_CM7EVSEL4, baz); + + let foo = evc_csr.r(utra::evc::SFR_CM7EVSEL_CM7EVSEL5); + evc_csr.wo(utra::evc::SFR_CM7EVSEL_CM7EVSEL5, foo); + let bar = evc_csr.rf(utra::evc::SFR_CM7EVSEL_CM7EVSEL5_CM7EVSEL5); + evc_csr.rmwf(utra::evc::SFR_CM7EVSEL_CM7EVSEL5_CM7EVSEL5, bar); + let mut baz = evc_csr.zf(utra::evc::SFR_CM7EVSEL_CM7EVSEL5_CM7EVSEL5, bar); + baz |= evc_csr.ms(utra::evc::SFR_CM7EVSEL_CM7EVSEL5_CM7EVSEL5, 1); + evc_csr.wfo(utra::evc::SFR_CM7EVSEL_CM7EVSEL5_CM7EVSEL5, baz); + + let foo = evc_csr.r(utra::evc::SFR_CM7EVSEL_CM7EVSEL6); + evc_csr.wo(utra::evc::SFR_CM7EVSEL_CM7EVSEL6, foo); + let bar = evc_csr.rf(utra::evc::SFR_CM7EVSEL_CM7EVSEL6_CM7EVSEL6); + evc_csr.rmwf(utra::evc::SFR_CM7EVSEL_CM7EVSEL6_CM7EVSEL6, bar); + let mut baz = evc_csr.zf(utra::evc::SFR_CM7EVSEL_CM7EVSEL6_CM7EVSEL6, bar); + baz |= evc_csr.ms(utra::evc::SFR_CM7EVSEL_CM7EVSEL6_CM7EVSEL6, 1); + evc_csr.wfo(utra::evc::SFR_CM7EVSEL_CM7EVSEL6_CM7EVSEL6, baz); + + let foo = evc_csr.r(utra::evc::SFR_CM7EVSEL_CM7EVSEL7); + evc_csr.wo(utra::evc::SFR_CM7EVSEL_CM7EVSEL7, foo); + let bar = evc_csr.rf(utra::evc::SFR_CM7EVSEL_CM7EVSEL7_CM7EVSEL7); + evc_csr.rmwf(utra::evc::SFR_CM7EVSEL_CM7EVSEL7_CM7EVSEL7, bar); + let mut baz = evc_csr.zf(utra::evc::SFR_CM7EVSEL_CM7EVSEL7_CM7EVSEL7, bar); + baz |= evc_csr.ms(utra::evc::SFR_CM7EVSEL_CM7EVSEL7_CM7EVSEL7, 1); + evc_csr.wfo(utra::evc::SFR_CM7EVSEL_CM7EVSEL7_CM7EVSEL7, baz); + + let foo = evc_csr.r(utra::evc::SFR_CM7EVEN); + evc_csr.wo(utra::evc::SFR_CM7EVEN, foo); + let bar = evc_csr.rf(utra::evc::SFR_CM7EVEN_CM7EVEN); + evc_csr.rmwf(utra::evc::SFR_CM7EVEN_CM7EVEN, bar); + let mut baz = evc_csr.zf(utra::evc::SFR_CM7EVEN_CM7EVEN, bar); + baz |= evc_csr.ms(utra::evc::SFR_CM7EVEN_CM7EVEN, 1); + evc_csr.wfo(utra::evc::SFR_CM7EVEN_CM7EVEN, baz); + + let foo = evc_csr.r(utra::evc::SFR_CM7EVFR); + evc_csr.wo(utra::evc::SFR_CM7EVFR, foo); + let bar = evc_csr.rf(utra::evc::SFR_CM7EVFR_CM7EVS); + evc_csr.rmwf(utra::evc::SFR_CM7EVFR_CM7EVS, bar); + let mut baz = evc_csr.zf(utra::evc::SFR_CM7EVFR_CM7EVS, bar); + baz |= evc_csr.ms(utra::evc::SFR_CM7EVFR_CM7EVS, 1); + evc_csr.wfo(utra::evc::SFR_CM7EVFR_CM7EVS, baz); + + let foo = evc_csr.r(utra::evc::SFR_TMREVSEL); + evc_csr.wo(utra::evc::SFR_TMREVSEL, foo); + let bar = evc_csr.rf(utra::evc::SFR_TMREVSEL_TMR_EVSEL); + evc_csr.rmwf(utra::evc::SFR_TMREVSEL_TMR_EVSEL, bar); + let mut baz = evc_csr.zf(utra::evc::SFR_TMREVSEL_TMR_EVSEL, bar); + baz |= evc_csr.ms(utra::evc::SFR_TMREVSEL_TMR_EVSEL, 1); + evc_csr.wfo(utra::evc::SFR_TMREVSEL_TMR_EVSEL, baz); + + let foo = evc_csr.r(utra::evc::SFR_PWMEVSEL); + evc_csr.wo(utra::evc::SFR_PWMEVSEL, foo); + let bar = evc_csr.rf(utra::evc::SFR_PWMEVSEL_PWM_EVSEL); + evc_csr.rmwf(utra::evc::SFR_PWMEVSEL_PWM_EVSEL, bar); + let mut baz = evc_csr.zf(utra::evc::SFR_PWMEVSEL_PWM_EVSEL, bar); + baz |= evc_csr.ms(utra::evc::SFR_PWMEVSEL_PWM_EVSEL, 1); + evc_csr.wfo(utra::evc::SFR_PWMEVSEL_PWM_EVSEL, baz); + + let foo = evc_csr.r(utra::evc::SFR_IFEVEN_IFEVEN0); + evc_csr.wo(utra::evc::SFR_IFEVEN_IFEVEN0, foo); + let bar = evc_csr.rf(utra::evc::SFR_IFEVEN_IFEVEN0_IFEVEN0); + evc_csr.rmwf(utra::evc::SFR_IFEVEN_IFEVEN0_IFEVEN0, bar); + let mut baz = evc_csr.zf(utra::evc::SFR_IFEVEN_IFEVEN0_IFEVEN0, bar); + baz |= evc_csr.ms(utra::evc::SFR_IFEVEN_IFEVEN0_IFEVEN0, 1); + evc_csr.wfo(utra::evc::SFR_IFEVEN_IFEVEN0_IFEVEN0, baz); + + let foo = evc_csr.r(utra::evc::SFR_IFEVEN_IFEVEN1); + evc_csr.wo(utra::evc::SFR_IFEVEN_IFEVEN1, foo); + let bar = evc_csr.rf(utra::evc::SFR_IFEVEN_IFEVEN1_IFEVEN1); + evc_csr.rmwf(utra::evc::SFR_IFEVEN_IFEVEN1_IFEVEN1, bar); + let mut baz = evc_csr.zf(utra::evc::SFR_IFEVEN_IFEVEN1_IFEVEN1, bar); + baz |= evc_csr.ms(utra::evc::SFR_IFEVEN_IFEVEN1_IFEVEN1, 1); + evc_csr.wfo(utra::evc::SFR_IFEVEN_IFEVEN1_IFEVEN1, baz); + + let foo = evc_csr.r(utra::evc::SFR_IFEVEN_IFEVEN2); + evc_csr.wo(utra::evc::SFR_IFEVEN_IFEVEN2, foo); + let bar = evc_csr.rf(utra::evc::SFR_IFEVEN_IFEVEN2_IFEVEN2); + evc_csr.rmwf(utra::evc::SFR_IFEVEN_IFEVEN2_IFEVEN2, bar); + let mut baz = evc_csr.zf(utra::evc::SFR_IFEVEN_IFEVEN2_IFEVEN2, bar); + baz |= evc_csr.ms(utra::evc::SFR_IFEVEN_IFEVEN2_IFEVEN2, 1); + evc_csr.wfo(utra::evc::SFR_IFEVEN_IFEVEN2_IFEVEN2, baz); + + let foo = evc_csr.r(utra::evc::SFR_IFEVEN_IFEVEN3); + evc_csr.wo(utra::evc::SFR_IFEVEN_IFEVEN3, foo); + let bar = evc_csr.rf(utra::evc::SFR_IFEVEN_IFEVEN3_IFEVEN3); + evc_csr.rmwf(utra::evc::SFR_IFEVEN_IFEVEN3_IFEVEN3, bar); + let mut baz = evc_csr.zf(utra::evc::SFR_IFEVEN_IFEVEN3_IFEVEN3, bar); + baz |= evc_csr.ms(utra::evc::SFR_IFEVEN_IFEVEN3_IFEVEN3, 1); + evc_csr.wfo(utra::evc::SFR_IFEVEN_IFEVEN3_IFEVEN3, baz); + + let foo = evc_csr.r(utra::evc::SFR_IFEVEN_IFEVEN4); + evc_csr.wo(utra::evc::SFR_IFEVEN_IFEVEN4, foo); + let bar = evc_csr.rf(utra::evc::SFR_IFEVEN_IFEVEN4_IFEVEN4); + evc_csr.rmwf(utra::evc::SFR_IFEVEN_IFEVEN4_IFEVEN4, bar); + let mut baz = evc_csr.zf(utra::evc::SFR_IFEVEN_IFEVEN4_IFEVEN4, bar); + baz |= evc_csr.ms(utra::evc::SFR_IFEVEN_IFEVEN4_IFEVEN4, 1); + evc_csr.wfo(utra::evc::SFR_IFEVEN_IFEVEN4_IFEVEN4, baz); + + let foo = evc_csr.r(utra::evc::SFR_IFEVEN_IFEVEN5); + evc_csr.wo(utra::evc::SFR_IFEVEN_IFEVEN5, foo); + let bar = evc_csr.rf(utra::evc::SFR_IFEVEN_IFEVEN5_IFEVEN5); + evc_csr.rmwf(utra::evc::SFR_IFEVEN_IFEVEN5_IFEVEN5, bar); + let mut baz = evc_csr.zf(utra::evc::SFR_IFEVEN_IFEVEN5_IFEVEN5, bar); + baz |= evc_csr.ms(utra::evc::SFR_IFEVEN_IFEVEN5_IFEVEN5, 1); + evc_csr.wfo(utra::evc::SFR_IFEVEN_IFEVEN5_IFEVEN5, baz); + + let foo = evc_csr.r(utra::evc::SFR_IFEVEN_IFEVEN6); + evc_csr.wo(utra::evc::SFR_IFEVEN_IFEVEN6, foo); + let bar = evc_csr.rf(utra::evc::SFR_IFEVEN_IFEVEN6_IFEVEN6); + evc_csr.rmwf(utra::evc::SFR_IFEVEN_IFEVEN6_IFEVEN6, bar); + let mut baz = evc_csr.zf(utra::evc::SFR_IFEVEN_IFEVEN6_IFEVEN6, bar); + baz |= evc_csr.ms(utra::evc::SFR_IFEVEN_IFEVEN6_IFEVEN6, 1); + evc_csr.wfo(utra::evc::SFR_IFEVEN_IFEVEN6_IFEVEN6, baz); + + let foo = evc_csr.r(utra::evc::SFR_IFEVEN_IFEVEN7); + evc_csr.wo(utra::evc::SFR_IFEVEN_IFEVEN7, foo); + let bar = evc_csr.rf(utra::evc::SFR_IFEVEN_IFEVEN7_IFEVEN7); + evc_csr.rmwf(utra::evc::SFR_IFEVEN_IFEVEN7_IFEVEN7, bar); + let mut baz = evc_csr.zf(utra::evc::SFR_IFEVEN_IFEVEN7_IFEVEN7, bar); + baz |= evc_csr.ms(utra::evc::SFR_IFEVEN_IFEVEN7_IFEVEN7, 1); + evc_csr.wfo(utra::evc::SFR_IFEVEN_IFEVEN7_IFEVEN7, baz); + + let foo = evc_csr.r(utra::evc::SFR_IFEVERRFR); + evc_csr.wo(utra::evc::SFR_IFEVERRFR, foo); + let bar = evc_csr.rf(utra::evc::SFR_IFEVERRFR_IFEV_ERRS); + evc_csr.rmwf(utra::evc::SFR_IFEVERRFR_IFEV_ERRS, bar); + let mut baz = evc_csr.zf(utra::evc::SFR_IFEVERRFR_IFEV_ERRS, bar); + baz |= evc_csr.ms(utra::evc::SFR_IFEVERRFR_IFEV_ERRS, 1); + evc_csr.wfo(utra::evc::SFR_IFEVERRFR_IFEV_ERRS, baz); + + let foo = evc_csr.r(utra::evc::SFR_CM7ERRFR); + evc_csr.wo(utra::evc::SFR_CM7ERRFR, foo); + let bar = evc_csr.rf(utra::evc::SFR_CM7ERRFR_ERRIN); + evc_csr.rmwf(utra::evc::SFR_CM7ERRFR_ERRIN, bar); + let mut baz = evc_csr.zf(utra::evc::SFR_CM7ERRFR_ERRIN, bar); + baz |= evc_csr.ms(utra::evc::SFR_CM7ERRFR_ERRIN, 1); + evc_csr.wfo(utra::evc::SFR_CM7ERRFR_ERRIN, baz); + } + + #[test] + #[ignore] + fn compile_check_sysctrl_csr() { + use super::*; + let mut sysctrl_csr = CSR::new(HW_SYSCTRL_BASE as *mut u32); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_CGUSEC); + sysctrl_csr.wo(utra::sysctrl::SFR_CGUSEC, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_CGUSEC_SFR_CGUSEC); + sysctrl_csr.rmwf(utra::sysctrl::SFR_CGUSEC_SFR_CGUSEC, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_CGUSEC_SFR_CGUSEC, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_CGUSEC_SFR_CGUSEC, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_CGUSEC_SFR_CGUSEC, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_CGULP); + sysctrl_csr.wo(utra::sysctrl::SFR_CGULP, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_CGULP_SFR_CGULP); + sysctrl_csr.rmwf(utra::sysctrl::SFR_CGULP_SFR_CGULP, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_CGULP_SFR_CGULP, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_CGULP_SFR_CGULP, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_CGULP_SFR_CGULP, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_CGUSEL0); + sysctrl_csr.wo(utra::sysctrl::SFR_CGUSEL0, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_CGUSEL0_SFR_CGUSEL0); + sysctrl_csr.rmwf(utra::sysctrl::SFR_CGUSEL0_SFR_CGUSEL0, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_CGUSEL0_SFR_CGUSEL0, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_CGUSEL0_SFR_CGUSEL0, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_CGUSEL0_SFR_CGUSEL0, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_CGUFD_CFGFDCR0); + sysctrl_csr.wo(utra::sysctrl::SFR_CGUFD_CFGFDCR0, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_CGUFD_CFGFDCR0_CFGFDCR0); + sysctrl_csr.rmwf(utra::sysctrl::SFR_CGUFD_CFGFDCR0_CFGFDCR0, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_CGUFD_CFGFDCR0_CFGFDCR0, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_CGUFD_CFGFDCR0_CFGFDCR0, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_CGUFD_CFGFDCR0_CFGFDCR0, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_CGUFD_CFGFDCR1); + sysctrl_csr.wo(utra::sysctrl::SFR_CGUFD_CFGFDCR1, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_CGUFD_CFGFDCR1_CFGFDCR1); + sysctrl_csr.rmwf(utra::sysctrl::SFR_CGUFD_CFGFDCR1_CFGFDCR1, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_CGUFD_CFGFDCR1_CFGFDCR1, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_CGUFD_CFGFDCR1_CFGFDCR1, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_CGUFD_CFGFDCR1_CFGFDCR1, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_CGUFD_CFGFDCR2); + sysctrl_csr.wo(utra::sysctrl::SFR_CGUFD_CFGFDCR2, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_CGUFD_CFGFDCR2_CFGFDCR2); + sysctrl_csr.rmwf(utra::sysctrl::SFR_CGUFD_CFGFDCR2_CFGFDCR2, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_CGUFD_CFGFDCR2_CFGFDCR2, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_CGUFD_CFGFDCR2_CFGFDCR2, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_CGUFD_CFGFDCR2_CFGFDCR2, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_CGUFD_CFGFDCR3); + sysctrl_csr.wo(utra::sysctrl::SFR_CGUFD_CFGFDCR3, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_CGUFD_CFGFDCR3_CFGFDCR3); + sysctrl_csr.rmwf(utra::sysctrl::SFR_CGUFD_CFGFDCR3_CFGFDCR3, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_CGUFD_CFGFDCR3_CFGFDCR3, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_CGUFD_CFGFDCR3_CFGFDCR3, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_CGUFD_CFGFDCR3_CFGFDCR3, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_CGUFD_CFGFDCR4); + sysctrl_csr.wo(utra::sysctrl::SFR_CGUFD_CFGFDCR4, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_CGUFD_CFGFDCR4_CFGFDCR4); + sysctrl_csr.rmwf(utra::sysctrl::SFR_CGUFD_CFGFDCR4_CFGFDCR4, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_CGUFD_CFGFDCR4_CFGFDCR4, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_CGUFD_CFGFDCR4_CFGFDCR4, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_CGUFD_CFGFDCR4_CFGFDCR4, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_CGUSET); + sysctrl_csr.wo(utra::sysctrl::SFR_CGUSET, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_CGUSET_SFR_CGUSET); + sysctrl_csr.rmwf(utra::sysctrl::SFR_CGUSET_SFR_CGUSET, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_CGUSET_SFR_CGUSET, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_CGUSET_SFR_CGUSET, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_CGUSET_SFR_CGUSET, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_CGUSEL1); + sysctrl_csr.wo(utra::sysctrl::SFR_CGUSEL1, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_CGUSEL1_SFR_CGUSEL1); + sysctrl_csr.rmwf(utra::sysctrl::SFR_CGUSEL1_SFR_CGUSEL1, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_CGUSEL1_SFR_CGUSEL1, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_CGUSEL1_SFR_CGUSEL1, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_CGUSEL1_SFR_CGUSEL1, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_CGUFSSR_FSFREQ0); + sysctrl_csr.wo(utra::sysctrl::SFR_CGUFSSR_FSFREQ0, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_CGUFSSR_FSFREQ0_FSFREQ0); + sysctrl_csr.rmwf(utra::sysctrl::SFR_CGUFSSR_FSFREQ0_FSFREQ0, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_CGUFSSR_FSFREQ0_FSFREQ0, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_CGUFSSR_FSFREQ0_FSFREQ0, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_CGUFSSR_FSFREQ0_FSFREQ0, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_CGUFSSR_FSFREQ1); + sysctrl_csr.wo(utra::sysctrl::SFR_CGUFSSR_FSFREQ1, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_CGUFSSR_FSFREQ1_FSFREQ1); + sysctrl_csr.rmwf(utra::sysctrl::SFR_CGUFSSR_FSFREQ1_FSFREQ1, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_CGUFSSR_FSFREQ1_FSFREQ1, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_CGUFSSR_FSFREQ1_FSFREQ1, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_CGUFSSR_FSFREQ1_FSFREQ1, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_CGUFSSR_FSFREQ2); + sysctrl_csr.wo(utra::sysctrl::SFR_CGUFSSR_FSFREQ2, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_CGUFSSR_FSFREQ2_FSFREQ2); + sysctrl_csr.rmwf(utra::sysctrl::SFR_CGUFSSR_FSFREQ2_FSFREQ2, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_CGUFSSR_FSFREQ2_FSFREQ2, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_CGUFSSR_FSFREQ2_FSFREQ2, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_CGUFSSR_FSFREQ2_FSFREQ2, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_CGUFSSR_FSFREQ3); + sysctrl_csr.wo(utra::sysctrl::SFR_CGUFSSR_FSFREQ3, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_CGUFSSR_FSFREQ3_FSFREQ3); + sysctrl_csr.rmwf(utra::sysctrl::SFR_CGUFSSR_FSFREQ3_FSFREQ3, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_CGUFSSR_FSFREQ3_FSFREQ3, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_CGUFSSR_FSFREQ3_FSFREQ3, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_CGUFSSR_FSFREQ3_FSFREQ3, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_CGUFSVLD); + sysctrl_csr.wo(utra::sysctrl::SFR_CGUFSVLD, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_CGUFSVLD_SFR_CGUFSVLD); + sysctrl_csr.rmwf(utra::sysctrl::SFR_CGUFSVLD_SFR_CGUFSVLD, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_CGUFSVLD_SFR_CGUFSVLD, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_CGUFSVLD_SFR_CGUFSVLD, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_CGUFSVLD_SFR_CGUFSVLD, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_CGUFSCR); + sysctrl_csr.wo(utra::sysctrl::SFR_CGUFSCR, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_CGUFSCR_SFR_CGUFSCR); + sysctrl_csr.rmwf(utra::sysctrl::SFR_CGUFSCR_SFR_CGUFSCR, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_CGUFSCR_SFR_CGUFSCR, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_CGUFSCR_SFR_CGUFSCR, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_CGUFSCR_SFR_CGUFSCR, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_ACLKGR); + sysctrl_csr.wo(utra::sysctrl::SFR_ACLKGR, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_ACLKGR_SFR_ACLKGR); + sysctrl_csr.rmwf(utra::sysctrl::SFR_ACLKGR_SFR_ACLKGR, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_ACLKGR_SFR_ACLKGR, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_ACLKGR_SFR_ACLKGR, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_ACLKGR_SFR_ACLKGR, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_HCLKGR); + sysctrl_csr.wo(utra::sysctrl::SFR_HCLKGR, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_HCLKGR_SFR_HCLKGR); + sysctrl_csr.rmwf(utra::sysctrl::SFR_HCLKGR_SFR_HCLKGR, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_HCLKGR_SFR_HCLKGR, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_HCLKGR_SFR_HCLKGR, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_HCLKGR_SFR_HCLKGR, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_ICLKGR); + sysctrl_csr.wo(utra::sysctrl::SFR_ICLKGR, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_ICLKGR_SFR_ICLKGR); + sysctrl_csr.rmwf(utra::sysctrl::SFR_ICLKGR_SFR_ICLKGR, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_ICLKGR_SFR_ICLKGR, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_ICLKGR_SFR_ICLKGR, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_ICLKGR_SFR_ICLKGR, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_PCLKGR); + sysctrl_csr.wo(utra::sysctrl::SFR_PCLKGR, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_PCLKGR_SFR_PCLKGR); + sysctrl_csr.rmwf(utra::sysctrl::SFR_PCLKGR_SFR_PCLKGR, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_PCLKGR_SFR_PCLKGR, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_PCLKGR_SFR_PCLKGR, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_PCLKGR_SFR_PCLKGR, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_RCURST0); + sysctrl_csr.wo(utra::sysctrl::SFR_RCURST0, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_RCURST0_SFR_RCURST0); + sysctrl_csr.rmwf(utra::sysctrl::SFR_RCURST0_SFR_RCURST0, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_RCURST0_SFR_RCURST0, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_RCURST0_SFR_RCURST0, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_RCURST0_SFR_RCURST0, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_RCURST1); + sysctrl_csr.wo(utra::sysctrl::SFR_RCURST1, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_RCURST1_SFR_RCURST1); + sysctrl_csr.rmwf(utra::sysctrl::SFR_RCURST1_SFR_RCURST1, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_RCURST1_SFR_RCURST1, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_RCURST1_SFR_RCURST1, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_RCURST1_SFR_RCURST1, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_RCUSRCFR); + sysctrl_csr.wo(utra::sysctrl::SFR_RCUSRCFR, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_RCUSRCFR_SFR_RCUSRCFR); + sysctrl_csr.rmwf(utra::sysctrl::SFR_RCUSRCFR_SFR_RCUSRCFR, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_RCUSRCFR_SFR_RCUSRCFR, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_RCUSRCFR_SFR_RCUSRCFR, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_RCUSRCFR_SFR_RCUSRCFR, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_IPCARIPFLOW); + sysctrl_csr.wo(utra::sysctrl::SFR_IPCARIPFLOW, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_IPCARIPFLOW_SFR_IPCARIPFLOW); + sysctrl_csr.rmwf(utra::sysctrl::SFR_IPCARIPFLOW_SFR_IPCARIPFLOW, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_IPCARIPFLOW_SFR_IPCARIPFLOW, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_IPCARIPFLOW_SFR_IPCARIPFLOW, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_IPCARIPFLOW_SFR_IPCARIPFLOW, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_IPCEN); + sysctrl_csr.wo(utra::sysctrl::SFR_IPCEN, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_IPCEN_SFR_IPCEN); + sysctrl_csr.rmwf(utra::sysctrl::SFR_IPCEN_SFR_IPCEN, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_IPCEN_SFR_IPCEN, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_IPCEN_SFR_IPCEN, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_IPCEN_SFR_IPCEN, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_IPCLPEN); + sysctrl_csr.wo(utra::sysctrl::SFR_IPCLPEN, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_IPCLPEN_SFR_IPCLPEN); + sysctrl_csr.rmwf(utra::sysctrl::SFR_IPCLPEN_SFR_IPCLPEN, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_IPCLPEN_SFR_IPCLPEN, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_IPCLPEN_SFR_IPCLPEN, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_IPCLPEN_SFR_IPCLPEN, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_IPCOSC); + sysctrl_csr.wo(utra::sysctrl::SFR_IPCOSC, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_IPCOSC_SFR_IPCOSC); + sysctrl_csr.rmwf(utra::sysctrl::SFR_IPCOSC_SFR_IPCOSC, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_IPCOSC_SFR_IPCOSC, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_IPCOSC_SFR_IPCOSC, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_IPCOSC_SFR_IPCOSC, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_IPCPLLMN); + sysctrl_csr.wo(utra::sysctrl::SFR_IPCPLLMN, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_IPCPLLMN_SFR_IPCPLLMN); + sysctrl_csr.rmwf(utra::sysctrl::SFR_IPCPLLMN_SFR_IPCPLLMN, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_IPCPLLMN_SFR_IPCPLLMN, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_IPCPLLMN_SFR_IPCPLLMN, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_IPCPLLMN_SFR_IPCPLLMN, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_IPCPLLF); + sysctrl_csr.wo(utra::sysctrl::SFR_IPCPLLF, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_IPCPLLF_SFR_IPCPLLF); + sysctrl_csr.rmwf(utra::sysctrl::SFR_IPCPLLF_SFR_IPCPLLF, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_IPCPLLF_SFR_IPCPLLF, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_IPCPLLF_SFR_IPCPLLF, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_IPCPLLF_SFR_IPCPLLF, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_IPCPLLQ); + sysctrl_csr.wo(utra::sysctrl::SFR_IPCPLLQ, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_IPCPLLQ_SFR_IPCPLLQ); + sysctrl_csr.rmwf(utra::sysctrl::SFR_IPCPLLQ_SFR_IPCPLLQ, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_IPCPLLQ_SFR_IPCPLLQ, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_IPCPLLQ_SFR_IPCPLLQ, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_IPCPLLQ_SFR_IPCPLLQ, baz); + + let foo = sysctrl_csr.r(utra::sysctrl::SFR_IPCCR); + sysctrl_csr.wo(utra::sysctrl::SFR_IPCCR, foo); + let bar = sysctrl_csr.rf(utra::sysctrl::SFR_IPCCR_SFR_IPCCR); + sysctrl_csr.rmwf(utra::sysctrl::SFR_IPCCR_SFR_IPCCR, bar); + let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_IPCCR_SFR_IPCCR, bar); + baz |= sysctrl_csr.ms(utra::sysctrl::SFR_IPCCR_SFR_IPCCR, 1); + sysctrl_csr.wfo(utra::sysctrl::SFR_IPCCR_SFR_IPCCR, baz); + } + + #[test] + #[ignore] + fn compile_check_apb_thru_csr() { + use super::*; + let mut apb_thru_csr = CSR::new(HW_APB_THRU_BASE as *mut u32); + } + + #[test] + #[ignore] + fn compile_check_iox_csr() { + use super::*; + let mut iox_csr = CSR::new(HW_IOX_BASE as *mut u32); + + let foo = iox_csr.r(utra::iox::SFR_AFSEL_CRAFSEL0); + iox_csr.wo(utra::iox::SFR_AFSEL_CRAFSEL0, foo); + let bar = iox_csr.rf(utra::iox::SFR_AFSEL_CRAFSEL0_CRAFSEL0); + iox_csr.rmwf(utra::iox::SFR_AFSEL_CRAFSEL0_CRAFSEL0, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_AFSEL_CRAFSEL0_CRAFSEL0, bar); + baz |= iox_csr.ms(utra::iox::SFR_AFSEL_CRAFSEL0_CRAFSEL0, 1); + iox_csr.wfo(utra::iox::SFR_AFSEL_CRAFSEL0_CRAFSEL0, baz); + + let foo = iox_csr.r(utra::iox::SFR_AFSEL_CRAFSEL1); + iox_csr.wo(utra::iox::SFR_AFSEL_CRAFSEL1, foo); + let bar = iox_csr.rf(utra::iox::SFR_AFSEL_CRAFSEL1_CRAFSEL1); + iox_csr.rmwf(utra::iox::SFR_AFSEL_CRAFSEL1_CRAFSEL1, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_AFSEL_CRAFSEL1_CRAFSEL1, bar); + baz |= iox_csr.ms(utra::iox::SFR_AFSEL_CRAFSEL1_CRAFSEL1, 1); + iox_csr.wfo(utra::iox::SFR_AFSEL_CRAFSEL1_CRAFSEL1, baz); + + let foo = iox_csr.r(utra::iox::SFR_AFSEL_CRAFSEL2); + iox_csr.wo(utra::iox::SFR_AFSEL_CRAFSEL2, foo); + let bar = iox_csr.rf(utra::iox::SFR_AFSEL_CRAFSEL2_CRAFSEL2); + iox_csr.rmwf(utra::iox::SFR_AFSEL_CRAFSEL2_CRAFSEL2, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_AFSEL_CRAFSEL2_CRAFSEL2, bar); + baz |= iox_csr.ms(utra::iox::SFR_AFSEL_CRAFSEL2_CRAFSEL2, 1); + iox_csr.wfo(utra::iox::SFR_AFSEL_CRAFSEL2_CRAFSEL2, baz); + + let foo = iox_csr.r(utra::iox::SFR_AFSEL_CRAFSEL3); + iox_csr.wo(utra::iox::SFR_AFSEL_CRAFSEL3, foo); + let bar = iox_csr.rf(utra::iox::SFR_AFSEL_CRAFSEL3_CRAFSEL3); + iox_csr.rmwf(utra::iox::SFR_AFSEL_CRAFSEL3_CRAFSEL3, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_AFSEL_CRAFSEL3_CRAFSEL3, bar); + baz |= iox_csr.ms(utra::iox::SFR_AFSEL_CRAFSEL3_CRAFSEL3, 1); + iox_csr.wfo(utra::iox::SFR_AFSEL_CRAFSEL3_CRAFSEL3, baz); + + let foo = iox_csr.r(utra::iox::SFR_AFSEL_CRAFSEL4); + iox_csr.wo(utra::iox::SFR_AFSEL_CRAFSEL4, foo); + let bar = iox_csr.rf(utra::iox::SFR_AFSEL_CRAFSEL4_CRAFSEL4); + iox_csr.rmwf(utra::iox::SFR_AFSEL_CRAFSEL4_CRAFSEL4, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_AFSEL_CRAFSEL4_CRAFSEL4, bar); + baz |= iox_csr.ms(utra::iox::SFR_AFSEL_CRAFSEL4_CRAFSEL4, 1); + iox_csr.wfo(utra::iox::SFR_AFSEL_CRAFSEL4_CRAFSEL4, baz); + + let foo = iox_csr.r(utra::iox::SFR_AFSEL_CRAFSEL5); + iox_csr.wo(utra::iox::SFR_AFSEL_CRAFSEL5, foo); + let bar = iox_csr.rf(utra::iox::SFR_AFSEL_CRAFSEL5_CRAFSEL5); + iox_csr.rmwf(utra::iox::SFR_AFSEL_CRAFSEL5_CRAFSEL5, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_AFSEL_CRAFSEL5_CRAFSEL5, bar); + baz |= iox_csr.ms(utra::iox::SFR_AFSEL_CRAFSEL5_CRAFSEL5, 1); + iox_csr.wfo(utra::iox::SFR_AFSEL_CRAFSEL5_CRAFSEL5, baz); + + let foo = iox_csr.r(utra::iox::SFR_AFSEL_CRAFSEL6); + iox_csr.wo(utra::iox::SFR_AFSEL_CRAFSEL6, foo); + let bar = iox_csr.rf(utra::iox::SFR_AFSEL_CRAFSEL6_CRAFSEL6); + iox_csr.rmwf(utra::iox::SFR_AFSEL_CRAFSEL6_CRAFSEL6, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_AFSEL_CRAFSEL6_CRAFSEL6, bar); + baz |= iox_csr.ms(utra::iox::SFR_AFSEL_CRAFSEL6_CRAFSEL6, 1); + iox_csr.wfo(utra::iox::SFR_AFSEL_CRAFSEL6_CRAFSEL6, baz); + + let foo = iox_csr.r(utra::iox::SFR_AFSEL_CRAFSEL7); + iox_csr.wo(utra::iox::SFR_AFSEL_CRAFSEL7, foo); + let bar = iox_csr.rf(utra::iox::SFR_AFSEL_CRAFSEL7_CRAFSEL7); + iox_csr.rmwf(utra::iox::SFR_AFSEL_CRAFSEL7_CRAFSEL7, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_AFSEL_CRAFSEL7_CRAFSEL7, bar); + baz |= iox_csr.ms(utra::iox::SFR_AFSEL_CRAFSEL7_CRAFSEL7, 1); + iox_csr.wfo(utra::iox::SFR_AFSEL_CRAFSEL7_CRAFSEL7, baz); + + let foo = iox_csr.r(utra::iox::SFR_INTCR_CRINT0); + iox_csr.wo(utra::iox::SFR_INTCR_CRINT0, foo); + let bar = iox_csr.rf(utra::iox::SFR_INTCR_CRINT0_CRINT0); + iox_csr.rmwf(utra::iox::SFR_INTCR_CRINT0_CRINT0, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_INTCR_CRINT0_CRINT0, bar); + baz |= iox_csr.ms(utra::iox::SFR_INTCR_CRINT0_CRINT0, 1); + iox_csr.wfo(utra::iox::SFR_INTCR_CRINT0_CRINT0, baz); + + let foo = iox_csr.r(utra::iox::SFR_INTCR_CRINT1); + iox_csr.wo(utra::iox::SFR_INTCR_CRINT1, foo); + let bar = iox_csr.rf(utra::iox::SFR_INTCR_CRINT1_CRINT1); + iox_csr.rmwf(utra::iox::SFR_INTCR_CRINT1_CRINT1, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_INTCR_CRINT1_CRINT1, bar); + baz |= iox_csr.ms(utra::iox::SFR_INTCR_CRINT1_CRINT1, 1); + iox_csr.wfo(utra::iox::SFR_INTCR_CRINT1_CRINT1, baz); + + let foo = iox_csr.r(utra::iox::SFR_INTCR_CRINT2); + iox_csr.wo(utra::iox::SFR_INTCR_CRINT2, foo); + let bar = iox_csr.rf(utra::iox::SFR_INTCR_CRINT2_CRINT2); + iox_csr.rmwf(utra::iox::SFR_INTCR_CRINT2_CRINT2, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_INTCR_CRINT2_CRINT2, bar); + baz |= iox_csr.ms(utra::iox::SFR_INTCR_CRINT2_CRINT2, 1); + iox_csr.wfo(utra::iox::SFR_INTCR_CRINT2_CRINT2, baz); + + let foo = iox_csr.r(utra::iox::SFR_INTCR_CRINT3); + iox_csr.wo(utra::iox::SFR_INTCR_CRINT3, foo); + let bar = iox_csr.rf(utra::iox::SFR_INTCR_CRINT3_CRINT3); + iox_csr.rmwf(utra::iox::SFR_INTCR_CRINT3_CRINT3, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_INTCR_CRINT3_CRINT3, bar); + baz |= iox_csr.ms(utra::iox::SFR_INTCR_CRINT3_CRINT3, 1); + iox_csr.wfo(utra::iox::SFR_INTCR_CRINT3_CRINT3, baz); + + let foo = iox_csr.r(utra::iox::SFR_INTCR_CRINT4); + iox_csr.wo(utra::iox::SFR_INTCR_CRINT4, foo); + let bar = iox_csr.rf(utra::iox::SFR_INTCR_CRINT4_CRINT4); + iox_csr.rmwf(utra::iox::SFR_INTCR_CRINT4_CRINT4, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_INTCR_CRINT4_CRINT4, bar); + baz |= iox_csr.ms(utra::iox::SFR_INTCR_CRINT4_CRINT4, 1); + iox_csr.wfo(utra::iox::SFR_INTCR_CRINT4_CRINT4, baz); + + let foo = iox_csr.r(utra::iox::SFR_INTCR_CRINT5); + iox_csr.wo(utra::iox::SFR_INTCR_CRINT5, foo); + let bar = iox_csr.rf(utra::iox::SFR_INTCR_CRINT5_CRINT5); + iox_csr.rmwf(utra::iox::SFR_INTCR_CRINT5_CRINT5, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_INTCR_CRINT5_CRINT5, bar); + baz |= iox_csr.ms(utra::iox::SFR_INTCR_CRINT5_CRINT5, 1); + iox_csr.wfo(utra::iox::SFR_INTCR_CRINT5_CRINT5, baz); + + let foo = iox_csr.r(utra::iox::SFR_INTCR_CRINT6); + iox_csr.wo(utra::iox::SFR_INTCR_CRINT6, foo); + let bar = iox_csr.rf(utra::iox::SFR_INTCR_CRINT6_CRINT6); + iox_csr.rmwf(utra::iox::SFR_INTCR_CRINT6_CRINT6, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_INTCR_CRINT6_CRINT6, bar); + baz |= iox_csr.ms(utra::iox::SFR_INTCR_CRINT6_CRINT6, 1); + iox_csr.wfo(utra::iox::SFR_INTCR_CRINT6_CRINT6, baz); + + let foo = iox_csr.r(utra::iox::SFR_INTCR_CRINT7); + iox_csr.wo(utra::iox::SFR_INTCR_CRINT7, foo); + let bar = iox_csr.rf(utra::iox::SFR_INTCR_CRINT7_CRINT7); + iox_csr.rmwf(utra::iox::SFR_INTCR_CRINT7_CRINT7, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_INTCR_CRINT7_CRINT7, bar); + baz |= iox_csr.ms(utra::iox::SFR_INTCR_CRINT7_CRINT7, 1); + iox_csr.wfo(utra::iox::SFR_INTCR_CRINT7_CRINT7, baz); + + let foo = iox_csr.r(utra::iox::SFR_INTFR); + iox_csr.wo(utra::iox::SFR_INTFR, foo); + let bar = iox_csr.rf(utra::iox::SFR_INTFR_FRINT); + iox_csr.rmwf(utra::iox::SFR_INTFR_FRINT, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_INTFR_FRINT, bar); + baz |= iox_csr.ms(utra::iox::SFR_INTFR_FRINT, 1); + iox_csr.wfo(utra::iox::SFR_INTFR_FRINT, baz); + + let foo = iox_csr.r(utra::iox::SFR_GPIOOUT_CRGO0); + iox_csr.wo(utra::iox::SFR_GPIOOUT_CRGO0, foo); + let bar = iox_csr.rf(utra::iox::SFR_GPIOOUT_CRGO0_CRGO0); + iox_csr.rmwf(utra::iox::SFR_GPIOOUT_CRGO0_CRGO0, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_GPIOOUT_CRGO0_CRGO0, bar); + baz |= iox_csr.ms(utra::iox::SFR_GPIOOUT_CRGO0_CRGO0, 1); + iox_csr.wfo(utra::iox::SFR_GPIOOUT_CRGO0_CRGO0, baz); + + let foo = iox_csr.r(utra::iox::SFR_GPIOOUT_CRGO1); + iox_csr.wo(utra::iox::SFR_GPIOOUT_CRGO1, foo); + let bar = iox_csr.rf(utra::iox::SFR_GPIOOUT_CRGO1_CRGO1); + iox_csr.rmwf(utra::iox::SFR_GPIOOUT_CRGO1_CRGO1, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_GPIOOUT_CRGO1_CRGO1, bar); + baz |= iox_csr.ms(utra::iox::SFR_GPIOOUT_CRGO1_CRGO1, 1); + iox_csr.wfo(utra::iox::SFR_GPIOOUT_CRGO1_CRGO1, baz); + + let foo = iox_csr.r(utra::iox::SFR_GPIOOUT_CRGO2); + iox_csr.wo(utra::iox::SFR_GPIOOUT_CRGO2, foo); + let bar = iox_csr.rf(utra::iox::SFR_GPIOOUT_CRGO2_CRGO2); + iox_csr.rmwf(utra::iox::SFR_GPIOOUT_CRGO2_CRGO2, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_GPIOOUT_CRGO2_CRGO2, bar); + baz |= iox_csr.ms(utra::iox::SFR_GPIOOUT_CRGO2_CRGO2, 1); + iox_csr.wfo(utra::iox::SFR_GPIOOUT_CRGO2_CRGO2, baz); + + let foo = iox_csr.r(utra::iox::SFR_GPIOOUT_CRGO3); + iox_csr.wo(utra::iox::SFR_GPIOOUT_CRGO3, foo); + let bar = iox_csr.rf(utra::iox::SFR_GPIOOUT_CRGO3_CRGO3); + iox_csr.rmwf(utra::iox::SFR_GPIOOUT_CRGO3_CRGO3, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_GPIOOUT_CRGO3_CRGO3, bar); + baz |= iox_csr.ms(utra::iox::SFR_GPIOOUT_CRGO3_CRGO3, 1); + iox_csr.wfo(utra::iox::SFR_GPIOOUT_CRGO3_CRGO3, baz); + + let foo = iox_csr.r(utra::iox::SFR_GPIOOE_CRGOE0); + iox_csr.wo(utra::iox::SFR_GPIOOE_CRGOE0, foo); + let bar = iox_csr.rf(utra::iox::SFR_GPIOOE_CRGOE0_CRGOE0); + iox_csr.rmwf(utra::iox::SFR_GPIOOE_CRGOE0_CRGOE0, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_GPIOOE_CRGOE0_CRGOE0, bar); + baz |= iox_csr.ms(utra::iox::SFR_GPIOOE_CRGOE0_CRGOE0, 1); + iox_csr.wfo(utra::iox::SFR_GPIOOE_CRGOE0_CRGOE0, baz); + + let foo = iox_csr.r(utra::iox::SFR_GPIOOE_CRGOE1); + iox_csr.wo(utra::iox::SFR_GPIOOE_CRGOE1, foo); + let bar = iox_csr.rf(utra::iox::SFR_GPIOOE_CRGOE1_CRGOE1); + iox_csr.rmwf(utra::iox::SFR_GPIOOE_CRGOE1_CRGOE1, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_GPIOOE_CRGOE1_CRGOE1, bar); + baz |= iox_csr.ms(utra::iox::SFR_GPIOOE_CRGOE1_CRGOE1, 1); + iox_csr.wfo(utra::iox::SFR_GPIOOE_CRGOE1_CRGOE1, baz); + + let foo = iox_csr.r(utra::iox::SFR_GPIOOE_CRGOE2); + iox_csr.wo(utra::iox::SFR_GPIOOE_CRGOE2, foo); + let bar = iox_csr.rf(utra::iox::SFR_GPIOOE_CRGOE2_CRGOE2); + iox_csr.rmwf(utra::iox::SFR_GPIOOE_CRGOE2_CRGOE2, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_GPIOOE_CRGOE2_CRGOE2, bar); + baz |= iox_csr.ms(utra::iox::SFR_GPIOOE_CRGOE2_CRGOE2, 1); + iox_csr.wfo(utra::iox::SFR_GPIOOE_CRGOE2_CRGOE2, baz); + + let foo = iox_csr.r(utra::iox::SFR_GPIOOE_CRGOE3); + iox_csr.wo(utra::iox::SFR_GPIOOE_CRGOE3, foo); + let bar = iox_csr.rf(utra::iox::SFR_GPIOOE_CRGOE3_CRGOE3); + iox_csr.rmwf(utra::iox::SFR_GPIOOE_CRGOE3_CRGOE3, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_GPIOOE_CRGOE3_CRGOE3, bar); + baz |= iox_csr.ms(utra::iox::SFR_GPIOOE_CRGOE3_CRGOE3, 1); + iox_csr.wfo(utra::iox::SFR_GPIOOE_CRGOE3_CRGOE3, baz); + + let foo = iox_csr.r(utra::iox::SFR_GPIOPU_CRGPU0); + iox_csr.wo(utra::iox::SFR_GPIOPU_CRGPU0, foo); + let bar = iox_csr.rf(utra::iox::SFR_GPIOPU_CRGPU0_CRGPU0); + iox_csr.rmwf(utra::iox::SFR_GPIOPU_CRGPU0_CRGPU0, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_GPIOPU_CRGPU0_CRGPU0, bar); + baz |= iox_csr.ms(utra::iox::SFR_GPIOPU_CRGPU0_CRGPU0, 1); + iox_csr.wfo(utra::iox::SFR_GPIOPU_CRGPU0_CRGPU0, baz); + + let foo = iox_csr.r(utra::iox::SFR_GPIOPU_CRGPU1); + iox_csr.wo(utra::iox::SFR_GPIOPU_CRGPU1, foo); + let bar = iox_csr.rf(utra::iox::SFR_GPIOPU_CRGPU1_CRGPU1); + iox_csr.rmwf(utra::iox::SFR_GPIOPU_CRGPU1_CRGPU1, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_GPIOPU_CRGPU1_CRGPU1, bar); + baz |= iox_csr.ms(utra::iox::SFR_GPIOPU_CRGPU1_CRGPU1, 1); + iox_csr.wfo(utra::iox::SFR_GPIOPU_CRGPU1_CRGPU1, baz); + + let foo = iox_csr.r(utra::iox::SFR_GPIOPU_CRGPU2); + iox_csr.wo(utra::iox::SFR_GPIOPU_CRGPU2, foo); + let bar = iox_csr.rf(utra::iox::SFR_GPIOPU_CRGPU2_CRGPU2); + iox_csr.rmwf(utra::iox::SFR_GPIOPU_CRGPU2_CRGPU2, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_GPIOPU_CRGPU2_CRGPU2, bar); + baz |= iox_csr.ms(utra::iox::SFR_GPIOPU_CRGPU2_CRGPU2, 1); + iox_csr.wfo(utra::iox::SFR_GPIOPU_CRGPU2_CRGPU2, baz); + + let foo = iox_csr.r(utra::iox::SFR_GPIOPU_CRGPU3); + iox_csr.wo(utra::iox::SFR_GPIOPU_CRGPU3, foo); + let bar = iox_csr.rf(utra::iox::SFR_GPIOPU_CRGPU3_CRGPU3); + iox_csr.rmwf(utra::iox::SFR_GPIOPU_CRGPU3_CRGPU3, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_GPIOPU_CRGPU3_CRGPU3, bar); + baz |= iox_csr.ms(utra::iox::SFR_GPIOPU_CRGPU3_CRGPU3, 1); + iox_csr.wfo(utra::iox::SFR_GPIOPU_CRGPU3_CRGPU3, baz); + + let foo = iox_csr.r(utra::iox::SFR_GPIOIN_SRGI0); + iox_csr.wo(utra::iox::SFR_GPIOIN_SRGI0, foo); + let bar = iox_csr.rf(utra::iox::SFR_GPIOIN_SRGI0_SRGI0); + iox_csr.rmwf(utra::iox::SFR_GPIOIN_SRGI0_SRGI0, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_GPIOIN_SRGI0_SRGI0, bar); + baz |= iox_csr.ms(utra::iox::SFR_GPIOIN_SRGI0_SRGI0, 1); + iox_csr.wfo(utra::iox::SFR_GPIOIN_SRGI0_SRGI0, baz); + + let foo = iox_csr.r(utra::iox::SFR_GPIOIN_SRGI1); + iox_csr.wo(utra::iox::SFR_GPIOIN_SRGI1, foo); + let bar = iox_csr.rf(utra::iox::SFR_GPIOIN_SRGI1_SRGI1); + iox_csr.rmwf(utra::iox::SFR_GPIOIN_SRGI1_SRGI1, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_GPIOIN_SRGI1_SRGI1, bar); + baz |= iox_csr.ms(utra::iox::SFR_GPIOIN_SRGI1_SRGI1, 1); + iox_csr.wfo(utra::iox::SFR_GPIOIN_SRGI1_SRGI1, baz); + + let foo = iox_csr.r(utra::iox::SFR_GPIOIN_SRGI2); + iox_csr.wo(utra::iox::SFR_GPIOIN_SRGI2, foo); + let bar = iox_csr.rf(utra::iox::SFR_GPIOIN_SRGI2_SRGI2); + iox_csr.rmwf(utra::iox::SFR_GPIOIN_SRGI2_SRGI2, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_GPIOIN_SRGI2_SRGI2, bar); + baz |= iox_csr.ms(utra::iox::SFR_GPIOIN_SRGI2_SRGI2, 1); + iox_csr.wfo(utra::iox::SFR_GPIOIN_SRGI2_SRGI2, baz); + + let foo = iox_csr.r(utra::iox::SFR_GPIOIN_SRGI3); + iox_csr.wo(utra::iox::SFR_GPIOIN_SRGI3, foo); + let bar = iox_csr.rf(utra::iox::SFR_GPIOIN_SRGI3_SRGI3); + iox_csr.rmwf(utra::iox::SFR_GPIOIN_SRGI3_SRGI3, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_GPIOIN_SRGI3_SRGI3, bar); + baz |= iox_csr.ms(utra::iox::SFR_GPIOIN_SRGI3_SRGI3, 1); + iox_csr.wfo(utra::iox::SFR_GPIOIN_SRGI3_SRGI3, baz); + + let foo = iox_csr.r(utra::iox::SFR_PIOSEL); + iox_csr.wo(utra::iox::SFR_PIOSEL, foo); + let bar = iox_csr.rf(utra::iox::SFR_PIOSEL_PIOSEL); + iox_csr.rmwf(utra::iox::SFR_PIOSEL_PIOSEL, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_PIOSEL_PIOSEL, bar); + baz |= iox_csr.ms(utra::iox::SFR_PIOSEL_PIOSEL, 1); + iox_csr.wfo(utra::iox::SFR_PIOSEL_PIOSEL, baz); + + let foo = iox_csr.r(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL0); + iox_csr.wo(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL0, foo); + let bar = iox_csr.rf(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL0_CR_CFG_SCHMSEL0); + iox_csr.rmwf(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL0_CR_CFG_SCHMSEL0, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL0_CR_CFG_SCHMSEL0, bar); + baz |= iox_csr.ms(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL0_CR_CFG_SCHMSEL0, 1); + iox_csr.wfo(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL0_CR_CFG_SCHMSEL0, baz); + + let foo = iox_csr.r(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL1); + iox_csr.wo(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL1, foo); + let bar = iox_csr.rf(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL1_CR_CFG_SCHMSEL1); + iox_csr.rmwf(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL1_CR_CFG_SCHMSEL1, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL1_CR_CFG_SCHMSEL1, bar); + baz |= iox_csr.ms(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL1_CR_CFG_SCHMSEL1, 1); + iox_csr.wfo(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL1_CR_CFG_SCHMSEL1, baz); + + let foo = iox_csr.r(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL2); + iox_csr.wo(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL2, foo); + let bar = iox_csr.rf(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL2_CR_CFG_SCHMSEL2); + iox_csr.rmwf(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL2_CR_CFG_SCHMSEL2, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL2_CR_CFG_SCHMSEL2, bar); + baz |= iox_csr.ms(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL2_CR_CFG_SCHMSEL2, 1); + iox_csr.wfo(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL2_CR_CFG_SCHMSEL2, baz); + + let foo = iox_csr.r(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL3); + iox_csr.wo(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL3, foo); + let bar = iox_csr.rf(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL3_CR_CFG_SCHMSEL3); + iox_csr.rmwf(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL3_CR_CFG_SCHMSEL3, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL3_CR_CFG_SCHMSEL3, bar); + baz |= iox_csr.ms(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL3_CR_CFG_SCHMSEL3, 1); + iox_csr.wfo(utra::iox::SFR_CFG_SCHM_CR_CFG_SCHMSEL3_CR_CFG_SCHMSEL3, baz); + + let foo = iox_csr.r(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW0); + iox_csr.wo(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW0, foo); + let bar = iox_csr.rf(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW0_CR_CFG_SLEWSLOW0); + iox_csr.rmwf(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW0_CR_CFG_SLEWSLOW0, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW0_CR_CFG_SLEWSLOW0, bar); + baz |= iox_csr.ms(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW0_CR_CFG_SLEWSLOW0, 1); + iox_csr.wfo(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW0_CR_CFG_SLEWSLOW0, baz); + + let foo = iox_csr.r(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW1); + iox_csr.wo(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW1, foo); + let bar = iox_csr.rf(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW1_CR_CFG_SLEWSLOW1); + iox_csr.rmwf(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW1_CR_CFG_SLEWSLOW1, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW1_CR_CFG_SLEWSLOW1, bar); + baz |= iox_csr.ms(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW1_CR_CFG_SLEWSLOW1, 1); + iox_csr.wfo(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW1_CR_CFG_SLEWSLOW1, baz); + + let foo = iox_csr.r(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW2); + iox_csr.wo(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW2, foo); + let bar = iox_csr.rf(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW2_CR_CFG_SLEWSLOW2); + iox_csr.rmwf(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW2_CR_CFG_SLEWSLOW2, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW2_CR_CFG_SLEWSLOW2, bar); + baz |= iox_csr.ms(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW2_CR_CFG_SLEWSLOW2, 1); + iox_csr.wfo(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW2_CR_CFG_SLEWSLOW2, baz); + + let foo = iox_csr.r(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW3); + iox_csr.wo(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW3, foo); + let bar = iox_csr.rf(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW3_CR_CFG_SLEWSLOW3); + iox_csr.rmwf(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW3_CR_CFG_SLEWSLOW3, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW3_CR_CFG_SLEWSLOW3, bar); + baz |= iox_csr.ms(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW3_CR_CFG_SLEWSLOW3, 1); + iox_csr.wfo(utra::iox::SFR_CFG_SLEW_CR_CFG_SLEWSLOW3_CR_CFG_SLEWSLOW3, baz); + + let foo = iox_csr.r(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL0); + iox_csr.wo(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL0, foo); + let bar = iox_csr.rf(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL0_CR_CFG_DRVSEL0); + iox_csr.rmwf(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL0_CR_CFG_DRVSEL0, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL0_CR_CFG_DRVSEL0, bar); + baz |= iox_csr.ms(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL0_CR_CFG_DRVSEL0, 1); + iox_csr.wfo(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL0_CR_CFG_DRVSEL0, baz); + + let foo = iox_csr.r(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL1); + iox_csr.wo(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL1, foo); + let bar = iox_csr.rf(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL1_CR_CFG_DRVSEL1); + iox_csr.rmwf(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL1_CR_CFG_DRVSEL1, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL1_CR_CFG_DRVSEL1, bar); + baz |= iox_csr.ms(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL1_CR_CFG_DRVSEL1, 1); + iox_csr.wfo(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL1_CR_CFG_DRVSEL1, baz); + + let foo = iox_csr.r(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL2); + iox_csr.wo(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL2, foo); + let bar = iox_csr.rf(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL2_CR_CFG_DRVSEL2); + iox_csr.rmwf(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL2_CR_CFG_DRVSEL2, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL2_CR_CFG_DRVSEL2, bar); + baz |= iox_csr.ms(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL2_CR_CFG_DRVSEL2, 1); + iox_csr.wfo(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL2_CR_CFG_DRVSEL2, baz); + + let foo = iox_csr.r(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL3); + iox_csr.wo(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL3, foo); + let bar = iox_csr.rf(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL3_CR_CFG_DRVSEL3); + iox_csr.rmwf(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL3_CR_CFG_DRVSEL3, bar); + let mut baz = iox_csr.zf(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL3_CR_CFG_DRVSEL3, bar); + baz |= iox_csr.ms(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL3_CR_CFG_DRVSEL3, 1); + iox_csr.wfo(utra::iox::SFR_CFG_DRVSEL_CR_CFG_DRVSEL3_CR_CFG_DRVSEL3, baz); + } + + #[test] + #[ignore] + fn compile_check_pwm_csr() { + use super::*; + let mut pwm_csr = CSR::new(HW_PWM_BASE as *mut u32); + } + + #[test] + #[ignore] + fn compile_check_sddc_csr() { + use super::*; + let mut sddc_csr = CSR::new(HW_SDDC_BASE as *mut u32); + + let foo = sddc_csr.r(utra::sddc::SFR_IO); + sddc_csr.wo(utra::sddc::SFR_IO, foo); + let bar = sddc_csr.rf(utra::sddc::SFR_IO_SFR_IO); + sddc_csr.rmwf(utra::sddc::SFR_IO_SFR_IO, bar); + let mut baz = sddc_csr.zf(utra::sddc::SFR_IO_SFR_IO, bar); + baz |= sddc_csr.ms(utra::sddc::SFR_IO_SFR_IO, 1); + sddc_csr.wfo(utra::sddc::SFR_IO_SFR_IO, baz); + + let foo = sddc_csr.r(utra::sddc::SFR_AR); + sddc_csr.wo(utra::sddc::SFR_AR, foo); + let bar = sddc_csr.rf(utra::sddc::SFR_AR_SFR_AR); + sddc_csr.rmwf(utra::sddc::SFR_AR_SFR_AR, bar); + let mut baz = sddc_csr.zf(utra::sddc::SFR_AR_SFR_AR, bar); + baz |= sddc_csr.ms(utra::sddc::SFR_AR_SFR_AR, 1); + sddc_csr.wfo(utra::sddc::SFR_AR_SFR_AR, baz); + + let foo = sddc_csr.r(utra::sddc::CR_OCR); + sddc_csr.wo(utra::sddc::CR_OCR, foo); + let bar = sddc_csr.rf(utra::sddc::CR_OCR_CR_OCR); + sddc_csr.rmwf(utra::sddc::CR_OCR_CR_OCR, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_OCR_CR_OCR, bar); + baz |= sddc_csr.ms(utra::sddc::CR_OCR_CR_OCR, 1); + sddc_csr.wfo(utra::sddc::CR_OCR_CR_OCR, baz); + + let foo = sddc_csr.r(utra::sddc::CR_RDFFTHRES); + sddc_csr.wo(utra::sddc::CR_RDFFTHRES, foo); + let bar = sddc_csr.rf(utra::sddc::CR_RDFFTHRES_CR_RDFFTHRES); + sddc_csr.rmwf(utra::sddc::CR_RDFFTHRES_CR_RDFFTHRES, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_RDFFTHRES_CR_RDFFTHRES, bar); + baz |= sddc_csr.ms(utra::sddc::CR_RDFFTHRES_CR_RDFFTHRES, 1); + sddc_csr.wfo(utra::sddc::CR_RDFFTHRES_CR_RDFFTHRES, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REV); + sddc_csr.wo(utra::sddc::CR_REV, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REV_CFG_REG_SD_SPEC_REVISION); + sddc_csr.rmwf(utra::sddc::CR_REV_CFG_REG_SD_SPEC_REVISION, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REV_CFG_REG_SD_SPEC_REVISION, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REV_CFG_REG_SD_SPEC_REVISION, 1); + sddc_csr.wfo(utra::sddc::CR_REV_CFG_REG_SD_SPEC_REVISION, baz); + let bar = sddc_csr.rf(utra::sddc::CR_REV_CFG_REG_CCCR_SDIO_REVISION); + sddc_csr.rmwf(utra::sddc::CR_REV_CFG_REG_CCCR_SDIO_REVISION, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REV_CFG_REG_CCCR_SDIO_REVISION, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REV_CFG_REG_CCCR_SDIO_REVISION, 1); + sddc_csr.wfo(utra::sddc::CR_REV_CFG_REG_CCCR_SDIO_REVISION, baz); + + let foo = sddc_csr.r(utra::sddc::CR_BACSA); + sddc_csr.wo(utra::sddc::CR_BACSA, foo); + let bar = sddc_csr.rf(utra::sddc::CR_BACSA_CFG_BASE_ADDR_CSA); + sddc_csr.rmwf(utra::sddc::CR_BACSA_CFG_BASE_ADDR_CSA, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_BACSA_CFG_BASE_ADDR_CSA, bar); + baz |= sddc_csr.ms(utra::sddc::CR_BACSA_CFG_BASE_ADDR_CSA, 1); + sddc_csr.wfo(utra::sddc::CR_BACSA_CFG_BASE_ADDR_CSA, baz); + + let foo = sddc_csr.r(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC0); + sddc_csr.wo(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC0, foo); + let bar = sddc_csr.rf(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC0_CFG_BASE_ADDR_IO_FUNC0); + sddc_csr.rmwf(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC0_CFG_BASE_ADDR_IO_FUNC0, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC0_CFG_BASE_ADDR_IO_FUNC0, bar); + baz |= sddc_csr.ms(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC0_CFG_BASE_ADDR_IO_FUNC0, 1); + sddc_csr.wfo(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC0_CFG_BASE_ADDR_IO_FUNC0, baz); + + let foo = sddc_csr.r(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC1); + sddc_csr.wo(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC1, foo); + let bar = sddc_csr.rf(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC1_CFG_BASE_ADDR_IO_FUNC1); + sddc_csr.rmwf(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC1_CFG_BASE_ADDR_IO_FUNC1, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC1_CFG_BASE_ADDR_IO_FUNC1, bar); + baz |= sddc_csr.ms(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC1_CFG_BASE_ADDR_IO_FUNC1, 1); + sddc_csr.wfo(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC1_CFG_BASE_ADDR_IO_FUNC1, baz); + + let foo = sddc_csr.r(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC2); + sddc_csr.wo(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC2, foo); + let bar = sddc_csr.rf(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC2_CFG_BASE_ADDR_IO_FUNC2); + sddc_csr.rmwf(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC2_CFG_BASE_ADDR_IO_FUNC2, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC2_CFG_BASE_ADDR_IO_FUNC2, bar); + baz |= sddc_csr.ms(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC2_CFG_BASE_ADDR_IO_FUNC2, 1); + sddc_csr.wfo(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC2_CFG_BASE_ADDR_IO_FUNC2, baz); + + let foo = sddc_csr.r(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC3); + sddc_csr.wo(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC3, foo); + let bar = sddc_csr.rf(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC3_CFG_BASE_ADDR_IO_FUNC3); + sddc_csr.rmwf(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC3_CFG_BASE_ADDR_IO_FUNC3, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC3_CFG_BASE_ADDR_IO_FUNC3, bar); + baz |= sddc_csr.ms(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC3_CFG_BASE_ADDR_IO_FUNC3, 1); + sddc_csr.wfo(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC3_CFG_BASE_ADDR_IO_FUNC3, baz); + + let foo = sddc_csr.r(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC4); + sddc_csr.wo(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC4, foo); + let bar = sddc_csr.rf(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC4_CFG_BASE_ADDR_IO_FUNC4); + sddc_csr.rmwf(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC4_CFG_BASE_ADDR_IO_FUNC4, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC4_CFG_BASE_ADDR_IO_FUNC4, bar); + baz |= sddc_csr.ms(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC4_CFG_BASE_ADDR_IO_FUNC4, 1); + sddc_csr.wfo(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC4_CFG_BASE_ADDR_IO_FUNC4, baz); + + let foo = sddc_csr.r(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC5); + sddc_csr.wo(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC5, foo); + let bar = sddc_csr.rf(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC5_CFG_BASE_ADDR_IO_FUNC5); + sddc_csr.rmwf(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC5_CFG_BASE_ADDR_IO_FUNC5, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC5_CFG_BASE_ADDR_IO_FUNC5, bar); + baz |= sddc_csr.ms(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC5_CFG_BASE_ADDR_IO_FUNC5, 1); + sddc_csr.wfo(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC5_CFG_BASE_ADDR_IO_FUNC5, baz); + + let foo = sddc_csr.r(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC6); + sddc_csr.wo(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC6, foo); + let bar = sddc_csr.rf(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC6_CFG_BASE_ADDR_IO_FUNC6); + sddc_csr.rmwf(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC6_CFG_BASE_ADDR_IO_FUNC6, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC6_CFG_BASE_ADDR_IO_FUNC6, bar); + baz |= sddc_csr.ms(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC6_CFG_BASE_ADDR_IO_FUNC6, 1); + sddc_csr.wfo(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC6_CFG_BASE_ADDR_IO_FUNC6, baz); + + let foo = sddc_csr.r(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC7); + sddc_csr.wo(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC7, foo); + let bar = sddc_csr.rf(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC7_CFG_BASE_ADDR_IO_FUNC7); + sddc_csr.rmwf(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC7_CFG_BASE_ADDR_IO_FUNC7, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC7_CFG_BASE_ADDR_IO_FUNC7, bar); + baz |= sddc_csr.ms(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC7_CFG_BASE_ADDR_IO_FUNC7, 1); + sddc_csr.wfo(utra::sddc::CR_BAIOFN_CFG_BASE_ADDR_IO_FUNC7_CFG_BASE_ADDR_IO_FUNC7, baz); + + let foo = sddc_csr.r(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR0); + sddc_csr.wo(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR0, foo); + let bar = sddc_csr.rf(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR0_CFG_REG_FUNC_CIS_PTR0); + sddc_csr.rmwf(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR0_CFG_REG_FUNC_CIS_PTR0, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR0_CFG_REG_FUNC_CIS_PTR0, bar); + baz |= sddc_csr.ms(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR0_CFG_REG_FUNC_CIS_PTR0, 1); + sddc_csr.wfo(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR0_CFG_REG_FUNC_CIS_PTR0, baz); + + let foo = sddc_csr.r(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR1); + sddc_csr.wo(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR1, foo); + let bar = sddc_csr.rf(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR1_CFG_REG_FUNC_CIS_PTR1); + sddc_csr.rmwf(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR1_CFG_REG_FUNC_CIS_PTR1, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR1_CFG_REG_FUNC_CIS_PTR1, bar); + baz |= sddc_csr.ms(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR1_CFG_REG_FUNC_CIS_PTR1, 1); + sddc_csr.wfo(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR1_CFG_REG_FUNC_CIS_PTR1, baz); + + let foo = sddc_csr.r(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR2); + sddc_csr.wo(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR2, foo); + let bar = sddc_csr.rf(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR2_CFG_REG_FUNC_CIS_PTR2); + sddc_csr.rmwf(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR2_CFG_REG_FUNC_CIS_PTR2, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR2_CFG_REG_FUNC_CIS_PTR2, bar); + baz |= sddc_csr.ms(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR2_CFG_REG_FUNC_CIS_PTR2, 1); + sddc_csr.wfo(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR2_CFG_REG_FUNC_CIS_PTR2, baz); + + let foo = sddc_csr.r(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR3); + sddc_csr.wo(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR3, foo); + let bar = sddc_csr.rf(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR3_CFG_REG_FUNC_CIS_PTR3); + sddc_csr.rmwf(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR3_CFG_REG_FUNC_CIS_PTR3, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR3_CFG_REG_FUNC_CIS_PTR3, bar); + baz |= sddc_csr.ms(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR3_CFG_REG_FUNC_CIS_PTR3, 1); + sddc_csr.wfo(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR3_CFG_REG_FUNC_CIS_PTR3, baz); + + let foo = sddc_csr.r(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR4); + sddc_csr.wo(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR4, foo); + let bar = sddc_csr.rf(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR4_CFG_REG_FUNC_CIS_PTR4); + sddc_csr.rmwf(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR4_CFG_REG_FUNC_CIS_PTR4, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR4_CFG_REG_FUNC_CIS_PTR4, bar); + baz |= sddc_csr.ms(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR4_CFG_REG_FUNC_CIS_PTR4, 1); + sddc_csr.wfo(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR4_CFG_REG_FUNC_CIS_PTR4, baz); + + let foo = sddc_csr.r(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR5); + sddc_csr.wo(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR5, foo); + let bar = sddc_csr.rf(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR5_CFG_REG_FUNC_CIS_PTR5); + sddc_csr.rmwf(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR5_CFG_REG_FUNC_CIS_PTR5, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR5_CFG_REG_FUNC_CIS_PTR5, bar); + baz |= sddc_csr.ms(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR5_CFG_REG_FUNC_CIS_PTR5, 1); + sddc_csr.wfo(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR5_CFG_REG_FUNC_CIS_PTR5, baz); + + let foo = sddc_csr.r(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR6); + sddc_csr.wo(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR6, foo); + let bar = sddc_csr.rf(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR6_CFG_REG_FUNC_CIS_PTR6); + sddc_csr.rmwf(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR6_CFG_REG_FUNC_CIS_PTR6, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR6_CFG_REG_FUNC_CIS_PTR6, bar); + baz |= sddc_csr.ms(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR6_CFG_REG_FUNC_CIS_PTR6, 1); + sddc_csr.wfo(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR6_CFG_REG_FUNC_CIS_PTR6, baz); + + let foo = sddc_csr.r(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR7); + sddc_csr.wo(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR7, foo); + let bar = sddc_csr.rf(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR7_CFG_REG_FUNC_CIS_PTR7); + sddc_csr.rmwf(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR7_CFG_REG_FUNC_CIS_PTR7, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR7_CFG_REG_FUNC_CIS_PTR7, bar); + baz |= sddc_csr.ms(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR7_CFG_REG_FUNC_CIS_PTR7, 1); + sddc_csr.wfo(utra::sddc::CR_FNCISPTR_CFG_REG_FUNC_CIS_PTR7_CFG_REG_FUNC_CIS_PTR7, baz); + + let foo = sddc_csr.r(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE0); + sddc_csr.wo(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE0, foo); + let bar = sddc_csr.rf(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE0_CFG_REG_FUNC_EXT_STD_CODE0); + sddc_csr.rmwf(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE0_CFG_REG_FUNC_EXT_STD_CODE0, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE0_CFG_REG_FUNC_EXT_STD_CODE0, bar); + baz |= sddc_csr.ms(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE0_CFG_REG_FUNC_EXT_STD_CODE0, 1); + sddc_csr.wfo(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE0_CFG_REG_FUNC_EXT_STD_CODE0, baz); + + let foo = sddc_csr.r(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE1); + sddc_csr.wo(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE1, foo); + let bar = sddc_csr.rf(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE1_CFG_REG_FUNC_EXT_STD_CODE1); + sddc_csr.rmwf(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE1_CFG_REG_FUNC_EXT_STD_CODE1, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE1_CFG_REG_FUNC_EXT_STD_CODE1, bar); + baz |= sddc_csr.ms(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE1_CFG_REG_FUNC_EXT_STD_CODE1, 1); + sddc_csr.wfo(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE1_CFG_REG_FUNC_EXT_STD_CODE1, baz); + + let foo = sddc_csr.r(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE2); + sddc_csr.wo(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE2, foo); + let bar = sddc_csr.rf(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE2_CFG_REG_FUNC_EXT_STD_CODE2); + sddc_csr.rmwf(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE2_CFG_REG_FUNC_EXT_STD_CODE2, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE2_CFG_REG_FUNC_EXT_STD_CODE2, bar); + baz |= sddc_csr.ms(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE2_CFG_REG_FUNC_EXT_STD_CODE2, 1); + sddc_csr.wfo(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE2_CFG_REG_FUNC_EXT_STD_CODE2, baz); + + let foo = sddc_csr.r(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE3); + sddc_csr.wo(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE3, foo); + let bar = sddc_csr.rf(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE3_CFG_REG_FUNC_EXT_STD_CODE3); + sddc_csr.rmwf(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE3_CFG_REG_FUNC_EXT_STD_CODE3, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE3_CFG_REG_FUNC_EXT_STD_CODE3, bar); + baz |= sddc_csr.ms(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE3_CFG_REG_FUNC_EXT_STD_CODE3, 1); + sddc_csr.wfo(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE3_CFG_REG_FUNC_EXT_STD_CODE3, baz); + + let foo = sddc_csr.r(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE4); + sddc_csr.wo(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE4, foo); + let bar = sddc_csr.rf(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE4_CFG_REG_FUNC_EXT_STD_CODE4); + sddc_csr.rmwf(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE4_CFG_REG_FUNC_EXT_STD_CODE4, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE4_CFG_REG_FUNC_EXT_STD_CODE4, bar); + baz |= sddc_csr.ms(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE4_CFG_REG_FUNC_EXT_STD_CODE4, 1); + sddc_csr.wfo(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE4_CFG_REG_FUNC_EXT_STD_CODE4, baz); + + let foo = sddc_csr.r(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE5); + sddc_csr.wo(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE5, foo); + let bar = sddc_csr.rf(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE5_CFG_REG_FUNC_EXT_STD_CODE5); + sddc_csr.rmwf(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE5_CFG_REG_FUNC_EXT_STD_CODE5, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE5_CFG_REG_FUNC_EXT_STD_CODE5, bar); + baz |= sddc_csr.ms(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE5_CFG_REG_FUNC_EXT_STD_CODE5, 1); + sddc_csr.wfo(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE5_CFG_REG_FUNC_EXT_STD_CODE5, baz); + + let foo = sddc_csr.r(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE6); + sddc_csr.wo(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE6, foo); + let bar = sddc_csr.rf(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE6_CFG_REG_FUNC_EXT_STD_CODE6); + sddc_csr.rmwf(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE6_CFG_REG_FUNC_EXT_STD_CODE6, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE6_CFG_REG_FUNC_EXT_STD_CODE6, bar); + baz |= sddc_csr.ms(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE6_CFG_REG_FUNC_EXT_STD_CODE6, 1); + sddc_csr.wfo(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE6_CFG_REG_FUNC_EXT_STD_CODE6, baz); + + let foo = sddc_csr.r(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE7); + sddc_csr.wo(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE7, foo); + let bar = sddc_csr.rf(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE7_CFG_REG_FUNC_EXT_STD_CODE7); + sddc_csr.rmwf(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE7_CFG_REG_FUNC_EXT_STD_CODE7, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE7_CFG_REG_FUNC_EXT_STD_CODE7, bar); + baz |= sddc_csr.ms(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE7_CFG_REG_FUNC_EXT_STD_CODE7, 1); + sddc_csr.wfo(utra::sddc::CR_FNEXTSTDCODE_CFG_REG_FUNC_EXT_STD_CODE7_CFG_REG_FUNC_EXT_STD_CODE7, baz); + + let foo = sddc_csr.r(utra::sddc::CR_WRITE_PROTECT); + sddc_csr.wo(utra::sddc::CR_WRITE_PROTECT, foo); + let bar = sddc_csr.rf(utra::sddc::CR_WRITE_PROTECT_CR_WRITE_PROTECT); + sddc_csr.rmwf(utra::sddc::CR_WRITE_PROTECT_CR_WRITE_PROTECT, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_WRITE_PROTECT_CR_WRITE_PROTECT, bar); + baz |= sddc_csr.ms(utra::sddc::CR_WRITE_PROTECT_CR_WRITE_PROTECT, 1); + sddc_csr.wfo(utra::sddc::CR_WRITE_PROTECT_CR_WRITE_PROTECT, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_DSR); + sddc_csr.wo(utra::sddc::CR_REG_DSR, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_DSR_CR_REG_DSR); + sddc_csr.rmwf(utra::sddc::CR_REG_DSR_CR_REG_DSR, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_DSR_CR_REG_DSR, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_DSR_CR_REG_DSR, 1); + sddc_csr.wfo(utra::sddc::CR_REG_DSR_CR_REG_DSR, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_CID_CFG_REG_CID0); + sddc_csr.wo(utra::sddc::CR_REG_CID_CFG_REG_CID0, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_CID_CFG_REG_CID0_CFG_REG_CID0); + sddc_csr.rmwf(utra::sddc::CR_REG_CID_CFG_REG_CID0_CFG_REG_CID0, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_CID_CFG_REG_CID0_CFG_REG_CID0, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_CID_CFG_REG_CID0_CFG_REG_CID0, 1); + sddc_csr.wfo(utra::sddc::CR_REG_CID_CFG_REG_CID0_CFG_REG_CID0, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_CID_CFG_REG_CID1); + sddc_csr.wo(utra::sddc::CR_REG_CID_CFG_REG_CID1, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_CID_CFG_REG_CID1_CFG_REG_CID1); + sddc_csr.rmwf(utra::sddc::CR_REG_CID_CFG_REG_CID1_CFG_REG_CID1, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_CID_CFG_REG_CID1_CFG_REG_CID1, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_CID_CFG_REG_CID1_CFG_REG_CID1, 1); + sddc_csr.wfo(utra::sddc::CR_REG_CID_CFG_REG_CID1_CFG_REG_CID1, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_CID_CFG_REG_CID2); + sddc_csr.wo(utra::sddc::CR_REG_CID_CFG_REG_CID2, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_CID_CFG_REG_CID2_CFG_REG_CID2); + sddc_csr.rmwf(utra::sddc::CR_REG_CID_CFG_REG_CID2_CFG_REG_CID2, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_CID_CFG_REG_CID2_CFG_REG_CID2, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_CID_CFG_REG_CID2_CFG_REG_CID2, 1); + sddc_csr.wfo(utra::sddc::CR_REG_CID_CFG_REG_CID2_CFG_REG_CID2, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_CID_CFG_REG_CID3); + sddc_csr.wo(utra::sddc::CR_REG_CID_CFG_REG_CID3, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_CID_CFG_REG_CID3_CFG_REG_CID3); + sddc_csr.rmwf(utra::sddc::CR_REG_CID_CFG_REG_CID3_CFG_REG_CID3, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_CID_CFG_REG_CID3_CFG_REG_CID3, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_CID_CFG_REG_CID3_CFG_REG_CID3, 1); + sddc_csr.wfo(utra::sddc::CR_REG_CID_CFG_REG_CID3_CFG_REG_CID3, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_CSD_CFG_REG_CSD0); + sddc_csr.wo(utra::sddc::CR_REG_CSD_CFG_REG_CSD0, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_CSD_CFG_REG_CSD0_CFG_REG_CSD0); + sddc_csr.rmwf(utra::sddc::CR_REG_CSD_CFG_REG_CSD0_CFG_REG_CSD0, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_CSD_CFG_REG_CSD0_CFG_REG_CSD0, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_CSD_CFG_REG_CSD0_CFG_REG_CSD0, 1); + sddc_csr.wfo(utra::sddc::CR_REG_CSD_CFG_REG_CSD0_CFG_REG_CSD0, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_CSD_CFG_REG_CSD1); + sddc_csr.wo(utra::sddc::CR_REG_CSD_CFG_REG_CSD1, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_CSD_CFG_REG_CSD1_CFG_REG_CSD1); + sddc_csr.rmwf(utra::sddc::CR_REG_CSD_CFG_REG_CSD1_CFG_REG_CSD1, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_CSD_CFG_REG_CSD1_CFG_REG_CSD1, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_CSD_CFG_REG_CSD1_CFG_REG_CSD1, 1); + sddc_csr.wfo(utra::sddc::CR_REG_CSD_CFG_REG_CSD1_CFG_REG_CSD1, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_CSD_CFG_REG_CSD2); + sddc_csr.wo(utra::sddc::CR_REG_CSD_CFG_REG_CSD2, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_CSD_CFG_REG_CSD2_CFG_REG_CSD2); + sddc_csr.rmwf(utra::sddc::CR_REG_CSD_CFG_REG_CSD2_CFG_REG_CSD2, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_CSD_CFG_REG_CSD2_CFG_REG_CSD2, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_CSD_CFG_REG_CSD2_CFG_REG_CSD2, 1); + sddc_csr.wfo(utra::sddc::CR_REG_CSD_CFG_REG_CSD2_CFG_REG_CSD2, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_CSD_CFG_REG_CSD3); + sddc_csr.wo(utra::sddc::CR_REG_CSD_CFG_REG_CSD3, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_CSD_CFG_REG_CSD3_CFG_REG_CSD3); + sddc_csr.rmwf(utra::sddc::CR_REG_CSD_CFG_REG_CSD3_CFG_REG_CSD3, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_CSD_CFG_REG_CSD3_CFG_REG_CSD3, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_CSD_CFG_REG_CSD3_CFG_REG_CSD3, 1); + sddc_csr.wfo(utra::sddc::CR_REG_CSD_CFG_REG_CSD3_CFG_REG_CSD3, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_SCR_CFG_REG_SCR0); + sddc_csr.wo(utra::sddc::CR_REG_SCR_CFG_REG_SCR0, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_SCR_CFG_REG_SCR0_CFG_REG_SCR0); + sddc_csr.rmwf(utra::sddc::CR_REG_SCR_CFG_REG_SCR0_CFG_REG_SCR0, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_SCR_CFG_REG_SCR0_CFG_REG_SCR0, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_SCR_CFG_REG_SCR0_CFG_REG_SCR0, 1); + sddc_csr.wfo(utra::sddc::CR_REG_SCR_CFG_REG_SCR0_CFG_REG_SCR0, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_SCR_CFG_REG_SCR1); + sddc_csr.wo(utra::sddc::CR_REG_SCR_CFG_REG_SCR1, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_SCR_CFG_REG_SCR1_CFG_REG_SCR1); + sddc_csr.rmwf(utra::sddc::CR_REG_SCR_CFG_REG_SCR1_CFG_REG_SCR1, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_SCR_CFG_REG_SCR1_CFG_REG_SCR1, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_SCR_CFG_REG_SCR1_CFG_REG_SCR1, 1); + sddc_csr.wfo(utra::sddc::CR_REG_SCR_CFG_REG_SCR1_CFG_REG_SCR1, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS0); + sddc_csr.wo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS0, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS0_CFG_REG_SD_STATUS0); + sddc_csr.rmwf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS0_CFG_REG_SD_STATUS0, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS0_CFG_REG_SD_STATUS0, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS0_CFG_REG_SD_STATUS0, 1); + sddc_csr.wfo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS0_CFG_REG_SD_STATUS0, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS1); + sddc_csr.wo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS1, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS1_CFG_REG_SD_STATUS1); + sddc_csr.rmwf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS1_CFG_REG_SD_STATUS1, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS1_CFG_REG_SD_STATUS1, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS1_CFG_REG_SD_STATUS1, 1); + sddc_csr.wfo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS1_CFG_REG_SD_STATUS1, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS2); + sddc_csr.wo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS2, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS2_CFG_REG_SD_STATUS2); + sddc_csr.rmwf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS2_CFG_REG_SD_STATUS2, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS2_CFG_REG_SD_STATUS2, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS2_CFG_REG_SD_STATUS2, 1); + sddc_csr.wfo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS2_CFG_REG_SD_STATUS2, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS3); + sddc_csr.wo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS3, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS3_CFG_REG_SD_STATUS3); + sddc_csr.rmwf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS3_CFG_REG_SD_STATUS3, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS3_CFG_REG_SD_STATUS3, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS3_CFG_REG_SD_STATUS3, 1); + sddc_csr.wfo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS3_CFG_REG_SD_STATUS3, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS4); + sddc_csr.wo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS4, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS4_CFG_REG_SD_STATUS4); + sddc_csr.rmwf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS4_CFG_REG_SD_STATUS4, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS4_CFG_REG_SD_STATUS4, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS4_CFG_REG_SD_STATUS4, 1); + sddc_csr.wfo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS4_CFG_REG_SD_STATUS4, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS5); + sddc_csr.wo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS5, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS5_CFG_REG_SD_STATUS5); + sddc_csr.rmwf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS5_CFG_REG_SD_STATUS5, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS5_CFG_REG_SD_STATUS5, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS5_CFG_REG_SD_STATUS5, 1); + sddc_csr.wfo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS5_CFG_REG_SD_STATUS5, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS6); + sddc_csr.wo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS6, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS6_CFG_REG_SD_STATUS6); + sddc_csr.rmwf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS6_CFG_REG_SD_STATUS6, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS6_CFG_REG_SD_STATUS6, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS6_CFG_REG_SD_STATUS6, 1); + sddc_csr.wfo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS6_CFG_REG_SD_STATUS6, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS7); + sddc_csr.wo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS7, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS7_CFG_REG_SD_STATUS7); + sddc_csr.rmwf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS7_CFG_REG_SD_STATUS7, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS7_CFG_REG_SD_STATUS7, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS7_CFG_REG_SD_STATUS7, 1); + sddc_csr.wfo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS7_CFG_REG_SD_STATUS7, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS8); + sddc_csr.wo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS8, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS8_CFG_REG_SD_STATUS8); + sddc_csr.rmwf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS8_CFG_REG_SD_STATUS8, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS8_CFG_REG_SD_STATUS8, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS8_CFG_REG_SD_STATUS8, 1); + sddc_csr.wfo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS8_CFG_REG_SD_STATUS8, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS9); + sddc_csr.wo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS9, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS9_CFG_REG_SD_STATUS9); + sddc_csr.rmwf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS9_CFG_REG_SD_STATUS9, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS9_CFG_REG_SD_STATUS9, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS9_CFG_REG_SD_STATUS9, 1); + sddc_csr.wfo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS9_CFG_REG_SD_STATUS9, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS10); + sddc_csr.wo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS10, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS10_CFG_REG_SD_STATUS10); + sddc_csr.rmwf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS10_CFG_REG_SD_STATUS10, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS10_CFG_REG_SD_STATUS10, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS10_CFG_REG_SD_STATUS10, 1); + sddc_csr.wfo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS10_CFG_REG_SD_STATUS10, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS11); + sddc_csr.wo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS11, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS11_CFG_REG_SD_STATUS11); + sddc_csr.rmwf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS11_CFG_REG_SD_STATUS11, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS11_CFG_REG_SD_STATUS11, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS11_CFG_REG_SD_STATUS11, 1); + sddc_csr.wfo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS11_CFG_REG_SD_STATUS11, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS12); + sddc_csr.wo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS12, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS12_CFG_REG_SD_STATUS12); + sddc_csr.rmwf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS12_CFG_REG_SD_STATUS12, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS12_CFG_REG_SD_STATUS12, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS12_CFG_REG_SD_STATUS12, 1); + sddc_csr.wfo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS12_CFG_REG_SD_STATUS12, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS13); + sddc_csr.wo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS13, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS13_CFG_REG_SD_STATUS13); + sddc_csr.rmwf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS13_CFG_REG_SD_STATUS13, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS13_CFG_REG_SD_STATUS13, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS13_CFG_REG_SD_STATUS13, 1); + sddc_csr.wfo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS13_CFG_REG_SD_STATUS13, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS14); + sddc_csr.wo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS14, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS14_CFG_REG_SD_STATUS14); + sddc_csr.rmwf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS14_CFG_REG_SD_STATUS14, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS14_CFG_REG_SD_STATUS14, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS14_CFG_REG_SD_STATUS14, 1); + sddc_csr.wfo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS14_CFG_REG_SD_STATUS14, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS15); + sddc_csr.wo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS15, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS15_CFG_REG_SD_STATUS15); + sddc_csr.rmwf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS15_CFG_REG_SD_STATUS15, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS15_CFG_REG_SD_STATUS15, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS15_CFG_REG_SD_STATUS15, 1); + sddc_csr.wfo(utra::sddc::CR_REG_SD_STATUS_CFG_REG_SD_STATUS15_CFG_REG_SD_STATUS15, baz); + + let foo = sddc_csr.r(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC0); + sddc_csr.wo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC0, foo); + let bar = sddc_csr.rf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC0_CFG_BASE_ADDR_MEM_FUNC0); + sddc_csr.rmwf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC0_CFG_BASE_ADDR_MEM_FUNC0, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC0_CFG_BASE_ADDR_MEM_FUNC0, bar); + baz |= sddc_csr.ms(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC0_CFG_BASE_ADDR_MEM_FUNC0, 1); + sddc_csr.wfo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC0_CFG_BASE_ADDR_MEM_FUNC0, baz); + + let foo = sddc_csr.r(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC1); + sddc_csr.wo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC1, foo); + let bar = sddc_csr.rf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC1_CFG_BASE_ADDR_MEM_FUNC1); + sddc_csr.rmwf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC1_CFG_BASE_ADDR_MEM_FUNC1, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC1_CFG_BASE_ADDR_MEM_FUNC1, bar); + baz |= sddc_csr.ms(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC1_CFG_BASE_ADDR_MEM_FUNC1, 1); + sddc_csr.wfo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC1_CFG_BASE_ADDR_MEM_FUNC1, baz); + + let foo = sddc_csr.r(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC2); + sddc_csr.wo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC2, foo); + let bar = sddc_csr.rf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC2_CFG_BASE_ADDR_MEM_FUNC2); + sddc_csr.rmwf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC2_CFG_BASE_ADDR_MEM_FUNC2, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC2_CFG_BASE_ADDR_MEM_FUNC2, bar); + baz |= sddc_csr.ms(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC2_CFG_BASE_ADDR_MEM_FUNC2, 1); + sddc_csr.wfo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC2_CFG_BASE_ADDR_MEM_FUNC2, baz); + + let foo = sddc_csr.r(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC3); + sddc_csr.wo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC3, foo); + let bar = sddc_csr.rf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC3_CFG_BASE_ADDR_MEM_FUNC3); + sddc_csr.rmwf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC3_CFG_BASE_ADDR_MEM_FUNC3, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC3_CFG_BASE_ADDR_MEM_FUNC3, bar); + baz |= sddc_csr.ms(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC3_CFG_BASE_ADDR_MEM_FUNC3, 1); + sddc_csr.wfo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC3_CFG_BASE_ADDR_MEM_FUNC3, baz); + + let foo = sddc_csr.r(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC4); + sddc_csr.wo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC4, foo); + let bar = sddc_csr.rf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC4_CFG_BASE_ADDR_MEM_FUNC4); + sddc_csr.rmwf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC4_CFG_BASE_ADDR_MEM_FUNC4, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC4_CFG_BASE_ADDR_MEM_FUNC4, bar); + baz |= sddc_csr.ms(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC4_CFG_BASE_ADDR_MEM_FUNC4, 1); + sddc_csr.wfo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC4_CFG_BASE_ADDR_MEM_FUNC4, baz); + + let foo = sddc_csr.r(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC5); + sddc_csr.wo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC5, foo); + let bar = sddc_csr.rf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC5_CFG_BASE_ADDR_MEM_FUNC5); + sddc_csr.rmwf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC5_CFG_BASE_ADDR_MEM_FUNC5, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC5_CFG_BASE_ADDR_MEM_FUNC5, bar); + baz |= sddc_csr.ms(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC5_CFG_BASE_ADDR_MEM_FUNC5, 1); + sddc_csr.wfo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC5_CFG_BASE_ADDR_MEM_FUNC5, baz); + + let foo = sddc_csr.r(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC6); + sddc_csr.wo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC6, foo); + let bar = sddc_csr.rf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC6_CFG_BASE_ADDR_MEM_FUNC6); + sddc_csr.rmwf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC6_CFG_BASE_ADDR_MEM_FUNC6, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC6_CFG_BASE_ADDR_MEM_FUNC6, bar); + baz |= sddc_csr.ms(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC6_CFG_BASE_ADDR_MEM_FUNC6, 1); + sddc_csr.wfo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC6_CFG_BASE_ADDR_MEM_FUNC6, baz); + + let foo = sddc_csr.r(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC7); + sddc_csr.wo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC7, foo); + let bar = sddc_csr.rf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC7_CFG_BASE_ADDR_MEM_FUNC7); + sddc_csr.rmwf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC7_CFG_BASE_ADDR_MEM_FUNC7, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC7_CFG_BASE_ADDR_MEM_FUNC7, bar); + baz |= sddc_csr.ms(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC7_CFG_BASE_ADDR_MEM_FUNC7, 1); + sddc_csr.wfo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC7_CFG_BASE_ADDR_MEM_FUNC7, baz); + + let foo = sddc_csr.r(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC8); + sddc_csr.wo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC8, foo); + let bar = sddc_csr.rf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC8_CFG_BASE_ADDR_MEM_FUNC8); + sddc_csr.rmwf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC8_CFG_BASE_ADDR_MEM_FUNC8, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC8_CFG_BASE_ADDR_MEM_FUNC8, bar); + baz |= sddc_csr.ms(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC8_CFG_BASE_ADDR_MEM_FUNC8, 1); + sddc_csr.wfo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC8_CFG_BASE_ADDR_MEM_FUNC8, baz); + + let foo = sddc_csr.r(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC9); + sddc_csr.wo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC9, foo); + let bar = sddc_csr.rf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC9_CFG_BASE_ADDR_MEM_FUNC9); + sddc_csr.rmwf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC9_CFG_BASE_ADDR_MEM_FUNC9, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC9_CFG_BASE_ADDR_MEM_FUNC9, bar); + baz |= sddc_csr.ms(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC9_CFG_BASE_ADDR_MEM_FUNC9, 1); + sddc_csr.wfo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC9_CFG_BASE_ADDR_MEM_FUNC9, baz); + + let foo = sddc_csr.r(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC10); + sddc_csr.wo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC10, foo); + let bar = sddc_csr.rf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC10_CFG_BASE_ADDR_MEM_FUNC10); + sddc_csr.rmwf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC10_CFG_BASE_ADDR_MEM_FUNC10, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC10_CFG_BASE_ADDR_MEM_FUNC10, bar); + baz |= sddc_csr.ms(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC10_CFG_BASE_ADDR_MEM_FUNC10, 1); + sddc_csr.wfo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC10_CFG_BASE_ADDR_MEM_FUNC10, baz); + + let foo = sddc_csr.r(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC11); + sddc_csr.wo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC11, foo); + let bar = sddc_csr.rf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC11_CFG_BASE_ADDR_MEM_FUNC11); + sddc_csr.rmwf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC11_CFG_BASE_ADDR_MEM_FUNC11, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC11_CFG_BASE_ADDR_MEM_FUNC11, bar); + baz |= sddc_csr.ms(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC11_CFG_BASE_ADDR_MEM_FUNC11, 1); + sddc_csr.wfo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC11_CFG_BASE_ADDR_MEM_FUNC11, baz); + + let foo = sddc_csr.r(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC12); + sddc_csr.wo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC12, foo); + let bar = sddc_csr.rf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC12_CFG_BASE_ADDR_MEM_FUNC12); + sddc_csr.rmwf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC12_CFG_BASE_ADDR_MEM_FUNC12, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC12_CFG_BASE_ADDR_MEM_FUNC12, bar); + baz |= sddc_csr.ms(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC12_CFG_BASE_ADDR_MEM_FUNC12, 1); + sddc_csr.wfo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC12_CFG_BASE_ADDR_MEM_FUNC12, baz); + + let foo = sddc_csr.r(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC13); + sddc_csr.wo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC13, foo); + let bar = sddc_csr.rf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC13_CFG_BASE_ADDR_MEM_FUNC13); + sddc_csr.rmwf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC13_CFG_BASE_ADDR_MEM_FUNC13, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC13_CFG_BASE_ADDR_MEM_FUNC13, bar); + baz |= sddc_csr.ms(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC13_CFG_BASE_ADDR_MEM_FUNC13, 1); + sddc_csr.wfo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC13_CFG_BASE_ADDR_MEM_FUNC13, baz); + + let foo = sddc_csr.r(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC14); + sddc_csr.wo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC14, foo); + let bar = sddc_csr.rf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC14_CFG_BASE_ADDR_MEM_FUNC14); + sddc_csr.rmwf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC14_CFG_BASE_ADDR_MEM_FUNC14, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC14_CFG_BASE_ADDR_MEM_FUNC14, bar); + baz |= sddc_csr.ms(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC14_CFG_BASE_ADDR_MEM_FUNC14, 1); + sddc_csr.wfo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC14_CFG_BASE_ADDR_MEM_FUNC14, baz); + + let foo = sddc_csr.r(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC15); + sddc_csr.wo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC15, foo); + let bar = sddc_csr.rf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC15_CFG_BASE_ADDR_MEM_FUNC15); + sddc_csr.rmwf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC15_CFG_BASE_ADDR_MEM_FUNC15, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC15_CFG_BASE_ADDR_MEM_FUNC15, bar); + baz |= sddc_csr.ms(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC15_CFG_BASE_ADDR_MEM_FUNC15, 1); + sddc_csr.wfo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC15_CFG_BASE_ADDR_MEM_FUNC15, baz); + + let foo = sddc_csr.r(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC16); + sddc_csr.wo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC16, foo); + let bar = sddc_csr.rf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC16_CFG_BASE_ADDR_MEM_FUNC16); + sddc_csr.rmwf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC16_CFG_BASE_ADDR_MEM_FUNC16, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC16_CFG_BASE_ADDR_MEM_FUNC16, bar); + baz |= sddc_csr.ms(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC16_CFG_BASE_ADDR_MEM_FUNC16, 1); + sddc_csr.wfo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC16_CFG_BASE_ADDR_MEM_FUNC16, baz); + + let foo = sddc_csr.r(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC17); + sddc_csr.wo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC17, foo); + let bar = sddc_csr.rf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC17_CFG_BASE_ADDR_MEM_FUNC17); + sddc_csr.rmwf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC17_CFG_BASE_ADDR_MEM_FUNC17, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC17_CFG_BASE_ADDR_MEM_FUNC17, bar); + baz |= sddc_csr.ms(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC17_CFG_BASE_ADDR_MEM_FUNC17, 1); + sddc_csr.wfo(utra::sddc::CR_BASE_ADDR_MEM_FUNC_CFG_BASE_ADDR_MEM_FUNC17_CFG_BASE_ADDR_MEM_FUNC17, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE0); + sddc_csr.wo(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE0, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE0_CFG_REG_FUNC_ISDIO_INTERFACE_CODE0); + sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE0_CFG_REG_FUNC_ISDIO_INTERFACE_CODE0, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE0_CFG_REG_FUNC_ISDIO_INTERFACE_CODE0, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE0_CFG_REG_FUNC_ISDIO_INTERFACE_CODE0, 1); + sddc_csr.wfo(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE0_CFG_REG_FUNC_ISDIO_INTERFACE_CODE0, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE1); + sddc_csr.wo(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE1, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE1_CFG_REG_FUNC_ISDIO_INTERFACE_CODE1); + sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE1_CFG_REG_FUNC_ISDIO_INTERFACE_CODE1, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE1_CFG_REG_FUNC_ISDIO_INTERFACE_CODE1, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE1_CFG_REG_FUNC_ISDIO_INTERFACE_CODE1, 1); + sddc_csr.wfo(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE1_CFG_REG_FUNC_ISDIO_INTERFACE_CODE1, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE2); + sddc_csr.wo(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE2, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE2_CFG_REG_FUNC_ISDIO_INTERFACE_CODE2); + sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE2_CFG_REG_FUNC_ISDIO_INTERFACE_CODE2, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE2_CFG_REG_FUNC_ISDIO_INTERFACE_CODE2, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE2_CFG_REG_FUNC_ISDIO_INTERFACE_CODE2, 1); + sddc_csr.wfo(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE2_CFG_REG_FUNC_ISDIO_INTERFACE_CODE2, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE3); + sddc_csr.wo(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE3, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE3_CFG_REG_FUNC_ISDIO_INTERFACE_CODE3); + sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE3_CFG_REG_FUNC_ISDIO_INTERFACE_CODE3, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE3_CFG_REG_FUNC_ISDIO_INTERFACE_CODE3, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE3_CFG_REG_FUNC_ISDIO_INTERFACE_CODE3, 1); + sddc_csr.wfo(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE3_CFG_REG_FUNC_ISDIO_INTERFACE_CODE3, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE4); + sddc_csr.wo(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE4, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE4_CFG_REG_FUNC_ISDIO_INTERFACE_CODE4); + sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE4_CFG_REG_FUNC_ISDIO_INTERFACE_CODE4, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE4_CFG_REG_FUNC_ISDIO_INTERFACE_CODE4, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE4_CFG_REG_FUNC_ISDIO_INTERFACE_CODE4, 1); + sddc_csr.wfo(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE4_CFG_REG_FUNC_ISDIO_INTERFACE_CODE4, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE5); + sddc_csr.wo(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE5, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE5_CFG_REG_FUNC_ISDIO_INTERFACE_CODE5); + sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE5_CFG_REG_FUNC_ISDIO_INTERFACE_CODE5, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE5_CFG_REG_FUNC_ISDIO_INTERFACE_CODE5, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE5_CFG_REG_FUNC_ISDIO_INTERFACE_CODE5, 1); + sddc_csr.wfo(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE5_CFG_REG_FUNC_ISDIO_INTERFACE_CODE5, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE6); + sddc_csr.wo(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE6, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE6_CFG_REG_FUNC_ISDIO_INTERFACE_CODE6); + sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE6_CFG_REG_FUNC_ISDIO_INTERFACE_CODE6, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE6_CFG_REG_FUNC_ISDIO_INTERFACE_CODE6, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE6_CFG_REG_FUNC_ISDIO_INTERFACE_CODE6, 1); + sddc_csr.wfo(utra::sddc::CR_REG_FUNC_ISDIO_INTERFACE_CODE_CFG_REG_FUNC_ISDIO_INTERFACE_CODE6_CFG_REG_FUNC_ISDIO_INTERFACE_CODE6, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE0); + sddc_csr.wo(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE0, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE0_CFG_REG_FUNC_MANUFACT_CODE0); + sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE0_CFG_REG_FUNC_MANUFACT_CODE0, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE0_CFG_REG_FUNC_MANUFACT_CODE0, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE0_CFG_REG_FUNC_MANUFACT_CODE0, 1); + sddc_csr.wfo(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE0_CFG_REG_FUNC_MANUFACT_CODE0, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE1); + sddc_csr.wo(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE1, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE1_CFG_REG_FUNC_MANUFACT_CODE1); + sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE1_CFG_REG_FUNC_MANUFACT_CODE1, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE1_CFG_REG_FUNC_MANUFACT_CODE1, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE1_CFG_REG_FUNC_MANUFACT_CODE1, 1); + sddc_csr.wfo(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE1_CFG_REG_FUNC_MANUFACT_CODE1, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE2); + sddc_csr.wo(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE2, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE2_CFG_REG_FUNC_MANUFACT_CODE2); + sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE2_CFG_REG_FUNC_MANUFACT_CODE2, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE2_CFG_REG_FUNC_MANUFACT_CODE2, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE2_CFG_REG_FUNC_MANUFACT_CODE2, 1); + sddc_csr.wfo(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE2_CFG_REG_FUNC_MANUFACT_CODE2, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE3); + sddc_csr.wo(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE3, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE3_CFG_REG_FUNC_MANUFACT_CODE3); + sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE3_CFG_REG_FUNC_MANUFACT_CODE3, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE3_CFG_REG_FUNC_MANUFACT_CODE3, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE3_CFG_REG_FUNC_MANUFACT_CODE3, 1); + sddc_csr.wfo(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE3_CFG_REG_FUNC_MANUFACT_CODE3, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE4); + sddc_csr.wo(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE4, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE4_CFG_REG_FUNC_MANUFACT_CODE4); + sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE4_CFG_REG_FUNC_MANUFACT_CODE4, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE4_CFG_REG_FUNC_MANUFACT_CODE4, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE4_CFG_REG_FUNC_MANUFACT_CODE4, 1); + sddc_csr.wfo(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE4_CFG_REG_FUNC_MANUFACT_CODE4, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE5); + sddc_csr.wo(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE5, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE5_CFG_REG_FUNC_MANUFACT_CODE5); + sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE5_CFG_REG_FUNC_MANUFACT_CODE5, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE5_CFG_REG_FUNC_MANUFACT_CODE5, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE5_CFG_REG_FUNC_MANUFACT_CODE5, 1); + sddc_csr.wfo(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE5_CFG_REG_FUNC_MANUFACT_CODE5, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE6); + sddc_csr.wo(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE6, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE6_CFG_REG_FUNC_MANUFACT_CODE6); + sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE6_CFG_REG_FUNC_MANUFACT_CODE6, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE6_CFG_REG_FUNC_MANUFACT_CODE6, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE6_CFG_REG_FUNC_MANUFACT_CODE6, 1); + sddc_csr.wfo(utra::sddc::CR_REG_FUNC_MANUFACT_CODE_CFG_REG_FUNC_MANUFACT_CODE6_CFG_REG_FUNC_MANUFACT_CODE6, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO0); + sddc_csr.wo(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO0, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO0_CFG_REG_FUNC_MANUFACT_INFO0); + sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO0_CFG_REG_FUNC_MANUFACT_INFO0, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO0_CFG_REG_FUNC_MANUFACT_INFO0, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO0_CFG_REG_FUNC_MANUFACT_INFO0, 1); + sddc_csr.wfo(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO0_CFG_REG_FUNC_MANUFACT_INFO0, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO1); + sddc_csr.wo(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO1, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO1_CFG_REG_FUNC_MANUFACT_INFO1); + sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO1_CFG_REG_FUNC_MANUFACT_INFO1, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO1_CFG_REG_FUNC_MANUFACT_INFO1, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO1_CFG_REG_FUNC_MANUFACT_INFO1, 1); + sddc_csr.wfo(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO1_CFG_REG_FUNC_MANUFACT_INFO1, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO2); + sddc_csr.wo(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO2, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO2_CFG_REG_FUNC_MANUFACT_INFO2); + sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO2_CFG_REG_FUNC_MANUFACT_INFO2, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO2_CFG_REG_FUNC_MANUFACT_INFO2, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO2_CFG_REG_FUNC_MANUFACT_INFO2, 1); + sddc_csr.wfo(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO2_CFG_REG_FUNC_MANUFACT_INFO2, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO3); + sddc_csr.wo(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO3, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO3_CFG_REG_FUNC_MANUFACT_INFO3); + sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO3_CFG_REG_FUNC_MANUFACT_INFO3, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO3_CFG_REG_FUNC_MANUFACT_INFO3, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO3_CFG_REG_FUNC_MANUFACT_INFO3, 1); + sddc_csr.wfo(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO3_CFG_REG_FUNC_MANUFACT_INFO3, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO4); + sddc_csr.wo(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO4, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO4_CFG_REG_FUNC_MANUFACT_INFO4); + sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO4_CFG_REG_FUNC_MANUFACT_INFO4, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO4_CFG_REG_FUNC_MANUFACT_INFO4, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO4_CFG_REG_FUNC_MANUFACT_INFO4, 1); + sddc_csr.wfo(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO4_CFG_REG_FUNC_MANUFACT_INFO4, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO5); + sddc_csr.wo(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO5, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO5_CFG_REG_FUNC_MANUFACT_INFO5); + sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO5_CFG_REG_FUNC_MANUFACT_INFO5, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO5_CFG_REG_FUNC_MANUFACT_INFO5, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO5_CFG_REG_FUNC_MANUFACT_INFO5, 1); + sddc_csr.wfo(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO5_CFG_REG_FUNC_MANUFACT_INFO5, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO6); + sddc_csr.wo(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO6, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO6_CFG_REG_FUNC_MANUFACT_INFO6); + sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO6_CFG_REG_FUNC_MANUFACT_INFO6, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO6_CFG_REG_FUNC_MANUFACT_INFO6, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO6_CFG_REG_FUNC_MANUFACT_INFO6, 1); + sddc_csr.wfo(utra::sddc::CR_REG_FUNC_MANUFACT_INFO_CFG_REG_FUNC_MANUFACT_INFO6_CFG_REG_FUNC_MANUFACT_INFO6, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE0); + sddc_csr.wo(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE0, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE0_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE0); + sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE0_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE0, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE0_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE0, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE0_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE0, 1); + sddc_csr.wfo(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE0_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE0, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE1); + sddc_csr.wo(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE1, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE1_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE1); + sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE1_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE1, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE1_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE1, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE1_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE1, 1); + sddc_csr.wfo(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE1_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE1, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE2); + sddc_csr.wo(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE2, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE2_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE2); + sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE2_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE2, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE2_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE2, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE2_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE2, 1); + sddc_csr.wfo(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE2_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE2, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE3); + sddc_csr.wo(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE3, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE3_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE3); + sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE3_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE3, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE3_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE3, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE3_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE3, 1); + sddc_csr.wfo(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE3_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE3, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE4); + sddc_csr.wo(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE4, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE4_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE4); + sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE4_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE4, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE4_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE4, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE4_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE4, 1); + sddc_csr.wfo(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE4_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE4, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE5); + sddc_csr.wo(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE5, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE5_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE5); + sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE5_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE5, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE5_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE5, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE5_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE5, 1); + sddc_csr.wfo(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE5_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE5, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE6); + sddc_csr.wo(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE6, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE6_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE6); + sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE6_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE6, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE6_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE6, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE6_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE6, 1); + sddc_csr.wfo(utra::sddc::CR_REG_FUNC_ISDIO_TYPE_SUP_CODE_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE6_CFG_REG_FUNC_ISDIO_TYPE_SUP_CODE6, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO0); + sddc_csr.wo(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO0, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO0_CFG_REG_FUNC_INFO0); + sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO0_CFG_REG_FUNC_INFO0, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO0_CFG_REG_FUNC_INFO0, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO0_CFG_REG_FUNC_INFO0, 1); + sddc_csr.wfo(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO0_CFG_REG_FUNC_INFO0, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO1); + sddc_csr.wo(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO1, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO1_CFG_REG_FUNC_INFO1); + sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO1_CFG_REG_FUNC_INFO1, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO1_CFG_REG_FUNC_INFO1, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO1_CFG_REG_FUNC_INFO1, 1); + sddc_csr.wfo(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO1_CFG_REG_FUNC_INFO1, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO2); + sddc_csr.wo(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO2, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO2_CFG_REG_FUNC_INFO2); + sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO2_CFG_REG_FUNC_INFO2, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO2_CFG_REG_FUNC_INFO2, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO2_CFG_REG_FUNC_INFO2, 1); + sddc_csr.wfo(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO2_CFG_REG_FUNC_INFO2, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO3); + sddc_csr.wo(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO3, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO3_CFG_REG_FUNC_INFO3); + sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO3_CFG_REG_FUNC_INFO3, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO3_CFG_REG_FUNC_INFO3, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO3_CFG_REG_FUNC_INFO3, 1); + sddc_csr.wfo(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO3_CFG_REG_FUNC_INFO3, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO4); + sddc_csr.wo(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO4, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO4_CFG_REG_FUNC_INFO4); + sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO4_CFG_REG_FUNC_INFO4, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO4_CFG_REG_FUNC_INFO4, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO4_CFG_REG_FUNC_INFO4, 1); + sddc_csr.wfo(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO4_CFG_REG_FUNC_INFO4, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO5); + sddc_csr.wo(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO5, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO5_CFG_REG_FUNC_INFO5); + sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO5_CFG_REG_FUNC_INFO5, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO5_CFG_REG_FUNC_INFO5, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO5_CFG_REG_FUNC_INFO5, 1); + sddc_csr.wfo(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO5_CFG_REG_FUNC_INFO5, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO6); + sddc_csr.wo(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO6, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO6_CFG_REG_FUNC_INFO6); + sddc_csr.rmwf(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO6_CFG_REG_FUNC_INFO6, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO6_CFG_REG_FUNC_INFO6, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO6_CFG_REG_FUNC_INFO6, 1); + sddc_csr.wfo(utra::sddc::CR_REG_FUNC_INFO_CFG_REG_FUNC_INFO6_CFG_REG_FUNC_INFO6, baz); + + let foo = sddc_csr.r(utra::sddc::CR_REG_UHS_1_SUPPORT); + sddc_csr.wo(utra::sddc::CR_REG_UHS_1_SUPPORT, foo); + let bar = sddc_csr.rf(utra::sddc::CR_REG_UHS_1_SUPPORT_CFG_REG_MAX_CURRENT); + sddc_csr.rmwf(utra::sddc::CR_REG_UHS_1_SUPPORT_CFG_REG_MAX_CURRENT, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_UHS_1_SUPPORT_CFG_REG_MAX_CURRENT, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_UHS_1_SUPPORT_CFG_REG_MAX_CURRENT, 1); + sddc_csr.wfo(utra::sddc::CR_REG_UHS_1_SUPPORT_CFG_REG_MAX_CURRENT, baz); + let bar = sddc_csr.rf(utra::sddc::CR_REG_UHS_1_SUPPORT_CFG_REG_DATA_STRC_VERSION); + sddc_csr.rmwf(utra::sddc::CR_REG_UHS_1_SUPPORT_CFG_REG_DATA_STRC_VERSION, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_UHS_1_SUPPORT_CFG_REG_DATA_STRC_VERSION, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_UHS_1_SUPPORT_CFG_REG_DATA_STRC_VERSION, 1); + sddc_csr.wfo(utra::sddc::CR_REG_UHS_1_SUPPORT_CFG_REG_DATA_STRC_VERSION, baz); + let bar = sddc_csr.rf(utra::sddc::CR_REG_UHS_1_SUPPORT_CFG_REG_UHS_1_SUPPORT); + sddc_csr.rmwf(utra::sddc::CR_REG_UHS_1_SUPPORT_CFG_REG_UHS_1_SUPPORT, bar); + let mut baz = sddc_csr.zf(utra::sddc::CR_REG_UHS_1_SUPPORT_CFG_REG_UHS_1_SUPPORT, bar); + baz |= sddc_csr.ms(utra::sddc::CR_REG_UHS_1_SUPPORT_CFG_REG_UHS_1_SUPPORT, 1); + sddc_csr.wfo(utra::sddc::CR_REG_UHS_1_SUPPORT_CFG_REG_UHS_1_SUPPORT, baz); + } + + #[test] + #[ignore] + fn compile_check_rp_pio_csr() { + use super::*; + let mut rp_pio_csr = CSR::new(HW_RP_PIO_BASE as *mut u32); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_CTRL); + rp_pio_csr.wo(utra::rp_pio::SFR_CTRL, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_CTRL_EN); + rp_pio_csr.rmwf(utra::rp_pio::SFR_CTRL_EN, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_CTRL_EN, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_CTRL_EN, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_CTRL_EN, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_CTRL_RESTART); + rp_pio_csr.rmwf(utra::rp_pio::SFR_CTRL_RESTART, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_CTRL_RESTART, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_CTRL_RESTART, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_CTRL_RESTART, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_CTRL_CLKDIV_RESTART); + rp_pio_csr.rmwf(utra::rp_pio::SFR_CTRL_CLKDIV_RESTART, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_CTRL_CLKDIV_RESTART, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_CTRL_CLKDIV_RESTART, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_CTRL_CLKDIV_RESTART, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_FSTAT); + rp_pio_csr.wo(utra::rp_pio::SFR_FSTAT, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FSTAT_RX_FULL); + rp_pio_csr.rmwf(utra::rp_pio::SFR_FSTAT_RX_FULL, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FSTAT_RX_FULL, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FSTAT_RX_FULL, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_FSTAT_RX_FULL, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FSTAT_CONSTANT0); + rp_pio_csr.rmwf(utra::rp_pio::SFR_FSTAT_CONSTANT0, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FSTAT_CONSTANT0, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FSTAT_CONSTANT0, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_FSTAT_CONSTANT0, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FSTAT_RX_EMPTY); + rp_pio_csr.rmwf(utra::rp_pio::SFR_FSTAT_RX_EMPTY, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FSTAT_RX_EMPTY, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FSTAT_RX_EMPTY, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_FSTAT_RX_EMPTY, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FSTAT_CONSTANT1); + rp_pio_csr.rmwf(utra::rp_pio::SFR_FSTAT_CONSTANT1, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FSTAT_CONSTANT1, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FSTAT_CONSTANT1, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_FSTAT_CONSTANT1, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FSTAT_TX_FULL); + rp_pio_csr.rmwf(utra::rp_pio::SFR_FSTAT_TX_FULL, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FSTAT_TX_FULL, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FSTAT_TX_FULL, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_FSTAT_TX_FULL, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FSTAT_CONSTANT2); + rp_pio_csr.rmwf(utra::rp_pio::SFR_FSTAT_CONSTANT2, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FSTAT_CONSTANT2, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FSTAT_CONSTANT2, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_FSTAT_CONSTANT2, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FSTAT_TX_EMPTY); + rp_pio_csr.rmwf(utra::rp_pio::SFR_FSTAT_TX_EMPTY, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FSTAT_TX_EMPTY, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FSTAT_TX_EMPTY, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_FSTAT_TX_EMPTY, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FSTAT_CONSTANT3); + rp_pio_csr.rmwf(utra::rp_pio::SFR_FSTAT_CONSTANT3, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FSTAT_CONSTANT3, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FSTAT_CONSTANT3, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_FSTAT_CONSTANT3, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_FDEBUG); + rp_pio_csr.wo(utra::rp_pio::SFR_FDEBUG, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FDEBUG_RXSTALL); + rp_pio_csr.rmwf(utra::rp_pio::SFR_FDEBUG_RXSTALL, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FDEBUG_RXSTALL, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FDEBUG_RXSTALL, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_FDEBUG_RXSTALL, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FDEBUG_NC_DBG3); + rp_pio_csr.rmwf(utra::rp_pio::SFR_FDEBUG_NC_DBG3, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FDEBUG_NC_DBG3, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FDEBUG_NC_DBG3, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_FDEBUG_NC_DBG3, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FDEBUG_RXUNDER); + rp_pio_csr.rmwf(utra::rp_pio::SFR_FDEBUG_RXUNDER, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FDEBUG_RXUNDER, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FDEBUG_RXUNDER, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_FDEBUG_RXUNDER, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FDEBUG_NC_DBG2); + rp_pio_csr.rmwf(utra::rp_pio::SFR_FDEBUG_NC_DBG2, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FDEBUG_NC_DBG2, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FDEBUG_NC_DBG2, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_FDEBUG_NC_DBG2, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FDEBUG_TXOVER); + rp_pio_csr.rmwf(utra::rp_pio::SFR_FDEBUG_TXOVER, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FDEBUG_TXOVER, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FDEBUG_TXOVER, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_FDEBUG_TXOVER, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FDEBUG_NC_DBG1); + rp_pio_csr.rmwf(utra::rp_pio::SFR_FDEBUG_NC_DBG1, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FDEBUG_NC_DBG1, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FDEBUG_NC_DBG1, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_FDEBUG_NC_DBG1, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FDEBUG_TXSTALL); + rp_pio_csr.rmwf(utra::rp_pio::SFR_FDEBUG_TXSTALL, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FDEBUG_TXSTALL, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FDEBUG_TXSTALL, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_FDEBUG_TXSTALL, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FDEBUG_NC_DBG0); + rp_pio_csr.rmwf(utra::rp_pio::SFR_FDEBUG_NC_DBG0, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FDEBUG_NC_DBG0, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FDEBUG_NC_DBG0, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_FDEBUG_NC_DBG0, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_FLEVEL); + rp_pio_csr.wo(utra::rp_pio::SFR_FLEVEL, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FLEVEL_TX_LEVEL0); + rp_pio_csr.rmwf(utra::rp_pio::SFR_FLEVEL_TX_LEVEL0, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FLEVEL_TX_LEVEL0, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FLEVEL_TX_LEVEL0, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_FLEVEL_TX_LEVEL0, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FLEVEL_CONSTANT0); + rp_pio_csr.rmwf(utra::rp_pio::SFR_FLEVEL_CONSTANT0, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FLEVEL_CONSTANT0, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FLEVEL_CONSTANT0, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_FLEVEL_CONSTANT0, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FLEVEL_RX_LEVEL0); + rp_pio_csr.rmwf(utra::rp_pio::SFR_FLEVEL_RX_LEVEL0, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FLEVEL_RX_LEVEL0, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FLEVEL_RX_LEVEL0, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_FLEVEL_RX_LEVEL0, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FLEVEL_CONSTANT1); + rp_pio_csr.rmwf(utra::rp_pio::SFR_FLEVEL_CONSTANT1, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FLEVEL_CONSTANT1, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FLEVEL_CONSTANT1, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_FLEVEL_CONSTANT1, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FLEVEL_TX_LEVEL1); + rp_pio_csr.rmwf(utra::rp_pio::SFR_FLEVEL_TX_LEVEL1, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FLEVEL_TX_LEVEL1, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FLEVEL_TX_LEVEL1, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_FLEVEL_TX_LEVEL1, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FLEVEL_CONSTANT2); + rp_pio_csr.rmwf(utra::rp_pio::SFR_FLEVEL_CONSTANT2, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FLEVEL_CONSTANT2, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FLEVEL_CONSTANT2, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_FLEVEL_CONSTANT2, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FLEVEL_RX_LEVEL1); + rp_pio_csr.rmwf(utra::rp_pio::SFR_FLEVEL_RX_LEVEL1, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FLEVEL_RX_LEVEL1, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FLEVEL_RX_LEVEL1, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_FLEVEL_RX_LEVEL1, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FLEVEL_CONSTANT3); + rp_pio_csr.rmwf(utra::rp_pio::SFR_FLEVEL_CONSTANT3, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FLEVEL_CONSTANT3, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FLEVEL_CONSTANT3, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_FLEVEL_CONSTANT3, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FLEVEL_TX_LEVEL2); + rp_pio_csr.rmwf(utra::rp_pio::SFR_FLEVEL_TX_LEVEL2, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FLEVEL_TX_LEVEL2, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FLEVEL_TX_LEVEL2, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_FLEVEL_TX_LEVEL2, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FLEVEL_CONSTANT4); + rp_pio_csr.rmwf(utra::rp_pio::SFR_FLEVEL_CONSTANT4, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FLEVEL_CONSTANT4, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FLEVEL_CONSTANT4, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_FLEVEL_CONSTANT4, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FLEVEL_RX_LEVEL2); + rp_pio_csr.rmwf(utra::rp_pio::SFR_FLEVEL_RX_LEVEL2, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FLEVEL_RX_LEVEL2, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FLEVEL_RX_LEVEL2, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_FLEVEL_RX_LEVEL2, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FLEVEL_CONSTANT5); + rp_pio_csr.rmwf(utra::rp_pio::SFR_FLEVEL_CONSTANT5, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FLEVEL_CONSTANT5, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FLEVEL_CONSTANT5, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_FLEVEL_CONSTANT5, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FLEVEL_TX_LEVEL3); + rp_pio_csr.rmwf(utra::rp_pio::SFR_FLEVEL_TX_LEVEL3, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FLEVEL_TX_LEVEL3, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FLEVEL_TX_LEVEL3, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_FLEVEL_TX_LEVEL3, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FLEVEL_CONSTANT6); + rp_pio_csr.rmwf(utra::rp_pio::SFR_FLEVEL_CONSTANT6, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FLEVEL_CONSTANT6, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FLEVEL_CONSTANT6, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_FLEVEL_CONSTANT6, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FLEVEL_RX_LEVEL3); + rp_pio_csr.rmwf(utra::rp_pio::SFR_FLEVEL_RX_LEVEL3, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FLEVEL_RX_LEVEL3, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FLEVEL_RX_LEVEL3, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_FLEVEL_RX_LEVEL3, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FLEVEL_CONSTANT7); + rp_pio_csr.rmwf(utra::rp_pio::SFR_FLEVEL_CONSTANT7, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FLEVEL_CONSTANT7, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FLEVEL_CONSTANT7, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_FLEVEL_CONSTANT7, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_TXF0); + rp_pio_csr.wo(utra::rp_pio::SFR_TXF0, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_TXF0_FDIN); + rp_pio_csr.rmwf(utra::rp_pio::SFR_TXF0_FDIN, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_TXF0_FDIN, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_TXF0_FDIN, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_TXF0_FDIN, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_TXF1); + rp_pio_csr.wo(utra::rp_pio::SFR_TXF1, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_TXF1_FDIN); + rp_pio_csr.rmwf(utra::rp_pio::SFR_TXF1_FDIN, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_TXF1_FDIN, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_TXF1_FDIN, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_TXF1_FDIN, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_TXF2); + rp_pio_csr.wo(utra::rp_pio::SFR_TXF2, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_TXF2_FDIN); + rp_pio_csr.rmwf(utra::rp_pio::SFR_TXF2_FDIN, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_TXF2_FDIN, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_TXF2_FDIN, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_TXF2_FDIN, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_TXF3); + rp_pio_csr.wo(utra::rp_pio::SFR_TXF3, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_TXF3_FDIN); + rp_pio_csr.rmwf(utra::rp_pio::SFR_TXF3_FDIN, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_TXF3_FDIN, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_TXF3_FDIN, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_TXF3_FDIN, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_RXF0); + rp_pio_csr.wo(utra::rp_pio::SFR_RXF0, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_RXF0_PDOUT); + rp_pio_csr.rmwf(utra::rp_pio::SFR_RXF0_PDOUT, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_RXF0_PDOUT, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_RXF0_PDOUT, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_RXF0_PDOUT, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_RXF1); + rp_pio_csr.wo(utra::rp_pio::SFR_RXF1, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_RXF1_PDOUT); + rp_pio_csr.rmwf(utra::rp_pio::SFR_RXF1_PDOUT, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_RXF1_PDOUT, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_RXF1_PDOUT, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_RXF1_PDOUT, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_RXF2); + rp_pio_csr.wo(utra::rp_pio::SFR_RXF2, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_RXF2_PDOUT); + rp_pio_csr.rmwf(utra::rp_pio::SFR_RXF2_PDOUT, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_RXF2_PDOUT, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_RXF2_PDOUT, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_RXF2_PDOUT, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_RXF3); + rp_pio_csr.wo(utra::rp_pio::SFR_RXF3, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_RXF3_PDOUT); + rp_pio_csr.rmwf(utra::rp_pio::SFR_RXF3_PDOUT, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_RXF3_PDOUT, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_RXF3_PDOUT, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_RXF3_PDOUT, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_IRQ); + rp_pio_csr.wo(utra::rp_pio::SFR_IRQ, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_IRQ_SFR_IRQ); + rp_pio_csr.rmwf(utra::rp_pio::SFR_IRQ_SFR_IRQ, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_IRQ_SFR_IRQ, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_IRQ_SFR_IRQ, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_IRQ_SFR_IRQ, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_IRQ_FORCE); + rp_pio_csr.wo(utra::rp_pio::SFR_IRQ_FORCE, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_IRQ_FORCE_SFR_IRQ_FORCE); + rp_pio_csr.rmwf(utra::rp_pio::SFR_IRQ_FORCE_SFR_IRQ_FORCE, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_IRQ_FORCE_SFR_IRQ_FORCE, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_IRQ_FORCE_SFR_IRQ_FORCE, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_IRQ_FORCE_SFR_IRQ_FORCE, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_SYNC_BYPASS); + rp_pio_csr.wo(utra::rp_pio::SFR_SYNC_BYPASS, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SYNC_BYPASS_SFR_SYNC_BYPASS); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SYNC_BYPASS_SFR_SYNC_BYPASS, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SYNC_BYPASS_SFR_SYNC_BYPASS, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SYNC_BYPASS_SFR_SYNC_BYPASS, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SYNC_BYPASS_SFR_SYNC_BYPASS, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_DBG_PADOUT); + rp_pio_csr.wo(utra::rp_pio::SFR_DBG_PADOUT, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_DBG_PADOUT_SFR_DBG_PADOUT); + rp_pio_csr.rmwf(utra::rp_pio::SFR_DBG_PADOUT_SFR_DBG_PADOUT, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_DBG_PADOUT_SFR_DBG_PADOUT, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_DBG_PADOUT_SFR_DBG_PADOUT, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_DBG_PADOUT_SFR_DBG_PADOUT, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_DBG_PADOE); + rp_pio_csr.wo(utra::rp_pio::SFR_DBG_PADOE, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_DBG_PADOE_SFR_DBG_PADOE); + rp_pio_csr.rmwf(utra::rp_pio::SFR_DBG_PADOE_SFR_DBG_PADOE, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_DBG_PADOE_SFR_DBG_PADOE, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_DBG_PADOE_SFR_DBG_PADOE, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_DBG_PADOE_SFR_DBG_PADOE, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_DBG_CFGINFO); + rp_pio_csr.wo(utra::rp_pio::SFR_DBG_CFGINFO, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_DBG_CFGINFO_CONSTANT0); + rp_pio_csr.rmwf(utra::rp_pio::SFR_DBG_CFGINFO_CONSTANT0, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_DBG_CFGINFO_CONSTANT0, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_DBG_CFGINFO_CONSTANT0, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_DBG_CFGINFO_CONSTANT0, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_DBG_CFGINFO_CONSTANT1); + rp_pio_csr.rmwf(utra::rp_pio::SFR_DBG_CFGINFO_CONSTANT1, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_DBG_CFGINFO_CONSTANT1, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_DBG_CFGINFO_CONSTANT1, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_DBG_CFGINFO_CONSTANT1, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_DBG_CFGINFO_CONSTANT2); + rp_pio_csr.rmwf(utra::rp_pio::SFR_DBG_CFGINFO_CONSTANT2, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_DBG_CFGINFO_CONSTANT2, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_DBG_CFGINFO_CONSTANT2, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_DBG_CFGINFO_CONSTANT2, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM0); + rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM0, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM0_INSTR); + rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM0_INSTR, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM0_INSTR, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM0_INSTR, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM0_INSTR, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM1); + rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM1, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM1_INSTR); + rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM1_INSTR, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM1_INSTR, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM1_INSTR, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM1_INSTR, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM2); + rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM2, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM2_INSTR); + rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM2_INSTR, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM2_INSTR, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM2_INSTR, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM2_INSTR, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM3); + rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM3, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM3_INSTR); + rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM3_INSTR, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM3_INSTR, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM3_INSTR, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM3_INSTR, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM4); + rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM4, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM4_INSTR); + rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM4_INSTR, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM4_INSTR, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM4_INSTR, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM4_INSTR, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM5); + rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM5, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM5_INSTR); + rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM5_INSTR, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM5_INSTR, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM5_INSTR, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM5_INSTR, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM6); + rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM6, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM6_INSTR); + rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM6_INSTR, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM6_INSTR, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM6_INSTR, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM6_INSTR, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM7); + rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM7, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM7_INSTR); + rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM7_INSTR, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM7_INSTR, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM7_INSTR, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM7_INSTR, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM8); + rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM8, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM8_INSTR); + rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM8_INSTR, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM8_INSTR, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM8_INSTR, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM8_INSTR, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM9); + rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM9, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM9_INSTR); + rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM9_INSTR, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM9_INSTR, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM9_INSTR, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM9_INSTR, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM10); + rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM10, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM10_INSTR); + rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM10_INSTR, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM10_INSTR, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM10_INSTR, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM10_INSTR, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM11); + rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM11, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM11_INSTR); + rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM11_INSTR, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM11_INSTR, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM11_INSTR, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM11_INSTR, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM12); + rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM12, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM12_INSTR); + rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM12_INSTR, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM12_INSTR, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM12_INSTR, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM12_INSTR, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM13); + rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM13, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM13_INSTR); + rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM13_INSTR, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM13_INSTR, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM13_INSTR, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM13_INSTR, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM14); + rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM14, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM14_INSTR); + rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM14_INSTR, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM14_INSTR, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM14_INSTR, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM14_INSTR, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM15); + rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM15, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM15_INSTR); + rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM15_INSTR, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM15_INSTR, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM15_INSTR, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM15_INSTR, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM16); + rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM16, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM16_INSTR); + rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM16_INSTR, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM16_INSTR, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM16_INSTR, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM16_INSTR, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM17); + rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM17, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM17_INSTR); + rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM17_INSTR, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM17_INSTR, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM17_INSTR, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM17_INSTR, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM18); + rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM18, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM18_INSTR); + rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM18_INSTR, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM18_INSTR, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM18_INSTR, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM18_INSTR, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM19); + rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM19, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM19_INSTR); + rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM19_INSTR, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM19_INSTR, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM19_INSTR, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM19_INSTR, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM20); + rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM20, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM20_INSTR); + rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM20_INSTR, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM20_INSTR, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM20_INSTR, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM20_INSTR, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM21); + rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM21, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM21_INSTR); + rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM21_INSTR, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM21_INSTR, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM21_INSTR, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM21_INSTR, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM22); + rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM22, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM22_INSTR); + rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM22_INSTR, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM22_INSTR, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM22_INSTR, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM22_INSTR, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM23); + rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM23, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM23_INSTR); + rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM23_INSTR, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM23_INSTR, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM23_INSTR, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM23_INSTR, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM24); + rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM24, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM24_INSTR); + rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM24_INSTR, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM24_INSTR, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM24_INSTR, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM24_INSTR, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM25); + rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM25, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM25_INSTR); + rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM25_INSTR, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM25_INSTR, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM25_INSTR, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM25_INSTR, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM26); + rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM26, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM26_INSTR); + rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM26_INSTR, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM26_INSTR, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM26_INSTR, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM26_INSTR, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM27); + rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM27, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM27_INSTR); + rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM27_INSTR, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM27_INSTR, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM27_INSTR, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM27_INSTR, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM28); + rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM28, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM28_INSTR); + rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM28_INSTR, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM28_INSTR, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM28_INSTR, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM28_INSTR, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM29); + rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM29, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM29_INSTR); + rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM29_INSTR, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM29_INSTR, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM29_INSTR, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM29_INSTR, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM30); + rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM30, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM30_INSTR); + rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM30_INSTR, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM30_INSTR, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM30_INSTR, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM30_INSTR, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_INSTR_MEM31); + rp_pio_csr.wo(utra::rp_pio::SFR_INSTR_MEM31, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INSTR_MEM31_INSTR); + rp_pio_csr.rmwf(utra::rp_pio::SFR_INSTR_MEM31_INSTR, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INSTR_MEM31_INSTR, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INSTR_MEM31_INSTR, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_INSTR_MEM31_INSTR, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_SM0_CLKDIV); + rp_pio_csr.wo(utra::rp_pio::SFR_SM0_CLKDIV, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_CLKDIV_UNUSED_DIV); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_CLKDIV_UNUSED_DIV, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_CLKDIV_UNUSED_DIV, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_CLKDIV_UNUSED_DIV, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_CLKDIV_UNUSED_DIV, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_CLKDIV_DIV_FRAC); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_CLKDIV_DIV_FRAC, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_CLKDIV_DIV_FRAC, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_CLKDIV_DIV_FRAC, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_CLKDIV_DIV_FRAC, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_CLKDIV_DIV_INT); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_CLKDIV_DIV_INT, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_CLKDIV_DIV_INT, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_CLKDIV_DIV_INT, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_CLKDIV_DIV_INT, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_SM0_EXECCTRL); + rp_pio_csr.wo(utra::rp_pio::SFR_SM0_EXECCTRL, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_EXECCTRL_STATUS_N); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_EXECCTRL_STATUS_N, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_EXECCTRL_STATUS_N, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_EXECCTRL_STATUS_N, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_EXECCTRL_STATUS_N, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_EXECCTRL_STATUS_SEL); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_EXECCTRL_STATUS_SEL, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_EXECCTRL_STATUS_SEL, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_EXECCTRL_STATUS_SEL, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_EXECCTRL_STATUS_SEL, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_EXECCTRL_RESVD_EXEC); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_EXECCTRL_RESVD_EXEC, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_EXECCTRL_RESVD_EXEC, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_EXECCTRL_RESVD_EXEC, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_EXECCTRL_RESVD_EXEC, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_EXECCTRL_WRAP_TARGET); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_EXECCTRL_WRAP_TARGET, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_EXECCTRL_WRAP_TARGET, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_EXECCTRL_WRAP_TARGET, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_EXECCTRL_WRAP_TARGET, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_EXECCTRL_PEND); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_EXECCTRL_PEND, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_EXECCTRL_PEND, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_EXECCTRL_PEND, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_EXECCTRL_PEND, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_EXECCTRL_OUT_STICKY); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_EXECCTRL_OUT_STICKY, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_EXECCTRL_OUT_STICKY, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_EXECCTRL_OUT_STICKY, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_EXECCTRL_OUT_STICKY, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_EXECCTRL_INLINE_OUT_EN); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_EXECCTRL_INLINE_OUT_EN, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_EXECCTRL_INLINE_OUT_EN, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_EXECCTRL_INLINE_OUT_EN, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_EXECCTRL_INLINE_OUT_EN, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_EXECCTRL_OUT_EN_SEL); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_EXECCTRL_OUT_EN_SEL, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_EXECCTRL_OUT_EN_SEL, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_EXECCTRL_OUT_EN_SEL, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_EXECCTRL_OUT_EN_SEL, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_EXECCTRL_JMP_PIN); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_EXECCTRL_JMP_PIN, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_EXECCTRL_JMP_PIN, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_EXECCTRL_JMP_PIN, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_EXECCTRL_JMP_PIN, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_EXECCTRL_SIDE_PINDIR); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_EXECCTRL_SIDE_PINDIR, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_EXECCTRL_SIDE_PINDIR, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_EXECCTRL_SIDE_PINDIR, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_EXECCTRL_SIDE_PINDIR, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_EXECCTRL_SIDESET_ENABLE_BIT); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_EXECCTRL_SIDESET_ENABLE_BIT, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_EXECCTRL_SIDESET_ENABLE_BIT, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_EXECCTRL_SIDESET_ENABLE_BIT, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_EXECCTRL_SIDESET_ENABLE_BIT, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_EXECCTRL_EXEC_STALLED_RO0); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_EXECCTRL_EXEC_STALLED_RO0, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_EXECCTRL_EXEC_STALLED_RO0, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_EXECCTRL_EXEC_STALLED_RO0, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_EXECCTRL_EXEC_STALLED_RO0, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_SM0_SHIFTCTRL); + rp_pio_csr.wo(utra::rp_pio::SFR_SM0_SHIFTCTRL, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_SHIFTCTRL_RESVD_SHIFT); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_SHIFTCTRL_RESVD_SHIFT, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_SHIFTCTRL_RESVD_SHIFT, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_SHIFTCTRL_RESVD_SHIFT, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_SHIFTCTRL_RESVD_SHIFT, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_SHIFTCTRL_AUTO_PUSH); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_SHIFTCTRL_AUTO_PUSH, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_SHIFTCTRL_AUTO_PUSH, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_SHIFTCTRL_AUTO_PUSH, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_SHIFTCTRL_AUTO_PUSH, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_SHIFTCTRL_AUTO_PULL); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_SHIFTCTRL_AUTO_PULL, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_SHIFTCTRL_AUTO_PULL, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_SHIFTCTRL_AUTO_PULL, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_SHIFTCTRL_AUTO_PULL, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_SHIFTCTRL_IN_SHIFT_DIR); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_SHIFTCTRL_IN_SHIFT_DIR, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_SHIFTCTRL_IN_SHIFT_DIR, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_SHIFTCTRL_IN_SHIFT_DIR, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_SHIFTCTRL_IN_SHIFT_DIR, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_SHIFTCTRL_OUT_SHIFT_DIR); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_SHIFTCTRL_OUT_SHIFT_DIR, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_SHIFTCTRL_OUT_SHIFT_DIR, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_SHIFTCTRL_OUT_SHIFT_DIR, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_SHIFTCTRL_OUT_SHIFT_DIR, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_SHIFTCTRL_ISR_THRESHOLD); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_SHIFTCTRL_ISR_THRESHOLD, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_SHIFTCTRL_ISR_THRESHOLD, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_SHIFTCTRL_ISR_THRESHOLD, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_SHIFTCTRL_ISR_THRESHOLD, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_SHIFTCTRL_OSR_THRESHOLD); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_SHIFTCTRL_OSR_THRESHOLD, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_SHIFTCTRL_OSR_THRESHOLD, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_SHIFTCTRL_OSR_THRESHOLD, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_SHIFTCTRL_OSR_THRESHOLD, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_SHIFTCTRL_JOIN_TX); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_SHIFTCTRL_JOIN_TX, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_SHIFTCTRL_JOIN_TX, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_SHIFTCTRL_JOIN_TX, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_SHIFTCTRL_JOIN_TX, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_SHIFTCTRL_JOIN_RX); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_SHIFTCTRL_JOIN_RX, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_SHIFTCTRL_JOIN_RX, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_SHIFTCTRL_JOIN_RX, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_SHIFTCTRL_JOIN_RX, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_SM0_ADDR); + rp_pio_csr.wo(utra::rp_pio::SFR_SM0_ADDR, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_ADDR_PC); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_ADDR_PC, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_ADDR_PC, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_ADDR_PC, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_ADDR_PC, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_SM0_INSTR); + rp_pio_csr.wo(utra::rp_pio::SFR_SM0_INSTR, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_INSTR_IMM_INSTR); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_INSTR_IMM_INSTR, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_INSTR_IMM_INSTR, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_INSTR_IMM_INSTR, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_INSTR_IMM_INSTR, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_SM0_PINCTRL); + rp_pio_csr.wo(utra::rp_pio::SFR_SM0_PINCTRL, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_PINCTRL_PINS_OUT_BASE); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_PINCTRL_PINS_OUT_BASE, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_PINCTRL_PINS_OUT_BASE, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_PINCTRL_PINS_OUT_BASE, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_PINCTRL_PINS_OUT_BASE, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_PINCTRL_PINS_SET_BASE); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_PINCTRL_PINS_SET_BASE, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_PINCTRL_PINS_SET_BASE, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_PINCTRL_PINS_SET_BASE, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_PINCTRL_PINS_SET_BASE, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_PINCTRL_PINS_SIDE_BASE); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_PINCTRL_PINS_SIDE_BASE, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_PINCTRL_PINS_SIDE_BASE, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_PINCTRL_PINS_SIDE_BASE, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_PINCTRL_PINS_SIDE_BASE, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_PINCTRL_PINS_IN_BASE); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_PINCTRL_PINS_IN_BASE, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_PINCTRL_PINS_IN_BASE, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_PINCTRL_PINS_IN_BASE, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_PINCTRL_PINS_IN_BASE, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_PINCTRL_PINS_OUT_COUNT); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_PINCTRL_PINS_OUT_COUNT, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_PINCTRL_PINS_OUT_COUNT, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_PINCTRL_PINS_OUT_COUNT, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_PINCTRL_PINS_OUT_COUNT, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_PINCTRL_PINS_SET_COUNT); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_PINCTRL_PINS_SET_COUNT, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_PINCTRL_PINS_SET_COUNT, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_PINCTRL_PINS_SET_COUNT, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_PINCTRL_PINS_SET_COUNT, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM0_PINCTRL_PINS_SIDE_COUNT); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM0_PINCTRL_PINS_SIDE_COUNT, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM0_PINCTRL_PINS_SIDE_COUNT, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM0_PINCTRL_PINS_SIDE_COUNT, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM0_PINCTRL_PINS_SIDE_COUNT, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_SM1_CLKDIV); + rp_pio_csr.wo(utra::rp_pio::SFR_SM1_CLKDIV, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_CLKDIV_UNUSED_DIV); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_CLKDIV_UNUSED_DIV, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_CLKDIV_UNUSED_DIV, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_CLKDIV_UNUSED_DIV, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_CLKDIV_UNUSED_DIV, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_CLKDIV_DIV_FRAC); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_CLKDIV_DIV_FRAC, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_CLKDIV_DIV_FRAC, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_CLKDIV_DIV_FRAC, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_CLKDIV_DIV_FRAC, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_CLKDIV_DIV_INT); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_CLKDIV_DIV_INT, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_CLKDIV_DIV_INT, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_CLKDIV_DIV_INT, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_CLKDIV_DIV_INT, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_SM1_EXECCTRL); + rp_pio_csr.wo(utra::rp_pio::SFR_SM1_EXECCTRL, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_EXECCTRL_STATUS_N); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_EXECCTRL_STATUS_N, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_EXECCTRL_STATUS_N, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_EXECCTRL_STATUS_N, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_EXECCTRL_STATUS_N, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_EXECCTRL_STATUS_SEL); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_EXECCTRL_STATUS_SEL, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_EXECCTRL_STATUS_SEL, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_EXECCTRL_STATUS_SEL, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_EXECCTRL_STATUS_SEL, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_EXECCTRL_RESVD_EXEC); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_EXECCTRL_RESVD_EXEC, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_EXECCTRL_RESVD_EXEC, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_EXECCTRL_RESVD_EXEC, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_EXECCTRL_RESVD_EXEC, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_EXECCTRL_WRAP_TARGET); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_EXECCTRL_WRAP_TARGET, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_EXECCTRL_WRAP_TARGET, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_EXECCTRL_WRAP_TARGET, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_EXECCTRL_WRAP_TARGET, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_EXECCTRL_PEND); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_EXECCTRL_PEND, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_EXECCTRL_PEND, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_EXECCTRL_PEND, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_EXECCTRL_PEND, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_EXECCTRL_OUT_STICKY); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_EXECCTRL_OUT_STICKY, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_EXECCTRL_OUT_STICKY, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_EXECCTRL_OUT_STICKY, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_EXECCTRL_OUT_STICKY, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_EXECCTRL_INLINE_OUT_EN); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_EXECCTRL_INLINE_OUT_EN, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_EXECCTRL_INLINE_OUT_EN, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_EXECCTRL_INLINE_OUT_EN, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_EXECCTRL_INLINE_OUT_EN, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_EXECCTRL_OUT_EN_SEL); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_EXECCTRL_OUT_EN_SEL, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_EXECCTRL_OUT_EN_SEL, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_EXECCTRL_OUT_EN_SEL, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_EXECCTRL_OUT_EN_SEL, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_EXECCTRL_JMP_PIN); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_EXECCTRL_JMP_PIN, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_EXECCTRL_JMP_PIN, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_EXECCTRL_JMP_PIN, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_EXECCTRL_JMP_PIN, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_EXECCTRL_SIDE_PINDIR); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_EXECCTRL_SIDE_PINDIR, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_EXECCTRL_SIDE_PINDIR, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_EXECCTRL_SIDE_PINDIR, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_EXECCTRL_SIDE_PINDIR, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_EXECCTRL_SIDESET_ENABLE_BIT); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_EXECCTRL_SIDESET_ENABLE_BIT, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_EXECCTRL_SIDESET_ENABLE_BIT, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_EXECCTRL_SIDESET_ENABLE_BIT, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_EXECCTRL_SIDESET_ENABLE_BIT, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_EXECCTRL_EXEC_STALLED_RO1); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_EXECCTRL_EXEC_STALLED_RO1, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_EXECCTRL_EXEC_STALLED_RO1, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_EXECCTRL_EXEC_STALLED_RO1, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_EXECCTRL_EXEC_STALLED_RO1, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_SM1_SHIFTCTRL); + rp_pio_csr.wo(utra::rp_pio::SFR_SM1_SHIFTCTRL, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_SHIFTCTRL_RESVD_SHIFT); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_SHIFTCTRL_RESVD_SHIFT, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_SHIFTCTRL_RESVD_SHIFT, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_SHIFTCTRL_RESVD_SHIFT, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_SHIFTCTRL_RESVD_SHIFT, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_SHIFTCTRL_AUTO_PUSH); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_SHIFTCTRL_AUTO_PUSH, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_SHIFTCTRL_AUTO_PUSH, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_SHIFTCTRL_AUTO_PUSH, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_SHIFTCTRL_AUTO_PUSH, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_SHIFTCTRL_AUTO_PULL); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_SHIFTCTRL_AUTO_PULL, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_SHIFTCTRL_AUTO_PULL, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_SHIFTCTRL_AUTO_PULL, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_SHIFTCTRL_AUTO_PULL, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_SHIFTCTRL_IN_SHIFT_DIR); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_SHIFTCTRL_IN_SHIFT_DIR, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_SHIFTCTRL_IN_SHIFT_DIR, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_SHIFTCTRL_IN_SHIFT_DIR, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_SHIFTCTRL_IN_SHIFT_DIR, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_SHIFTCTRL_OUT_SHIFT_DIR); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_SHIFTCTRL_OUT_SHIFT_DIR, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_SHIFTCTRL_OUT_SHIFT_DIR, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_SHIFTCTRL_OUT_SHIFT_DIR, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_SHIFTCTRL_OUT_SHIFT_DIR, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_SHIFTCTRL_ISR_THRESHOLD); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_SHIFTCTRL_ISR_THRESHOLD, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_SHIFTCTRL_ISR_THRESHOLD, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_SHIFTCTRL_ISR_THRESHOLD, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_SHIFTCTRL_ISR_THRESHOLD, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_SHIFTCTRL_OSR_THRESHOLD); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_SHIFTCTRL_OSR_THRESHOLD, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_SHIFTCTRL_OSR_THRESHOLD, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_SHIFTCTRL_OSR_THRESHOLD, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_SHIFTCTRL_OSR_THRESHOLD, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_SHIFTCTRL_JOIN_TX); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_SHIFTCTRL_JOIN_TX, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_SHIFTCTRL_JOIN_TX, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_SHIFTCTRL_JOIN_TX, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_SHIFTCTRL_JOIN_TX, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_SHIFTCTRL_JOIN_RX); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_SHIFTCTRL_JOIN_RX, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_SHIFTCTRL_JOIN_RX, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_SHIFTCTRL_JOIN_RX, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_SHIFTCTRL_JOIN_RX, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_SM1_ADDR); + rp_pio_csr.wo(utra::rp_pio::SFR_SM1_ADDR, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_ADDR_PC); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_ADDR_PC, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_ADDR_PC, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_ADDR_PC, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_ADDR_PC, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_SM1_INSTR); + rp_pio_csr.wo(utra::rp_pio::SFR_SM1_INSTR, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_INSTR_IMM_INSTR); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_INSTR_IMM_INSTR, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_INSTR_IMM_INSTR, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_INSTR_IMM_INSTR, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_INSTR_IMM_INSTR, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_SM1_PINCTRL); + rp_pio_csr.wo(utra::rp_pio::SFR_SM1_PINCTRL, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_PINCTRL_PINS_OUT_BASE); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_PINCTRL_PINS_OUT_BASE, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_PINCTRL_PINS_OUT_BASE, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_PINCTRL_PINS_OUT_BASE, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_PINCTRL_PINS_OUT_BASE, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_PINCTRL_PINS_SET_BASE); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_PINCTRL_PINS_SET_BASE, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_PINCTRL_PINS_SET_BASE, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_PINCTRL_PINS_SET_BASE, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_PINCTRL_PINS_SET_BASE, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_PINCTRL_PINS_SIDE_BASE); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_PINCTRL_PINS_SIDE_BASE, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_PINCTRL_PINS_SIDE_BASE, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_PINCTRL_PINS_SIDE_BASE, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_PINCTRL_PINS_SIDE_BASE, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_PINCTRL_PINS_IN_BASE); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_PINCTRL_PINS_IN_BASE, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_PINCTRL_PINS_IN_BASE, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_PINCTRL_PINS_IN_BASE, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_PINCTRL_PINS_IN_BASE, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_PINCTRL_PINS_OUT_COUNT); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_PINCTRL_PINS_OUT_COUNT, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_PINCTRL_PINS_OUT_COUNT, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_PINCTRL_PINS_OUT_COUNT, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_PINCTRL_PINS_OUT_COUNT, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_PINCTRL_PINS_SET_COUNT); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_PINCTRL_PINS_SET_COUNT, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_PINCTRL_PINS_SET_COUNT, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_PINCTRL_PINS_SET_COUNT, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_PINCTRL_PINS_SET_COUNT, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM1_PINCTRL_PINS_SIDE_COUNT); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM1_PINCTRL_PINS_SIDE_COUNT, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM1_PINCTRL_PINS_SIDE_COUNT, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM1_PINCTRL_PINS_SIDE_COUNT, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM1_PINCTRL_PINS_SIDE_COUNT, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_SM2_CLKDIV); + rp_pio_csr.wo(utra::rp_pio::SFR_SM2_CLKDIV, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_CLKDIV_UNUSED_DIV); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_CLKDIV_UNUSED_DIV, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_CLKDIV_UNUSED_DIV, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_CLKDIV_UNUSED_DIV, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_CLKDIV_UNUSED_DIV, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_CLKDIV_DIV_FRAC); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_CLKDIV_DIV_FRAC, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_CLKDIV_DIV_FRAC, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_CLKDIV_DIV_FRAC, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_CLKDIV_DIV_FRAC, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_CLKDIV_DIV_INT); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_CLKDIV_DIV_INT, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_CLKDIV_DIV_INT, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_CLKDIV_DIV_INT, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_CLKDIV_DIV_INT, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_SM2_EXECCTRL); + rp_pio_csr.wo(utra::rp_pio::SFR_SM2_EXECCTRL, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_EXECCTRL_STATUS_N); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_EXECCTRL_STATUS_N, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_EXECCTRL_STATUS_N, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_EXECCTRL_STATUS_N, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_EXECCTRL_STATUS_N, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_EXECCTRL_STATUS_SEL); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_EXECCTRL_STATUS_SEL, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_EXECCTRL_STATUS_SEL, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_EXECCTRL_STATUS_SEL, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_EXECCTRL_STATUS_SEL, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_EXECCTRL_RESVD_EXEC); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_EXECCTRL_RESVD_EXEC, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_EXECCTRL_RESVD_EXEC, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_EXECCTRL_RESVD_EXEC, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_EXECCTRL_RESVD_EXEC, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_EXECCTRL_WRAP_TARGET); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_EXECCTRL_WRAP_TARGET, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_EXECCTRL_WRAP_TARGET, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_EXECCTRL_WRAP_TARGET, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_EXECCTRL_WRAP_TARGET, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_EXECCTRL_PEND); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_EXECCTRL_PEND, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_EXECCTRL_PEND, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_EXECCTRL_PEND, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_EXECCTRL_PEND, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_EXECCTRL_OUT_STICKY); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_EXECCTRL_OUT_STICKY, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_EXECCTRL_OUT_STICKY, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_EXECCTRL_OUT_STICKY, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_EXECCTRL_OUT_STICKY, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_EXECCTRL_INLINE_OUT_EN); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_EXECCTRL_INLINE_OUT_EN, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_EXECCTRL_INLINE_OUT_EN, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_EXECCTRL_INLINE_OUT_EN, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_EXECCTRL_INLINE_OUT_EN, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_EXECCTRL_OUT_EN_SEL); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_EXECCTRL_OUT_EN_SEL, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_EXECCTRL_OUT_EN_SEL, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_EXECCTRL_OUT_EN_SEL, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_EXECCTRL_OUT_EN_SEL, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_EXECCTRL_JMP_PIN); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_EXECCTRL_JMP_PIN, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_EXECCTRL_JMP_PIN, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_EXECCTRL_JMP_PIN, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_EXECCTRL_JMP_PIN, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_EXECCTRL_SIDE_PINDIR); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_EXECCTRL_SIDE_PINDIR, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_EXECCTRL_SIDE_PINDIR, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_EXECCTRL_SIDE_PINDIR, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_EXECCTRL_SIDE_PINDIR, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_EXECCTRL_SIDESET_ENABLE_BIT); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_EXECCTRL_SIDESET_ENABLE_BIT, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_EXECCTRL_SIDESET_ENABLE_BIT, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_EXECCTRL_SIDESET_ENABLE_BIT, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_EXECCTRL_SIDESET_ENABLE_BIT, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_EXECCTRL_EXEC_STALLED_RO2); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_EXECCTRL_EXEC_STALLED_RO2, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_EXECCTRL_EXEC_STALLED_RO2, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_EXECCTRL_EXEC_STALLED_RO2, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_EXECCTRL_EXEC_STALLED_RO2, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_SM2_SHIFTCTRL); + rp_pio_csr.wo(utra::rp_pio::SFR_SM2_SHIFTCTRL, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_SHIFTCTRL_RESVD_SHIFT); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_SHIFTCTRL_RESVD_SHIFT, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_SHIFTCTRL_RESVD_SHIFT, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_SHIFTCTRL_RESVD_SHIFT, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_SHIFTCTRL_RESVD_SHIFT, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_SHIFTCTRL_AUTO_PUSH); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_SHIFTCTRL_AUTO_PUSH, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_SHIFTCTRL_AUTO_PUSH, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_SHIFTCTRL_AUTO_PUSH, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_SHIFTCTRL_AUTO_PUSH, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_SHIFTCTRL_AUTO_PULL); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_SHIFTCTRL_AUTO_PULL, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_SHIFTCTRL_AUTO_PULL, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_SHIFTCTRL_AUTO_PULL, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_SHIFTCTRL_AUTO_PULL, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_SHIFTCTRL_IN_SHIFT_DIR); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_SHIFTCTRL_IN_SHIFT_DIR, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_SHIFTCTRL_IN_SHIFT_DIR, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_SHIFTCTRL_IN_SHIFT_DIR, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_SHIFTCTRL_IN_SHIFT_DIR, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_SHIFTCTRL_OUT_SHIFT_DIR); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_SHIFTCTRL_OUT_SHIFT_DIR, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_SHIFTCTRL_OUT_SHIFT_DIR, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_SHIFTCTRL_OUT_SHIFT_DIR, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_SHIFTCTRL_OUT_SHIFT_DIR, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_SHIFTCTRL_ISR_THRESHOLD); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_SHIFTCTRL_ISR_THRESHOLD, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_SHIFTCTRL_ISR_THRESHOLD, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_SHIFTCTRL_ISR_THRESHOLD, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_SHIFTCTRL_ISR_THRESHOLD, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_SHIFTCTRL_OSR_THRESHOLD); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_SHIFTCTRL_OSR_THRESHOLD, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_SHIFTCTRL_OSR_THRESHOLD, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_SHIFTCTRL_OSR_THRESHOLD, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_SHIFTCTRL_OSR_THRESHOLD, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_SHIFTCTRL_JOIN_TX); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_SHIFTCTRL_JOIN_TX, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_SHIFTCTRL_JOIN_TX, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_SHIFTCTRL_JOIN_TX, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_SHIFTCTRL_JOIN_TX, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_SHIFTCTRL_JOIN_RX); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_SHIFTCTRL_JOIN_RX, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_SHIFTCTRL_JOIN_RX, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_SHIFTCTRL_JOIN_RX, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_SHIFTCTRL_JOIN_RX, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_SM2_ADDR); + rp_pio_csr.wo(utra::rp_pio::SFR_SM2_ADDR, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_ADDR_PC); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_ADDR_PC, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_ADDR_PC, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_ADDR_PC, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_ADDR_PC, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_SM2_INSTR); + rp_pio_csr.wo(utra::rp_pio::SFR_SM2_INSTR, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_INSTR_IMM_INSTR); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_INSTR_IMM_INSTR, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_INSTR_IMM_INSTR, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_INSTR_IMM_INSTR, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_INSTR_IMM_INSTR, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_SM2_PINCTRL); + rp_pio_csr.wo(utra::rp_pio::SFR_SM2_PINCTRL, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_PINCTRL_PINS_OUT_BASE); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_PINCTRL_PINS_OUT_BASE, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_PINCTRL_PINS_OUT_BASE, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_PINCTRL_PINS_OUT_BASE, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_PINCTRL_PINS_OUT_BASE, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_PINCTRL_PINS_SET_BASE); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_PINCTRL_PINS_SET_BASE, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_PINCTRL_PINS_SET_BASE, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_PINCTRL_PINS_SET_BASE, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_PINCTRL_PINS_SET_BASE, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_PINCTRL_PINS_SIDE_BASE); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_PINCTRL_PINS_SIDE_BASE, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_PINCTRL_PINS_SIDE_BASE, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_PINCTRL_PINS_SIDE_BASE, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_PINCTRL_PINS_SIDE_BASE, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_PINCTRL_PINS_IN_BASE); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_PINCTRL_PINS_IN_BASE, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_PINCTRL_PINS_IN_BASE, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_PINCTRL_PINS_IN_BASE, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_PINCTRL_PINS_IN_BASE, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_PINCTRL_PINS_OUT_COUNT); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_PINCTRL_PINS_OUT_COUNT, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_PINCTRL_PINS_OUT_COUNT, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_PINCTRL_PINS_OUT_COUNT, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_PINCTRL_PINS_OUT_COUNT, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_PINCTRL_PINS_SET_COUNT); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_PINCTRL_PINS_SET_COUNT, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_PINCTRL_PINS_SET_COUNT, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_PINCTRL_PINS_SET_COUNT, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_PINCTRL_PINS_SET_COUNT, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM2_PINCTRL_PINS_SIDE_COUNT); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM2_PINCTRL_PINS_SIDE_COUNT, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM2_PINCTRL_PINS_SIDE_COUNT, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM2_PINCTRL_PINS_SIDE_COUNT, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM2_PINCTRL_PINS_SIDE_COUNT, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_SM3_CLKDIV); + rp_pio_csr.wo(utra::rp_pio::SFR_SM3_CLKDIV, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_CLKDIV_UNUSED_DIV); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_CLKDIV_UNUSED_DIV, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_CLKDIV_UNUSED_DIV, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_CLKDIV_UNUSED_DIV, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_CLKDIV_UNUSED_DIV, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_CLKDIV_DIV_FRAC); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_CLKDIV_DIV_FRAC, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_CLKDIV_DIV_FRAC, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_CLKDIV_DIV_FRAC, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_CLKDIV_DIV_FRAC, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_CLKDIV_DIV_INT); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_CLKDIV_DIV_INT, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_CLKDIV_DIV_INT, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_CLKDIV_DIV_INT, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_CLKDIV_DIV_INT, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_SM3_EXECCTRL); + rp_pio_csr.wo(utra::rp_pio::SFR_SM3_EXECCTRL, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_EXECCTRL_STATUS_N); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_EXECCTRL_STATUS_N, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_EXECCTRL_STATUS_N, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_EXECCTRL_STATUS_N, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_EXECCTRL_STATUS_N, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_EXECCTRL_STATUS_SEL); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_EXECCTRL_STATUS_SEL, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_EXECCTRL_STATUS_SEL, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_EXECCTRL_STATUS_SEL, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_EXECCTRL_STATUS_SEL, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_EXECCTRL_RESVD_EXEC); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_EXECCTRL_RESVD_EXEC, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_EXECCTRL_RESVD_EXEC, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_EXECCTRL_RESVD_EXEC, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_EXECCTRL_RESVD_EXEC, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_EXECCTRL_WRAP_TARGET); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_EXECCTRL_WRAP_TARGET, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_EXECCTRL_WRAP_TARGET, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_EXECCTRL_WRAP_TARGET, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_EXECCTRL_WRAP_TARGET, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_EXECCTRL_PEND); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_EXECCTRL_PEND, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_EXECCTRL_PEND, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_EXECCTRL_PEND, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_EXECCTRL_PEND, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_EXECCTRL_OUT_STICKY); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_EXECCTRL_OUT_STICKY, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_EXECCTRL_OUT_STICKY, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_EXECCTRL_OUT_STICKY, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_EXECCTRL_OUT_STICKY, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_EXECCTRL_INLINE_OUT_EN); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_EXECCTRL_INLINE_OUT_EN, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_EXECCTRL_INLINE_OUT_EN, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_EXECCTRL_INLINE_OUT_EN, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_EXECCTRL_INLINE_OUT_EN, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_EXECCTRL_OUT_EN_SEL); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_EXECCTRL_OUT_EN_SEL, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_EXECCTRL_OUT_EN_SEL, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_EXECCTRL_OUT_EN_SEL, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_EXECCTRL_OUT_EN_SEL, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_EXECCTRL_JMP_PIN); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_EXECCTRL_JMP_PIN, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_EXECCTRL_JMP_PIN, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_EXECCTRL_JMP_PIN, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_EXECCTRL_JMP_PIN, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_EXECCTRL_SIDE_PINDIR); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_EXECCTRL_SIDE_PINDIR, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_EXECCTRL_SIDE_PINDIR, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_EXECCTRL_SIDE_PINDIR, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_EXECCTRL_SIDE_PINDIR, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_EXECCTRL_SIDESET_ENABLE_BIT); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_EXECCTRL_SIDESET_ENABLE_BIT, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_EXECCTRL_SIDESET_ENABLE_BIT, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_EXECCTRL_SIDESET_ENABLE_BIT, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_EXECCTRL_SIDESET_ENABLE_BIT, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_EXECCTRL_EXEC_STALLED_RO3); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_EXECCTRL_EXEC_STALLED_RO3, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_EXECCTRL_EXEC_STALLED_RO3, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_EXECCTRL_EXEC_STALLED_RO3, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_EXECCTRL_EXEC_STALLED_RO3, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_SM3_SHIFTCTRL); + rp_pio_csr.wo(utra::rp_pio::SFR_SM3_SHIFTCTRL, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_SHIFTCTRL_RESVD_SHIFT); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_SHIFTCTRL_RESVD_SHIFT, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_SHIFTCTRL_RESVD_SHIFT, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_SHIFTCTRL_RESVD_SHIFT, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_SHIFTCTRL_RESVD_SHIFT, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_SHIFTCTRL_AUTO_PUSH); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_SHIFTCTRL_AUTO_PUSH, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_SHIFTCTRL_AUTO_PUSH, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_SHIFTCTRL_AUTO_PUSH, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_SHIFTCTRL_AUTO_PUSH, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_SHIFTCTRL_AUTO_PULL); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_SHIFTCTRL_AUTO_PULL, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_SHIFTCTRL_AUTO_PULL, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_SHIFTCTRL_AUTO_PULL, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_SHIFTCTRL_AUTO_PULL, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_SHIFTCTRL_IN_SHIFT_DIR); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_SHIFTCTRL_IN_SHIFT_DIR, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_SHIFTCTRL_IN_SHIFT_DIR, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_SHIFTCTRL_IN_SHIFT_DIR, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_SHIFTCTRL_IN_SHIFT_DIR, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_SHIFTCTRL_OUT_SHIFT_DIR); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_SHIFTCTRL_OUT_SHIFT_DIR, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_SHIFTCTRL_OUT_SHIFT_DIR, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_SHIFTCTRL_OUT_SHIFT_DIR, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_SHIFTCTRL_OUT_SHIFT_DIR, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_SHIFTCTRL_ISR_THRESHOLD); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_SHIFTCTRL_ISR_THRESHOLD, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_SHIFTCTRL_ISR_THRESHOLD, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_SHIFTCTRL_ISR_THRESHOLD, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_SHIFTCTRL_ISR_THRESHOLD, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_SHIFTCTRL_OSR_THRESHOLD); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_SHIFTCTRL_OSR_THRESHOLD, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_SHIFTCTRL_OSR_THRESHOLD, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_SHIFTCTRL_OSR_THRESHOLD, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_SHIFTCTRL_OSR_THRESHOLD, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_SHIFTCTRL_JOIN_TX); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_SHIFTCTRL_JOIN_TX, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_SHIFTCTRL_JOIN_TX, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_SHIFTCTRL_JOIN_TX, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_SHIFTCTRL_JOIN_TX, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_SHIFTCTRL_JOIN_RX); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_SHIFTCTRL_JOIN_RX, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_SHIFTCTRL_JOIN_RX, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_SHIFTCTRL_JOIN_RX, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_SHIFTCTRL_JOIN_RX, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_SM3_ADDR); + rp_pio_csr.wo(utra::rp_pio::SFR_SM3_ADDR, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_ADDR_PC); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_ADDR_PC, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_ADDR_PC, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_ADDR_PC, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_ADDR_PC, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_SM3_INSTR); + rp_pio_csr.wo(utra::rp_pio::SFR_SM3_INSTR, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_INSTR_IMM_INSTR); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_INSTR_IMM_INSTR, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_INSTR_IMM_INSTR, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_INSTR_IMM_INSTR, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_INSTR_IMM_INSTR, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_SM3_PINCTRL); + rp_pio_csr.wo(utra::rp_pio::SFR_SM3_PINCTRL, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_PINCTRL_PINS_OUT_BASE); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_PINCTRL_PINS_OUT_BASE, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_PINCTRL_PINS_OUT_BASE, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_PINCTRL_PINS_OUT_BASE, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_PINCTRL_PINS_OUT_BASE, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_PINCTRL_PINS_SET_BASE); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_PINCTRL_PINS_SET_BASE, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_PINCTRL_PINS_SET_BASE, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_PINCTRL_PINS_SET_BASE, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_PINCTRL_PINS_SET_BASE, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_PINCTRL_PINS_SIDE_BASE); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_PINCTRL_PINS_SIDE_BASE, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_PINCTRL_PINS_SIDE_BASE, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_PINCTRL_PINS_SIDE_BASE, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_PINCTRL_PINS_SIDE_BASE, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_PINCTRL_PINS_IN_BASE); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_PINCTRL_PINS_IN_BASE, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_PINCTRL_PINS_IN_BASE, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_PINCTRL_PINS_IN_BASE, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_PINCTRL_PINS_IN_BASE, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_PINCTRL_PINS_OUT_COUNT); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_PINCTRL_PINS_OUT_COUNT, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_PINCTRL_PINS_OUT_COUNT, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_PINCTRL_PINS_OUT_COUNT, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_PINCTRL_PINS_OUT_COUNT, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_PINCTRL_PINS_SET_COUNT); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_PINCTRL_PINS_SET_COUNT, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_PINCTRL_PINS_SET_COUNT, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_PINCTRL_PINS_SET_COUNT, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_PINCTRL_PINS_SET_COUNT, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_SM3_PINCTRL_PINS_SIDE_COUNT); + rp_pio_csr.rmwf(utra::rp_pio::SFR_SM3_PINCTRL_PINS_SIDE_COUNT, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_SM3_PINCTRL_PINS_SIDE_COUNT, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_SM3_PINCTRL_PINS_SIDE_COUNT, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_SM3_PINCTRL_PINS_SIDE_COUNT, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_INTR); + rp_pio_csr.wo(utra::rp_pio::SFR_INTR, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INTR_INTR_RXNEMPTY); + rp_pio_csr.rmwf(utra::rp_pio::SFR_INTR_INTR_RXNEMPTY, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INTR_INTR_RXNEMPTY, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INTR_INTR_RXNEMPTY, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_INTR_INTR_RXNEMPTY, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INTR_INTR_TXNFULL); + rp_pio_csr.rmwf(utra::rp_pio::SFR_INTR_INTR_TXNFULL, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INTR_INTR_TXNFULL, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INTR_INTR_TXNFULL, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_INTR_INTR_TXNFULL, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_INTR_INTR_SM); + rp_pio_csr.rmwf(utra::rp_pio::SFR_INTR_INTR_SM, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_INTR_INTR_SM, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_INTR_INTR_SM, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_INTR_INTR_SM, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_IRQ0_INTE); + rp_pio_csr.wo(utra::rp_pio::SFR_IRQ0_INTE, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_IRQ0_INTE_IRQ0_INTE_RXNEMPTY); + rp_pio_csr.rmwf(utra::rp_pio::SFR_IRQ0_INTE_IRQ0_INTE_RXNEMPTY, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_IRQ0_INTE_IRQ0_INTE_RXNEMPTY, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_IRQ0_INTE_IRQ0_INTE_RXNEMPTY, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_IRQ0_INTE_IRQ0_INTE_RXNEMPTY, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_IRQ0_INTE_IRQ0_INTE_TXNFULL); + rp_pio_csr.rmwf(utra::rp_pio::SFR_IRQ0_INTE_IRQ0_INTE_TXNFULL, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_IRQ0_INTE_IRQ0_INTE_TXNFULL, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_IRQ0_INTE_IRQ0_INTE_TXNFULL, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_IRQ0_INTE_IRQ0_INTE_TXNFULL, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_IRQ0_INTE_IRQ0_INTE_SM); + rp_pio_csr.rmwf(utra::rp_pio::SFR_IRQ0_INTE_IRQ0_INTE_SM, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_IRQ0_INTE_IRQ0_INTE_SM, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_IRQ0_INTE_IRQ0_INTE_SM, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_IRQ0_INTE_IRQ0_INTE_SM, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_IRQ0_INTF); + rp_pio_csr.wo(utra::rp_pio::SFR_IRQ0_INTF, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_IRQ0_INTF_IRQ0_INTF_RXNEMPTY); + rp_pio_csr.rmwf(utra::rp_pio::SFR_IRQ0_INTF_IRQ0_INTF_RXNEMPTY, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_IRQ0_INTF_IRQ0_INTF_RXNEMPTY, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_IRQ0_INTF_IRQ0_INTF_RXNEMPTY, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_IRQ0_INTF_IRQ0_INTF_RXNEMPTY, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_IRQ0_INTF_IRQ0_INTF_TXNFULL); + rp_pio_csr.rmwf(utra::rp_pio::SFR_IRQ0_INTF_IRQ0_INTF_TXNFULL, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_IRQ0_INTF_IRQ0_INTF_TXNFULL, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_IRQ0_INTF_IRQ0_INTF_TXNFULL, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_IRQ0_INTF_IRQ0_INTF_TXNFULL, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_IRQ0_INTF_IRQ0_INTF_SM); + rp_pio_csr.rmwf(utra::rp_pio::SFR_IRQ0_INTF_IRQ0_INTF_SM, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_IRQ0_INTF_IRQ0_INTF_SM, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_IRQ0_INTF_IRQ0_INTF_SM, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_IRQ0_INTF_IRQ0_INTF_SM, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_IRQ0_INTS); + rp_pio_csr.wo(utra::rp_pio::SFR_IRQ0_INTS, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_IRQ0_INTS_IRQ0_INTS_RXNEMPTY); + rp_pio_csr.rmwf(utra::rp_pio::SFR_IRQ0_INTS_IRQ0_INTS_RXNEMPTY, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_IRQ0_INTS_IRQ0_INTS_RXNEMPTY, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_IRQ0_INTS_IRQ0_INTS_RXNEMPTY, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_IRQ0_INTS_IRQ0_INTS_RXNEMPTY, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_IRQ0_INTS_IRQ0_INTS_TXNFULL); + rp_pio_csr.rmwf(utra::rp_pio::SFR_IRQ0_INTS_IRQ0_INTS_TXNFULL, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_IRQ0_INTS_IRQ0_INTS_TXNFULL, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_IRQ0_INTS_IRQ0_INTS_TXNFULL, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_IRQ0_INTS_IRQ0_INTS_TXNFULL, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_IRQ0_INTS_IRQ0_INTS_SM); + rp_pio_csr.rmwf(utra::rp_pio::SFR_IRQ0_INTS_IRQ0_INTS_SM, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_IRQ0_INTS_IRQ0_INTS_SM, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_IRQ0_INTS_IRQ0_INTS_SM, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_IRQ0_INTS_IRQ0_INTS_SM, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_IRQ1_INTE); + rp_pio_csr.wo(utra::rp_pio::SFR_IRQ1_INTE, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_IRQ1_INTE_IRQ1_INTE_RXNEMPTY); + rp_pio_csr.rmwf(utra::rp_pio::SFR_IRQ1_INTE_IRQ1_INTE_RXNEMPTY, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_IRQ1_INTE_IRQ1_INTE_RXNEMPTY, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_IRQ1_INTE_IRQ1_INTE_RXNEMPTY, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_IRQ1_INTE_IRQ1_INTE_RXNEMPTY, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_IRQ1_INTE_IRQ1_INTE_TXNFULL); + rp_pio_csr.rmwf(utra::rp_pio::SFR_IRQ1_INTE_IRQ1_INTE_TXNFULL, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_IRQ1_INTE_IRQ1_INTE_TXNFULL, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_IRQ1_INTE_IRQ1_INTE_TXNFULL, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_IRQ1_INTE_IRQ1_INTE_TXNFULL, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_IRQ1_INTE_IRQ1_INTE_SM); + rp_pio_csr.rmwf(utra::rp_pio::SFR_IRQ1_INTE_IRQ1_INTE_SM, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_IRQ1_INTE_IRQ1_INTE_SM, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_IRQ1_INTE_IRQ1_INTE_SM, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_IRQ1_INTE_IRQ1_INTE_SM, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_IRQ1_INTF); + rp_pio_csr.wo(utra::rp_pio::SFR_IRQ1_INTF, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_IRQ1_INTF_IRQ1_INTF_RXNEMPTY); + rp_pio_csr.rmwf(utra::rp_pio::SFR_IRQ1_INTF_IRQ1_INTF_RXNEMPTY, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_IRQ1_INTF_IRQ1_INTF_RXNEMPTY, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_IRQ1_INTF_IRQ1_INTF_RXNEMPTY, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_IRQ1_INTF_IRQ1_INTF_RXNEMPTY, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_IRQ1_INTF_IRQ1_INTF_TXNFULL); + rp_pio_csr.rmwf(utra::rp_pio::SFR_IRQ1_INTF_IRQ1_INTF_TXNFULL, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_IRQ1_INTF_IRQ1_INTF_TXNFULL, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_IRQ1_INTF_IRQ1_INTF_TXNFULL, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_IRQ1_INTF_IRQ1_INTF_TXNFULL, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_IRQ1_INTF_IRQ1_INTF_SM); + rp_pio_csr.rmwf(utra::rp_pio::SFR_IRQ1_INTF_IRQ1_INTF_SM, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_IRQ1_INTF_IRQ1_INTF_SM, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_IRQ1_INTF_IRQ1_INTF_SM, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_IRQ1_INTF_IRQ1_INTF_SM, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_IRQ1_INTS); + rp_pio_csr.wo(utra::rp_pio::SFR_IRQ1_INTS, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_IRQ1_INTS_IRQ1_INTS_RXNEMPTY); + rp_pio_csr.rmwf(utra::rp_pio::SFR_IRQ1_INTS_IRQ1_INTS_RXNEMPTY, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_IRQ1_INTS_IRQ1_INTS_RXNEMPTY, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_IRQ1_INTS_IRQ1_INTS_RXNEMPTY, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_IRQ1_INTS_IRQ1_INTS_RXNEMPTY, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_IRQ1_INTS_IRQ1_INTS_TXNFULL); + rp_pio_csr.rmwf(utra::rp_pio::SFR_IRQ1_INTS_IRQ1_INTS_TXNFULL, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_IRQ1_INTS_IRQ1_INTS_TXNFULL, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_IRQ1_INTS_IRQ1_INTS_TXNFULL, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_IRQ1_INTS_IRQ1_INTS_TXNFULL, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_IRQ1_INTS_IRQ1_INTS_SM); + rp_pio_csr.rmwf(utra::rp_pio::SFR_IRQ1_INTS_IRQ1_INTS_SM, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_IRQ1_INTS_IRQ1_INTS_SM, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_IRQ1_INTS_IRQ1_INTS_SM, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_IRQ1_INTS_IRQ1_INTS_SM, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_IO_OE_INV); + rp_pio_csr.wo(utra::rp_pio::SFR_IO_OE_INV, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_IO_OE_INV_SFR_IO_OE_INV); + rp_pio_csr.rmwf(utra::rp_pio::SFR_IO_OE_INV_SFR_IO_OE_INV, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_IO_OE_INV_SFR_IO_OE_INV, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_IO_OE_INV_SFR_IO_OE_INV, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_IO_OE_INV_SFR_IO_OE_INV, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_IO_O_INV); + rp_pio_csr.wo(utra::rp_pio::SFR_IO_O_INV, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_IO_O_INV_SFR_IO_O_INV); + rp_pio_csr.rmwf(utra::rp_pio::SFR_IO_O_INV_SFR_IO_O_INV, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_IO_O_INV_SFR_IO_O_INV, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_IO_O_INV_SFR_IO_O_INV, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_IO_O_INV_SFR_IO_O_INV, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_IO_I_INV); + rp_pio_csr.wo(utra::rp_pio::SFR_IO_I_INV, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_IO_I_INV_SFR_IO_I_INV); + rp_pio_csr.rmwf(utra::rp_pio::SFR_IO_I_INV_SFR_IO_I_INV, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_IO_I_INV_SFR_IO_I_INV, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_IO_I_INV_SFR_IO_I_INV, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_IO_I_INV_SFR_IO_I_INV, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_FIFO_MARGIN); + rp_pio_csr.wo(utra::rp_pio::SFR_FIFO_MARGIN, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_TX_MARGIN0); + rp_pio_csr.rmwf(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_TX_MARGIN0, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_TX_MARGIN0, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_TX_MARGIN0, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_TX_MARGIN0, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_RX_MARGIN0); + rp_pio_csr.rmwf(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_RX_MARGIN0, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_RX_MARGIN0, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_RX_MARGIN0, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_RX_MARGIN0, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_TX_MARGIN1); + rp_pio_csr.rmwf(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_TX_MARGIN1, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_TX_MARGIN1, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_TX_MARGIN1, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_TX_MARGIN1, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_RX_MARGIN1); + rp_pio_csr.rmwf(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_RX_MARGIN1, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_RX_MARGIN1, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_RX_MARGIN1, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_RX_MARGIN1, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_TX_MARGIN2); + rp_pio_csr.rmwf(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_TX_MARGIN2, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_TX_MARGIN2, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_TX_MARGIN2, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_TX_MARGIN2, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_RX_MARGIN2); + rp_pio_csr.rmwf(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_RX_MARGIN2, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_RX_MARGIN2, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_RX_MARGIN2, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_RX_MARGIN2, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_TX_MARGIN3); + rp_pio_csr.rmwf(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_TX_MARGIN3, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_TX_MARGIN3, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_TX_MARGIN3, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_TX_MARGIN3, baz); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_RX_MARGIN3); + rp_pio_csr.rmwf(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_RX_MARGIN3, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_RX_MARGIN3, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_RX_MARGIN3, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_FIFO_MARGIN_FIFO_RX_MARGIN3, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_ZERO0); + rp_pio_csr.wo(utra::rp_pio::SFR_ZERO0, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_ZERO0_SFR_ZERO0); + rp_pio_csr.rmwf(utra::rp_pio::SFR_ZERO0_SFR_ZERO0, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_ZERO0_SFR_ZERO0, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_ZERO0_SFR_ZERO0, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_ZERO0_SFR_ZERO0, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_ZERO1); + rp_pio_csr.wo(utra::rp_pio::SFR_ZERO1, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_ZERO1_SFR_ZERO1); + rp_pio_csr.rmwf(utra::rp_pio::SFR_ZERO1_SFR_ZERO1, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_ZERO1_SFR_ZERO1, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_ZERO1_SFR_ZERO1, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_ZERO1_SFR_ZERO1, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_ZERO2); + rp_pio_csr.wo(utra::rp_pio::SFR_ZERO2, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_ZERO2_SFR_ZERO2); + rp_pio_csr.rmwf(utra::rp_pio::SFR_ZERO2_SFR_ZERO2, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_ZERO2_SFR_ZERO2, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_ZERO2_SFR_ZERO2, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_ZERO2_SFR_ZERO2, baz); + + let foo = rp_pio_csr.r(utra::rp_pio::SFR_ZERO3); + rp_pio_csr.wo(utra::rp_pio::SFR_ZERO3, foo); + let bar = rp_pio_csr.rf(utra::rp_pio::SFR_ZERO3_SFR_ZERO3); + rp_pio_csr.rmwf(utra::rp_pio::SFR_ZERO3_SFR_ZERO3, bar); + let mut baz = rp_pio_csr.zf(utra::rp_pio::SFR_ZERO3_SFR_ZERO3, bar); + baz |= rp_pio_csr.ms(utra::rp_pio::SFR_ZERO3_SFR_ZERO3, 1); + rp_pio_csr.wfo(utra::rp_pio::SFR_ZERO3_SFR_ZERO3, baz); + } + + #[test] + #[ignore] + fn compile_check_mdma_csr() { + use super::*; + let mut mdma_csr = CSR::new(HW_MDMA_BASE as *mut u32); + + let foo = mdma_csr.r(utra::mdma::SFR_EVSEL_CR_EVSEL0); + mdma_csr.wo(utra::mdma::SFR_EVSEL_CR_EVSEL0, foo); + let bar = mdma_csr.rf(utra::mdma::SFR_EVSEL_CR_EVSEL0_CR_EVSEL0); + mdma_csr.rmwf(utra::mdma::SFR_EVSEL_CR_EVSEL0_CR_EVSEL0, bar); + let mut baz = mdma_csr.zf(utra::mdma::SFR_EVSEL_CR_EVSEL0_CR_EVSEL0, bar); + baz |= mdma_csr.ms(utra::mdma::SFR_EVSEL_CR_EVSEL0_CR_EVSEL0, 1); + mdma_csr.wfo(utra::mdma::SFR_EVSEL_CR_EVSEL0_CR_EVSEL0, baz); + + let foo = mdma_csr.r(utra::mdma::SFR_EVSEL_CR_EVSEL1); + mdma_csr.wo(utra::mdma::SFR_EVSEL_CR_EVSEL1, foo); + let bar = mdma_csr.rf(utra::mdma::SFR_EVSEL_CR_EVSEL1_CR_EVSEL1); + mdma_csr.rmwf(utra::mdma::SFR_EVSEL_CR_EVSEL1_CR_EVSEL1, bar); + let mut baz = mdma_csr.zf(utra::mdma::SFR_EVSEL_CR_EVSEL1_CR_EVSEL1, bar); + baz |= mdma_csr.ms(utra::mdma::SFR_EVSEL_CR_EVSEL1_CR_EVSEL1, 1); + mdma_csr.wfo(utra::mdma::SFR_EVSEL_CR_EVSEL1_CR_EVSEL1, baz); + + let foo = mdma_csr.r(utra::mdma::SFR_EVSEL_CR_EVSEL2); + mdma_csr.wo(utra::mdma::SFR_EVSEL_CR_EVSEL2, foo); + let bar = mdma_csr.rf(utra::mdma::SFR_EVSEL_CR_EVSEL2_CR_EVSEL2); + mdma_csr.rmwf(utra::mdma::SFR_EVSEL_CR_EVSEL2_CR_EVSEL2, bar); + let mut baz = mdma_csr.zf(utra::mdma::SFR_EVSEL_CR_EVSEL2_CR_EVSEL2, bar); + baz |= mdma_csr.ms(utra::mdma::SFR_EVSEL_CR_EVSEL2_CR_EVSEL2, 1); + mdma_csr.wfo(utra::mdma::SFR_EVSEL_CR_EVSEL2_CR_EVSEL2, baz); + + let foo = mdma_csr.r(utra::mdma::SFR_EVSEL_CR_EVSEL3); + mdma_csr.wo(utra::mdma::SFR_EVSEL_CR_EVSEL3, foo); + let bar = mdma_csr.rf(utra::mdma::SFR_EVSEL_CR_EVSEL3_CR_EVSEL3); + mdma_csr.rmwf(utra::mdma::SFR_EVSEL_CR_EVSEL3_CR_EVSEL3, bar); + let mut baz = mdma_csr.zf(utra::mdma::SFR_EVSEL_CR_EVSEL3_CR_EVSEL3, bar); + baz |= mdma_csr.ms(utra::mdma::SFR_EVSEL_CR_EVSEL3_CR_EVSEL3, 1); + mdma_csr.wfo(utra::mdma::SFR_EVSEL_CR_EVSEL3_CR_EVSEL3, baz); + + let foo = mdma_csr.r(utra::mdma::SFR_EVSEL_CR_EVSEL4); + mdma_csr.wo(utra::mdma::SFR_EVSEL_CR_EVSEL4, foo); + let bar = mdma_csr.rf(utra::mdma::SFR_EVSEL_CR_EVSEL4_CR_EVSEL4); + mdma_csr.rmwf(utra::mdma::SFR_EVSEL_CR_EVSEL4_CR_EVSEL4, bar); + let mut baz = mdma_csr.zf(utra::mdma::SFR_EVSEL_CR_EVSEL4_CR_EVSEL4, bar); + baz |= mdma_csr.ms(utra::mdma::SFR_EVSEL_CR_EVSEL4_CR_EVSEL4, 1); + mdma_csr.wfo(utra::mdma::SFR_EVSEL_CR_EVSEL4_CR_EVSEL4, baz); + + let foo = mdma_csr.r(utra::mdma::SFR_EVSEL_CR_EVSEL5); + mdma_csr.wo(utra::mdma::SFR_EVSEL_CR_EVSEL5, foo); + let bar = mdma_csr.rf(utra::mdma::SFR_EVSEL_CR_EVSEL5_CR_EVSEL5); + mdma_csr.rmwf(utra::mdma::SFR_EVSEL_CR_EVSEL5_CR_EVSEL5, bar); + let mut baz = mdma_csr.zf(utra::mdma::SFR_EVSEL_CR_EVSEL5_CR_EVSEL5, bar); + baz |= mdma_csr.ms(utra::mdma::SFR_EVSEL_CR_EVSEL5_CR_EVSEL5, 1); + mdma_csr.wfo(utra::mdma::SFR_EVSEL_CR_EVSEL5_CR_EVSEL5, baz); + + let foo = mdma_csr.r(utra::mdma::SFR_EVSEL_CR_EVSEL6); + mdma_csr.wo(utra::mdma::SFR_EVSEL_CR_EVSEL6, foo); + let bar = mdma_csr.rf(utra::mdma::SFR_EVSEL_CR_EVSEL6_CR_EVSEL6); + mdma_csr.rmwf(utra::mdma::SFR_EVSEL_CR_EVSEL6_CR_EVSEL6, bar); + let mut baz = mdma_csr.zf(utra::mdma::SFR_EVSEL_CR_EVSEL6_CR_EVSEL6, bar); + baz |= mdma_csr.ms(utra::mdma::SFR_EVSEL_CR_EVSEL6_CR_EVSEL6, 1); + mdma_csr.wfo(utra::mdma::SFR_EVSEL_CR_EVSEL6_CR_EVSEL6, baz); + + let foo = mdma_csr.r(utra::mdma::SFR_EVSEL_CR_EVSEL7); + mdma_csr.wo(utra::mdma::SFR_EVSEL_CR_EVSEL7, foo); + let bar = mdma_csr.rf(utra::mdma::SFR_EVSEL_CR_EVSEL7_CR_EVSEL7); + mdma_csr.rmwf(utra::mdma::SFR_EVSEL_CR_EVSEL7_CR_EVSEL7, bar); + let mut baz = mdma_csr.zf(utra::mdma::SFR_EVSEL_CR_EVSEL7_CR_EVSEL7, bar); + baz |= mdma_csr.ms(utra::mdma::SFR_EVSEL_CR_EVSEL7_CR_EVSEL7, 1); + mdma_csr.wfo(utra::mdma::SFR_EVSEL_CR_EVSEL7_CR_EVSEL7, baz); + + let foo = mdma_csr.r(utra::mdma::SFR_CR_CR_MDMAREQ0); + mdma_csr.wo(utra::mdma::SFR_CR_CR_MDMAREQ0, foo); + let bar = mdma_csr.rf(utra::mdma::SFR_CR_CR_MDMAREQ0_CR_MDMAREQ0); + mdma_csr.rmwf(utra::mdma::SFR_CR_CR_MDMAREQ0_CR_MDMAREQ0, bar); + let mut baz = mdma_csr.zf(utra::mdma::SFR_CR_CR_MDMAREQ0_CR_MDMAREQ0, bar); + baz |= mdma_csr.ms(utra::mdma::SFR_CR_CR_MDMAREQ0_CR_MDMAREQ0, 1); + mdma_csr.wfo(utra::mdma::SFR_CR_CR_MDMAREQ0_CR_MDMAREQ0, baz); + + let foo = mdma_csr.r(utra::mdma::SFR_CR_CR_MDMAREQ1); + mdma_csr.wo(utra::mdma::SFR_CR_CR_MDMAREQ1, foo); + let bar = mdma_csr.rf(utra::mdma::SFR_CR_CR_MDMAREQ1_CR_MDMAREQ1); + mdma_csr.rmwf(utra::mdma::SFR_CR_CR_MDMAREQ1_CR_MDMAREQ1, bar); + let mut baz = mdma_csr.zf(utra::mdma::SFR_CR_CR_MDMAREQ1_CR_MDMAREQ1, bar); + baz |= mdma_csr.ms(utra::mdma::SFR_CR_CR_MDMAREQ1_CR_MDMAREQ1, 1); + mdma_csr.wfo(utra::mdma::SFR_CR_CR_MDMAREQ1_CR_MDMAREQ1, baz); + + let foo = mdma_csr.r(utra::mdma::SFR_CR_CR_MDMAREQ2); + mdma_csr.wo(utra::mdma::SFR_CR_CR_MDMAREQ2, foo); + let bar = mdma_csr.rf(utra::mdma::SFR_CR_CR_MDMAREQ2_CR_MDMAREQ2); + mdma_csr.rmwf(utra::mdma::SFR_CR_CR_MDMAREQ2_CR_MDMAREQ2, bar); + let mut baz = mdma_csr.zf(utra::mdma::SFR_CR_CR_MDMAREQ2_CR_MDMAREQ2, bar); + baz |= mdma_csr.ms(utra::mdma::SFR_CR_CR_MDMAREQ2_CR_MDMAREQ2, 1); + mdma_csr.wfo(utra::mdma::SFR_CR_CR_MDMAREQ2_CR_MDMAREQ2, baz); + + let foo = mdma_csr.r(utra::mdma::SFR_CR_CR_MDMAREQ3); + mdma_csr.wo(utra::mdma::SFR_CR_CR_MDMAREQ3, foo); + let bar = mdma_csr.rf(utra::mdma::SFR_CR_CR_MDMAREQ3_CR_MDMAREQ3); + mdma_csr.rmwf(utra::mdma::SFR_CR_CR_MDMAREQ3_CR_MDMAREQ3, bar); + let mut baz = mdma_csr.zf(utra::mdma::SFR_CR_CR_MDMAREQ3_CR_MDMAREQ3, bar); + baz |= mdma_csr.ms(utra::mdma::SFR_CR_CR_MDMAREQ3_CR_MDMAREQ3, 1); + mdma_csr.wfo(utra::mdma::SFR_CR_CR_MDMAREQ3_CR_MDMAREQ3, baz); + + let foo = mdma_csr.r(utra::mdma::SFR_CR_CR_MDMAREQ4); + mdma_csr.wo(utra::mdma::SFR_CR_CR_MDMAREQ4, foo); + let bar = mdma_csr.rf(utra::mdma::SFR_CR_CR_MDMAREQ4_CR_MDMAREQ4); + mdma_csr.rmwf(utra::mdma::SFR_CR_CR_MDMAREQ4_CR_MDMAREQ4, bar); + let mut baz = mdma_csr.zf(utra::mdma::SFR_CR_CR_MDMAREQ4_CR_MDMAREQ4, bar); + baz |= mdma_csr.ms(utra::mdma::SFR_CR_CR_MDMAREQ4_CR_MDMAREQ4, 1); + mdma_csr.wfo(utra::mdma::SFR_CR_CR_MDMAREQ4_CR_MDMAREQ4, baz); + + let foo = mdma_csr.r(utra::mdma::SFR_CR_CR_MDMAREQ5); + mdma_csr.wo(utra::mdma::SFR_CR_CR_MDMAREQ5, foo); + let bar = mdma_csr.rf(utra::mdma::SFR_CR_CR_MDMAREQ5_CR_MDMAREQ5); + mdma_csr.rmwf(utra::mdma::SFR_CR_CR_MDMAREQ5_CR_MDMAREQ5, bar); + let mut baz = mdma_csr.zf(utra::mdma::SFR_CR_CR_MDMAREQ5_CR_MDMAREQ5, bar); + baz |= mdma_csr.ms(utra::mdma::SFR_CR_CR_MDMAREQ5_CR_MDMAREQ5, 1); + mdma_csr.wfo(utra::mdma::SFR_CR_CR_MDMAREQ5_CR_MDMAREQ5, baz); + + let foo = mdma_csr.r(utra::mdma::SFR_CR_CR_MDMAREQ6); + mdma_csr.wo(utra::mdma::SFR_CR_CR_MDMAREQ6, foo); + let bar = mdma_csr.rf(utra::mdma::SFR_CR_CR_MDMAREQ6_CR_MDMAREQ6); + mdma_csr.rmwf(utra::mdma::SFR_CR_CR_MDMAREQ6_CR_MDMAREQ6, bar); + let mut baz = mdma_csr.zf(utra::mdma::SFR_CR_CR_MDMAREQ6_CR_MDMAREQ6, bar); + baz |= mdma_csr.ms(utra::mdma::SFR_CR_CR_MDMAREQ6_CR_MDMAREQ6, 1); + mdma_csr.wfo(utra::mdma::SFR_CR_CR_MDMAREQ6_CR_MDMAREQ6, baz); + + let foo = mdma_csr.r(utra::mdma::SFR_CR_CR_MDMAREQ7); + mdma_csr.wo(utra::mdma::SFR_CR_CR_MDMAREQ7, foo); + let bar = mdma_csr.rf(utra::mdma::SFR_CR_CR_MDMAREQ7_CR_MDMAREQ7); + mdma_csr.rmwf(utra::mdma::SFR_CR_CR_MDMAREQ7_CR_MDMAREQ7, bar); + let mut baz = mdma_csr.zf(utra::mdma::SFR_CR_CR_MDMAREQ7_CR_MDMAREQ7, bar); + baz |= mdma_csr.ms(utra::mdma::SFR_CR_CR_MDMAREQ7_CR_MDMAREQ7, 1); + mdma_csr.wfo(utra::mdma::SFR_CR_CR_MDMAREQ7_CR_MDMAREQ7, baz); + + let foo = mdma_csr.r(utra::mdma::SFR_SR_SR_MDMAREQ0); + mdma_csr.wo(utra::mdma::SFR_SR_SR_MDMAREQ0, foo); + let bar = mdma_csr.rf(utra::mdma::SFR_SR_SR_MDMAREQ0_SR_MDMAREQ0); + mdma_csr.rmwf(utra::mdma::SFR_SR_SR_MDMAREQ0_SR_MDMAREQ0, bar); + let mut baz = mdma_csr.zf(utra::mdma::SFR_SR_SR_MDMAREQ0_SR_MDMAREQ0, bar); + baz |= mdma_csr.ms(utra::mdma::SFR_SR_SR_MDMAREQ0_SR_MDMAREQ0, 1); + mdma_csr.wfo(utra::mdma::SFR_SR_SR_MDMAREQ0_SR_MDMAREQ0, baz); + + let foo = mdma_csr.r(utra::mdma::SFR_SR_SR_MDMAREQ1); + mdma_csr.wo(utra::mdma::SFR_SR_SR_MDMAREQ1, foo); + let bar = mdma_csr.rf(utra::mdma::SFR_SR_SR_MDMAREQ1_SR_MDMAREQ1); + mdma_csr.rmwf(utra::mdma::SFR_SR_SR_MDMAREQ1_SR_MDMAREQ1, bar); + let mut baz = mdma_csr.zf(utra::mdma::SFR_SR_SR_MDMAREQ1_SR_MDMAREQ1, bar); + baz |= mdma_csr.ms(utra::mdma::SFR_SR_SR_MDMAREQ1_SR_MDMAREQ1, 1); + mdma_csr.wfo(utra::mdma::SFR_SR_SR_MDMAREQ1_SR_MDMAREQ1, baz); + + let foo = mdma_csr.r(utra::mdma::SFR_SR_SR_MDMAREQ2); + mdma_csr.wo(utra::mdma::SFR_SR_SR_MDMAREQ2, foo); + let bar = mdma_csr.rf(utra::mdma::SFR_SR_SR_MDMAREQ2_SR_MDMAREQ2); + mdma_csr.rmwf(utra::mdma::SFR_SR_SR_MDMAREQ2_SR_MDMAREQ2, bar); + let mut baz = mdma_csr.zf(utra::mdma::SFR_SR_SR_MDMAREQ2_SR_MDMAREQ2, bar); + baz |= mdma_csr.ms(utra::mdma::SFR_SR_SR_MDMAREQ2_SR_MDMAREQ2, 1); + mdma_csr.wfo(utra::mdma::SFR_SR_SR_MDMAREQ2_SR_MDMAREQ2, baz); + + let foo = mdma_csr.r(utra::mdma::SFR_SR_SR_MDMAREQ3); + mdma_csr.wo(utra::mdma::SFR_SR_SR_MDMAREQ3, foo); + let bar = mdma_csr.rf(utra::mdma::SFR_SR_SR_MDMAREQ3_SR_MDMAREQ3); + mdma_csr.rmwf(utra::mdma::SFR_SR_SR_MDMAREQ3_SR_MDMAREQ3, bar); + let mut baz = mdma_csr.zf(utra::mdma::SFR_SR_SR_MDMAREQ3_SR_MDMAREQ3, bar); + baz |= mdma_csr.ms(utra::mdma::SFR_SR_SR_MDMAREQ3_SR_MDMAREQ3, 1); + mdma_csr.wfo(utra::mdma::SFR_SR_SR_MDMAREQ3_SR_MDMAREQ3, baz); + + let foo = mdma_csr.r(utra::mdma::SFR_SR_SR_MDMAREQ4); + mdma_csr.wo(utra::mdma::SFR_SR_SR_MDMAREQ4, foo); + let bar = mdma_csr.rf(utra::mdma::SFR_SR_SR_MDMAREQ4_SR_MDMAREQ4); + mdma_csr.rmwf(utra::mdma::SFR_SR_SR_MDMAREQ4_SR_MDMAREQ4, bar); + let mut baz = mdma_csr.zf(utra::mdma::SFR_SR_SR_MDMAREQ4_SR_MDMAREQ4, bar); + baz |= mdma_csr.ms(utra::mdma::SFR_SR_SR_MDMAREQ4_SR_MDMAREQ4, 1); + mdma_csr.wfo(utra::mdma::SFR_SR_SR_MDMAREQ4_SR_MDMAREQ4, baz); + + let foo = mdma_csr.r(utra::mdma::SFR_SR_SR_MDMAREQ5); + mdma_csr.wo(utra::mdma::SFR_SR_SR_MDMAREQ5, foo); + let bar = mdma_csr.rf(utra::mdma::SFR_SR_SR_MDMAREQ5_SR_MDMAREQ5); + mdma_csr.rmwf(utra::mdma::SFR_SR_SR_MDMAREQ5_SR_MDMAREQ5, bar); + let mut baz = mdma_csr.zf(utra::mdma::SFR_SR_SR_MDMAREQ5_SR_MDMAREQ5, bar); + baz |= mdma_csr.ms(utra::mdma::SFR_SR_SR_MDMAREQ5_SR_MDMAREQ5, 1); + mdma_csr.wfo(utra::mdma::SFR_SR_SR_MDMAREQ5_SR_MDMAREQ5, baz); + + let foo = mdma_csr.r(utra::mdma::SFR_SR_SR_MDMAREQ6); + mdma_csr.wo(utra::mdma::SFR_SR_SR_MDMAREQ6, foo); + let bar = mdma_csr.rf(utra::mdma::SFR_SR_SR_MDMAREQ6_SR_MDMAREQ6); + mdma_csr.rmwf(utra::mdma::SFR_SR_SR_MDMAREQ6_SR_MDMAREQ6, bar); + let mut baz = mdma_csr.zf(utra::mdma::SFR_SR_SR_MDMAREQ6_SR_MDMAREQ6, bar); + baz |= mdma_csr.ms(utra::mdma::SFR_SR_SR_MDMAREQ6_SR_MDMAREQ6, 1); + mdma_csr.wfo(utra::mdma::SFR_SR_SR_MDMAREQ6_SR_MDMAREQ6, baz); + + let foo = mdma_csr.r(utra::mdma::SFR_SR_SR_MDMAREQ7); + mdma_csr.wo(utra::mdma::SFR_SR_SR_MDMAREQ7, foo); + let bar = mdma_csr.rf(utra::mdma::SFR_SR_SR_MDMAREQ7_SR_MDMAREQ7); + mdma_csr.rmwf(utra::mdma::SFR_SR_SR_MDMAREQ7_SR_MDMAREQ7, bar); + let mut baz = mdma_csr.zf(utra::mdma::SFR_SR_SR_MDMAREQ7_SR_MDMAREQ7, bar); + baz |= mdma_csr.ms(utra::mdma::SFR_SR_SR_MDMAREQ7_SR_MDMAREQ7, 1); + mdma_csr.wfo(utra::mdma::SFR_SR_SR_MDMAREQ7_SR_MDMAREQ7, baz); + } + + #[test] + #[ignore] + fn compile_check_qfc_csr() { + use super::*; + let mut qfc_csr = CSR::new(HW_QFC_BASE as *mut u32); + + let foo = qfc_csr.r(utra::qfc::SFR_IO); + qfc_csr.wo(utra::qfc::SFR_IO, foo); + let bar = qfc_csr.rf(utra::qfc::SFR_IO_SFR_IO); + qfc_csr.rmwf(utra::qfc::SFR_IO_SFR_IO, bar); + let mut baz = qfc_csr.zf(utra::qfc::SFR_IO_SFR_IO, bar); + baz |= qfc_csr.ms(utra::qfc::SFR_IO_SFR_IO, 1); + qfc_csr.wfo(utra::qfc::SFR_IO_SFR_IO, baz); + + let foo = qfc_csr.r(utra::qfc::SFR_AR); + qfc_csr.wo(utra::qfc::SFR_AR, foo); + let bar = qfc_csr.rf(utra::qfc::SFR_AR_SFR_AR); + qfc_csr.rmwf(utra::qfc::SFR_AR_SFR_AR, bar); + let mut baz = qfc_csr.zf(utra::qfc::SFR_AR_SFR_AR, bar); + baz |= qfc_csr.ms(utra::qfc::SFR_AR_SFR_AR, 1); + qfc_csr.wfo(utra::qfc::SFR_AR_SFR_AR, baz); + + let foo = qfc_csr.r(utra::qfc::SFR_IODRV); + qfc_csr.wo(utra::qfc::SFR_IODRV, foo); + let bar = qfc_csr.rf(utra::qfc::SFR_IODRV_PADDRVSEL); + qfc_csr.rmwf(utra::qfc::SFR_IODRV_PADDRVSEL, bar); + let mut baz = qfc_csr.zf(utra::qfc::SFR_IODRV_PADDRVSEL, bar); + baz |= qfc_csr.ms(utra::qfc::SFR_IODRV_PADDRVSEL, 1); + qfc_csr.wfo(utra::qfc::SFR_IODRV_PADDRVSEL, baz); + + let foo = qfc_csr.r(utra::qfc::CR_XIP_ADDRMODE); + qfc_csr.wo(utra::qfc::CR_XIP_ADDRMODE, foo); + let bar = qfc_csr.rf(utra::qfc::CR_XIP_ADDRMODE_CR_XIP_ADDRMODE); + qfc_csr.rmwf(utra::qfc::CR_XIP_ADDRMODE_CR_XIP_ADDRMODE, bar); + let mut baz = qfc_csr.zf(utra::qfc::CR_XIP_ADDRMODE_CR_XIP_ADDRMODE, bar); + baz |= qfc_csr.ms(utra::qfc::CR_XIP_ADDRMODE_CR_XIP_ADDRMODE, 1); + qfc_csr.wfo(utra::qfc::CR_XIP_ADDRMODE_CR_XIP_ADDRMODE, baz); + + let foo = qfc_csr.r(utra::qfc::CR_XIP_OPCODE); + qfc_csr.wo(utra::qfc::CR_XIP_OPCODE, foo); + let bar = qfc_csr.rf(utra::qfc::CR_XIP_OPCODE_CR_XIP_OPCODE); + qfc_csr.rmwf(utra::qfc::CR_XIP_OPCODE_CR_XIP_OPCODE, bar); + let mut baz = qfc_csr.zf(utra::qfc::CR_XIP_OPCODE_CR_XIP_OPCODE, bar); + baz |= qfc_csr.ms(utra::qfc::CR_XIP_OPCODE_CR_XIP_OPCODE, 1); + qfc_csr.wfo(utra::qfc::CR_XIP_OPCODE_CR_XIP_OPCODE, baz); + + let foo = qfc_csr.r(utra::qfc::CR_XIP_WIDTH); + qfc_csr.wo(utra::qfc::CR_XIP_WIDTH, foo); + let bar = qfc_csr.rf(utra::qfc::CR_XIP_WIDTH_CR_XIP_WIDTH); + qfc_csr.rmwf(utra::qfc::CR_XIP_WIDTH_CR_XIP_WIDTH, bar); + let mut baz = qfc_csr.zf(utra::qfc::CR_XIP_WIDTH_CR_XIP_WIDTH, bar); + baz |= qfc_csr.ms(utra::qfc::CR_XIP_WIDTH_CR_XIP_WIDTH, 1); + qfc_csr.wfo(utra::qfc::CR_XIP_WIDTH_CR_XIP_WIDTH, baz); + + let foo = qfc_csr.r(utra::qfc::CR_XIP_SSEL); + qfc_csr.wo(utra::qfc::CR_XIP_SSEL, foo); + let bar = qfc_csr.rf(utra::qfc::CR_XIP_SSEL_CR_XIP_SSEL); + qfc_csr.rmwf(utra::qfc::CR_XIP_SSEL_CR_XIP_SSEL, bar); + let mut baz = qfc_csr.zf(utra::qfc::CR_XIP_SSEL_CR_XIP_SSEL, bar); + baz |= qfc_csr.ms(utra::qfc::CR_XIP_SSEL_CR_XIP_SSEL, 1); + qfc_csr.wfo(utra::qfc::CR_XIP_SSEL_CR_XIP_SSEL, baz); + + let foo = qfc_csr.r(utra::qfc::CR_XIP_DUMCYC); + qfc_csr.wo(utra::qfc::CR_XIP_DUMCYC, foo); + let bar = qfc_csr.rf(utra::qfc::CR_XIP_DUMCYC_CR_XIP_DUMCYC); + qfc_csr.rmwf(utra::qfc::CR_XIP_DUMCYC_CR_XIP_DUMCYC, bar); + let mut baz = qfc_csr.zf(utra::qfc::CR_XIP_DUMCYC_CR_XIP_DUMCYC, bar); + baz |= qfc_csr.ms(utra::qfc::CR_XIP_DUMCYC_CR_XIP_DUMCYC, 1); + qfc_csr.wfo(utra::qfc::CR_XIP_DUMCYC_CR_XIP_DUMCYC, baz); + + let foo = qfc_csr.r(utra::qfc::CR_XIP_CFG); + qfc_csr.wo(utra::qfc::CR_XIP_CFG, foo); + let bar = qfc_csr.rf(utra::qfc::CR_XIP_CFG_CR_XIP_CFG); + qfc_csr.rmwf(utra::qfc::CR_XIP_CFG_CR_XIP_CFG, bar); + let mut baz = qfc_csr.zf(utra::qfc::CR_XIP_CFG_CR_XIP_CFG, bar); + baz |= qfc_csr.ms(utra::qfc::CR_XIP_CFG_CR_XIP_CFG, 1); + qfc_csr.wfo(utra::qfc::CR_XIP_CFG_CR_XIP_CFG, baz); + + let foo = qfc_csr.r(utra::qfc::CR_AESKEY_AESKEYIN0); + qfc_csr.wo(utra::qfc::CR_AESKEY_AESKEYIN0, foo); + let bar = qfc_csr.rf(utra::qfc::CR_AESKEY_AESKEYIN0_AESKEYIN0); + qfc_csr.rmwf(utra::qfc::CR_AESKEY_AESKEYIN0_AESKEYIN0, bar); + let mut baz = qfc_csr.zf(utra::qfc::CR_AESKEY_AESKEYIN0_AESKEYIN0, bar); + baz |= qfc_csr.ms(utra::qfc::CR_AESKEY_AESKEYIN0_AESKEYIN0, 1); + qfc_csr.wfo(utra::qfc::CR_AESKEY_AESKEYIN0_AESKEYIN0, baz); + + let foo = qfc_csr.r(utra::qfc::CR_AESKEY_AESKEYIN1); + qfc_csr.wo(utra::qfc::CR_AESKEY_AESKEYIN1, foo); + let bar = qfc_csr.rf(utra::qfc::CR_AESKEY_AESKEYIN1_AESKEYIN1); + qfc_csr.rmwf(utra::qfc::CR_AESKEY_AESKEYIN1_AESKEYIN1, bar); + let mut baz = qfc_csr.zf(utra::qfc::CR_AESKEY_AESKEYIN1_AESKEYIN1, bar); + baz |= qfc_csr.ms(utra::qfc::CR_AESKEY_AESKEYIN1_AESKEYIN1, 1); + qfc_csr.wfo(utra::qfc::CR_AESKEY_AESKEYIN1_AESKEYIN1, baz); + + let foo = qfc_csr.r(utra::qfc::CR_AESKEY_AESKEYIN2); + qfc_csr.wo(utra::qfc::CR_AESKEY_AESKEYIN2, foo); + let bar = qfc_csr.rf(utra::qfc::CR_AESKEY_AESKEYIN2_AESKEYIN2); + qfc_csr.rmwf(utra::qfc::CR_AESKEY_AESKEYIN2_AESKEYIN2, bar); + let mut baz = qfc_csr.zf(utra::qfc::CR_AESKEY_AESKEYIN2_AESKEYIN2, bar); + baz |= qfc_csr.ms(utra::qfc::CR_AESKEY_AESKEYIN2_AESKEYIN2, 1); + qfc_csr.wfo(utra::qfc::CR_AESKEY_AESKEYIN2_AESKEYIN2, baz); + + let foo = qfc_csr.r(utra::qfc::CR_AESKEY_AESKEYIN3); + qfc_csr.wo(utra::qfc::CR_AESKEY_AESKEYIN3, foo); + let bar = qfc_csr.rf(utra::qfc::CR_AESKEY_AESKEYIN3_AESKEYIN3); + qfc_csr.rmwf(utra::qfc::CR_AESKEY_AESKEYIN3_AESKEYIN3, bar); + let mut baz = qfc_csr.zf(utra::qfc::CR_AESKEY_AESKEYIN3_AESKEYIN3, bar); + baz |= qfc_csr.ms(utra::qfc::CR_AESKEY_AESKEYIN3_AESKEYIN3, 1); + qfc_csr.wfo(utra::qfc::CR_AESKEY_AESKEYIN3_AESKEYIN3, baz); + + let foo = qfc_csr.r(utra::qfc::CR_AESENA); + qfc_csr.wo(utra::qfc::CR_AESENA, foo); + let bar = qfc_csr.rf(utra::qfc::CR_AESENA_CR_AESENA); + qfc_csr.rmwf(utra::qfc::CR_AESENA_CR_AESENA, bar); + let mut baz = qfc_csr.zf(utra::qfc::CR_AESENA_CR_AESENA, bar); + baz |= qfc_csr.ms(utra::qfc::CR_AESENA_CR_AESENA, 1); + qfc_csr.wfo(utra::qfc::CR_AESENA_CR_AESENA, baz); + } + + #[test] + #[ignore] + fn compile_check_pl230_placeholder_csr() { + use super::*; + let mut pl230_placeholder_csr = CSR::new(HW_PL230_PLACEHOLDER_BASE as *mut u32); + } + + #[test] + #[ignore] + fn compile_check_gluechain_csr() { + use super::*; + let mut gluechain_csr = CSR::new(HW_GLUECHAIN_BASE as *mut u32); + + let foo = gluechain_csr.r(utra::gluechain::SFR_GCMASK); + gluechain_csr.wo(utra::gluechain::SFR_GCMASK, foo); + let bar = gluechain_csr.rf(utra::gluechain::SFR_GCMASK_CR_GCMASK); + gluechain_csr.rmwf(utra::gluechain::SFR_GCMASK_CR_GCMASK, bar); + let mut baz = gluechain_csr.zf(utra::gluechain::SFR_GCMASK_CR_GCMASK, bar); + baz |= gluechain_csr.ms(utra::gluechain::SFR_GCMASK_CR_GCMASK, 1); + gluechain_csr.wfo(utra::gluechain::SFR_GCMASK_CR_GCMASK, baz); + + let foo = gluechain_csr.r(utra::gluechain::SFR_GCSR); + gluechain_csr.wo(utra::gluechain::SFR_GCSR, foo); + let bar = gluechain_csr.rf(utra::gluechain::SFR_GCSR_GLUEREG); + gluechain_csr.rmwf(utra::gluechain::SFR_GCSR_GLUEREG, bar); + let mut baz = gluechain_csr.zf(utra::gluechain::SFR_GCSR_GLUEREG, bar); + baz |= gluechain_csr.ms(utra::gluechain::SFR_GCSR_GLUEREG, 1); + gluechain_csr.wfo(utra::gluechain::SFR_GCSR_GLUEREG, baz); + + let foo = gluechain_csr.r(utra::gluechain::SFR_GCRST); + gluechain_csr.wo(utra::gluechain::SFR_GCRST, foo); + let bar = gluechain_csr.rf(utra::gluechain::SFR_GCRST_GLUERST); + gluechain_csr.rmwf(utra::gluechain::SFR_GCRST_GLUERST, bar); + let mut baz = gluechain_csr.zf(utra::gluechain::SFR_GCRST_GLUERST, bar); + baz |= gluechain_csr.ms(utra::gluechain::SFR_GCRST_GLUERST, 1); + gluechain_csr.wfo(utra::gluechain::SFR_GCRST_GLUERST, baz); + + let foo = gluechain_csr.r(utra::gluechain::SFR_GCTEST); + gluechain_csr.wo(utra::gluechain::SFR_GCTEST, foo); + let bar = gluechain_csr.rf(utra::gluechain::SFR_GCTEST_GLUETEST); + gluechain_csr.rmwf(utra::gluechain::SFR_GCTEST_GLUETEST, bar); + let mut baz = gluechain_csr.zf(utra::gluechain::SFR_GCTEST_GLUETEST, bar); + baz |= gluechain_csr.ms(utra::gluechain::SFR_GCTEST_GLUETEST, 1); + gluechain_csr.wfo(utra::gluechain::SFR_GCTEST_GLUETEST, baz); + } + + #[test] + #[ignore] + fn compile_check_mesh_csr() { + use super::*; + let mut mesh_csr = CSR::new(HW_MESH_BASE as *mut u32); + + let foo = mesh_csr.r(utra::mesh::SFR_MLDRV_CR_MLDRV0); + mesh_csr.wo(utra::mesh::SFR_MLDRV_CR_MLDRV0, foo); + let bar = mesh_csr.rf(utra::mesh::SFR_MLDRV_CR_MLDRV0_CR_MLDRV0); + mesh_csr.rmwf(utra::mesh::SFR_MLDRV_CR_MLDRV0_CR_MLDRV0, bar); + let mut baz = mesh_csr.zf(utra::mesh::SFR_MLDRV_CR_MLDRV0_CR_MLDRV0, bar); + baz |= mesh_csr.ms(utra::mesh::SFR_MLDRV_CR_MLDRV0_CR_MLDRV0, 1); + mesh_csr.wfo(utra::mesh::SFR_MLDRV_CR_MLDRV0_CR_MLDRV0, baz); + + let foo = mesh_csr.r(utra::mesh::SFR_MLIE_CR_MLIE0); + mesh_csr.wo(utra::mesh::SFR_MLIE_CR_MLIE0, foo); + let bar = mesh_csr.rf(utra::mesh::SFR_MLIE_CR_MLIE0_CR_MLIE0); + mesh_csr.rmwf(utra::mesh::SFR_MLIE_CR_MLIE0_CR_MLIE0, bar); + let mut baz = mesh_csr.zf(utra::mesh::SFR_MLIE_CR_MLIE0_CR_MLIE0, bar); + baz |= mesh_csr.ms(utra::mesh::SFR_MLIE_CR_MLIE0_CR_MLIE0, 1); + mesh_csr.wfo(utra::mesh::SFR_MLIE_CR_MLIE0_CR_MLIE0, baz); + + let foo = mesh_csr.r(utra::mesh::SFR_MLSR_SR_MLSR0); + mesh_csr.wo(utra::mesh::SFR_MLSR_SR_MLSR0, foo); + let bar = mesh_csr.rf(utra::mesh::SFR_MLSR_SR_MLSR0_SR_MLSR0); + mesh_csr.rmwf(utra::mesh::SFR_MLSR_SR_MLSR0_SR_MLSR0, bar); + let mut baz = mesh_csr.zf(utra::mesh::SFR_MLSR_SR_MLSR0_SR_MLSR0, bar); + baz |= mesh_csr.ms(utra::mesh::SFR_MLSR_SR_MLSR0_SR_MLSR0, 1); + mesh_csr.wfo(utra::mesh::SFR_MLSR_SR_MLSR0_SR_MLSR0, baz); + + let foo = mesh_csr.r(utra::mesh::SFR_MLSR_SR_MLSR1); + mesh_csr.wo(utra::mesh::SFR_MLSR_SR_MLSR1, foo); + let bar = mesh_csr.rf(utra::mesh::SFR_MLSR_SR_MLSR1_SR_MLSR1); + mesh_csr.rmwf(utra::mesh::SFR_MLSR_SR_MLSR1_SR_MLSR1, bar); + let mut baz = mesh_csr.zf(utra::mesh::SFR_MLSR_SR_MLSR1_SR_MLSR1, bar); + baz |= mesh_csr.ms(utra::mesh::SFR_MLSR_SR_MLSR1_SR_MLSR1, 1); + mesh_csr.wfo(utra::mesh::SFR_MLSR_SR_MLSR1_SR_MLSR1, baz); + + let foo = mesh_csr.r(utra::mesh::SFR_MLSR_SR_MLSR2); + mesh_csr.wo(utra::mesh::SFR_MLSR_SR_MLSR2, foo); + let bar = mesh_csr.rf(utra::mesh::SFR_MLSR_SR_MLSR2_SR_MLSR2); + mesh_csr.rmwf(utra::mesh::SFR_MLSR_SR_MLSR2_SR_MLSR2, bar); + let mut baz = mesh_csr.zf(utra::mesh::SFR_MLSR_SR_MLSR2_SR_MLSR2, bar); + baz |= mesh_csr.ms(utra::mesh::SFR_MLSR_SR_MLSR2_SR_MLSR2, 1); + mesh_csr.wfo(utra::mesh::SFR_MLSR_SR_MLSR2_SR_MLSR2, baz); + + let foo = mesh_csr.r(utra::mesh::SFR_MLSR_SR_MLSR3); + mesh_csr.wo(utra::mesh::SFR_MLSR_SR_MLSR3, foo); + let bar = mesh_csr.rf(utra::mesh::SFR_MLSR_SR_MLSR3_SR_MLSR3); + mesh_csr.rmwf(utra::mesh::SFR_MLSR_SR_MLSR3_SR_MLSR3, bar); + let mut baz = mesh_csr.zf(utra::mesh::SFR_MLSR_SR_MLSR3_SR_MLSR3, bar); + baz |= mesh_csr.ms(utra::mesh::SFR_MLSR_SR_MLSR3_SR_MLSR3, 1); + mesh_csr.wfo(utra::mesh::SFR_MLSR_SR_MLSR3_SR_MLSR3, baz); + + let foo = mesh_csr.r(utra::mesh::SFR_MLSR_SR_MLSR4); + mesh_csr.wo(utra::mesh::SFR_MLSR_SR_MLSR4, foo); + let bar = mesh_csr.rf(utra::mesh::SFR_MLSR_SR_MLSR4_SR_MLSR4); + mesh_csr.rmwf(utra::mesh::SFR_MLSR_SR_MLSR4_SR_MLSR4, bar); + let mut baz = mesh_csr.zf(utra::mesh::SFR_MLSR_SR_MLSR4_SR_MLSR4, bar); + baz |= mesh_csr.ms(utra::mesh::SFR_MLSR_SR_MLSR4_SR_MLSR4, 1); + mesh_csr.wfo(utra::mesh::SFR_MLSR_SR_MLSR4_SR_MLSR4, baz); + + let foo = mesh_csr.r(utra::mesh::SFR_MLSR_SR_MLSR5); + mesh_csr.wo(utra::mesh::SFR_MLSR_SR_MLSR5, foo); + let bar = mesh_csr.rf(utra::mesh::SFR_MLSR_SR_MLSR5_SR_MLSR5); + mesh_csr.rmwf(utra::mesh::SFR_MLSR_SR_MLSR5_SR_MLSR5, bar); + let mut baz = mesh_csr.zf(utra::mesh::SFR_MLSR_SR_MLSR5_SR_MLSR5, bar); + baz |= mesh_csr.ms(utra::mesh::SFR_MLSR_SR_MLSR5_SR_MLSR5, 1); + mesh_csr.wfo(utra::mesh::SFR_MLSR_SR_MLSR5_SR_MLSR5, baz); + + let foo = mesh_csr.r(utra::mesh::SFR_MLSR_SR_MLSR6); + mesh_csr.wo(utra::mesh::SFR_MLSR_SR_MLSR6, foo); + let bar = mesh_csr.rf(utra::mesh::SFR_MLSR_SR_MLSR6_SR_MLSR6); + mesh_csr.rmwf(utra::mesh::SFR_MLSR_SR_MLSR6_SR_MLSR6, bar); + let mut baz = mesh_csr.zf(utra::mesh::SFR_MLSR_SR_MLSR6_SR_MLSR6, bar); + baz |= mesh_csr.ms(utra::mesh::SFR_MLSR_SR_MLSR6_SR_MLSR6, 1); + mesh_csr.wfo(utra::mesh::SFR_MLSR_SR_MLSR6_SR_MLSR6, baz); + + let foo = mesh_csr.r(utra::mesh::SFR_MLSR_SR_MLSR7); + mesh_csr.wo(utra::mesh::SFR_MLSR_SR_MLSR7, foo); + let bar = mesh_csr.rf(utra::mesh::SFR_MLSR_SR_MLSR7_SR_MLSR7); + mesh_csr.rmwf(utra::mesh::SFR_MLSR_SR_MLSR7_SR_MLSR7, bar); + let mut baz = mesh_csr.zf(utra::mesh::SFR_MLSR_SR_MLSR7_SR_MLSR7, bar); + baz |= mesh_csr.ms(utra::mesh::SFR_MLSR_SR_MLSR7_SR_MLSR7, 1); + mesh_csr.wfo(utra::mesh::SFR_MLSR_SR_MLSR7_SR_MLSR7, baz); + } + + #[test] + #[ignore] + fn compile_check_sensorc_csr() { + use super::*; + let mut sensorc_csr = CSR::new(HW_SENSORC_BASE as *mut u32); + + let foo = sensorc_csr.r(utra::sensorc::SFR_VDMASK0); + sensorc_csr.wo(utra::sensorc::SFR_VDMASK0, foo); + let bar = sensorc_csr.rf(utra::sensorc::SFR_VDMASK0_CR_VDMASK0); + sensorc_csr.rmwf(utra::sensorc::SFR_VDMASK0_CR_VDMASK0, bar); + let mut baz = sensorc_csr.zf(utra::sensorc::SFR_VDMASK0_CR_VDMASK0, bar); + baz |= sensorc_csr.ms(utra::sensorc::SFR_VDMASK0_CR_VDMASK0, 1); + sensorc_csr.wfo(utra::sensorc::SFR_VDMASK0_CR_VDMASK0, baz); + + let foo = sensorc_csr.r(utra::sensorc::SFR_VDMASK1); + sensorc_csr.wo(utra::sensorc::SFR_VDMASK1, foo); + let bar = sensorc_csr.rf(utra::sensorc::SFR_VDMASK1_CR_VDMASK1); + sensorc_csr.rmwf(utra::sensorc::SFR_VDMASK1_CR_VDMASK1, bar); + let mut baz = sensorc_csr.zf(utra::sensorc::SFR_VDMASK1_CR_VDMASK1, bar); + baz |= sensorc_csr.ms(utra::sensorc::SFR_VDMASK1_CR_VDMASK1, 1); + sensorc_csr.wfo(utra::sensorc::SFR_VDMASK1_CR_VDMASK1, baz); + + let foo = sensorc_csr.r(utra::sensorc::SFR_VDSR); + sensorc_csr.wo(utra::sensorc::SFR_VDSR, foo); + let bar = sensorc_csr.rf(utra::sensorc::SFR_VDSR_SR_VDSR); + sensorc_csr.rmwf(utra::sensorc::SFR_VDSR_SR_VDSR, bar); + let mut baz = sensorc_csr.zf(utra::sensorc::SFR_VDSR_SR_VDSR, bar); + baz |= sensorc_csr.ms(utra::sensorc::SFR_VDSR_SR_VDSR, 1); + sensorc_csr.wfo(utra::sensorc::SFR_VDSR_SR_VDSR, baz); + + let foo = sensorc_csr.r(utra::sensorc::SFR_LDMASK); + sensorc_csr.wo(utra::sensorc::SFR_LDMASK, foo); + let bar = sensorc_csr.rf(utra::sensorc::SFR_LDMASK_CR_LDMASK); + sensorc_csr.rmwf(utra::sensorc::SFR_LDMASK_CR_LDMASK, bar); + let mut baz = sensorc_csr.zf(utra::sensorc::SFR_LDMASK_CR_LDMASK, bar); + baz |= sensorc_csr.ms(utra::sensorc::SFR_LDMASK_CR_LDMASK, 1); + sensorc_csr.wfo(utra::sensorc::SFR_LDMASK_CR_LDMASK, baz); + + let foo = sensorc_csr.r(utra::sensorc::SFR_LDSR); + sensorc_csr.wo(utra::sensorc::SFR_LDSR, foo); + let bar = sensorc_csr.rf(utra::sensorc::SFR_LDSR_SR_LDSR); + sensorc_csr.rmwf(utra::sensorc::SFR_LDSR_SR_LDSR, bar); + let mut baz = sensorc_csr.zf(utra::sensorc::SFR_LDSR_SR_LDSR, bar); + baz |= sensorc_csr.ms(utra::sensorc::SFR_LDSR_SR_LDSR, 1); + sensorc_csr.wfo(utra::sensorc::SFR_LDSR_SR_LDSR, baz); + + let foo = sensorc_csr.r(utra::sensorc::SFR_LDCFG); + sensorc_csr.wo(utra::sensorc::SFR_LDCFG, foo); + let bar = sensorc_csr.rf(utra::sensorc::SFR_LDCFG_SFR_LDCFG); + sensorc_csr.rmwf(utra::sensorc::SFR_LDCFG_SFR_LDCFG, bar); + let mut baz = sensorc_csr.zf(utra::sensorc::SFR_LDCFG_SFR_LDCFG, bar); + baz |= sensorc_csr.ms(utra::sensorc::SFR_LDCFG_SFR_LDCFG, 1); + sensorc_csr.wfo(utra::sensorc::SFR_LDCFG_SFR_LDCFG, baz); + + let foo = sensorc_csr.r(utra::sensorc::SFR_VDCFG_CR_VDCFG0); + sensorc_csr.wo(utra::sensorc::SFR_VDCFG_CR_VDCFG0, foo); + let bar = sensorc_csr.rf(utra::sensorc::SFR_VDCFG_CR_VDCFG0_CR_VDCFG0); + sensorc_csr.rmwf(utra::sensorc::SFR_VDCFG_CR_VDCFG0_CR_VDCFG0, bar); + let mut baz = sensorc_csr.zf(utra::sensorc::SFR_VDCFG_CR_VDCFG0_CR_VDCFG0, bar); + baz |= sensorc_csr.ms(utra::sensorc::SFR_VDCFG_CR_VDCFG0_CR_VDCFG0, 1); + sensorc_csr.wfo(utra::sensorc::SFR_VDCFG_CR_VDCFG0_CR_VDCFG0, baz); + + let foo = sensorc_csr.r(utra::sensorc::SFR_VDCFG_CR_VDCFG1); + sensorc_csr.wo(utra::sensorc::SFR_VDCFG_CR_VDCFG1, foo); + let bar = sensorc_csr.rf(utra::sensorc::SFR_VDCFG_CR_VDCFG1_CR_VDCFG1); + sensorc_csr.rmwf(utra::sensorc::SFR_VDCFG_CR_VDCFG1_CR_VDCFG1, bar); + let mut baz = sensorc_csr.zf(utra::sensorc::SFR_VDCFG_CR_VDCFG1_CR_VDCFG1, bar); + baz |= sensorc_csr.ms(utra::sensorc::SFR_VDCFG_CR_VDCFG1_CR_VDCFG1, 1); + sensorc_csr.wfo(utra::sensorc::SFR_VDCFG_CR_VDCFG1_CR_VDCFG1, baz); + + let foo = sensorc_csr.r(utra::sensorc::SFR_VDCFG_CR_VDCFG2); + sensorc_csr.wo(utra::sensorc::SFR_VDCFG_CR_VDCFG2, foo); + let bar = sensorc_csr.rf(utra::sensorc::SFR_VDCFG_CR_VDCFG2_CR_VDCFG2); + sensorc_csr.rmwf(utra::sensorc::SFR_VDCFG_CR_VDCFG2_CR_VDCFG2, bar); + let mut baz = sensorc_csr.zf(utra::sensorc::SFR_VDCFG_CR_VDCFG2_CR_VDCFG2, bar); + baz |= sensorc_csr.ms(utra::sensorc::SFR_VDCFG_CR_VDCFG2_CR_VDCFG2, 1); + sensorc_csr.wfo(utra::sensorc::SFR_VDCFG_CR_VDCFG2_CR_VDCFG2, baz); + + let foo = sensorc_csr.r(utra::sensorc::SFR_VDCFG_CR_VDCFG3); + sensorc_csr.wo(utra::sensorc::SFR_VDCFG_CR_VDCFG3, foo); + let bar = sensorc_csr.rf(utra::sensorc::SFR_VDCFG_CR_VDCFG3_CR_VDCFG3); + sensorc_csr.rmwf(utra::sensorc::SFR_VDCFG_CR_VDCFG3_CR_VDCFG3, bar); + let mut baz = sensorc_csr.zf(utra::sensorc::SFR_VDCFG_CR_VDCFG3_CR_VDCFG3, bar); + baz |= sensorc_csr.ms(utra::sensorc::SFR_VDCFG_CR_VDCFG3_CR_VDCFG3, 1); + sensorc_csr.wfo(utra::sensorc::SFR_VDCFG_CR_VDCFG3_CR_VDCFG3, baz); + + let foo = sensorc_csr.r(utra::sensorc::SFR_VDCFG_CR_VDCFG4); + sensorc_csr.wo(utra::sensorc::SFR_VDCFG_CR_VDCFG4, foo); + let bar = sensorc_csr.rf(utra::sensorc::SFR_VDCFG_CR_VDCFG4_CR_VDCFG4); + sensorc_csr.rmwf(utra::sensorc::SFR_VDCFG_CR_VDCFG4_CR_VDCFG4, bar); + let mut baz = sensorc_csr.zf(utra::sensorc::SFR_VDCFG_CR_VDCFG4_CR_VDCFG4, bar); + baz |= sensorc_csr.ms(utra::sensorc::SFR_VDCFG_CR_VDCFG4_CR_VDCFG4, 1); + sensorc_csr.wfo(utra::sensorc::SFR_VDCFG_CR_VDCFG4_CR_VDCFG4, baz); + + let foo = sensorc_csr.r(utra::sensorc::SFR_VDCFG_CR_VDCFG5); + sensorc_csr.wo(utra::sensorc::SFR_VDCFG_CR_VDCFG5, foo); + let bar = sensorc_csr.rf(utra::sensorc::SFR_VDCFG_CR_VDCFG5_CR_VDCFG5); + sensorc_csr.rmwf(utra::sensorc::SFR_VDCFG_CR_VDCFG5_CR_VDCFG5, bar); + let mut baz = sensorc_csr.zf(utra::sensorc::SFR_VDCFG_CR_VDCFG5_CR_VDCFG5, bar); + baz |= sensorc_csr.ms(utra::sensorc::SFR_VDCFG_CR_VDCFG5_CR_VDCFG5, 1); + sensorc_csr.wfo(utra::sensorc::SFR_VDCFG_CR_VDCFG5_CR_VDCFG5, baz); + + let foo = sensorc_csr.r(utra::sensorc::SFR_VDCFG_CR_VDCFG6); + sensorc_csr.wo(utra::sensorc::SFR_VDCFG_CR_VDCFG6, foo); + let bar = sensorc_csr.rf(utra::sensorc::SFR_VDCFG_CR_VDCFG6_CR_VDCFG6); + sensorc_csr.rmwf(utra::sensorc::SFR_VDCFG_CR_VDCFG6_CR_VDCFG6, bar); + let mut baz = sensorc_csr.zf(utra::sensorc::SFR_VDCFG_CR_VDCFG6_CR_VDCFG6, bar); + baz |= sensorc_csr.ms(utra::sensorc::SFR_VDCFG_CR_VDCFG6_CR_VDCFG6, 1); + sensorc_csr.wfo(utra::sensorc::SFR_VDCFG_CR_VDCFG6_CR_VDCFG6, baz); + + let foo = sensorc_csr.r(utra::sensorc::SFR_VDCFG_CR_VDCFG7); + sensorc_csr.wo(utra::sensorc::SFR_VDCFG_CR_VDCFG7, foo); + let bar = sensorc_csr.rf(utra::sensorc::SFR_VDCFG_CR_VDCFG7_CR_VDCFG7); + sensorc_csr.rmwf(utra::sensorc::SFR_VDCFG_CR_VDCFG7_CR_VDCFG7, bar); + let mut baz = sensorc_csr.zf(utra::sensorc::SFR_VDCFG_CR_VDCFG7_CR_VDCFG7, bar); + baz |= sensorc_csr.ms(utra::sensorc::SFR_VDCFG_CR_VDCFG7_CR_VDCFG7, 1); + sensorc_csr.wfo(utra::sensorc::SFR_VDCFG_CR_VDCFG7_CR_VDCFG7, baz); + } +}