From 0befcca63f5b09971deb9a6eac921fa0bed936ce Mon Sep 17 00:00:00 2001 From: Afonso Oliveira Date: Fri, 1 May 2026 17:26:20 +0100 Subject: [PATCH 1/3] [erbium-hal] add RDL -> C header regeneration scripts Pipeline that reproduces erbium-hal/include/hwinc/ from Erbium SystemRDL sources: - rdl2hal.py converts one SystemRDL register block into a Semifore-style C header. It emits per-register _ADDRESS, _OFFSET, _SIZE, _RESET_VALUE, field accessor macros, and a block-level typedef struct. - top2h.py parses the top-level address-map RDL and emits _TOP__BASE macros for every peripheral instance, including nested external regions such as BOOTROM and SRAM inside ROMRAM. - csr2rdl.py converts the Minion CSR CSV into synthetic SystemRDL as a byte-addressed register map, using byte_offset = csr_number * 8, so the same RDL-to-C generator can handle the CSR block. This is adapted from the hardware team csr2rdl.py. - gen_all_headers.py is the driver. It invokes csr2rdl.py for Minion CSRs, rdl2hal.py per peripheral, and top2h.py for the top map. All input paths are provided by the caller through CLI flags or environment variables. The scripts do not hardcode RTL-tree paths. --- erbium-hal/scripts/csr2rdl.py | 458 ++++++++++++++++++++++ erbium-hal/scripts/gen_all_headers.py | 232 +++++++++++ erbium-hal/scripts/rdl2hal.py | 355 +++++++++++++++++ erbium-hal/scripts/top2h.py | 540 ++++++++++++++++++++++++++ 4 files changed, 1585 insertions(+) create mode 100755 erbium-hal/scripts/csr2rdl.py create mode 100755 erbium-hal/scripts/gen_all_headers.py create mode 100755 erbium-hal/scripts/rdl2hal.py create mode 100755 erbium-hal/scripts/top2h.py diff --git a/erbium-hal/scripts/csr2rdl.py b/erbium-hal/scripts/csr2rdl.py new file mode 100755 index 000000000..72b1943dc --- /dev/null +++ b/erbium-hal/scripts/csr2rdl.py @@ -0,0 +1,458 @@ +#!/usr/bin/env python3 +"""Convert Minion CSR CSV sources into synthetic SystemRDL. + +Builds a byte-addressed synthetic CSR bank: + + CSR byte offset = csr_number * 8 + +Inputs (all paths must be provided — no built-in defaults, to avoid +hard-coding any particular hardware-repo layout): + + Input Env var CLI flag + -------------------------------------------------------------------- + semifore CSV ERBIUM_HAL_CSR_SEMIFORE_CSV --semifore-csv + register CSV ERBIUM_HAL_CSR_REG_CSV --reg-csv + types dir ERBIUM_HAL_CSR_TYPES_DIR --types-dir + RDL output ERBIUM_HAL_CSR_RDL_OUT --rdl-out + +The --rdl-only mode (the only mode used by gen_all_headers.py) +generates the RDL file and exits. The optional c-header pipeline +(peakrdl + rdl2h.py) is kept for upstream compatibility but also +requires all its paths to be supplied explicitly. +""" + +from __future__ import annotations + +import argparse +import csv +import os +import re +import subprocess +import sys +from dataclasses import dataclass, field +from pathlib import Path + + +RESERVED_NAMES = {"WIRI", "WPRI", "ZERO"} + + +@dataclass +class FieldInfo: + name: str + low: int + high: int + access: str + reset: int = 0 + desc: str = "" + onwrite: str | None = None + onread: str | None = None + + @property + def width(self) -> int: + return self.high - self.low + 1 + + +@dataclass +class RegisterInfo: + name: str + csr_number: int + access: str + title: str = "" + desc: str = "" + reset: int | None = None + reset_mask: int | None = None + type_name: str | None = None + fields: list[FieldInfo] = field(default_factory=list) + + @property + def byte_offset(self) -> int: + return self.csr_number * 8 + + +def fatal(msg: str) -> None: + sys.exit(f"[csr2rdl] {msg}") + + +def resolve_path(cli_value: Path | None, env_name: str, label: str) -> Path: + """Resolve a path from CLI arg or env var, or abort with a clear error.""" + if cli_value is not None: + return cli_value.expanduser().resolve() + env_value = os.environ.get(env_name) + if env_value: + return Path(env_value).expanduser().resolve() + fatal( + f"{label} path not provided.\n" + f" Set ${env_name} or pass --{label.replace('_', '-')}" + ) + + +def parse_num(text: str | None) -> int | None: + if text is None: + return None + value = text.strip().strip('"') + if not value: + return None + if "'" in value: + _width, digits = value.split("'", 1) + base = digits[0].lower() + number = digits[1:].replace("_", "") + if base == "h": + return int(number, 16) + if base == "d": + return int(number, 10) + if base == "b": + return int(number, 2) + if base == "o": + return int(number, 8) + raise ValueError(f"unsupported literal: {text}") + return int(value, 0) + + +def sanitize_identifier(name: str) -> str: + identifier = re.sub(r"[^0-9A-Za-z_]+", "_", name.strip()) + identifier = re.sub(r"_+", "_", identifier).strip("_") + if not identifier: + identifier = "unnamed" + if identifier[0].isdigit(): + identifier = f"csr_{identifier}" + return identifier.lower() + + +def clean_text(text: str | None) -> str: + if not text: + return "" + text = text.replace("\r", " ").replace("\n", " ") + text = re.sub(r"\s+", " ", text).strip() + text = text.replace("\\", "\\\\").replace('"', '\\"') + return text + + +def parse_position(text: str) -> tuple[int, int]: + value = text.strip() + match = re.fullmatch(r"\[(\d+):(\d+)\]", value) + if match: + high = int(match.group(1)) + low = int(match.group(2)) + if high < low: + high, low = low, high + return low, high + match = re.fullmatch(r"\[(\d+)\]", value) + if match: + bit = int(match.group(1)) + return bit, bit + raise ValueError(f"unsupported bit position: {text}") + + +def map_sw(access: str) -> str: + value = access.upper().replace(" ", "") + if value in {"R", "RO"}: + return "r" + if value in {"W", "WO"}: + return "w" + return "rw" + + +def map_onwrite(access: str) -> str | None: + value = access.upper().replace(" ", "") + if value.endswith("1C"): + return "woclr" + if value.endswith("1S"): + return "woset" + if value.endswith("0C"): + return "wzc" + if value.endswith("0S"): + return "wzs" + if value.endswith("1T"): + return "wot" + return None + + +def is_reserved_type_field(name: str) -> bool: + upper = sanitize_identifier(name).upper() + return upper in RESERVED_NAMES or upper.endswith("_ZERO") + + +def load_type_map(path: Path) -> dict[str, str]: + result: dict[str, str] = {} + with path.open(newline="", encoding="latin-1") as handle: + reader = csv.DictReader(handle) + for row in reader: + address = (row.get("Address") or "").strip() + name = (row.get("Name") or "").strip() + type_name = (row.get("Type") or "").strip() + if address.startswith("0x") and name: + result[name] = type_name + return result + + +def load_type_fields(types_dir: Path, type_name: str, register_reset: int | None) -> list[FieldInfo]: + path = types_dir / f"{type_name}.csv" + if not path.exists(): + return [] + + rows: dict[str, list[str]] = {} + with path.open(newline="", encoding="latin-1") as handle: + reader = csv.reader(handle) + for row in reader: + if row and row[0]: + rows[row[0]] = row[1:] + + names = list(reversed(rows.get("fields", []))) + widths = list(reversed(rows.get("width", []))) + ro_flags = list(reversed(rows.get("RO", []))) + if not names or not widths: + return [] + + while len(ro_flags) < len(names): + ro_flags.insert(0, "NO") + + fields: list[FieldInfo] = [] + shift = 0 + for raw_name, raw_width, raw_ro in zip(names, widths, ro_flags): + if not raw_width.strip(): + continue + width = int(raw_width, 0) + name = sanitize_identifier(raw_name) + if not is_reserved_type_field(raw_name): + mask = (1 << width) - 1 + reset = 0 + if register_reset is not None: + reset = (register_reset >> shift) & mask + access = "r" if raw_ro.strip().upper() == "YES" else "rw" + fields.append( + FieldInfo( + name=name, + low=shift, + high=shift + width - 1, + access=access, + reset=reset, + ) + ) + shift += width + return fields + + +def load_semifore_registers( + path: Path, type_map: dict[str, str], types_dir: Path +) -> list[RegisterInfo]: + registers: list[RegisterInfo] = [] + current: RegisterInfo | None = None + with path.open(newline="", encoding="latin-1") as handle: + reader = csv.DictReader(handle) + for row in reader: + offset = (row.get("Offset") or "").strip() + position = (row.get("Position") or "").strip() + identifier = (row.get("Identifier") or "").strip() + access = (row.get("Access") or "").strip() + row_type = (row.get("Type") or "").strip().lower() + + if offset.startswith("0x") and row_type == "register" and identifier: + current = RegisterInfo( + name=sanitize_identifier(identifier), + csr_number=int(offset, 0), + access=map_sw(access or "R/W"), + title=clean_text(row.get("Title")), + desc=clean_text(row.get("Description")), + reset=parse_num(row.get("Reset Value")), + reset_mask=parse_num(row.get("Reset Mask")), + type_name=type_map.get(identifier), + ) + registers.append(current) + continue + + if current is None or not position or not identifier: + continue + + low, high = parse_position(position) + current.fields.append( + FieldInfo( + name=sanitize_identifier(identifier), + low=low, + high=high, + access=map_sw(access or "R/W"), + reset=parse_num(row.get("Reset Value")) or 0, + desc=clean_text(row.get("Description")), + onwrite=map_onwrite(access or ""), + ) + ) + + for register in registers: + explicit = [field for field in register.fields] + use_explicit = False + if explicit: + if len(explicit) > 1: + use_explicit = True + else: + only = explicit[0] + if not (only.name == register.name and only.low == 0 and only.high == 63): + use_explicit = True + + if not use_explicit: + if register.type_name: + register.fields = load_type_fields(types_dir, register.type_name, register.reset) + else: + register.fields = explicit + + if not register.fields: + register.fields = [ + FieldInfo( + name=register.name, + low=0, + high=63, + access=register.access, + reset=register.reset or 0, + desc=register.desc, + ) + ] + + return registers + + +def format_reset(value: int) -> str: + return hex(value) + + +def render_field(field: FieldInfo) -> list[str]: + lines = [" field {"] + lines.append(f" sw = {field.access};") + if field.onwrite: + lines.append(f" onwrite = {field.onwrite};") + if field.onread: + lines.append(f" onread = {field.onread};") + if field.desc: + lines.append(f' desc = "{field.desc}";') + rng = f"[{field.high}:{field.low}]" + lines.append(f" }} {field.name}{rng} = {format_reset(field.reset)};") + return lines + + +def render_rdl(registers: list[RegisterInfo], top_name: str) -> str: + lines = [ + "// Generated by csr2rdl.py", + "// Synthetic byte-addressed CSR bank: byte_offset = csr_number * 8", + "", + f"addrmap {top_name} {{", + f' name = "{top_name}";', + " alignment = 8;", + " default regwidth = 64;", + "", + ] + + for register in registers: + lines.append(" reg {") + if register.title: + lines.append(f' name = "{register.title}";') + if register.desc: + lines.append(f' desc = "{register.desc}";') + for field in sorted(register.fields, key=lambda item: (item.low, item.high)): + lines.extend(render_field(field)) + lines.append(f" }} {register.name} @ 0x{register.byte_offset:X};") + lines.append("") + + lines.append("};") + lines.append("") + return "\n".join(lines) + + +def run_header_pipeline(rdl_path: Path, header_path: Path, helper_path: Path, top_name: str) -> None: + header_path.parent.mkdir(parents=True, exist_ok=True) + subprocess.run( + [ + "peakrdl", + "c-header", + str(rdl_path), + "-b", "ltoh", + "-i", + "-o", str(header_path), + ], + check=True, + ) + subprocess.run( + [ + sys.executable, + str(helper_path), + str(rdl_path), + str(header_path), + "-t", top_name, + ], + check=True, + ) + + +def parse_args() -> argparse.Namespace: + parser = argparse.ArgumentParser( + description=__doc__.splitlines()[0], + formatter_class=argparse.RawDescriptionHelpFormatter, + ) + parser.add_argument( + "--semifore-csv", type=Path, default=None, + help="Semifore CSV (register table). Defaults to $ERBIUM_HAL_CSR_SEMIFORE_CSV.", + ) + parser.add_argument( + "--reg-csv", type=Path, default=None, + help="Register-to-type mapping CSV. Defaults to $ERBIUM_HAL_CSR_REG_CSV.", + ) + parser.add_argument( + "--types-dir", type=Path, default=None, + help="Directory containing types/*.csv. Defaults to $ERBIUM_HAL_CSR_TYPES_DIR.", + ) + parser.add_argument( + "--rdl-out", type=Path, default=None, + help="Output path for the generated RDL. Defaults to $ERBIUM_HAL_CSR_RDL_OUT.", + ) + parser.add_argument( + "--header-out", type=Path, default=None, + help="Optional C-header output path (requires peakrdl and --rdl2h).", + ) + parser.add_argument( + "--rdl2h", type=Path, default=None, + help="Path to helper rdl2h.py used by the optional header pipeline.", + ) + parser.add_argument("--top-name", default="minion_csr") + parser.add_argument( + "--rdl-only", action="store_true", + help="Write the RDL only; skip the c-header pipeline.", + ) + return parser.parse_args() + + +def main() -> None: + args = parse_args() + + semifore_csv = resolve_path( + args.semifore_csv, "ERBIUM_HAL_CSR_SEMIFORE_CSV", "semifore_csv" + ) + reg_csv = resolve_path( + args.reg_csv, "ERBIUM_HAL_CSR_REG_CSV", "reg_csv" + ) + types_dir = resolve_path( + args.types_dir, "ERBIUM_HAL_CSR_TYPES_DIR", "types_dir" + ) + rdl_out = resolve_path( + args.rdl_out, "ERBIUM_HAL_CSR_RDL_OUT", "rdl_out" + ) + + for p, kind in [(semifore_csv, "file"), (reg_csv, "file"), (types_dir, "dir")]: + if kind == "file" and not p.is_file(): + fatal(f"input file not found: {p}") + if kind == "dir" and not p.is_dir(): + fatal(f"input directory not found: {p}") + + type_map = load_type_map(reg_csv) + registers = load_semifore_registers(semifore_csv, type_map, types_dir) + rdl_text = render_rdl(registers, args.top_name) + + rdl_out.parent.mkdir(parents=True, exist_ok=True) + rdl_out.write_text(rdl_text) + print(f"[csr2rdl] wrote {rdl_out}") + + if not args.rdl_only: + if args.header_out is None or args.rdl2h is None: + fatal( + "--header-out and --rdl2h are required when not in --rdl-only mode" + ) + run_header_pipeline(rdl_out, args.header_out, args.rdl2h, args.top_name) + + +if __name__ == "__main__": + main() diff --git a/erbium-hal/scripts/gen_all_headers.py b/erbium-hal/scripts/gen_all_headers.py new file mode 100755 index 000000000..20102a82a --- /dev/null +++ b/erbium-hal/scripts/gen_all_headers.py @@ -0,0 +1,232 @@ +#!/usr/bin/env python3 +"""Regenerate erbium-hal/include/hwinc/ headers from RDL sources. + +Pipeline: + + CSV (+ types/*.csv) ─► csr2rdl.py ─► minion_csr.rdl ─┐ + │ + ├─► rdl2hal.py ─► hwinc/*.h + hand-written RDLs ────────────────────────────────────┘ + (uart, system, qspi, i2c, plic, esr) + + top_cpu_mm.rdl ─────────────────────────────────────► top2h.py ─► hwinc/top.h + +This script has NO built-in knowledge of the RDL tree layout. Every +path to an RDL file (and to the csr2rdl.py helper) must be supplied +explicitly, either through CLI flags or environment variables: + + Slot Env var CLI flag + -------------------------------------------------------------------- + uart ERBIUM_HAL_UART_RDL --uart-rdl + system ERBIUM_HAL_SYSTEM_RDL --system-rdl + qspi ERBIUM_HAL_QSPI_RDL --qspi-rdl + i2c ERBIUM_HAL_I2C_RDL --i2c-rdl + esr ERBIUM_HAL_ESR_RDL --esr-rdl + plic ERBIUM_HAL_PLIC_RDL --plic-rdl + minion_csr ERBIUM_HAL_MINION_CSR_RDL --minion-csr-rdl + top ERBIUM_HAL_TOP_RDL --top-rdl + csr2rdl script ERBIUM_HAL_CSR2RDL_SCRIPT --csr2rdl-script + +Typical usage (paths exported from a local, un-committed shell script): + + source ~/my-rtl-env.sh + gen_all_headers.py + +Or explicit: + + gen_all_headers.py \\ + --uart-rdl $UART_RDL \\ + --system-rdl $SYSTEM_RDL \\ + --qspi-rdl $QSPI_RDL \\ + --i2c-rdl $I2C_RDL \\ + --esr-rdl $ESR_RDL \\ + --plic-rdl $PLIC_RDL \\ + --minion-csr-rdl $MINION_CSR_RDL \\ + --top-rdl $TOP_RDL \\ + --csr2rdl-script $CSR2RDL + +Use --skip-csr-regen when you already have a committed minion_csr.rdl +and don't want to re-run the CSV→RDL step (in which case csr2rdl-script +is not required). +""" + +from __future__ import annotations + +import argparse +import os +import subprocess +import sys +from pathlib import Path + + +SCRIPT_DIR = Path(__file__).resolve().parent +DEFAULT_OUT = (SCRIPT_DIR.parent / "include" / "hwinc").resolve() + +# Sibling helper scripts shipped in this repo. These are the only paths +# the script knows about — they live relative to itself, not to any +# hardware repo. +RDL2HAL = SCRIPT_DIR / "rdl2hal.py" +TOP2H = SCRIPT_DIR / "top2h.py" +CSR2RDL = SCRIPT_DIR / "csr2rdl.py" + +TOP_PREFIX = "ERBIUM_TOP" + +# (slot_name, output_header_name, optional_top_addrmap_hint_for_rdl2hal) +# +# The addrmap hint is a string identifier that rdl2hal.py uses to pick +# the top-level addrmap inside the RDL when there is more than one. +# It is not a path and does not leak filesystem layout. +SOURCES = [ + ("uart", "uart.h", None), + ("system", "system.h", None), + ("qspi", "qspi.h", None), + ("i2c", "i2c.h", "I2C_Reg"), + ("esr", "esr.h", "Erbium_ESR"), + ("plic", "plic.h", "PLIC_cpu"), + ("minion_csr", "minion_csr.h", None), +] + + +def env_var_for(slot: str) -> str: + return f"ERBIUM_HAL_{slot.upper()}_RDL" + + +def fatal(msg: str) -> None: + sys.exit(f"[gen_all_headers] {msg}") + + +def run(cmd: list[str]) -> None: + printable = " ".join(str(c) for c in cmd) + print(f" $ {printable}") + result = subprocess.run(cmd, check=False) + if result.returncode != 0: + fatal(f"command failed: {printable}") + + +def resolve_path(cli_value: Path | None, env_name: str, label: str) -> Path: + """Resolve a path from CLI arg or env var, or abort with a clear error.""" + if cli_value is not None: + return cli_value.expanduser().resolve() + env_value = os.environ.get(env_name) + if env_value: + return Path(env_value).expanduser().resolve() + fatal( + f"{label} path not provided.\n" + f" Set ${env_name} or pass --{label.replace('_', '-')}" + ) + + +def regen_minion_csr_rdl(csr2rdl: Path, minion_csr_rdl_out: Path) -> None: + if not csr2rdl.exists(): + fatal(f"csr2rdl.py not found at {csr2rdl}") + print("[1/3] CSV → RDL (minion_csr via csr2rdl.py)") + run([ + "python3", str(csr2rdl), + "--rdl-only", + "--rdl-out", str(minion_csr_rdl_out), + ]) + + +def regen_headers(rdl_paths: dict[str, Path], out_dir: Path) -> None: + out_dir.mkdir(parents=True, exist_ok=True) + print(f"[2/3] RDL → C headers (→ {out_dir})") + for slot, out_name, top_addrmap in SOURCES: + rdl = rdl_paths[slot] + if not rdl.exists(): + fatal(f"missing RDL source for '{slot}': {rdl}") + cmd = [ + "python3", str(RDL2HAL), + str(rdl), + "-o", str(out_dir / out_name), + ] + if top_addrmap: + cmd += ["-t", top_addrmap] + run(cmd) + + +def regen_top_header(top_rdl: Path, out_dir: Path) -> None: + if not top_rdl.exists(): + fatal(f"missing top-level RDL source: {top_rdl}") + print(f"[3/3] Top map → C header (→ {out_dir / 'top.h'})") + run([ + "python3", str(TOP2H), + str(top_rdl), + "-o", str(out_dir / "top.h"), + "-p", TOP_PREFIX, + ]) + + +def main() -> None: + ap = argparse.ArgumentParser( + description=__doc__.splitlines()[0], + formatter_class=argparse.RawDescriptionHelpFormatter, + ) + for slot, _out, _top in SOURCES: + ap.add_argument( + f"--{slot.replace('_', '-')}-rdl", + dest=f"{slot}_rdl", type=Path, default=None, + help=f"Path to the {slot} RDL source. " + f"Defaults to ${env_var_for(slot)}.", + ) + ap.add_argument( + "--top-rdl", dest="top_rdl", type=Path, default=None, + help="Path to the top-level address-map RDL. " + "Defaults to $ERBIUM_HAL_TOP_RDL.", + ) + ap.add_argument( + "--csr2rdl-script", dest="csr2rdl_script", type=Path, default=None, + help=f"Path to csr2rdl.py (produces minion_csr.rdl from CSVs). " + f"Defaults to $ERBIUM_HAL_CSR2RDL_SCRIPT, or the sibling " + f"copy at {CSR2RDL}. Not required when --skip-csr-regen.", + ) + ap.add_argument( + "--out", type=Path, default=DEFAULT_OUT, + help=f"Output directory for generated headers " + f"(default: {DEFAULT_OUT}).", + ) + ap.add_argument( + "--skip-csr-regen", action="store_true", + help="Skip the CSV→RDL step and use the minion_csr RDL as-is.", + ) + args = ap.parse_args() + + if not RDL2HAL.exists(): + fatal(f"rdl2hal.py not found at {RDL2HAL}") + if not TOP2H.exists(): + fatal(f"top2h.py not found at {TOP2H}") + + # Resolve every input path from CLI or env. + rdl_paths: dict[str, Path] = { + slot: resolve_path( + getattr(args, f"{slot}_rdl"), env_var_for(slot), f"{slot}_rdl" + ) + for slot, _, _ in SOURCES + } + top_rdl = resolve_path(args.top_rdl, "ERBIUM_HAL_TOP_RDL", "top_rdl") + out_dir = args.out.expanduser().resolve() + + if not args.skip_csr_regen: + # Prefer CLI flag, then env var, then the sibling shipped copy. + csr2rdl = ( + (args.csr2rdl_script.expanduser().resolve() + if args.csr2rdl_script else None) + or (Path(os.environ["ERBIUM_HAL_CSR2RDL_SCRIPT"]).expanduser().resolve() + if os.environ.get("ERBIUM_HAL_CSR2RDL_SCRIPT") else None) + or CSR2RDL + ) + regen_minion_csr_rdl(csr2rdl, rdl_paths["minion_csr"]) + else: + print("[skip] CSV → RDL (using existing minion_csr.rdl as-is)") + if not rdl_paths["minion_csr"].exists(): + fatal( + f"minion_csr.rdl at {rdl_paths['minion_csr']} does not exist — " + f"cannot --skip-csr-regen" + ) + + regen_headers(rdl_paths, out_dir) + regen_top_header(top_rdl, out_dir) + print(f"\nWrote {len(SOURCES) + 1} headers to {out_dir}") + + +if __name__ == "__main__": + main() diff --git a/erbium-hal/scripts/rdl2hal.py b/erbium-hal/scripts/rdl2hal.py new file mode 100755 index 000000000..ea4eb469e --- /dev/null +++ b/erbium-hal/scripts/rdl2hal.py @@ -0,0 +1,355 @@ +#!/usr/bin/env python3 +"""Generate a Semifore-style C header from a SystemRDL source. + +Emits per-register and per-field macros compatible with ET-SoC1's csrCompile +output style, plus block-level typedef struct for struct-cast access: + + Per-register: + __ADDRESS byte offset + __BYTE_ADDRESS (alias for ADDRESS) + __OFFSET same as ADDRESS (for compat) + __BYTE_OFFSET same as BYTE_ADDRESS + __SIZE size in bytes + __BYTE_SIZE (alias for SIZE) + __READ_ACCESS 0 or 1 + __WRITE_ACCESS 0 or 1 + __RESET_VALUE combined reset value + __RESET_MASK bits with defined reset + __READ_MASK readable bits + __WRITE_MASK writable bits + + Per-field: + ___MSB + ___LSB + ___WIDTH + ___READ_ACCESS + ___WRITE_ACCESS + ___RESET + ___FIELD_MASK + ___GET(x) + ___SET(x) + ___MODIFY(r, x) + + Per-enum (when SystemRDL 'encode' is used): + ___ value + + Block-level typedef: + typedef struct { + volatile uint32_t REG0; /* Offset 0x0 */ + uint8_t _pad0[0x4]; /* 0x4..0x7 reserved */ + volatile uint32_t REG1; /* Offset 0x8 */ + ... + } _t, *PTR__t; + + Register-aliasing union (when multiple regs share the same offset): + typedef union { + volatile uint32_t RBR; + volatile uint32_t DLL; + volatile uint32_t THR; + } _, *PTR__; + +Usage: + rdl2hal.py input.rdl -o output.h [-t TOP] [-I INCDIR ...] +""" +import argparse +import sys +import os +from collections import OrderedDict, defaultdict +from systemrdl import RDLCompiler +from systemrdl.node import AddrmapNode, RegNode, FieldNode +from systemrdl.rdltypes import AccessType + + +# --- helpers --------------------------------------------------------------- + +BLOCK_SUFFIXES = ("_Reg", "_Regs", "_REG", "_REGS") + + +def normalize_block(name: str) -> str: + """Strip common suffixes from addrmap names so UART_Reg -> UART.""" + for suffix in BLOCK_SUFFIXES: + if name.endswith(suffix): + return name[: -len(suffix)] + return name + + +def sw_flags(sw): + if sw == AccessType.rw: return 1, 1 + if sw == AccessType.r: return 1, 0 + if sw == AccessType.w: return 0, 1 + if sw == AccessType.rw1: return 1, 1 + if sw == AccessType.w1: return 0, 1 + return 0, 0 + + +def uname(*parts): + return "_".join(p.upper() for p in parts) + + +def hex_literal(value, regwidth=32): + if regwidth <= 32: + return f"0x{value:08X}ul" + return f"0x{value:016X}ull" + + +def ctype_for_width(regwidth: int) -> str: + return {8: "uint8_t", 16: "uint16_t", 32: "uint32_t", 64: "uint64_t"}.get( + regwidth, "uint32_t" + ) + + +def type_name_for_block(block_name: str) -> str: + """PascalCase-ish type name: 'UART' -> 'Uart_t', 'MINION_CSR' -> 'Minion_csr_t', + 'minion_csr' -> 'Minion_csr_t'.""" + n = normalize_block(block_name) + if not n: + return "_t" + if n.isupper(): + return n[0] + n[1:].lower() + "_t" + return n[0].upper() + n[1:] + "_t" + + +# --- emitters -------------------------------------------------------------- + +def emit_field(out, prefix, f: FieldNode, regwidth): + fp = uname(prefix, f.inst_name) + r, w = sw_flags(f.get_property("sw")) + fmask = ((1 << f.width) - 1) << f.low + inv_mask = ((1 << regwidth) - 1) ^ fmask + reset = f.get_property("reset") or 0 + + out.append(f"/* Field: {prefix}.{f.inst_name} */") + out.append(f"#define {fp}_MSB {f.high}u") + out.append(f"#define {fp}_LSB {f.low}u") + out.append(f"#define {fp}_WIDTH {f.width}u") + out.append(f"#define {fp}_READ_ACCESS {r}u") + out.append(f"#define {fp}_WRITE_ACCESS {w}u") + out.append(f"#define {fp}_RESET {hex_literal(reset, regwidth)}") + out.append(f"#define {fp}_FIELD_MASK {hex_literal(fmask, regwidth)}") + + lsb = f.low + if lsb == 0: + out.append(f"#define {fp}_GET(x) ((x) & {hex_literal(fmask, regwidth)})") + out.append(f"#define {fp}_SET(x) ((x) & {hex_literal(fmask, regwidth)})") + else: + out.append( + f"#define {fp}_GET(x) (((x) & {hex_literal(fmask, regwidth)}) >> {lsb})" + ) + out.append( + f"#define {fp}_SET(x) (((x) << {lsb}) & {hex_literal(fmask, regwidth)})" + ) + out.append( + f"#define {fp}_MODIFY(r, x) " + f"((((x) << {lsb}) & {hex_literal(fmask, regwidth)}) | " + f"((r) & {hex_literal(inv_mask, regwidth)}))" + ) + + enc = f.get_property("encode") + if enc is not None: + try: + members = list(enc) + except TypeError: + members = [] + for member in members: + out.append( + f"#define {fp}_{member.name.upper()} {hex_literal(member.value, regwidth)}" + ) + out.append("") + + +def emit_register(out, block_prefix, reg: RegNode): + rname = reg.inst_name + rp = uname(block_prefix, rname) + regwidth = reg.get_property("regwidth") or 32 + size_bytes = regwidth // 8 + + reset_val = 0 + reg_r = reg_w = 0 + reset_mask = read_mask = write_mask = 0 + for f in reg.fields(): + fr = f.get_property("reset") or 0 + fmask = ((1 << f.width) - 1) << f.low + reset_val |= (fr & ((1 << f.width) - 1)) << f.low + r, w = sw_flags(f.get_property("sw")) + reg_r |= r + reg_w |= w + reset_mask |= fmask + if r: + read_mask |= fmask + if w: + write_mask |= fmask + + out.append(f"/* Register: {block_prefix}.{rname} */") + out.append(f"#define {rp}_ADDRESS {hex_literal(reg.address_offset, 32)}") + out.append(f"#define {rp}_BYTE_ADDRESS {hex_literal(reg.address_offset, 32)}") + out.append(f"#define {rp}_OFFSET {hex_literal(reg.address_offset, 32)}") + out.append(f"#define {rp}_BYTE_OFFSET {hex_literal(reg.address_offset, 32)}") + out.append(f"#define {rp}_SIZE {hex_literal(size_bytes, 32)}") + out.append(f"#define {rp}_BYTE_SIZE {hex_literal(size_bytes, 32)}") + out.append(f"#define {rp}_READ_ACCESS {reg_r}u") + out.append(f"#define {rp}_WRITE_ACCESS {reg_w}u") + out.append(f"#define {rp}_RESET_VALUE {hex_literal(reset_val, regwidth)}") + out.append(f"#define {rp}_RESET_MASK {hex_literal(reset_mask, regwidth)}") + out.append(f"#define {rp}_READ_MASK {hex_literal(read_mask, regwidth)}") + out.append(f"#define {rp}_WRITE_MASK {hex_literal(write_mask, regwidth)}") + out.append("") + + for f in reg.fields(): + emit_field(out, uname(block_prefix, rname), f, regwidth) + + +def group_by_offset(regs): + """Return OrderedDict: offset -> list of RegNode sharing that offset.""" + groups = OrderedDict() + for r in sorted(regs, key=lambda r: r.address_offset): + groups.setdefault(r.address_offset, []).append(r) + return groups + + +def emit_aliasing_unions(out, block_prefix, type_prefix, groups): + """For each offset with ≥2 registers, emit a union typedef. + Returns dict: offset -> union type name (or None if no union).""" + union_names = {} + for off, regs_at_off in groups.items(): + if len(regs_at_off) < 2: + union_names[off] = None + continue + # Name the union by the first register at that offset + union_tag = regs_at_off[0].inst_name + union_type = f"{type_prefix}_{union_tag}" + out.append(f"/* Union: {block_prefix}.{union_tag} (aliased at offset 0x{off:X}) */") + out.append("typedef union {") + for r in regs_at_off: + rw = r.get_property("regwidth") or 32 + ct = ctype_for_width(rw) + # Determine access: if any field is writable it's R/W, else R + has_w = any(sw_flags(f.get_property("sw"))[1] for f in r.fields()) + access = "R/W" if has_w else "R" + out.append(f" volatile {ct} {r.inst_name}; /* Offset 0x{off:X} ({access}) */") + out.append(f"}} {union_type}, *PTR_{union_type};") + out.append("") + union_names[off] = union_type + return union_names + + +def emit_block_struct(out, block_prefix, type_name, groups, union_names): + """Emit block-level typedef struct with padding between non-contiguous regs.""" + out.append(f"/* Block-level typedef: {block_prefix} */") + out.append("typedef struct {") + cursor = 0 + pad_n = 0 + for off, regs_at_off in groups.items(): + if off > cursor: + gap = off - cursor + out.append(f" uint8_t _pad{pad_n}[0x{gap:X}]; /* 0x{cursor:X}..0x{off-1:X} reserved */") + pad_n += 1 + if len(regs_at_off) >= 2 and union_names.get(off): + # Use the union type + union_type = union_names[off] + member_name = regs_at_off[0].inst_name + out.append(f" {union_type} {member_name}; /* Offset 0x{off:X} */") + rw = regs_at_off[0].get_property("regwidth") or 32 + cursor = off + (rw // 8) + else: + r = regs_at_off[0] + rw = r.get_property("regwidth") or 32 + ct = ctype_for_width(rw) + has_w = any(sw_flags(f.get_property("sw"))[1] for f in r.fields()) + access = "R/W" if has_w else "R" + out.append(f" volatile {ct} {r.inst_name}; /* Offset 0x{off:X} ({access}) */") + cursor = off + (rw // 8) + out.append(f"}} {type_name}, *PTR_{type_name};") + out.append("") + + +def emit_block(out, block: AddrmapNode): + raw_name = block.inst_name + block_prefix = uname(normalize_block(raw_name)) + type_name = type_name_for_block(raw_name) + + out.append("/* ============================================================ */") + out.append(f"/* Block: {raw_name} (macro prefix: {block_prefix}) */") + out.append("/* ============================================================ */") + out.append("") + + regs = [r for r in block.descendants(unroll=True) if isinstance(r, RegNode)] + if not regs: + return + + # Per-register and per-field macros + for reg in sorted(regs, key=lambda r: r.address_offset): + emit_register(out, block_prefix, reg) + + # Group by offset (for aliasing detection) + groups = group_by_offset(regs) + + # Emit aliasing unions (if any) + union_names = emit_aliasing_unions(out, block_prefix, normalize_block(raw_name), groups) + + # Emit block-level struct + emit_block_struct(out, block_prefix, type_name, groups, union_names) + + +def emit_header(top: AddrmapNode, guard: str): + out = [] + out.append("/* Auto-generated by rdl2hal.py from SystemRDL. Do not edit. */") + out.append(f"#ifndef {guard}") + out.append(f"#define {guard}") + out.append("") + out.append("#include ") + out.append("") + out.append("#ifdef __cplusplus") + out.append('extern "C" {') + out.append("#endif") + out.append("") + + children = list(top.children(unroll=True)) + sub_addrmaps = [c for c in children if isinstance(c, AddrmapNode)] + if sub_addrmaps: + for b in sub_addrmaps: + emit_block(out, b) + elif any(isinstance(c, RegNode) for c in children): + emit_block(out, top) + else: + sys.exit("No registers or sub-addrmaps found in top addrmap") + + out.append("#ifdef __cplusplus") + out.append("}") + out.append("#endif") + out.append("") + out.append(f"#endif /* {guard} */") + return "\n".join(out) + + +def main(): + ap = argparse.ArgumentParser(description="Generate Semifore-style C header from SystemRDL") + ap.add_argument("rdl_file", help="Input .rdl file") + ap.add_argument("-o", "--output", required=True, help="Output .h file") + ap.add_argument("-t", "--top", default=None, help="Top-level addrmap name") + ap.add_argument("-I", "--incdir", action="append", default=[], help="Include search dirs") + ap.add_argument("-g", "--guard", default=None, help="Include guard name (default derived from output)") + args = ap.parse_args() + + rdlc = RDLCompiler() + rdlc.compile_file(args.rdl_file, incl_search_paths=args.incdir) + root = rdlc.elaborate(top_def_name=args.top) if args.top else rdlc.elaborate() + top = root.find_by_path(root.top.inst_name) + + guard = args.guard + if guard is None: + base = os.path.basename(args.output) + guard = "_" + base.replace(".", "_").upper() + "_" + + header = emit_header(top, guard) + + outdir = os.path.dirname(args.output) + if outdir and not os.path.exists(outdir): + os.makedirs(outdir, exist_ok=True) + with open(args.output, "w") as f: + f.write(header + "\n") + + print(f"Wrote {args.output}", file=sys.stderr) + + +if __name__ == "__main__": + main() diff --git a/erbium-hal/scripts/top2h.py b/erbium-hal/scripts/top2h.py new file mode 100755 index 000000000..bf03922e8 --- /dev/null +++ b/erbium-hal/scripts/top2h.py @@ -0,0 +1,540 @@ +#!/usr/bin/env python3 +"""Generate a top-level address header from a top RDL file. + +The input is a top-level memory-map style SystemRDL file such as +`top_cpu_mm.rdl`, where the important information is the placement of block +instances: + + System_Reg system_registers @0x2000000; + UART_Reg uart_registers @0x2004000; + Erbium_ESR cpu_registers @0x80000000; + +This script intentionally does not elaborate the full SystemRDL model. The top +maps often reference optional submodule RDLs that may be absent in a partial +checkout. Instead, it text-parses the top file and any available `include`d +RDLs to recover the address placements we need. + +Each placement is emitted as __BASE. When the source text +exposes enough information, __SIZE and _END macros are +emitted too. Sizes are resolved in this order for each placement's kind: + + 1. mem blocks: mementries * memwidth/8 (explicit in RDL) + 2. named reg types (`reg { ... };`): regwidth/8 bytes + 3. addrmap / regfile containers: recursive max(address + child_size) + across sub-placements and anonymous reg children + 4. no size emitted (kind not found or its content not parseable) +""" + +from __future__ import annotations + +import argparse +from dataclasses import dataclass +import re +import sys +from pathlib import Path + + +# SystemRDL has two container keywords with near-identical structure for our +# purposes: `addrmap` (top-level memory map) and `regfile` (named group of +# registers instantiable inside another map). Both can contain reg defs, reg +# instances, placements, alignment and regwidth. We treat them the same. +ADDRMAP_RE = re.compile(r"^\s*(?:addrmap|regfile)\s+([A-Za-z_][A-Za-z0-9_]*)\s*\{") +ADDR_RE = re.compile(r"@\s*(0x[0-9A-Fa-f_]+|[0-9_]+)") +INCLUDE_RE = re.compile(r'^\s*`include\s+"([^"]+)"') +MEM_RE = re.compile(r"^\s*mem\s+([A-Za-z_][A-Za-z0-9_]*)\s*\{") +MENTRIES_RE = re.compile(r"\bmementries\s*=\s*(0x[0-9A-Fa-f_]+|[0-9_]+)\s*;") +MEMWIDTH_RE = re.compile(r"\bmemwidth\s*=\s*(0x[0-9A-Fa-f_]+|[0-9_]+)\s*;") +# Anonymous reg inside an addrmap body: `reg` followed by `{` (no type name). +# We detect the `reg {` opener and then wait for the matching `}` at the +# original depth to find the trailing `Name [@ offset];`. +REG_OPEN_RE = re.compile(r"^\s*reg\s*(\{|$)") +REG_CLOSE_RE = re.compile( + r"\}\s*([A-Za-z_][A-Za-z0-9_]*)\s*(?:@\s*(0x[0-9A-Fa-f_]+|[0-9_]+))?\s*;" +) +# Named reg type definition at file scope: `reg { ... };`. Instances +# of it appear later as placements: `TypeName instance @ offset;`. +REG_TYPE_OPEN_RE = re.compile(r"^\s*reg\s+([A-Za-z_][A-Za-z0-9_]*)\s*(\{|$)") +ALIGN_RE = re.compile(r"^\s*alignment\s*=\s*(0x[0-9A-Fa-f_]+|[0-9_]+)\s*;") +DEFAULT_REGWIDTH_RE = re.compile( + r"^\s*default\s+regwidth\s*=\s*(0x[0-9A-Fa-f_]+|[0-9_]+)\s*;" +) +REGWIDTH_RE = re.compile(r"\bregwidth\s*=\s*(0x[0-9A-Fa-f_]+|[0-9_]+)\s*;") + + +@dataclass(frozen=True) +class Placement: + kind: str + instance: str + export_name: str + address: int + + +@dataclass(frozen=True) +class MemDef: + name: str + size: int + + +@dataclass(frozen=True) +class RegDef: + name: str + offset: int | None # explicit `@ 0xN` offset, or None for sequential + + +@dataclass +class AddrmapDef: + """Content of a parsed addrmap body relevant to size computation.""" + name: str + placements: list["Placement"] # sub-addrmap instances with @ offsets + regs: list[RegDef] # reg definitions inside this addrmap + alignment: int # `alignment = N;` or default 4 + regwidth: int # `default regwidth = W;` bits or default 32 + + +@dataclass(frozen=True) +class RegTypeDef: + """Named reg type defined at file scope: `reg { ... };`. + Instances of it are placed in addrmaps via ` @ offset;`.""" + name: str + regwidth: int # bits + + +def hex_literal(value: int) -> str: + if value <= 0xFFFFFFFF: + return f"0x{value:08X}ul" + return f"0x{value:016X}ull" + + +def sanitize_lines(path: Path) -> list[str]: + return [ + raw_line.split("//", 1)[0].strip() + for raw_line in path.read_text(encoding="utf-8").splitlines() + ] + + +def parse_int(token: str) -> int: + return int(token.replace("_", ""), 0) + + +def parse_available_includes(root: Path) -> list[Path]: + seen: set[Path] = set() + ordered: list[Path] = [] + + def walk(path: Path) -> None: + path = path.resolve() + if path in seen or not path.exists(): + return + seen.add(path) + ordered.append(path) + for line in sanitize_lines(path): + m = INCLUDE_RE.match(line) + if not m: + continue + inc = (path.parent / m.group(1)).resolve() + if inc.exists(): + walk(inc) + + walk(root) + return ordered + + +def parse_placement_line(line: str) -> Placement | None: + if "@" not in line or ";" not in line: + return None + + left, _ = line.split("@", 1) + tokens = left.strip().split() + if not tokens or tokens[0] == "property": + return None + + addr_match = ADDR_RE.search(line) + if not addr_match: + return None + + instance = tokens[-1] + kind = " ".join(tokens[:-1]) + export_name = tokens[1] if tokens[0] == "external" and len(tokens) >= 3 else instance + address = parse_int(addr_match.group(1)) + return Placement(kind=kind, instance=instance, export_name=export_name, address=address) + + +def parse_addrmap_defs(path: Path) -> tuple[dict[str, AddrmapDef], dict[str, RegTypeDef]]: + """Parse an RDL file and return (addrmaps, reg_types). Captures: + - addrmap sub-addrmap placements (Type instance @ offset;) + - addrmap anonymous reg definitions (reg { ... } Name [@ offset];) + - addrmap alignment and default regwidth properties + - file-scope named reg type definitions (reg { ... };) + Uses brace-depth bookkeeping to handle multi-line bodies and nested + field { ... } blocks.""" + addrmaps: dict[str, AddrmapDef] = {} + reg_types: dict[str, RegTypeDef] = {} + + cur_name: str | None = None + cur_placements: list[Placement] = [] + cur_regs: list[RegDef] = [] + cur_align = 4 + cur_regwidth = 32 + depth = 0 # brace depth relative to file start + addrmap_open_depth = -1 # depth at which the current addrmap opened + reg_open_depth: int | None = None # depth at which an anon reg body opened + + # File-scope named reg type currently being parsed. + file_regwidth = 32 # file-scope `default regwidth = W;` + cur_regtype: str | None = None + regtype_open_depth = -1 + regtype_width = 32 + + for line in sanitize_lines(path): + if not line: + continue + + opens = line.count("{") + closes = line.count("}") + + # --- File scope --- + if cur_name is None and cur_regtype is None: + m = ADDRMAP_RE.match(line) + if m: + cur_name = m.group(1) + cur_placements = [] + cur_regs = [] + cur_align = 4 + cur_regwidth = file_regwidth + addrmap_open_depth = depth + depth += opens - closes + continue + + m = REG_TYPE_OPEN_RE.match(line) + if m: + cur_regtype = m.group(1) + regtype_open_depth = depth + regtype_width = file_regwidth + depth += opens - closes + if depth <= regtype_open_depth: + # Whole `reg Name { ... };` on one line + reg_types[cur_regtype] = RegTypeDef( + name=cur_regtype, regwidth=regtype_width) + cur_regtype = None + continue + + m = DEFAULT_REGWIDTH_RE.match(line) + if m: + file_regwidth = parse_int(m.group(1)) + + depth += opens - closes + continue + + # --- Inside a named reg type body (file scope) --- + if cur_regtype is not None: + # Track regwidth overrides inside the reg body (not `default`). + m = REGWIDTH_RE.search(line) + if m and not line.lstrip().startswith("default "): + regtype_width = parse_int(m.group(1)) + depth += opens - closes + if depth <= regtype_open_depth: + reg_types[cur_regtype] = RegTypeDef( + name=cur_regtype, regwidth=regtype_width) + cur_regtype = None + continue + + # --- Inside an addrmap body --- + new_depth = depth + opens - closes + + if reg_open_depth is None and REG_OPEN_RE.match(line): + # Start of an anonymous reg body inside the addrmap. + reg_open_depth = depth + depth = new_depth + if depth <= reg_open_depth: + m = REG_CLOSE_RE.search(line) + if m: + off = parse_int(m.group(2)) if m.group(2) else None + cur_regs.append(RegDef(name=m.group(1), offset=off)) + reg_open_depth = None + continue + + if reg_open_depth is not None: + depth = new_depth + if depth <= reg_open_depth: + m = REG_CLOSE_RE.search(line) + if m: + off = parse_int(m.group(2)) if m.group(2) else None + cur_regs.append(RegDef(name=m.group(1), offset=off)) + reg_open_depth = None + continue + + m = ALIGN_RE.match(line) + if m: + cur_align = parse_int(m.group(1)) + depth = new_depth + continue + + m = DEFAULT_REGWIDTH_RE.match(line) + if m: + cur_regwidth = parse_int(m.group(1)) + depth = new_depth + continue + + placement = parse_placement_line(line) + if placement is not None: + cur_placements.append(placement) + + depth = new_depth + if depth <= addrmap_open_depth: + addrmaps[cur_name] = AddrmapDef( + name=cur_name, + placements=cur_placements, + regs=cur_regs, + alignment=cur_align, + regwidth=cur_regwidth, + ) + cur_name = None + addrmap_open_depth = -1 + reg_open_depth = None + + return addrmaps, reg_types + + +def compute_reg_block_size(addrmap: AddrmapDef) -> int: + """Derive an addrmap's block size from its reg definitions. + - regs with explicit `@ offset` sit at that byte offset + - sequential regs occupy stride = max(alignment, regwidth/8) each + Returns the max(offset + reg_size) across all regs, or 0 if none.""" + reg_bytes = addrmap.regwidth // 8 if addrmap.regwidth else 4 + stride = max(addrmap.alignment or 1, reg_bytes) + cursor = 0 + max_extent = 0 + for r in addrmap.regs: + off = r.offset if r.offset is not None else cursor + cursor = off + stride + max_extent = max(max_extent, off + reg_bytes) + return max_extent + + +# Back-compat shim: some callers only need the placements dict. +def parse_addrmaps(path: Path) -> dict[str, list[Placement]]: + addrmaps, _ = parse_addrmap_defs(path) + return {name: d.placements for name, d in addrmaps.items()} + + +def parse_memdefs(path: Path) -> dict[str, MemDef]: + memdefs: dict[str, MemDef] = {} + mem_name: str | None = None + brace_depth = 0 + in_mem = False + mementries: int | None = None + memwidth: int | None = None + + for line in sanitize_lines(path): + if not line: + continue + + if not in_mem: + m = MEM_RE.match(line) + if m: + mem_name = m.group(1) + in_mem = True + brace_depth = line.count("{") - line.count("}") + mementries = None + memwidth = None + continue + + mentries_match = MENTRIES_RE.search(line) + if mentries_match: + mementries = parse_int(mentries_match.group(1)) + memwidth_match = MEMWIDTH_RE.search(line) + if memwidth_match: + memwidth = parse_int(memwidth_match.group(1)) + + brace_depth += line.count("{") - line.count("}") + if brace_depth > 0: + continue + + if mem_name is not None and mementries is not None and memwidth is not None: + if memwidth % 8 != 0: + sys.exit(f"[top2h] memwidth for {mem_name} is not byte-aligned: {memwidth}") + memdefs[mem_name] = MemDef( + name=mem_name, + size=mementries * (memwidth // 8), + ) + + mem_name = None + in_mem = False + + return memdefs + + +def parse_top_rdl(path: Path): + all_addrmaps: dict[str, AddrmapDef] = {} + all_memdefs: dict[str, MemDef] = {} + all_reg_types: dict[str, RegTypeDef] = {} + for file_path in parse_available_includes(path): + addrmaps, reg_types = parse_addrmap_defs(file_path) + all_addrmaps.update(addrmaps) + all_reg_types.update(reg_types) + all_memdefs.update(parse_memdefs(file_path)) + + top_defs, _ = parse_addrmap_defs(path) + if not top_defs: + sys.exit(f"[top2h] no addrmap found in {path}") + top_name = next(iter(top_defs)) + top_def = all_addrmaps.get(top_name) + if top_def is None or not top_def.placements: + sys.exit(f"[top2h] no top-level placements found in {path}") + return top_name, top_def.placements, all_addrmaps, all_memdefs, all_reg_types + + +def definition_name(placement: Placement) -> str: + if placement.kind.startswith("external "): + return placement.export_name + return placement.kind + + +def resolve_size(kind: str, addrmaps: dict[str, AddrmapDef], + memdefs: dict[str, MemDef], + reg_types: dict[str, RegTypeDef], + size_cache: dict[str, int | None]) -> int | None: + """Return the byte size of an addrmap / mem / named reg-type kind. + + Resolution order: + 1. mem blocks: mementries * memwidth/8 (explicit) + 2. named reg types (reg { ... };): regwidth/8 bytes + 3. addrmaps with sub-placements: max(address + resolved child_size) + 4. addrmaps with anonymous reg children: highest occupied offset + size + (implicit from alignment + explicit or sequential @ offsets) + 5. None — nothing we can derive.""" + if kind in size_cache: + return size_cache[kind] + + memdef = memdefs.get(kind) + if memdef is not None: + size_cache[kind] = memdef.size + return memdef.size + + regtype = reg_types.get(kind) + if regtype is not None: + size_cache[kind] = regtype.regwidth // 8 + return size_cache[kind] + + addrmap = addrmaps.get(kind) + if addrmap is None: + size_cache[kind] = None + return None + + max_extent = 0 + found_child = False + + for placement in addrmap.placements: + child_size = resolve_size( + definition_name(placement), addrmaps, memdefs, reg_types, size_cache + ) + if child_size is None: + continue + found_child = True + max_extent = max(max_extent, placement.address + child_size) + + reg_extent = compute_reg_block_size(addrmap) + if reg_extent > 0: + found_child = True + max_extent = max(max_extent, reg_extent) + + size_cache[kind] = max_extent if found_child else None + return size_cache[kind] + + +def emit_placement(out: list[str], macro_prefix: str, placement: Placement, + absolute_address: int, size: int | None, + seen_macros: dict[str, int]) -> None: + macro = f"{macro_prefix}_{placement.export_name.upper()}_BASE" + if macro in seen_macros: + if seen_macros[macro] != absolute_address: + sys.exit( + f"[top2h] conflicting values for {macro}: " + f"0x{seen_macros[macro]:X} vs 0x{absolute_address:X}" + ) + return + + seen_macros[macro] = absolute_address + out.append(f"/* Instance: {placement.kind} {placement.instance} */") + out.append(f"#define {macro} {hex_literal(absolute_address)}") + if size is not None: + out.append( + f"#define {macro_prefix}_{placement.export_name.upper()}_SIZE " + f"{hex_literal(size)}" + ) + out.append( + f"#define {macro_prefix}_{placement.export_name.upper()}_END " + f"{hex_literal(absolute_address + size)}" + ) + out.append("") + + +def emit_nested_placements(out: list[str], macro_prefix: str, + placement: Placement, absolute_address: int, + addrmaps: dict[str, AddrmapDef], + memdefs: dict[str, MemDef], + reg_types: dict[str, RegTypeDef], + size_cache: dict[str, int | None], + seen_macros: dict[str, int]) -> None: + parent = addrmaps.get(placement.kind) + if parent is None: + return + for child in parent.placements: + if not child.kind.startswith("external "): + continue + child_abs = absolute_address + child.address + child_size = resolve_size( + definition_name(child), addrmaps, memdefs, reg_types, size_cache + ) + emit_placement(out, macro_prefix, child, child_abs, child_size, seen_macros) + + +def emit_header(input_path: Path, output_path: Path, prefix: str | None) -> str: + top_name, entries, addrmaps, memdefs, reg_types = parse_top_rdl(input_path) + macro_prefix = prefix or top_name.upper() + guard = f"_{output_path.name.replace('.', '_').upper()}_" + seen_macros: dict[str, int] = {} + size_cache: dict[str, int | None] = {} + + out = [] + out.append(f"/* Auto-generated by top2h.py from {input_path.name}. Do not edit. */") + out.append(f"#ifndef {guard}") + out.append(f"#define {guard}") + out.append("") + out.append("/* ============================================================ */") + out.append(f"/* Top map: {top_name} */") + out.append("/* ============================================================ */") + out.append("") + + for placement in entries: + placement_size = resolve_size( + definition_name(placement), addrmaps, memdefs, reg_types, size_cache + ) + emit_placement( + out, macro_prefix, placement, placement.address, placement_size, seen_macros + ) + emit_nested_placements( + out, macro_prefix, placement, placement.address, addrmaps, memdefs, + reg_types, size_cache, seen_macros + ) + + out.append(f"#endif /* {guard} */") + out.append("") + return "\n".join(out) + + +def main() -> None: + ap = argparse.ArgumentParser(description=__doc__.splitlines()[0]) + ap.add_argument("input", type=Path, help="Top-level RDL file to parse.") + ap.add_argument("-o", "--out", type=Path, required=True, + help="Output header path.") + ap.add_argument("-p", "--prefix", default=None, + help="Macro prefix override (default: top addrmap name).") + args = ap.parse_args() + + text = emit_header(args.input.resolve(), args.out.resolve(), args.prefix) + args.out.parent.mkdir(parents=True, exist_ok=True) + args.out.write_text(text, encoding="utf-8") + + +if __name__ == "__main__": + main() From 9263ef4221b2652943ae82d3089685471e8c375a Mon Sep 17 00:00:00 2001 From: Afonso Oliveira Date: Fri, 1 May 2026 17:42:57 +0100 Subject: [PATCH 2/3] [erbium-hal] add Erbium HAL backend Add the Erbium HAL as a repo-root host package under erbium-hal/. - include/hwinc/ contains Semifore-style register headers for Erbium peripherals generated by erbium-hal/scripts: esr, plic, uart, system, i2c, qspi, minion_csr, plus top.h for the top-level address map. - CMakeLists.txt declares erbium_hal as a header-only INTERFACE library, installs the hwinc/ headers, and exports erbium_hal::erbium_hal for consumers that use find_package(erbium_hal REQUIRED). - erbium_halConfig.cmake.in provides the package config boilerplate used by downstream CMake projects. The top-level build registers erbium-hal with HostProject(erbium-hal "") so it is built and installed from the repository root rather than through hal/platform/erbium. --- CMakeLists.txt | 1 + erbium-hal/CMakeLists.txt | 61 + erbium-hal/erbium_halConfig.cmake.in | 7 + erbium-hal/include/hwinc/esr.h | 3071 ++++++++++ erbium-hal/include/hwinc/i2c.h | 294 + erbium-hal/include/hwinc/minion_csr.h | 8142 +++++++++++++++++++++++++ erbium-hal/include/hwinc/plic.h | 3266 ++++++++++ erbium-hal/include/hwinc/qspi.h | 842 +++ erbium-hal/include/hwinc/system.h | 1298 ++++ erbium-hal/include/hwinc/top.h | 79 + erbium-hal/include/hwinc/uart.h | 490 ++ 11 files changed, 17551 insertions(+) create mode 100644 erbium-hal/CMakeLists.txt create mode 100644 erbium-hal/erbium_halConfig.cmake.in create mode 100644 erbium-hal/include/hwinc/esr.h create mode 100644 erbium-hal/include/hwinc/i2c.h create mode 100644 erbium-hal/include/hwinc/minion_csr.h create mode 100644 erbium-hal/include/hwinc/plic.h create mode 100644 erbium-hal/include/hwinc/qspi.h create mode 100644 erbium-hal/include/hwinc/system.h create mode 100644 erbium-hal/include/hwinc/top.h create mode 100644 erbium-hal/include/hwinc/uart.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 4ec82f699..ebd269c15 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -37,6 +37,7 @@ HostProject(et-driver "") HostProject(common-sw "" g3log) HostProject(device-api "" common-sw) DeviceProject(etsoc-hal "") +HostProject(erbium-hal "") DeviceProject(et-trace "") DeviceProject(et-common-libs "-DENABLE_WARNINGS_AS_ERRORS=OFF" et-trace etsoc-hal) diff --git a/erbium-hal/CMakeLists.txt b/erbium-hal/CMakeLists.txt new file mode 100644 index 000000000..9cebbbf5f --- /dev/null +++ b/erbium-hal/CMakeLists.txt @@ -0,0 +1,61 @@ +# Copyright (c) 2026 AIFoundry +# SPDX-License-Identifier: Apache-2.0 + +cmake_minimum_required(VERSION 3.15) +project(erbium_hal VERSION 0.1.0 LANGUAGES C) + +set(TARGET_NAME erbium_hal) +set(TARGET_NAMESPACE erbium_hal) + +include(GNUInstallDirs) + +### Header-only library + +# hwinc/*.h are generated register headers — no .c files to compile, so +# erbium_hal is an INTERFACE library that just exposes the include tree. +# If later additions introduce compiled sources (e.g. SP-boot wrappers +# analogous to etsoc_hal), switch STATIC and add sources here. +add_library(${TARGET_NAME} INTERFACE) +add_library(${TARGET_NAMESPACE}::${TARGET_NAME} ALIAS ${TARGET_NAME}) + +target_include_directories(${TARGET_NAME} + INTERFACE + $ + $ +) + +### Install project + +include(CMakePackageConfigHelpers) + +# hwinc/*.h — generated register headers + top.h +install(DIRECTORY include/hwinc + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/esperanto-fw/${TARGET_NAME} +) + +install(TARGETS ${TARGET_NAME} + EXPORT ${TARGET_NAME}Targets +) + +install(EXPORT ${TARGET_NAME}Targets + DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/${TARGET_NAME} + NAMESPACE ${TARGET_NAMESPACE}:: +) + +configure_package_config_file( + ${CMAKE_CURRENT_SOURCE_DIR}/${TARGET_NAME}Config.cmake.in + ${CMAKE_CURRENT_BINARY_DIR}/${TARGET_NAME}Config.cmake + INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/${TARGET_NAME} +) + +write_basic_package_version_file( + ${CMAKE_CURRENT_BINARY_DIR}/${TARGET_NAME}ConfigVersion.cmake + VERSION ${CMAKE_PROJECT_VERSION} + COMPATIBILITY SameMajorVersion +) + +install(FILES + ${CMAKE_CURRENT_BINARY_DIR}/${TARGET_NAME}Config.cmake + ${CMAKE_CURRENT_BINARY_DIR}/${TARGET_NAME}ConfigVersion.cmake + DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/${TARGET_NAME} +) diff --git a/erbium-hal/erbium_halConfig.cmake.in b/erbium-hal/erbium_halConfig.cmake.in new file mode 100644 index 000000000..35bb3393c --- /dev/null +++ b/erbium-hal/erbium_halConfig.cmake.in @@ -0,0 +1,7 @@ +# Copyright (c) 2026 AIFoundry +# SPDX-License-Identifier: Apache-2.0 + +@PACKAGE_INIT@ + +include(${CMAKE_CURRENT_LIST_DIR}/erbium_halTargets.cmake) +check_required_components(erbium_hal) diff --git a/erbium-hal/include/hwinc/esr.h b/erbium-hal/include/hwinc/esr.h new file mode 100644 index 000000000..734bd3bb8 --- /dev/null +++ b/erbium-hal/include/hwinc/esr.h @@ -0,0 +1,3071 @@ +/* Auto-generated by rdl2hal.py from SystemRDL. Do not edit. */ +#ifndef _ESR_H_ +#define _ESR_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* ============================================================ */ +/* Block: User_neigh (macro prefix: USER_NEIGH) */ +/* ============================================================ */ + +/* Register: USER_NEIGH.ipi_redirect_pc */ +#define USER_NEIGH_IPI_REDIRECT_PC_ADDRESS 0x00000040ul +#define USER_NEIGH_IPI_REDIRECT_PC_BYTE_ADDRESS 0x00000040ul +#define USER_NEIGH_IPI_REDIRECT_PC_OFFSET 0x00000040ul +#define USER_NEIGH_IPI_REDIRECT_PC_BYTE_OFFSET 0x00000040ul +#define USER_NEIGH_IPI_REDIRECT_PC_SIZE 0x00000008ul +#define USER_NEIGH_IPI_REDIRECT_PC_BYTE_SIZE 0x00000008ul +#define USER_NEIGH_IPI_REDIRECT_PC_READ_ACCESS 1u +#define USER_NEIGH_IPI_REDIRECT_PC_WRITE_ACCESS 1u +#define USER_NEIGH_IPI_REDIRECT_PC_RESET_VALUE 0x0000000000000000ull +#define USER_NEIGH_IPI_REDIRECT_PC_RESET_MASK 0x0000FFFFFFFFFFFFull +#define USER_NEIGH_IPI_REDIRECT_PC_READ_MASK 0x0000FFFFFFFFFFFFull +#define USER_NEIGH_IPI_REDIRECT_PC_WRITE_MASK 0x0000FFFFFFFFFFFFull + +/* Field: USER_NEIGH_IPI_REDIRECT_PC.ipi_redirect_pc */ +#define USER_NEIGH_IPI_REDIRECT_PC_IPI_REDIRECT_PC_MSB 47u +#define USER_NEIGH_IPI_REDIRECT_PC_IPI_REDIRECT_PC_LSB 0u +#define USER_NEIGH_IPI_REDIRECT_PC_IPI_REDIRECT_PC_WIDTH 48u +#define USER_NEIGH_IPI_REDIRECT_PC_IPI_REDIRECT_PC_READ_ACCESS 1u +#define USER_NEIGH_IPI_REDIRECT_PC_IPI_REDIRECT_PC_WRITE_ACCESS 1u +#define USER_NEIGH_IPI_REDIRECT_PC_IPI_REDIRECT_PC_RESET 0x0000000000000000ull +#define USER_NEIGH_IPI_REDIRECT_PC_IPI_REDIRECT_PC_FIELD_MASK 0x0000FFFFFFFFFFFFull +#define USER_NEIGH_IPI_REDIRECT_PC_IPI_REDIRECT_PC_GET(x) ((x) & 0x0000FFFFFFFFFFFFull) +#define USER_NEIGH_IPI_REDIRECT_PC_IPI_REDIRECT_PC_SET(x) ((x) & 0x0000FFFFFFFFFFFFull) +#define USER_NEIGH_IPI_REDIRECT_PC_IPI_REDIRECT_PC_MODIFY(r, x) ((((x) << 0) & 0x0000FFFFFFFFFFFFull) | ((r) & 0xFFFF000000000000ull)) + +/* Block-level typedef: USER_NEIGH */ +typedef struct { + uint8_t _pad0[0x40]; /* 0x0..0x3F reserved */ + volatile uint64_t ipi_redirect_pc; /* Offset 0x40 (R/W) */ +} User_neigh_t, *PTR_User_neigh_t; + +/* ============================================================ */ +/* Block: User_cpu (macro prefix: USER_CPU) */ +/* ============================================================ */ + +/* Register: USER_CPU.ipi_redirect_trigger */ +#define USER_CPU_IPI_REDIRECT_TRIGGER_ADDRESS 0x00000080ul +#define USER_CPU_IPI_REDIRECT_TRIGGER_BYTE_ADDRESS 0x00000080ul +#define USER_CPU_IPI_REDIRECT_TRIGGER_OFFSET 0x00000080ul +#define USER_CPU_IPI_REDIRECT_TRIGGER_BYTE_OFFSET 0x00000080ul +#define USER_CPU_IPI_REDIRECT_TRIGGER_SIZE 0x00000008ul +#define USER_CPU_IPI_REDIRECT_TRIGGER_BYTE_SIZE 0x00000008ul +#define USER_CPU_IPI_REDIRECT_TRIGGER_READ_ACCESS 1u +#define USER_CPU_IPI_REDIRECT_TRIGGER_WRITE_ACCESS 1u +#define USER_CPU_IPI_REDIRECT_TRIGGER_RESET_VALUE 0x0000000000000000ull +#define USER_CPU_IPI_REDIRECT_TRIGGER_RESET_MASK 0x000000000000FFFFull +#define USER_CPU_IPI_REDIRECT_TRIGGER_READ_MASK 0x000000000000FFFFull +#define USER_CPU_IPI_REDIRECT_TRIGGER_WRITE_MASK 0x000000000000FFFFull + +/* Field: USER_CPU_IPI_REDIRECT_TRIGGER.ipi_redirect_trigger */ +#define USER_CPU_IPI_REDIRECT_TRIGGER_IPI_REDIRECT_TRIGGER_MSB 15u +#define USER_CPU_IPI_REDIRECT_TRIGGER_IPI_REDIRECT_TRIGGER_LSB 0u +#define USER_CPU_IPI_REDIRECT_TRIGGER_IPI_REDIRECT_TRIGGER_WIDTH 16u +#define USER_CPU_IPI_REDIRECT_TRIGGER_IPI_REDIRECT_TRIGGER_READ_ACCESS 1u +#define USER_CPU_IPI_REDIRECT_TRIGGER_IPI_REDIRECT_TRIGGER_WRITE_ACCESS 1u +#define USER_CPU_IPI_REDIRECT_TRIGGER_IPI_REDIRECT_TRIGGER_RESET 0x0000000000000000ull +#define USER_CPU_IPI_REDIRECT_TRIGGER_IPI_REDIRECT_TRIGGER_FIELD_MASK 0x000000000000FFFFull +#define USER_CPU_IPI_REDIRECT_TRIGGER_IPI_REDIRECT_TRIGGER_GET(x) ((x) & 0x000000000000FFFFull) +#define USER_CPU_IPI_REDIRECT_TRIGGER_IPI_REDIRECT_TRIGGER_SET(x) ((x) & 0x000000000000FFFFull) +#define USER_CPU_IPI_REDIRECT_TRIGGER_IPI_REDIRECT_TRIGGER_MODIFY(r, x) ((((x) << 0) & 0x000000000000FFFFull) | ((r) & 0xFFFFFFFFFFFF0000ull)) + +/* Register: USER_CPU.CREDINC0 */ +#define USER_CPU_CREDINC0_ADDRESS 0x000000C0ul +#define USER_CPU_CREDINC0_BYTE_ADDRESS 0x000000C0ul +#define USER_CPU_CREDINC0_OFFSET 0x000000C0ul +#define USER_CPU_CREDINC0_BYTE_OFFSET 0x000000C0ul +#define USER_CPU_CREDINC0_SIZE 0x00000008ul +#define USER_CPU_CREDINC0_BYTE_SIZE 0x00000008ul +#define USER_CPU_CREDINC0_READ_ACCESS 1u +#define USER_CPU_CREDINC0_WRITE_ACCESS 0u +#define USER_CPU_CREDINC0_RESET_VALUE 0x0000000000000000ull +#define USER_CPU_CREDINC0_RESET_MASK 0x00000000000000FFull +#define USER_CPU_CREDINC0_READ_MASK 0x00000000000000FFull +#define USER_CPU_CREDINC0_WRITE_MASK 0x0000000000000000ull + +/* Field: USER_CPU_CREDINC0.mask0 */ +#define USER_CPU_CREDINC0_MASK0_MSB 7u +#define USER_CPU_CREDINC0_MASK0_LSB 0u +#define USER_CPU_CREDINC0_MASK0_WIDTH 8u +#define USER_CPU_CREDINC0_MASK0_READ_ACCESS 1u +#define USER_CPU_CREDINC0_MASK0_WRITE_ACCESS 0u +#define USER_CPU_CREDINC0_MASK0_RESET 0x0000000000000000ull +#define USER_CPU_CREDINC0_MASK0_FIELD_MASK 0x00000000000000FFull +#define USER_CPU_CREDINC0_MASK0_GET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_CREDINC0_MASK0_SET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_CREDINC0_MASK0_MODIFY(r, x) ((((x) << 0) & 0x00000000000000FFull) | ((r) & 0xFFFFFFFFFFFFFF00ull)) + +/* Register: USER_CPU.CREDINC1 */ +#define USER_CPU_CREDINC1_ADDRESS 0x000000C8ul +#define USER_CPU_CREDINC1_BYTE_ADDRESS 0x000000C8ul +#define USER_CPU_CREDINC1_OFFSET 0x000000C8ul +#define USER_CPU_CREDINC1_BYTE_OFFSET 0x000000C8ul +#define USER_CPU_CREDINC1_SIZE 0x00000008ul +#define USER_CPU_CREDINC1_BYTE_SIZE 0x00000008ul +#define USER_CPU_CREDINC1_READ_ACCESS 1u +#define USER_CPU_CREDINC1_WRITE_ACCESS 0u +#define USER_CPU_CREDINC1_RESET_VALUE 0x0000000000000000ull +#define USER_CPU_CREDINC1_RESET_MASK 0x00000000000000FFull +#define USER_CPU_CREDINC1_READ_MASK 0x00000000000000FFull +#define USER_CPU_CREDINC1_WRITE_MASK 0x0000000000000000ull + +/* Field: USER_CPU_CREDINC1.mask1 */ +#define USER_CPU_CREDINC1_MASK1_MSB 7u +#define USER_CPU_CREDINC1_MASK1_LSB 0u +#define USER_CPU_CREDINC1_MASK1_WIDTH 8u +#define USER_CPU_CREDINC1_MASK1_READ_ACCESS 1u +#define USER_CPU_CREDINC1_MASK1_WRITE_ACCESS 0u +#define USER_CPU_CREDINC1_MASK1_RESET 0x0000000000000000ull +#define USER_CPU_CREDINC1_MASK1_FIELD_MASK 0x00000000000000FFull +#define USER_CPU_CREDINC1_MASK1_GET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_CREDINC1_MASK1_SET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_CREDINC1_MASK1_MODIFY(r, x) ((((x) << 0) & 0x00000000000000FFull) | ((r) & 0xFFFFFFFFFFFFFF00ull)) + +/* Register: USER_CPU.CREDINC2 */ +#define USER_CPU_CREDINC2_ADDRESS 0x000000D0ul +#define USER_CPU_CREDINC2_BYTE_ADDRESS 0x000000D0ul +#define USER_CPU_CREDINC2_OFFSET 0x000000D0ul +#define USER_CPU_CREDINC2_BYTE_OFFSET 0x000000D0ul +#define USER_CPU_CREDINC2_SIZE 0x00000008ul +#define USER_CPU_CREDINC2_BYTE_SIZE 0x00000008ul +#define USER_CPU_CREDINC2_READ_ACCESS 1u +#define USER_CPU_CREDINC2_WRITE_ACCESS 0u +#define USER_CPU_CREDINC2_RESET_VALUE 0x0000000000000000ull +#define USER_CPU_CREDINC2_RESET_MASK 0x00000000000000FFull +#define USER_CPU_CREDINC2_READ_MASK 0x00000000000000FFull +#define USER_CPU_CREDINC2_WRITE_MASK 0x0000000000000000ull + +/* Field: USER_CPU_CREDINC2.mask2 */ +#define USER_CPU_CREDINC2_MASK2_MSB 7u +#define USER_CPU_CREDINC2_MASK2_LSB 0u +#define USER_CPU_CREDINC2_MASK2_WIDTH 8u +#define USER_CPU_CREDINC2_MASK2_READ_ACCESS 1u +#define USER_CPU_CREDINC2_MASK2_WRITE_ACCESS 0u +#define USER_CPU_CREDINC2_MASK2_RESET 0x0000000000000000ull +#define USER_CPU_CREDINC2_MASK2_FIELD_MASK 0x00000000000000FFull +#define USER_CPU_CREDINC2_MASK2_GET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_CREDINC2_MASK2_SET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_CREDINC2_MASK2_MODIFY(r, x) ((((x) << 0) & 0x00000000000000FFull) | ((r) & 0xFFFFFFFFFFFFFF00ull)) + +/* Register: USER_CPU.CREDINC3 */ +#define USER_CPU_CREDINC3_ADDRESS 0x000000D8ul +#define USER_CPU_CREDINC3_BYTE_ADDRESS 0x000000D8ul +#define USER_CPU_CREDINC3_OFFSET 0x000000D8ul +#define USER_CPU_CREDINC3_BYTE_OFFSET 0x000000D8ul +#define USER_CPU_CREDINC3_SIZE 0x00000008ul +#define USER_CPU_CREDINC3_BYTE_SIZE 0x00000008ul +#define USER_CPU_CREDINC3_READ_ACCESS 1u +#define USER_CPU_CREDINC3_WRITE_ACCESS 0u +#define USER_CPU_CREDINC3_RESET_VALUE 0x0000000000000000ull +#define USER_CPU_CREDINC3_RESET_MASK 0x00000000000000FFull +#define USER_CPU_CREDINC3_READ_MASK 0x00000000000000FFull +#define USER_CPU_CREDINC3_WRITE_MASK 0x0000000000000000ull + +/* Field: USER_CPU_CREDINC3.mask3 */ +#define USER_CPU_CREDINC3_MASK3_MSB 7u +#define USER_CPU_CREDINC3_MASK3_LSB 0u +#define USER_CPU_CREDINC3_MASK3_WIDTH 8u +#define USER_CPU_CREDINC3_MASK3_READ_ACCESS 1u +#define USER_CPU_CREDINC3_MASK3_WRITE_ACCESS 0u +#define USER_CPU_CREDINC3_MASK3_RESET 0x0000000000000000ull +#define USER_CPU_CREDINC3_MASK3_FIELD_MASK 0x00000000000000FFull +#define USER_CPU_CREDINC3_MASK3_GET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_CREDINC3_MASK3_SET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_CREDINC3_MASK3_MODIFY(r, x) ((((x) << 0) & 0x00000000000000FFull) | ((r) & 0xFFFFFFFFFFFFFF00ull)) + +/* Register: USER_CPU.fast_local_barrier0 */ +#define USER_CPU_FAST_LOCAL_BARRIER0_ADDRESS 0x00000100ul +#define USER_CPU_FAST_LOCAL_BARRIER0_BYTE_ADDRESS 0x00000100ul +#define USER_CPU_FAST_LOCAL_BARRIER0_OFFSET 0x00000100ul +#define USER_CPU_FAST_LOCAL_BARRIER0_BYTE_OFFSET 0x00000100ul +#define USER_CPU_FAST_LOCAL_BARRIER0_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER0_BYTE_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER0_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER0_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER0_RESET_VALUE 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER0_RESET_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER0_READ_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER0_WRITE_MASK 0x00000000000000FFull + +/* Field: USER_CPU_FAST_LOCAL_BARRIER0.fast_local_barrier0 */ +#define USER_CPU_FAST_LOCAL_BARRIER0_FAST_LOCAL_BARRIER0_MSB 7u +#define USER_CPU_FAST_LOCAL_BARRIER0_FAST_LOCAL_BARRIER0_LSB 0u +#define USER_CPU_FAST_LOCAL_BARRIER0_FAST_LOCAL_BARRIER0_WIDTH 8u +#define USER_CPU_FAST_LOCAL_BARRIER0_FAST_LOCAL_BARRIER0_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER0_FAST_LOCAL_BARRIER0_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER0_FAST_LOCAL_BARRIER0_RESET 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER0_FAST_LOCAL_BARRIER0_FIELD_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER0_FAST_LOCAL_BARRIER0_GET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER0_FAST_LOCAL_BARRIER0_SET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER0_FAST_LOCAL_BARRIER0_MODIFY(r, x) ((((x) << 0) & 0x00000000000000FFull) | ((r) & 0xFFFFFFFFFFFFFF00ull)) + +/* Register: USER_CPU.fast_local_barrier1 */ +#define USER_CPU_FAST_LOCAL_BARRIER1_ADDRESS 0x00000108ul +#define USER_CPU_FAST_LOCAL_BARRIER1_BYTE_ADDRESS 0x00000108ul +#define USER_CPU_FAST_LOCAL_BARRIER1_OFFSET 0x00000108ul +#define USER_CPU_FAST_LOCAL_BARRIER1_BYTE_OFFSET 0x00000108ul +#define USER_CPU_FAST_LOCAL_BARRIER1_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER1_BYTE_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER1_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER1_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER1_RESET_VALUE 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER1_RESET_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER1_READ_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER1_WRITE_MASK 0x00000000000000FFull + +/* Field: USER_CPU_FAST_LOCAL_BARRIER1.fast_local_barrier1 */ +#define USER_CPU_FAST_LOCAL_BARRIER1_FAST_LOCAL_BARRIER1_MSB 7u +#define USER_CPU_FAST_LOCAL_BARRIER1_FAST_LOCAL_BARRIER1_LSB 0u +#define USER_CPU_FAST_LOCAL_BARRIER1_FAST_LOCAL_BARRIER1_WIDTH 8u +#define USER_CPU_FAST_LOCAL_BARRIER1_FAST_LOCAL_BARRIER1_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER1_FAST_LOCAL_BARRIER1_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER1_FAST_LOCAL_BARRIER1_RESET 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER1_FAST_LOCAL_BARRIER1_FIELD_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER1_FAST_LOCAL_BARRIER1_GET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER1_FAST_LOCAL_BARRIER1_SET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER1_FAST_LOCAL_BARRIER1_MODIFY(r, x) ((((x) << 0) & 0x00000000000000FFull) | ((r) & 0xFFFFFFFFFFFFFF00ull)) + +/* Register: USER_CPU.fast_local_barrier2 */ +#define USER_CPU_FAST_LOCAL_BARRIER2_ADDRESS 0x00000110ul +#define USER_CPU_FAST_LOCAL_BARRIER2_BYTE_ADDRESS 0x00000110ul +#define USER_CPU_FAST_LOCAL_BARRIER2_OFFSET 0x00000110ul +#define USER_CPU_FAST_LOCAL_BARRIER2_BYTE_OFFSET 0x00000110ul +#define USER_CPU_FAST_LOCAL_BARRIER2_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER2_BYTE_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER2_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER2_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER2_RESET_VALUE 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER2_RESET_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER2_READ_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER2_WRITE_MASK 0x00000000000000FFull + +/* Field: USER_CPU_FAST_LOCAL_BARRIER2.fast_local_barrier2 */ +#define USER_CPU_FAST_LOCAL_BARRIER2_FAST_LOCAL_BARRIER2_MSB 7u +#define USER_CPU_FAST_LOCAL_BARRIER2_FAST_LOCAL_BARRIER2_LSB 0u +#define USER_CPU_FAST_LOCAL_BARRIER2_FAST_LOCAL_BARRIER2_WIDTH 8u +#define USER_CPU_FAST_LOCAL_BARRIER2_FAST_LOCAL_BARRIER2_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER2_FAST_LOCAL_BARRIER2_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER2_FAST_LOCAL_BARRIER2_RESET 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER2_FAST_LOCAL_BARRIER2_FIELD_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER2_FAST_LOCAL_BARRIER2_GET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER2_FAST_LOCAL_BARRIER2_SET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER2_FAST_LOCAL_BARRIER2_MODIFY(r, x) ((((x) << 0) & 0x00000000000000FFull) | ((r) & 0xFFFFFFFFFFFFFF00ull)) + +/* Register: USER_CPU.fast_local_barrier3 */ +#define USER_CPU_FAST_LOCAL_BARRIER3_ADDRESS 0x00000118ul +#define USER_CPU_FAST_LOCAL_BARRIER3_BYTE_ADDRESS 0x00000118ul +#define USER_CPU_FAST_LOCAL_BARRIER3_OFFSET 0x00000118ul +#define USER_CPU_FAST_LOCAL_BARRIER3_BYTE_OFFSET 0x00000118ul +#define USER_CPU_FAST_LOCAL_BARRIER3_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER3_BYTE_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER3_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER3_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER3_RESET_VALUE 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER3_RESET_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER3_READ_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER3_WRITE_MASK 0x00000000000000FFull + +/* Field: USER_CPU_FAST_LOCAL_BARRIER3.fast_local_barrier3 */ +#define USER_CPU_FAST_LOCAL_BARRIER3_FAST_LOCAL_BARRIER3_MSB 7u +#define USER_CPU_FAST_LOCAL_BARRIER3_FAST_LOCAL_BARRIER3_LSB 0u +#define USER_CPU_FAST_LOCAL_BARRIER3_FAST_LOCAL_BARRIER3_WIDTH 8u +#define USER_CPU_FAST_LOCAL_BARRIER3_FAST_LOCAL_BARRIER3_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER3_FAST_LOCAL_BARRIER3_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER3_FAST_LOCAL_BARRIER3_RESET 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER3_FAST_LOCAL_BARRIER3_FIELD_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER3_FAST_LOCAL_BARRIER3_GET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER3_FAST_LOCAL_BARRIER3_SET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER3_FAST_LOCAL_BARRIER3_MODIFY(r, x) ((((x) << 0) & 0x00000000000000FFull) | ((r) & 0xFFFFFFFFFFFFFF00ull)) + +/* Register: USER_CPU.fast_local_barrier4 */ +#define USER_CPU_FAST_LOCAL_BARRIER4_ADDRESS 0x00000120ul +#define USER_CPU_FAST_LOCAL_BARRIER4_BYTE_ADDRESS 0x00000120ul +#define USER_CPU_FAST_LOCAL_BARRIER4_OFFSET 0x00000120ul +#define USER_CPU_FAST_LOCAL_BARRIER4_BYTE_OFFSET 0x00000120ul +#define USER_CPU_FAST_LOCAL_BARRIER4_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER4_BYTE_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER4_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER4_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER4_RESET_VALUE 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER4_RESET_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER4_READ_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER4_WRITE_MASK 0x00000000000000FFull + +/* Field: USER_CPU_FAST_LOCAL_BARRIER4.fast_local_barrier4 */ +#define USER_CPU_FAST_LOCAL_BARRIER4_FAST_LOCAL_BARRIER4_MSB 7u +#define USER_CPU_FAST_LOCAL_BARRIER4_FAST_LOCAL_BARRIER4_LSB 0u +#define USER_CPU_FAST_LOCAL_BARRIER4_FAST_LOCAL_BARRIER4_WIDTH 8u +#define USER_CPU_FAST_LOCAL_BARRIER4_FAST_LOCAL_BARRIER4_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER4_FAST_LOCAL_BARRIER4_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER4_FAST_LOCAL_BARRIER4_RESET 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER4_FAST_LOCAL_BARRIER4_FIELD_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER4_FAST_LOCAL_BARRIER4_GET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER4_FAST_LOCAL_BARRIER4_SET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER4_FAST_LOCAL_BARRIER4_MODIFY(r, x) ((((x) << 0) & 0x00000000000000FFull) | ((r) & 0xFFFFFFFFFFFFFF00ull)) + +/* Register: USER_CPU.fast_local_barrier5 */ +#define USER_CPU_FAST_LOCAL_BARRIER5_ADDRESS 0x00000128ul +#define USER_CPU_FAST_LOCAL_BARRIER5_BYTE_ADDRESS 0x00000128ul +#define USER_CPU_FAST_LOCAL_BARRIER5_OFFSET 0x00000128ul +#define USER_CPU_FAST_LOCAL_BARRIER5_BYTE_OFFSET 0x00000128ul +#define USER_CPU_FAST_LOCAL_BARRIER5_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER5_BYTE_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER5_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER5_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER5_RESET_VALUE 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER5_RESET_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER5_READ_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER5_WRITE_MASK 0x00000000000000FFull + +/* Field: USER_CPU_FAST_LOCAL_BARRIER5.fast_local_barrier5 */ +#define USER_CPU_FAST_LOCAL_BARRIER5_FAST_LOCAL_BARRIER5_MSB 7u +#define USER_CPU_FAST_LOCAL_BARRIER5_FAST_LOCAL_BARRIER5_LSB 0u +#define USER_CPU_FAST_LOCAL_BARRIER5_FAST_LOCAL_BARRIER5_WIDTH 8u +#define USER_CPU_FAST_LOCAL_BARRIER5_FAST_LOCAL_BARRIER5_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER5_FAST_LOCAL_BARRIER5_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER5_FAST_LOCAL_BARRIER5_RESET 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER5_FAST_LOCAL_BARRIER5_FIELD_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER5_FAST_LOCAL_BARRIER5_GET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER5_FAST_LOCAL_BARRIER5_SET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER5_FAST_LOCAL_BARRIER5_MODIFY(r, x) ((((x) << 0) & 0x00000000000000FFull) | ((r) & 0xFFFFFFFFFFFFFF00ull)) + +/* Register: USER_CPU.fast_local_barrier6 */ +#define USER_CPU_FAST_LOCAL_BARRIER6_ADDRESS 0x00000130ul +#define USER_CPU_FAST_LOCAL_BARRIER6_BYTE_ADDRESS 0x00000130ul +#define USER_CPU_FAST_LOCAL_BARRIER6_OFFSET 0x00000130ul +#define USER_CPU_FAST_LOCAL_BARRIER6_BYTE_OFFSET 0x00000130ul +#define USER_CPU_FAST_LOCAL_BARRIER6_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER6_BYTE_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER6_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER6_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER6_RESET_VALUE 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER6_RESET_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER6_READ_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER6_WRITE_MASK 0x00000000000000FFull + +/* Field: USER_CPU_FAST_LOCAL_BARRIER6.fast_local_barrier6 */ +#define USER_CPU_FAST_LOCAL_BARRIER6_FAST_LOCAL_BARRIER6_MSB 7u +#define USER_CPU_FAST_LOCAL_BARRIER6_FAST_LOCAL_BARRIER6_LSB 0u +#define USER_CPU_FAST_LOCAL_BARRIER6_FAST_LOCAL_BARRIER6_WIDTH 8u +#define USER_CPU_FAST_LOCAL_BARRIER6_FAST_LOCAL_BARRIER6_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER6_FAST_LOCAL_BARRIER6_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER6_FAST_LOCAL_BARRIER6_RESET 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER6_FAST_LOCAL_BARRIER6_FIELD_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER6_FAST_LOCAL_BARRIER6_GET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER6_FAST_LOCAL_BARRIER6_SET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER6_FAST_LOCAL_BARRIER6_MODIFY(r, x) ((((x) << 0) & 0x00000000000000FFull) | ((r) & 0xFFFFFFFFFFFFFF00ull)) + +/* Register: USER_CPU.fast_local_barrier7 */ +#define USER_CPU_FAST_LOCAL_BARRIER7_ADDRESS 0x00000138ul +#define USER_CPU_FAST_LOCAL_BARRIER7_BYTE_ADDRESS 0x00000138ul +#define USER_CPU_FAST_LOCAL_BARRIER7_OFFSET 0x00000138ul +#define USER_CPU_FAST_LOCAL_BARRIER7_BYTE_OFFSET 0x00000138ul +#define USER_CPU_FAST_LOCAL_BARRIER7_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER7_BYTE_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER7_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER7_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER7_RESET_VALUE 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER7_RESET_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER7_READ_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER7_WRITE_MASK 0x00000000000000FFull + +/* Field: USER_CPU_FAST_LOCAL_BARRIER7.fast_local_barrier7 */ +#define USER_CPU_FAST_LOCAL_BARRIER7_FAST_LOCAL_BARRIER7_MSB 7u +#define USER_CPU_FAST_LOCAL_BARRIER7_FAST_LOCAL_BARRIER7_LSB 0u +#define USER_CPU_FAST_LOCAL_BARRIER7_FAST_LOCAL_BARRIER7_WIDTH 8u +#define USER_CPU_FAST_LOCAL_BARRIER7_FAST_LOCAL_BARRIER7_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER7_FAST_LOCAL_BARRIER7_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER7_FAST_LOCAL_BARRIER7_RESET 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER7_FAST_LOCAL_BARRIER7_FIELD_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER7_FAST_LOCAL_BARRIER7_GET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER7_FAST_LOCAL_BARRIER7_SET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER7_FAST_LOCAL_BARRIER7_MODIFY(r, x) ((((x) << 0) & 0x00000000000000FFull) | ((r) & 0xFFFFFFFFFFFFFF00ull)) + +/* Register: USER_CPU.fast_local_barrier8 */ +#define USER_CPU_FAST_LOCAL_BARRIER8_ADDRESS 0x00000140ul +#define USER_CPU_FAST_LOCAL_BARRIER8_BYTE_ADDRESS 0x00000140ul +#define USER_CPU_FAST_LOCAL_BARRIER8_OFFSET 0x00000140ul +#define USER_CPU_FAST_LOCAL_BARRIER8_BYTE_OFFSET 0x00000140ul +#define USER_CPU_FAST_LOCAL_BARRIER8_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER8_BYTE_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER8_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER8_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER8_RESET_VALUE 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER8_RESET_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER8_READ_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER8_WRITE_MASK 0x00000000000000FFull + +/* Field: USER_CPU_FAST_LOCAL_BARRIER8.fast_local_barrier8 */ +#define USER_CPU_FAST_LOCAL_BARRIER8_FAST_LOCAL_BARRIER8_MSB 7u +#define USER_CPU_FAST_LOCAL_BARRIER8_FAST_LOCAL_BARRIER8_LSB 0u +#define USER_CPU_FAST_LOCAL_BARRIER8_FAST_LOCAL_BARRIER8_WIDTH 8u +#define USER_CPU_FAST_LOCAL_BARRIER8_FAST_LOCAL_BARRIER8_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER8_FAST_LOCAL_BARRIER8_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER8_FAST_LOCAL_BARRIER8_RESET 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER8_FAST_LOCAL_BARRIER8_FIELD_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER8_FAST_LOCAL_BARRIER8_GET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER8_FAST_LOCAL_BARRIER8_SET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER8_FAST_LOCAL_BARRIER8_MODIFY(r, x) ((((x) << 0) & 0x00000000000000FFull) | ((r) & 0xFFFFFFFFFFFFFF00ull)) + +/* Register: USER_CPU.fast_local_barrier9 */ +#define USER_CPU_FAST_LOCAL_BARRIER9_ADDRESS 0x00000148ul +#define USER_CPU_FAST_LOCAL_BARRIER9_BYTE_ADDRESS 0x00000148ul +#define USER_CPU_FAST_LOCAL_BARRIER9_OFFSET 0x00000148ul +#define USER_CPU_FAST_LOCAL_BARRIER9_BYTE_OFFSET 0x00000148ul +#define USER_CPU_FAST_LOCAL_BARRIER9_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER9_BYTE_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER9_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER9_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER9_RESET_VALUE 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER9_RESET_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER9_READ_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER9_WRITE_MASK 0x00000000000000FFull + +/* Field: USER_CPU_FAST_LOCAL_BARRIER9.fast_local_barrier9 */ +#define USER_CPU_FAST_LOCAL_BARRIER9_FAST_LOCAL_BARRIER9_MSB 7u +#define USER_CPU_FAST_LOCAL_BARRIER9_FAST_LOCAL_BARRIER9_LSB 0u +#define USER_CPU_FAST_LOCAL_BARRIER9_FAST_LOCAL_BARRIER9_WIDTH 8u +#define USER_CPU_FAST_LOCAL_BARRIER9_FAST_LOCAL_BARRIER9_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER9_FAST_LOCAL_BARRIER9_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER9_FAST_LOCAL_BARRIER9_RESET 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER9_FAST_LOCAL_BARRIER9_FIELD_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER9_FAST_LOCAL_BARRIER9_GET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER9_FAST_LOCAL_BARRIER9_SET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER9_FAST_LOCAL_BARRIER9_MODIFY(r, x) ((((x) << 0) & 0x00000000000000FFull) | ((r) & 0xFFFFFFFFFFFFFF00ull)) + +/* Register: USER_CPU.fast_local_barrier10 */ +#define USER_CPU_FAST_LOCAL_BARRIER10_ADDRESS 0x00000150ul +#define USER_CPU_FAST_LOCAL_BARRIER10_BYTE_ADDRESS 0x00000150ul +#define USER_CPU_FAST_LOCAL_BARRIER10_OFFSET 0x00000150ul +#define USER_CPU_FAST_LOCAL_BARRIER10_BYTE_OFFSET 0x00000150ul +#define USER_CPU_FAST_LOCAL_BARRIER10_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER10_BYTE_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER10_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER10_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER10_RESET_VALUE 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER10_RESET_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER10_READ_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER10_WRITE_MASK 0x00000000000000FFull + +/* Field: USER_CPU_FAST_LOCAL_BARRIER10.fast_local_barrier10 */ +#define USER_CPU_FAST_LOCAL_BARRIER10_FAST_LOCAL_BARRIER10_MSB 7u +#define USER_CPU_FAST_LOCAL_BARRIER10_FAST_LOCAL_BARRIER10_LSB 0u +#define USER_CPU_FAST_LOCAL_BARRIER10_FAST_LOCAL_BARRIER10_WIDTH 8u +#define USER_CPU_FAST_LOCAL_BARRIER10_FAST_LOCAL_BARRIER10_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER10_FAST_LOCAL_BARRIER10_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER10_FAST_LOCAL_BARRIER10_RESET 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER10_FAST_LOCAL_BARRIER10_FIELD_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER10_FAST_LOCAL_BARRIER10_GET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER10_FAST_LOCAL_BARRIER10_SET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER10_FAST_LOCAL_BARRIER10_MODIFY(r, x) ((((x) << 0) & 0x00000000000000FFull) | ((r) & 0xFFFFFFFFFFFFFF00ull)) + +/* Register: USER_CPU.fast_local_barrier11 */ +#define USER_CPU_FAST_LOCAL_BARRIER11_ADDRESS 0x00000158ul +#define USER_CPU_FAST_LOCAL_BARRIER11_BYTE_ADDRESS 0x00000158ul +#define USER_CPU_FAST_LOCAL_BARRIER11_OFFSET 0x00000158ul +#define USER_CPU_FAST_LOCAL_BARRIER11_BYTE_OFFSET 0x00000158ul +#define USER_CPU_FAST_LOCAL_BARRIER11_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER11_BYTE_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER11_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER11_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER11_RESET_VALUE 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER11_RESET_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER11_READ_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER11_WRITE_MASK 0x00000000000000FFull + +/* Field: USER_CPU_FAST_LOCAL_BARRIER11.fast_local_barrier11 */ +#define USER_CPU_FAST_LOCAL_BARRIER11_FAST_LOCAL_BARRIER11_MSB 7u +#define USER_CPU_FAST_LOCAL_BARRIER11_FAST_LOCAL_BARRIER11_LSB 0u +#define USER_CPU_FAST_LOCAL_BARRIER11_FAST_LOCAL_BARRIER11_WIDTH 8u +#define USER_CPU_FAST_LOCAL_BARRIER11_FAST_LOCAL_BARRIER11_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER11_FAST_LOCAL_BARRIER11_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER11_FAST_LOCAL_BARRIER11_RESET 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER11_FAST_LOCAL_BARRIER11_FIELD_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER11_FAST_LOCAL_BARRIER11_GET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER11_FAST_LOCAL_BARRIER11_SET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER11_FAST_LOCAL_BARRIER11_MODIFY(r, x) ((((x) << 0) & 0x00000000000000FFull) | ((r) & 0xFFFFFFFFFFFFFF00ull)) + +/* Register: USER_CPU.fast_local_barrier12 */ +#define USER_CPU_FAST_LOCAL_BARRIER12_ADDRESS 0x00000160ul +#define USER_CPU_FAST_LOCAL_BARRIER12_BYTE_ADDRESS 0x00000160ul +#define USER_CPU_FAST_LOCAL_BARRIER12_OFFSET 0x00000160ul +#define USER_CPU_FAST_LOCAL_BARRIER12_BYTE_OFFSET 0x00000160ul +#define USER_CPU_FAST_LOCAL_BARRIER12_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER12_BYTE_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER12_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER12_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER12_RESET_VALUE 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER12_RESET_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER12_READ_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER12_WRITE_MASK 0x00000000000000FFull + +/* Field: USER_CPU_FAST_LOCAL_BARRIER12.fast_local_barrier12 */ +#define USER_CPU_FAST_LOCAL_BARRIER12_FAST_LOCAL_BARRIER12_MSB 7u +#define USER_CPU_FAST_LOCAL_BARRIER12_FAST_LOCAL_BARRIER12_LSB 0u +#define USER_CPU_FAST_LOCAL_BARRIER12_FAST_LOCAL_BARRIER12_WIDTH 8u +#define USER_CPU_FAST_LOCAL_BARRIER12_FAST_LOCAL_BARRIER12_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER12_FAST_LOCAL_BARRIER12_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER12_FAST_LOCAL_BARRIER12_RESET 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER12_FAST_LOCAL_BARRIER12_FIELD_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER12_FAST_LOCAL_BARRIER12_GET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER12_FAST_LOCAL_BARRIER12_SET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER12_FAST_LOCAL_BARRIER12_MODIFY(r, x) ((((x) << 0) & 0x00000000000000FFull) | ((r) & 0xFFFFFFFFFFFFFF00ull)) + +/* Register: USER_CPU.fast_local_barrier13 */ +#define USER_CPU_FAST_LOCAL_BARRIER13_ADDRESS 0x00000168ul +#define USER_CPU_FAST_LOCAL_BARRIER13_BYTE_ADDRESS 0x00000168ul +#define USER_CPU_FAST_LOCAL_BARRIER13_OFFSET 0x00000168ul +#define USER_CPU_FAST_LOCAL_BARRIER13_BYTE_OFFSET 0x00000168ul +#define USER_CPU_FAST_LOCAL_BARRIER13_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER13_BYTE_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER13_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER13_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER13_RESET_VALUE 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER13_RESET_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER13_READ_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER13_WRITE_MASK 0x00000000000000FFull + +/* Field: USER_CPU_FAST_LOCAL_BARRIER13.fast_local_barrier13 */ +#define USER_CPU_FAST_LOCAL_BARRIER13_FAST_LOCAL_BARRIER13_MSB 7u +#define USER_CPU_FAST_LOCAL_BARRIER13_FAST_LOCAL_BARRIER13_LSB 0u +#define USER_CPU_FAST_LOCAL_BARRIER13_FAST_LOCAL_BARRIER13_WIDTH 8u +#define USER_CPU_FAST_LOCAL_BARRIER13_FAST_LOCAL_BARRIER13_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER13_FAST_LOCAL_BARRIER13_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER13_FAST_LOCAL_BARRIER13_RESET 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER13_FAST_LOCAL_BARRIER13_FIELD_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER13_FAST_LOCAL_BARRIER13_GET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER13_FAST_LOCAL_BARRIER13_SET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER13_FAST_LOCAL_BARRIER13_MODIFY(r, x) ((((x) << 0) & 0x00000000000000FFull) | ((r) & 0xFFFFFFFFFFFFFF00ull)) + +/* Register: USER_CPU.fast_local_barrier14 */ +#define USER_CPU_FAST_LOCAL_BARRIER14_ADDRESS 0x00000170ul +#define USER_CPU_FAST_LOCAL_BARRIER14_BYTE_ADDRESS 0x00000170ul +#define USER_CPU_FAST_LOCAL_BARRIER14_OFFSET 0x00000170ul +#define USER_CPU_FAST_LOCAL_BARRIER14_BYTE_OFFSET 0x00000170ul +#define USER_CPU_FAST_LOCAL_BARRIER14_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER14_BYTE_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER14_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER14_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER14_RESET_VALUE 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER14_RESET_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER14_READ_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER14_WRITE_MASK 0x00000000000000FFull + +/* Field: USER_CPU_FAST_LOCAL_BARRIER14.fast_local_barrier14 */ +#define USER_CPU_FAST_LOCAL_BARRIER14_FAST_LOCAL_BARRIER14_MSB 7u +#define USER_CPU_FAST_LOCAL_BARRIER14_FAST_LOCAL_BARRIER14_LSB 0u +#define USER_CPU_FAST_LOCAL_BARRIER14_FAST_LOCAL_BARRIER14_WIDTH 8u +#define USER_CPU_FAST_LOCAL_BARRIER14_FAST_LOCAL_BARRIER14_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER14_FAST_LOCAL_BARRIER14_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER14_FAST_LOCAL_BARRIER14_RESET 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER14_FAST_LOCAL_BARRIER14_FIELD_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER14_FAST_LOCAL_BARRIER14_GET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER14_FAST_LOCAL_BARRIER14_SET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER14_FAST_LOCAL_BARRIER14_MODIFY(r, x) ((((x) << 0) & 0x00000000000000FFull) | ((r) & 0xFFFFFFFFFFFFFF00ull)) + +/* Register: USER_CPU.fast_local_barrier15 */ +#define USER_CPU_FAST_LOCAL_BARRIER15_ADDRESS 0x00000178ul +#define USER_CPU_FAST_LOCAL_BARRIER15_BYTE_ADDRESS 0x00000178ul +#define USER_CPU_FAST_LOCAL_BARRIER15_OFFSET 0x00000178ul +#define USER_CPU_FAST_LOCAL_BARRIER15_BYTE_OFFSET 0x00000178ul +#define USER_CPU_FAST_LOCAL_BARRIER15_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER15_BYTE_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER15_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER15_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER15_RESET_VALUE 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER15_RESET_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER15_READ_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER15_WRITE_MASK 0x00000000000000FFull + +/* Field: USER_CPU_FAST_LOCAL_BARRIER15.fast_local_barrier15 */ +#define USER_CPU_FAST_LOCAL_BARRIER15_FAST_LOCAL_BARRIER15_MSB 7u +#define USER_CPU_FAST_LOCAL_BARRIER15_FAST_LOCAL_BARRIER15_LSB 0u +#define USER_CPU_FAST_LOCAL_BARRIER15_FAST_LOCAL_BARRIER15_WIDTH 8u +#define USER_CPU_FAST_LOCAL_BARRIER15_FAST_LOCAL_BARRIER15_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER15_FAST_LOCAL_BARRIER15_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER15_FAST_LOCAL_BARRIER15_RESET 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER15_FAST_LOCAL_BARRIER15_FIELD_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER15_FAST_LOCAL_BARRIER15_GET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER15_FAST_LOCAL_BARRIER15_SET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER15_FAST_LOCAL_BARRIER15_MODIFY(r, x) ((((x) << 0) & 0x00000000000000FFull) | ((r) & 0xFFFFFFFFFFFFFF00ull)) + +/* Register: USER_CPU.fast_local_barrier16 */ +#define USER_CPU_FAST_LOCAL_BARRIER16_ADDRESS 0x00000180ul +#define USER_CPU_FAST_LOCAL_BARRIER16_BYTE_ADDRESS 0x00000180ul +#define USER_CPU_FAST_LOCAL_BARRIER16_OFFSET 0x00000180ul +#define USER_CPU_FAST_LOCAL_BARRIER16_BYTE_OFFSET 0x00000180ul +#define USER_CPU_FAST_LOCAL_BARRIER16_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER16_BYTE_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER16_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER16_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER16_RESET_VALUE 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER16_RESET_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER16_READ_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER16_WRITE_MASK 0x00000000000000FFull + +/* Field: USER_CPU_FAST_LOCAL_BARRIER16.fast_local_barrier16 */ +#define USER_CPU_FAST_LOCAL_BARRIER16_FAST_LOCAL_BARRIER16_MSB 7u +#define USER_CPU_FAST_LOCAL_BARRIER16_FAST_LOCAL_BARRIER16_LSB 0u +#define USER_CPU_FAST_LOCAL_BARRIER16_FAST_LOCAL_BARRIER16_WIDTH 8u +#define USER_CPU_FAST_LOCAL_BARRIER16_FAST_LOCAL_BARRIER16_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER16_FAST_LOCAL_BARRIER16_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER16_FAST_LOCAL_BARRIER16_RESET 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER16_FAST_LOCAL_BARRIER16_FIELD_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER16_FAST_LOCAL_BARRIER16_GET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER16_FAST_LOCAL_BARRIER16_SET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER16_FAST_LOCAL_BARRIER16_MODIFY(r, x) ((((x) << 0) & 0x00000000000000FFull) | ((r) & 0xFFFFFFFFFFFFFF00ull)) + +/* Register: USER_CPU.fast_local_barrier17 */ +#define USER_CPU_FAST_LOCAL_BARRIER17_ADDRESS 0x00000188ul +#define USER_CPU_FAST_LOCAL_BARRIER17_BYTE_ADDRESS 0x00000188ul +#define USER_CPU_FAST_LOCAL_BARRIER17_OFFSET 0x00000188ul +#define USER_CPU_FAST_LOCAL_BARRIER17_BYTE_OFFSET 0x00000188ul +#define USER_CPU_FAST_LOCAL_BARRIER17_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER17_BYTE_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER17_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER17_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER17_RESET_VALUE 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER17_RESET_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER17_READ_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER17_WRITE_MASK 0x00000000000000FFull + +/* Field: USER_CPU_FAST_LOCAL_BARRIER17.fast_local_barrier17 */ +#define USER_CPU_FAST_LOCAL_BARRIER17_FAST_LOCAL_BARRIER17_MSB 7u +#define USER_CPU_FAST_LOCAL_BARRIER17_FAST_LOCAL_BARRIER17_LSB 0u +#define USER_CPU_FAST_LOCAL_BARRIER17_FAST_LOCAL_BARRIER17_WIDTH 8u +#define USER_CPU_FAST_LOCAL_BARRIER17_FAST_LOCAL_BARRIER17_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER17_FAST_LOCAL_BARRIER17_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER17_FAST_LOCAL_BARRIER17_RESET 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER17_FAST_LOCAL_BARRIER17_FIELD_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER17_FAST_LOCAL_BARRIER17_GET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER17_FAST_LOCAL_BARRIER17_SET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER17_FAST_LOCAL_BARRIER17_MODIFY(r, x) ((((x) << 0) & 0x00000000000000FFull) | ((r) & 0xFFFFFFFFFFFFFF00ull)) + +/* Register: USER_CPU.fast_local_barrier18 */ +#define USER_CPU_FAST_LOCAL_BARRIER18_ADDRESS 0x00000190ul +#define USER_CPU_FAST_LOCAL_BARRIER18_BYTE_ADDRESS 0x00000190ul +#define USER_CPU_FAST_LOCAL_BARRIER18_OFFSET 0x00000190ul +#define USER_CPU_FAST_LOCAL_BARRIER18_BYTE_OFFSET 0x00000190ul +#define USER_CPU_FAST_LOCAL_BARRIER18_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER18_BYTE_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER18_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER18_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER18_RESET_VALUE 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER18_RESET_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER18_READ_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER18_WRITE_MASK 0x00000000000000FFull + +/* Field: USER_CPU_FAST_LOCAL_BARRIER18.fast_local_barrier18 */ +#define USER_CPU_FAST_LOCAL_BARRIER18_FAST_LOCAL_BARRIER18_MSB 7u +#define USER_CPU_FAST_LOCAL_BARRIER18_FAST_LOCAL_BARRIER18_LSB 0u +#define USER_CPU_FAST_LOCAL_BARRIER18_FAST_LOCAL_BARRIER18_WIDTH 8u +#define USER_CPU_FAST_LOCAL_BARRIER18_FAST_LOCAL_BARRIER18_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER18_FAST_LOCAL_BARRIER18_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER18_FAST_LOCAL_BARRIER18_RESET 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER18_FAST_LOCAL_BARRIER18_FIELD_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER18_FAST_LOCAL_BARRIER18_GET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER18_FAST_LOCAL_BARRIER18_SET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER18_FAST_LOCAL_BARRIER18_MODIFY(r, x) ((((x) << 0) & 0x00000000000000FFull) | ((r) & 0xFFFFFFFFFFFFFF00ull)) + +/* Register: USER_CPU.fast_local_barrier19 */ +#define USER_CPU_FAST_LOCAL_BARRIER19_ADDRESS 0x00000198ul +#define USER_CPU_FAST_LOCAL_BARRIER19_BYTE_ADDRESS 0x00000198ul +#define USER_CPU_FAST_LOCAL_BARRIER19_OFFSET 0x00000198ul +#define USER_CPU_FAST_LOCAL_BARRIER19_BYTE_OFFSET 0x00000198ul +#define USER_CPU_FAST_LOCAL_BARRIER19_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER19_BYTE_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER19_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER19_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER19_RESET_VALUE 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER19_RESET_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER19_READ_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER19_WRITE_MASK 0x00000000000000FFull + +/* Field: USER_CPU_FAST_LOCAL_BARRIER19.fast_local_barrier19 */ +#define USER_CPU_FAST_LOCAL_BARRIER19_FAST_LOCAL_BARRIER19_MSB 7u +#define USER_CPU_FAST_LOCAL_BARRIER19_FAST_LOCAL_BARRIER19_LSB 0u +#define USER_CPU_FAST_LOCAL_BARRIER19_FAST_LOCAL_BARRIER19_WIDTH 8u +#define USER_CPU_FAST_LOCAL_BARRIER19_FAST_LOCAL_BARRIER19_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER19_FAST_LOCAL_BARRIER19_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER19_FAST_LOCAL_BARRIER19_RESET 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER19_FAST_LOCAL_BARRIER19_FIELD_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER19_FAST_LOCAL_BARRIER19_GET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER19_FAST_LOCAL_BARRIER19_SET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER19_FAST_LOCAL_BARRIER19_MODIFY(r, x) ((((x) << 0) & 0x00000000000000FFull) | ((r) & 0xFFFFFFFFFFFFFF00ull)) + +/* Register: USER_CPU.fast_local_barrier20 */ +#define USER_CPU_FAST_LOCAL_BARRIER20_ADDRESS 0x000001A0ul +#define USER_CPU_FAST_LOCAL_BARRIER20_BYTE_ADDRESS 0x000001A0ul +#define USER_CPU_FAST_LOCAL_BARRIER20_OFFSET 0x000001A0ul +#define USER_CPU_FAST_LOCAL_BARRIER20_BYTE_OFFSET 0x000001A0ul +#define USER_CPU_FAST_LOCAL_BARRIER20_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER20_BYTE_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER20_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER20_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER20_RESET_VALUE 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER20_RESET_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER20_READ_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER20_WRITE_MASK 0x00000000000000FFull + +/* Field: USER_CPU_FAST_LOCAL_BARRIER20.fast_local_barrier20 */ +#define USER_CPU_FAST_LOCAL_BARRIER20_FAST_LOCAL_BARRIER20_MSB 7u +#define USER_CPU_FAST_LOCAL_BARRIER20_FAST_LOCAL_BARRIER20_LSB 0u +#define USER_CPU_FAST_LOCAL_BARRIER20_FAST_LOCAL_BARRIER20_WIDTH 8u +#define USER_CPU_FAST_LOCAL_BARRIER20_FAST_LOCAL_BARRIER20_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER20_FAST_LOCAL_BARRIER20_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER20_FAST_LOCAL_BARRIER20_RESET 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER20_FAST_LOCAL_BARRIER20_FIELD_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER20_FAST_LOCAL_BARRIER20_GET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER20_FAST_LOCAL_BARRIER20_SET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER20_FAST_LOCAL_BARRIER20_MODIFY(r, x) ((((x) << 0) & 0x00000000000000FFull) | ((r) & 0xFFFFFFFFFFFFFF00ull)) + +/* Register: USER_CPU.fast_local_barrier21 */ +#define USER_CPU_FAST_LOCAL_BARRIER21_ADDRESS 0x000001A8ul +#define USER_CPU_FAST_LOCAL_BARRIER21_BYTE_ADDRESS 0x000001A8ul +#define USER_CPU_FAST_LOCAL_BARRIER21_OFFSET 0x000001A8ul +#define USER_CPU_FAST_LOCAL_BARRIER21_BYTE_OFFSET 0x000001A8ul +#define USER_CPU_FAST_LOCAL_BARRIER21_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER21_BYTE_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER21_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER21_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER21_RESET_VALUE 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER21_RESET_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER21_READ_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER21_WRITE_MASK 0x00000000000000FFull + +/* Field: USER_CPU_FAST_LOCAL_BARRIER21.fast_local_barrier21 */ +#define USER_CPU_FAST_LOCAL_BARRIER21_FAST_LOCAL_BARRIER21_MSB 7u +#define USER_CPU_FAST_LOCAL_BARRIER21_FAST_LOCAL_BARRIER21_LSB 0u +#define USER_CPU_FAST_LOCAL_BARRIER21_FAST_LOCAL_BARRIER21_WIDTH 8u +#define USER_CPU_FAST_LOCAL_BARRIER21_FAST_LOCAL_BARRIER21_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER21_FAST_LOCAL_BARRIER21_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER21_FAST_LOCAL_BARRIER21_RESET 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER21_FAST_LOCAL_BARRIER21_FIELD_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER21_FAST_LOCAL_BARRIER21_GET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER21_FAST_LOCAL_BARRIER21_SET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER21_FAST_LOCAL_BARRIER21_MODIFY(r, x) ((((x) << 0) & 0x00000000000000FFull) | ((r) & 0xFFFFFFFFFFFFFF00ull)) + +/* Register: USER_CPU.fast_local_barrier22 */ +#define USER_CPU_FAST_LOCAL_BARRIER22_ADDRESS 0x000001B0ul +#define USER_CPU_FAST_LOCAL_BARRIER22_BYTE_ADDRESS 0x000001B0ul +#define USER_CPU_FAST_LOCAL_BARRIER22_OFFSET 0x000001B0ul +#define USER_CPU_FAST_LOCAL_BARRIER22_BYTE_OFFSET 0x000001B0ul +#define USER_CPU_FAST_LOCAL_BARRIER22_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER22_BYTE_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER22_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER22_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER22_RESET_VALUE 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER22_RESET_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER22_READ_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER22_WRITE_MASK 0x00000000000000FFull + +/* Field: USER_CPU_FAST_LOCAL_BARRIER22.fast_local_barrier22 */ +#define USER_CPU_FAST_LOCAL_BARRIER22_FAST_LOCAL_BARRIER22_MSB 7u +#define USER_CPU_FAST_LOCAL_BARRIER22_FAST_LOCAL_BARRIER22_LSB 0u +#define USER_CPU_FAST_LOCAL_BARRIER22_FAST_LOCAL_BARRIER22_WIDTH 8u +#define USER_CPU_FAST_LOCAL_BARRIER22_FAST_LOCAL_BARRIER22_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER22_FAST_LOCAL_BARRIER22_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER22_FAST_LOCAL_BARRIER22_RESET 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER22_FAST_LOCAL_BARRIER22_FIELD_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER22_FAST_LOCAL_BARRIER22_GET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER22_FAST_LOCAL_BARRIER22_SET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER22_FAST_LOCAL_BARRIER22_MODIFY(r, x) ((((x) << 0) & 0x00000000000000FFull) | ((r) & 0xFFFFFFFFFFFFFF00ull)) + +/* Register: USER_CPU.fast_local_barrier23 */ +#define USER_CPU_FAST_LOCAL_BARRIER23_ADDRESS 0x000001B8ul +#define USER_CPU_FAST_LOCAL_BARRIER23_BYTE_ADDRESS 0x000001B8ul +#define USER_CPU_FAST_LOCAL_BARRIER23_OFFSET 0x000001B8ul +#define USER_CPU_FAST_LOCAL_BARRIER23_BYTE_OFFSET 0x000001B8ul +#define USER_CPU_FAST_LOCAL_BARRIER23_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER23_BYTE_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER23_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER23_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER23_RESET_VALUE 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER23_RESET_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER23_READ_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER23_WRITE_MASK 0x00000000000000FFull + +/* Field: USER_CPU_FAST_LOCAL_BARRIER23.fast_local_barrier23 */ +#define USER_CPU_FAST_LOCAL_BARRIER23_FAST_LOCAL_BARRIER23_MSB 7u +#define USER_CPU_FAST_LOCAL_BARRIER23_FAST_LOCAL_BARRIER23_LSB 0u +#define USER_CPU_FAST_LOCAL_BARRIER23_FAST_LOCAL_BARRIER23_WIDTH 8u +#define USER_CPU_FAST_LOCAL_BARRIER23_FAST_LOCAL_BARRIER23_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER23_FAST_LOCAL_BARRIER23_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER23_FAST_LOCAL_BARRIER23_RESET 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER23_FAST_LOCAL_BARRIER23_FIELD_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER23_FAST_LOCAL_BARRIER23_GET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER23_FAST_LOCAL_BARRIER23_SET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER23_FAST_LOCAL_BARRIER23_MODIFY(r, x) ((((x) << 0) & 0x00000000000000FFull) | ((r) & 0xFFFFFFFFFFFFFF00ull)) + +/* Register: USER_CPU.fast_local_barrier24 */ +#define USER_CPU_FAST_LOCAL_BARRIER24_ADDRESS 0x000001C0ul +#define USER_CPU_FAST_LOCAL_BARRIER24_BYTE_ADDRESS 0x000001C0ul +#define USER_CPU_FAST_LOCAL_BARRIER24_OFFSET 0x000001C0ul +#define USER_CPU_FAST_LOCAL_BARRIER24_BYTE_OFFSET 0x000001C0ul +#define USER_CPU_FAST_LOCAL_BARRIER24_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER24_BYTE_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER24_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER24_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER24_RESET_VALUE 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER24_RESET_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER24_READ_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER24_WRITE_MASK 0x00000000000000FFull + +/* Field: USER_CPU_FAST_LOCAL_BARRIER24.fast_local_barrier24 */ +#define USER_CPU_FAST_LOCAL_BARRIER24_FAST_LOCAL_BARRIER24_MSB 7u +#define USER_CPU_FAST_LOCAL_BARRIER24_FAST_LOCAL_BARRIER24_LSB 0u +#define USER_CPU_FAST_LOCAL_BARRIER24_FAST_LOCAL_BARRIER24_WIDTH 8u +#define USER_CPU_FAST_LOCAL_BARRIER24_FAST_LOCAL_BARRIER24_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER24_FAST_LOCAL_BARRIER24_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER24_FAST_LOCAL_BARRIER24_RESET 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER24_FAST_LOCAL_BARRIER24_FIELD_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER24_FAST_LOCAL_BARRIER24_GET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER24_FAST_LOCAL_BARRIER24_SET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER24_FAST_LOCAL_BARRIER24_MODIFY(r, x) ((((x) << 0) & 0x00000000000000FFull) | ((r) & 0xFFFFFFFFFFFFFF00ull)) + +/* Register: USER_CPU.fast_local_barrier25 */ +#define USER_CPU_FAST_LOCAL_BARRIER25_ADDRESS 0x000001C8ul +#define USER_CPU_FAST_LOCAL_BARRIER25_BYTE_ADDRESS 0x000001C8ul +#define USER_CPU_FAST_LOCAL_BARRIER25_OFFSET 0x000001C8ul +#define USER_CPU_FAST_LOCAL_BARRIER25_BYTE_OFFSET 0x000001C8ul +#define USER_CPU_FAST_LOCAL_BARRIER25_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER25_BYTE_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER25_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER25_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER25_RESET_VALUE 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER25_RESET_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER25_READ_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER25_WRITE_MASK 0x00000000000000FFull + +/* Field: USER_CPU_FAST_LOCAL_BARRIER25.fast_local_barrier25 */ +#define USER_CPU_FAST_LOCAL_BARRIER25_FAST_LOCAL_BARRIER25_MSB 7u +#define USER_CPU_FAST_LOCAL_BARRIER25_FAST_LOCAL_BARRIER25_LSB 0u +#define USER_CPU_FAST_LOCAL_BARRIER25_FAST_LOCAL_BARRIER25_WIDTH 8u +#define USER_CPU_FAST_LOCAL_BARRIER25_FAST_LOCAL_BARRIER25_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER25_FAST_LOCAL_BARRIER25_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER25_FAST_LOCAL_BARRIER25_RESET 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER25_FAST_LOCAL_BARRIER25_FIELD_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER25_FAST_LOCAL_BARRIER25_GET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER25_FAST_LOCAL_BARRIER25_SET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER25_FAST_LOCAL_BARRIER25_MODIFY(r, x) ((((x) << 0) & 0x00000000000000FFull) | ((r) & 0xFFFFFFFFFFFFFF00ull)) + +/* Register: USER_CPU.fast_local_barrier26 */ +#define USER_CPU_FAST_LOCAL_BARRIER26_ADDRESS 0x000001D0ul +#define USER_CPU_FAST_LOCAL_BARRIER26_BYTE_ADDRESS 0x000001D0ul +#define USER_CPU_FAST_LOCAL_BARRIER26_OFFSET 0x000001D0ul +#define USER_CPU_FAST_LOCAL_BARRIER26_BYTE_OFFSET 0x000001D0ul +#define USER_CPU_FAST_LOCAL_BARRIER26_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER26_BYTE_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER26_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER26_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER26_RESET_VALUE 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER26_RESET_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER26_READ_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER26_WRITE_MASK 0x00000000000000FFull + +/* Field: USER_CPU_FAST_LOCAL_BARRIER26.fast_local_barrier26 */ +#define USER_CPU_FAST_LOCAL_BARRIER26_FAST_LOCAL_BARRIER26_MSB 7u +#define USER_CPU_FAST_LOCAL_BARRIER26_FAST_LOCAL_BARRIER26_LSB 0u +#define USER_CPU_FAST_LOCAL_BARRIER26_FAST_LOCAL_BARRIER26_WIDTH 8u +#define USER_CPU_FAST_LOCAL_BARRIER26_FAST_LOCAL_BARRIER26_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER26_FAST_LOCAL_BARRIER26_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER26_FAST_LOCAL_BARRIER26_RESET 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER26_FAST_LOCAL_BARRIER26_FIELD_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER26_FAST_LOCAL_BARRIER26_GET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER26_FAST_LOCAL_BARRIER26_SET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER26_FAST_LOCAL_BARRIER26_MODIFY(r, x) ((((x) << 0) & 0x00000000000000FFull) | ((r) & 0xFFFFFFFFFFFFFF00ull)) + +/* Register: USER_CPU.fast_local_barrier27 */ +#define USER_CPU_FAST_LOCAL_BARRIER27_ADDRESS 0x000001D8ul +#define USER_CPU_FAST_LOCAL_BARRIER27_BYTE_ADDRESS 0x000001D8ul +#define USER_CPU_FAST_LOCAL_BARRIER27_OFFSET 0x000001D8ul +#define USER_CPU_FAST_LOCAL_BARRIER27_BYTE_OFFSET 0x000001D8ul +#define USER_CPU_FAST_LOCAL_BARRIER27_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER27_BYTE_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER27_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER27_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER27_RESET_VALUE 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER27_RESET_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER27_READ_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER27_WRITE_MASK 0x00000000000000FFull + +/* Field: USER_CPU_FAST_LOCAL_BARRIER27.fast_local_barrier27 */ +#define USER_CPU_FAST_LOCAL_BARRIER27_FAST_LOCAL_BARRIER27_MSB 7u +#define USER_CPU_FAST_LOCAL_BARRIER27_FAST_LOCAL_BARRIER27_LSB 0u +#define USER_CPU_FAST_LOCAL_BARRIER27_FAST_LOCAL_BARRIER27_WIDTH 8u +#define USER_CPU_FAST_LOCAL_BARRIER27_FAST_LOCAL_BARRIER27_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER27_FAST_LOCAL_BARRIER27_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER27_FAST_LOCAL_BARRIER27_RESET 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER27_FAST_LOCAL_BARRIER27_FIELD_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER27_FAST_LOCAL_BARRIER27_GET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER27_FAST_LOCAL_BARRIER27_SET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER27_FAST_LOCAL_BARRIER27_MODIFY(r, x) ((((x) << 0) & 0x00000000000000FFull) | ((r) & 0xFFFFFFFFFFFFFF00ull)) + +/* Register: USER_CPU.fast_local_barrier28 */ +#define USER_CPU_FAST_LOCAL_BARRIER28_ADDRESS 0x000001E0ul +#define USER_CPU_FAST_LOCAL_BARRIER28_BYTE_ADDRESS 0x000001E0ul +#define USER_CPU_FAST_LOCAL_BARRIER28_OFFSET 0x000001E0ul +#define USER_CPU_FAST_LOCAL_BARRIER28_BYTE_OFFSET 0x000001E0ul +#define USER_CPU_FAST_LOCAL_BARRIER28_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER28_BYTE_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER28_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER28_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER28_RESET_VALUE 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER28_RESET_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER28_READ_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER28_WRITE_MASK 0x00000000000000FFull + +/* Field: USER_CPU_FAST_LOCAL_BARRIER28.fast_local_barrier28 */ +#define USER_CPU_FAST_LOCAL_BARRIER28_FAST_LOCAL_BARRIER28_MSB 7u +#define USER_CPU_FAST_LOCAL_BARRIER28_FAST_LOCAL_BARRIER28_LSB 0u +#define USER_CPU_FAST_LOCAL_BARRIER28_FAST_LOCAL_BARRIER28_WIDTH 8u +#define USER_CPU_FAST_LOCAL_BARRIER28_FAST_LOCAL_BARRIER28_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER28_FAST_LOCAL_BARRIER28_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER28_FAST_LOCAL_BARRIER28_RESET 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER28_FAST_LOCAL_BARRIER28_FIELD_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER28_FAST_LOCAL_BARRIER28_GET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER28_FAST_LOCAL_BARRIER28_SET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER28_FAST_LOCAL_BARRIER28_MODIFY(r, x) ((((x) << 0) & 0x00000000000000FFull) | ((r) & 0xFFFFFFFFFFFFFF00ull)) + +/* Register: USER_CPU.fast_local_barrier29 */ +#define USER_CPU_FAST_LOCAL_BARRIER29_ADDRESS 0x000001E8ul +#define USER_CPU_FAST_LOCAL_BARRIER29_BYTE_ADDRESS 0x000001E8ul +#define USER_CPU_FAST_LOCAL_BARRIER29_OFFSET 0x000001E8ul +#define USER_CPU_FAST_LOCAL_BARRIER29_BYTE_OFFSET 0x000001E8ul +#define USER_CPU_FAST_LOCAL_BARRIER29_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER29_BYTE_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER29_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER29_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER29_RESET_VALUE 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER29_RESET_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER29_READ_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER29_WRITE_MASK 0x00000000000000FFull + +/* Field: USER_CPU_FAST_LOCAL_BARRIER29.fast_local_barrier29 */ +#define USER_CPU_FAST_LOCAL_BARRIER29_FAST_LOCAL_BARRIER29_MSB 7u +#define USER_CPU_FAST_LOCAL_BARRIER29_FAST_LOCAL_BARRIER29_LSB 0u +#define USER_CPU_FAST_LOCAL_BARRIER29_FAST_LOCAL_BARRIER29_WIDTH 8u +#define USER_CPU_FAST_LOCAL_BARRIER29_FAST_LOCAL_BARRIER29_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER29_FAST_LOCAL_BARRIER29_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER29_FAST_LOCAL_BARRIER29_RESET 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER29_FAST_LOCAL_BARRIER29_FIELD_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER29_FAST_LOCAL_BARRIER29_GET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER29_FAST_LOCAL_BARRIER29_SET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER29_FAST_LOCAL_BARRIER29_MODIFY(r, x) ((((x) << 0) & 0x00000000000000FFull) | ((r) & 0xFFFFFFFFFFFFFF00ull)) + +/* Register: USER_CPU.fast_local_barrier30 */ +#define USER_CPU_FAST_LOCAL_BARRIER30_ADDRESS 0x000001F0ul +#define USER_CPU_FAST_LOCAL_BARRIER30_BYTE_ADDRESS 0x000001F0ul +#define USER_CPU_FAST_LOCAL_BARRIER30_OFFSET 0x000001F0ul +#define USER_CPU_FAST_LOCAL_BARRIER30_BYTE_OFFSET 0x000001F0ul +#define USER_CPU_FAST_LOCAL_BARRIER30_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER30_BYTE_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER30_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER30_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER30_RESET_VALUE 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER30_RESET_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER30_READ_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER30_WRITE_MASK 0x00000000000000FFull + +/* Field: USER_CPU_FAST_LOCAL_BARRIER30.fast_local_barrier30 */ +#define USER_CPU_FAST_LOCAL_BARRIER30_FAST_LOCAL_BARRIER30_MSB 7u +#define USER_CPU_FAST_LOCAL_BARRIER30_FAST_LOCAL_BARRIER30_LSB 0u +#define USER_CPU_FAST_LOCAL_BARRIER30_FAST_LOCAL_BARRIER30_WIDTH 8u +#define USER_CPU_FAST_LOCAL_BARRIER30_FAST_LOCAL_BARRIER30_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER30_FAST_LOCAL_BARRIER30_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER30_FAST_LOCAL_BARRIER30_RESET 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER30_FAST_LOCAL_BARRIER30_FIELD_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER30_FAST_LOCAL_BARRIER30_GET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER30_FAST_LOCAL_BARRIER30_SET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER30_FAST_LOCAL_BARRIER30_MODIFY(r, x) ((((x) << 0) & 0x00000000000000FFull) | ((r) & 0xFFFFFFFFFFFFFF00ull)) + +/* Register: USER_CPU.fast_local_barrier31 */ +#define USER_CPU_FAST_LOCAL_BARRIER31_ADDRESS 0x000001F8ul +#define USER_CPU_FAST_LOCAL_BARRIER31_BYTE_ADDRESS 0x000001F8ul +#define USER_CPU_FAST_LOCAL_BARRIER31_OFFSET 0x000001F8ul +#define USER_CPU_FAST_LOCAL_BARRIER31_BYTE_OFFSET 0x000001F8ul +#define USER_CPU_FAST_LOCAL_BARRIER31_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER31_BYTE_SIZE 0x00000008ul +#define USER_CPU_FAST_LOCAL_BARRIER31_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER31_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER31_RESET_VALUE 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER31_RESET_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER31_READ_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER31_WRITE_MASK 0x00000000000000FFull + +/* Field: USER_CPU_FAST_LOCAL_BARRIER31.fast_local_barrier31 */ +#define USER_CPU_FAST_LOCAL_BARRIER31_FAST_LOCAL_BARRIER31_MSB 7u +#define USER_CPU_FAST_LOCAL_BARRIER31_FAST_LOCAL_BARRIER31_LSB 0u +#define USER_CPU_FAST_LOCAL_BARRIER31_FAST_LOCAL_BARRIER31_WIDTH 8u +#define USER_CPU_FAST_LOCAL_BARRIER31_FAST_LOCAL_BARRIER31_READ_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER31_FAST_LOCAL_BARRIER31_WRITE_ACCESS 1u +#define USER_CPU_FAST_LOCAL_BARRIER31_FAST_LOCAL_BARRIER31_RESET 0x0000000000000000ull +#define USER_CPU_FAST_LOCAL_BARRIER31_FAST_LOCAL_BARRIER31_FIELD_MASK 0x00000000000000FFull +#define USER_CPU_FAST_LOCAL_BARRIER31_FAST_LOCAL_BARRIER31_GET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER31_FAST_LOCAL_BARRIER31_SET(x) ((x) & 0x00000000000000FFull) +#define USER_CPU_FAST_LOCAL_BARRIER31_FAST_LOCAL_BARRIER31_MODIFY(r, x) ((((x) << 0) & 0x00000000000000FFull) | ((r) & 0xFFFFFFFFFFFFFF00ull)) + +/* Register: USER_CPU.icache_uprefetch */ +#define USER_CPU_ICACHE_UPREFETCH_ADDRESS 0x000002F8ul +#define USER_CPU_ICACHE_UPREFETCH_BYTE_ADDRESS 0x000002F8ul +#define USER_CPU_ICACHE_UPREFETCH_OFFSET 0x000002F8ul +#define USER_CPU_ICACHE_UPREFETCH_BYTE_OFFSET 0x000002F8ul +#define USER_CPU_ICACHE_UPREFETCH_SIZE 0x00000008ul +#define USER_CPU_ICACHE_UPREFETCH_BYTE_SIZE 0x00000008ul +#define USER_CPU_ICACHE_UPREFETCH_READ_ACCESS 1u +#define USER_CPU_ICACHE_UPREFETCH_WRITE_ACCESS 1u +#define USER_CPU_ICACHE_UPREFETCH_RESET_VALUE 0x0000000000000000ull +#define USER_CPU_ICACHE_UPREFETCH_RESET_MASK 0x0000FFFFFFFFFFFFull +#define USER_CPU_ICACHE_UPREFETCH_READ_MASK 0x0000FFFFFFFFFFFFull +#define USER_CPU_ICACHE_UPREFETCH_WRITE_MASK 0x0000FFFFFFFFFFFFull + +/* Field: USER_CPU_ICACHE_UPREFETCH.count */ +#define USER_CPU_ICACHE_UPREFETCH_COUNT_MSB 5u +#define USER_CPU_ICACHE_UPREFETCH_COUNT_LSB 0u +#define USER_CPU_ICACHE_UPREFETCH_COUNT_WIDTH 6u +#define USER_CPU_ICACHE_UPREFETCH_COUNT_READ_ACCESS 1u +#define USER_CPU_ICACHE_UPREFETCH_COUNT_WRITE_ACCESS 1u +#define USER_CPU_ICACHE_UPREFETCH_COUNT_RESET 0x0000000000000000ull +#define USER_CPU_ICACHE_UPREFETCH_COUNT_FIELD_MASK 0x000000000000003Full +#define USER_CPU_ICACHE_UPREFETCH_COUNT_GET(x) ((x) & 0x000000000000003Full) +#define USER_CPU_ICACHE_UPREFETCH_COUNT_SET(x) ((x) & 0x000000000000003Full) +#define USER_CPU_ICACHE_UPREFETCH_COUNT_MODIFY(r, x) ((((x) << 0) & 0x000000000000003Full) | ((r) & 0xFFFFFFFFFFFFFFC0ull)) + +/* Field: USER_CPU_ICACHE_UPREFETCH.address */ +#define USER_CPU_ICACHE_UPREFETCH_ADDRESS_MSB 47u +#define USER_CPU_ICACHE_UPREFETCH_ADDRESS_LSB 6u +#define USER_CPU_ICACHE_UPREFETCH_ADDRESS_WIDTH 42u +#define USER_CPU_ICACHE_UPREFETCH_ADDRESS_READ_ACCESS 1u +#define USER_CPU_ICACHE_UPREFETCH_ADDRESS_WRITE_ACCESS 1u +#define USER_CPU_ICACHE_UPREFETCH_ADDRESS_RESET 0x0000000000000000ull +#define USER_CPU_ICACHE_UPREFETCH_ADDRESS_FIELD_MASK 0x0000FFFFFFFFFFC0ull +#define USER_CPU_ICACHE_UPREFETCH_ADDRESS_GET(x) (((x) & 0x0000FFFFFFFFFFC0ull) >> 6) +#define USER_CPU_ICACHE_UPREFETCH_ADDRESS_SET(x) (((x) << 6) & 0x0000FFFFFFFFFFC0ull) +#define USER_CPU_ICACHE_UPREFETCH_ADDRESS_MODIFY(r, x) ((((x) << 6) & 0x0000FFFFFFFFFFC0ull) | ((r) & 0xFFFF00000000003Full)) + +/* Block-level typedef: USER_CPU */ +typedef struct { + uint8_t _pad0[0x80]; /* 0x0..0x7F reserved */ + volatile uint64_t ipi_redirect_trigger; /* Offset 0x80 (R/W) */ + uint8_t _pad1[0x38]; /* 0x88..0xBF reserved */ + volatile uint64_t CREDINC0; /* Offset 0xC0 (R) */ + volatile uint64_t CREDINC1; /* Offset 0xC8 (R) */ + volatile uint64_t CREDINC2; /* Offset 0xD0 (R) */ + volatile uint64_t CREDINC3; /* Offset 0xD8 (R) */ + uint8_t _pad2[0x20]; /* 0xE0..0xFF reserved */ + volatile uint64_t fast_local_barrier0; /* Offset 0x100 (R/W) */ + volatile uint64_t fast_local_barrier1; /* Offset 0x108 (R/W) */ + volatile uint64_t fast_local_barrier2; /* Offset 0x110 (R/W) */ + volatile uint64_t fast_local_barrier3; /* Offset 0x118 (R/W) */ + volatile uint64_t fast_local_barrier4; /* Offset 0x120 (R/W) */ + volatile uint64_t fast_local_barrier5; /* Offset 0x128 (R/W) */ + volatile uint64_t fast_local_barrier6; /* Offset 0x130 (R/W) */ + volatile uint64_t fast_local_barrier7; /* Offset 0x138 (R/W) */ + volatile uint64_t fast_local_barrier8; /* Offset 0x140 (R/W) */ + volatile uint64_t fast_local_barrier9; /* Offset 0x148 (R/W) */ + volatile uint64_t fast_local_barrier10; /* Offset 0x150 (R/W) */ + volatile uint64_t fast_local_barrier11; /* Offset 0x158 (R/W) */ + volatile uint64_t fast_local_barrier12; /* Offset 0x160 (R/W) */ + volatile uint64_t fast_local_barrier13; /* Offset 0x168 (R/W) */ + volatile uint64_t fast_local_barrier14; /* Offset 0x170 (R/W) */ + volatile uint64_t fast_local_barrier15; /* Offset 0x178 (R/W) */ + volatile uint64_t fast_local_barrier16; /* Offset 0x180 (R/W) */ + volatile uint64_t fast_local_barrier17; /* Offset 0x188 (R/W) */ + volatile uint64_t fast_local_barrier18; /* Offset 0x190 (R/W) */ + volatile uint64_t fast_local_barrier19; /* Offset 0x198 (R/W) */ + volatile uint64_t fast_local_barrier20; /* Offset 0x1A0 (R/W) */ + volatile uint64_t fast_local_barrier21; /* Offset 0x1A8 (R/W) */ + volatile uint64_t fast_local_barrier22; /* Offset 0x1B0 (R/W) */ + volatile uint64_t fast_local_barrier23; /* Offset 0x1B8 (R/W) */ + volatile uint64_t fast_local_barrier24; /* Offset 0x1C0 (R/W) */ + volatile uint64_t fast_local_barrier25; /* Offset 0x1C8 (R/W) */ + volatile uint64_t fast_local_barrier26; /* Offset 0x1D0 (R/W) */ + volatile uint64_t fast_local_barrier27; /* Offset 0x1D8 (R/W) */ + volatile uint64_t fast_local_barrier28; /* Offset 0x1E0 (R/W) */ + volatile uint64_t fast_local_barrier29; /* Offset 0x1E8 (R/W) */ + volatile uint64_t fast_local_barrier30; /* Offset 0x1F0 (R/W) */ + volatile uint64_t fast_local_barrier31; /* Offset 0x1F8 (R/W) */ + uint8_t _pad3[0xF8]; /* 0x200..0x2F7 reserved */ + volatile uint64_t icache_uprefetch; /* Offset 0x2F8 (R/W) */ +} User_cpu_t, *PTR_User_cpu_t; + +/* ============================================================ */ +/* Block: Supervisor_cpu (macro prefix: SUPERVISOR_CPU) */ +/* ============================================================ */ + +/* Register: SUPERVISOR_CPU.shire_coop_mode */ +#define SUPERVISOR_CPU_SHIRE_COOP_MODE_ADDRESS 0x00000290ul +#define SUPERVISOR_CPU_SHIRE_COOP_MODE_BYTE_ADDRESS 0x00000290ul +#define SUPERVISOR_CPU_SHIRE_COOP_MODE_OFFSET 0x00000290ul +#define SUPERVISOR_CPU_SHIRE_COOP_MODE_BYTE_OFFSET 0x00000290ul +#define SUPERVISOR_CPU_SHIRE_COOP_MODE_SIZE 0x00000008ul +#define SUPERVISOR_CPU_SHIRE_COOP_MODE_BYTE_SIZE 0x00000008ul +#define SUPERVISOR_CPU_SHIRE_COOP_MODE_READ_ACCESS 1u +#define SUPERVISOR_CPU_SHIRE_COOP_MODE_WRITE_ACCESS 1u +#define SUPERVISOR_CPU_SHIRE_COOP_MODE_RESET_VALUE 0x0000000000000000ull +#define SUPERVISOR_CPU_SHIRE_COOP_MODE_RESET_MASK 0x0000000000000001ull +#define SUPERVISOR_CPU_SHIRE_COOP_MODE_READ_MASK 0x0000000000000001ull +#define SUPERVISOR_CPU_SHIRE_COOP_MODE_WRITE_MASK 0x0000000000000001ull + +/* Field: SUPERVISOR_CPU_SHIRE_COOP_MODE.coop_mode */ +#define SUPERVISOR_CPU_SHIRE_COOP_MODE_COOP_MODE_MSB 0u +#define SUPERVISOR_CPU_SHIRE_COOP_MODE_COOP_MODE_LSB 0u +#define SUPERVISOR_CPU_SHIRE_COOP_MODE_COOP_MODE_WIDTH 1u +#define SUPERVISOR_CPU_SHIRE_COOP_MODE_COOP_MODE_READ_ACCESS 1u +#define SUPERVISOR_CPU_SHIRE_COOP_MODE_COOP_MODE_WRITE_ACCESS 1u +#define SUPERVISOR_CPU_SHIRE_COOP_MODE_COOP_MODE_RESET 0x0000000000000000ull +#define SUPERVISOR_CPU_SHIRE_COOP_MODE_COOP_MODE_FIELD_MASK 0x0000000000000001ull +#define SUPERVISOR_CPU_SHIRE_COOP_MODE_COOP_MODE_GET(x) ((x) & 0x0000000000000001ull) +#define SUPERVISOR_CPU_SHIRE_COOP_MODE_COOP_MODE_SET(x) ((x) & 0x0000000000000001ull) +#define SUPERVISOR_CPU_SHIRE_COOP_MODE_COOP_MODE_MODIFY(r, x) ((((x) << 0) & 0x0000000000000001ull) | ((r) & 0xFFFFFFFFFFFFFFFEull)) + +/* Register: SUPERVISOR_CPU.icache_sprefetch */ +#define SUPERVISOR_CPU_ICACHE_SPREFETCH_ADDRESS 0x00000300ul +#define SUPERVISOR_CPU_ICACHE_SPREFETCH_BYTE_ADDRESS 0x00000300ul +#define SUPERVISOR_CPU_ICACHE_SPREFETCH_OFFSET 0x00000300ul +#define SUPERVISOR_CPU_ICACHE_SPREFETCH_BYTE_OFFSET 0x00000300ul +#define SUPERVISOR_CPU_ICACHE_SPREFETCH_SIZE 0x00000008ul +#define SUPERVISOR_CPU_ICACHE_SPREFETCH_BYTE_SIZE 0x00000008ul +#define SUPERVISOR_CPU_ICACHE_SPREFETCH_READ_ACCESS 1u +#define SUPERVISOR_CPU_ICACHE_SPREFETCH_WRITE_ACCESS 1u +#define SUPERVISOR_CPU_ICACHE_SPREFETCH_RESET_VALUE 0x0000000000000000ull +#define SUPERVISOR_CPU_ICACHE_SPREFETCH_RESET_MASK 0x0000FFFFFFFFFFFFull +#define SUPERVISOR_CPU_ICACHE_SPREFETCH_READ_MASK 0x0000FFFFFFFFFFFFull +#define SUPERVISOR_CPU_ICACHE_SPREFETCH_WRITE_MASK 0x0000FFFFFFFFFFFFull + +/* Field: SUPERVISOR_CPU_ICACHE_SPREFETCH.count */ +#define SUPERVISOR_CPU_ICACHE_SPREFETCH_COUNT_MSB 5u +#define SUPERVISOR_CPU_ICACHE_SPREFETCH_COUNT_LSB 0u +#define SUPERVISOR_CPU_ICACHE_SPREFETCH_COUNT_WIDTH 6u +#define SUPERVISOR_CPU_ICACHE_SPREFETCH_COUNT_READ_ACCESS 1u +#define SUPERVISOR_CPU_ICACHE_SPREFETCH_COUNT_WRITE_ACCESS 1u +#define SUPERVISOR_CPU_ICACHE_SPREFETCH_COUNT_RESET 0x0000000000000000ull +#define SUPERVISOR_CPU_ICACHE_SPREFETCH_COUNT_FIELD_MASK 0x000000000000003Full +#define SUPERVISOR_CPU_ICACHE_SPREFETCH_COUNT_GET(x) ((x) & 0x000000000000003Full) +#define SUPERVISOR_CPU_ICACHE_SPREFETCH_COUNT_SET(x) ((x) & 0x000000000000003Full) +#define SUPERVISOR_CPU_ICACHE_SPREFETCH_COUNT_MODIFY(r, x) ((((x) << 0) & 0x000000000000003Full) | ((r) & 0xFFFFFFFFFFFFFFC0ull)) + +/* Field: SUPERVISOR_CPU_ICACHE_SPREFETCH.address */ +#define SUPERVISOR_CPU_ICACHE_SPREFETCH_ADDRESS_MSB 47u +#define SUPERVISOR_CPU_ICACHE_SPREFETCH_ADDRESS_LSB 6u +#define SUPERVISOR_CPU_ICACHE_SPREFETCH_ADDRESS_WIDTH 42u +#define SUPERVISOR_CPU_ICACHE_SPREFETCH_ADDRESS_READ_ACCESS 1u +#define SUPERVISOR_CPU_ICACHE_SPREFETCH_ADDRESS_WRITE_ACCESS 1u +#define SUPERVISOR_CPU_ICACHE_SPREFETCH_ADDRESS_RESET 0x0000000000000000ull +#define SUPERVISOR_CPU_ICACHE_SPREFETCH_ADDRESS_FIELD_MASK 0x0000FFFFFFFFFFC0ull +#define SUPERVISOR_CPU_ICACHE_SPREFETCH_ADDRESS_GET(x) (((x) & 0x0000FFFFFFFFFFC0ull) >> 6) +#define SUPERVISOR_CPU_ICACHE_SPREFETCH_ADDRESS_SET(x) (((x) << 6) & 0x0000FFFFFFFFFFC0ull) +#define SUPERVISOR_CPU_ICACHE_SPREFETCH_ADDRESS_MODIFY(r, x) ((((x) << 6) & 0x0000FFFFFFFFFFC0ull) | ((r) & 0xFFFF00000000003Full)) + +/* Block-level typedef: SUPERVISOR_CPU */ +typedef struct { + uint8_t _pad0[0x290]; /* 0x0..0x28F reserved */ + volatile uint64_t shire_coop_mode; /* Offset 0x290 (R/W) */ + uint8_t _pad1[0x68]; /* 0x298..0x2FF reserved */ + volatile uint64_t icache_sprefetch; /* Offset 0x300 (R/W) */ +} Supervisor_cpu_t, *PTR_Supervisor_cpu_t; + +/* ============================================================ */ +/* Block: D_hart_esr (macro prefix: D_HART_ESR) */ +/* ============================================================ */ + +/* Register: D_HART_ESR.NXDATA0 */ +#define D_HART_ESR_NXDATA0_ADDRESS 0x0000F780ul +#define D_HART_ESR_NXDATA0_BYTE_ADDRESS 0x0000F780ul +#define D_HART_ESR_NXDATA0_OFFSET 0x0000F780ul +#define D_HART_ESR_NXDATA0_BYTE_OFFSET 0x0000F780ul +#define D_HART_ESR_NXDATA0_SIZE 0x00000008ul +#define D_HART_ESR_NXDATA0_BYTE_SIZE 0x00000008ul +#define D_HART_ESR_NXDATA0_READ_ACCESS 1u +#define D_HART_ESR_NXDATA0_WRITE_ACCESS 1u +#define D_HART_ESR_NXDATA0_RESET_VALUE 0x0000000000000000ull +#define D_HART_ESR_NXDATA0_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define D_HART_ESR_NXDATA0_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define D_HART_ESR_NXDATA0_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: D_HART_ESR_NXDATA0.NXDATA0_f0 */ +#define D_HART_ESR_NXDATA0_NXDATA0_F0_MSB 31u +#define D_HART_ESR_NXDATA0_NXDATA0_F0_LSB 0u +#define D_HART_ESR_NXDATA0_NXDATA0_F0_WIDTH 32u +#define D_HART_ESR_NXDATA0_NXDATA0_F0_READ_ACCESS 1u +#define D_HART_ESR_NXDATA0_NXDATA0_F0_WRITE_ACCESS 1u +#define D_HART_ESR_NXDATA0_NXDATA0_F0_RESET 0x0000000000000000ull +#define D_HART_ESR_NXDATA0_NXDATA0_F0_FIELD_MASK 0x00000000FFFFFFFFull +#define D_HART_ESR_NXDATA0_NXDATA0_F0_GET(x) ((x) & 0x00000000FFFFFFFFull) +#define D_HART_ESR_NXDATA0_NXDATA0_F0_SET(x) ((x) & 0x00000000FFFFFFFFull) +#define D_HART_ESR_NXDATA0_NXDATA0_F0_MODIFY(r, x) ((((x) << 0) & 0x00000000FFFFFFFFull) | ((r) & 0xFFFFFFFF00000000ull)) + +/* Field: D_HART_ESR_NXDATA0.NXDATA0_f1 */ +#define D_HART_ESR_NXDATA0_NXDATA0_F1_MSB 63u +#define D_HART_ESR_NXDATA0_NXDATA0_F1_LSB 32u +#define D_HART_ESR_NXDATA0_NXDATA0_F1_WIDTH 32u +#define D_HART_ESR_NXDATA0_NXDATA0_F1_READ_ACCESS 1u +#define D_HART_ESR_NXDATA0_NXDATA0_F1_WRITE_ACCESS 1u +#define D_HART_ESR_NXDATA0_NXDATA0_F1_RESET 0x0000000000000000ull +#define D_HART_ESR_NXDATA0_NXDATA0_F1_FIELD_MASK 0xFFFFFFFF00000000ull +#define D_HART_ESR_NXDATA0_NXDATA0_F1_GET(x) (((x) & 0xFFFFFFFF00000000ull) >> 32) +#define D_HART_ESR_NXDATA0_NXDATA0_F1_SET(x) (((x) << 32) & 0xFFFFFFFF00000000ull) +#define D_HART_ESR_NXDATA0_NXDATA0_F1_MODIFY(r, x) ((((x) << 32) & 0xFFFFFFFF00000000ull) | ((r) & 0x00000000FFFFFFFFull)) + +/* Register: D_HART_ESR.NXDATA1 */ +#define D_HART_ESR_NXDATA1_ADDRESS 0x0000F788ul +#define D_HART_ESR_NXDATA1_BYTE_ADDRESS 0x0000F788ul +#define D_HART_ESR_NXDATA1_OFFSET 0x0000F788ul +#define D_HART_ESR_NXDATA1_BYTE_OFFSET 0x0000F788ul +#define D_HART_ESR_NXDATA1_SIZE 0x00000008ul +#define D_HART_ESR_NXDATA1_BYTE_SIZE 0x00000008ul +#define D_HART_ESR_NXDATA1_READ_ACCESS 1u +#define D_HART_ESR_NXDATA1_WRITE_ACCESS 1u +#define D_HART_ESR_NXDATA1_RESET_VALUE 0x0000000000000000ull +#define D_HART_ESR_NXDATA1_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define D_HART_ESR_NXDATA1_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define D_HART_ESR_NXDATA1_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: D_HART_ESR_NXDATA1.NXDATA1_f0 */ +#define D_HART_ESR_NXDATA1_NXDATA1_F0_MSB 31u +#define D_HART_ESR_NXDATA1_NXDATA1_F0_LSB 0u +#define D_HART_ESR_NXDATA1_NXDATA1_F0_WIDTH 32u +#define D_HART_ESR_NXDATA1_NXDATA1_F0_READ_ACCESS 1u +#define D_HART_ESR_NXDATA1_NXDATA1_F0_WRITE_ACCESS 1u +#define D_HART_ESR_NXDATA1_NXDATA1_F0_RESET 0x0000000000000000ull +#define D_HART_ESR_NXDATA1_NXDATA1_F0_FIELD_MASK 0x00000000FFFFFFFFull +#define D_HART_ESR_NXDATA1_NXDATA1_F0_GET(x) ((x) & 0x00000000FFFFFFFFull) +#define D_HART_ESR_NXDATA1_NXDATA1_F0_SET(x) ((x) & 0x00000000FFFFFFFFull) +#define D_HART_ESR_NXDATA1_NXDATA1_F0_MODIFY(r, x) ((((x) << 0) & 0x00000000FFFFFFFFull) | ((r) & 0xFFFFFFFF00000000ull)) + +/* Field: D_HART_ESR_NXDATA1.NXDATA1_f1 */ +#define D_HART_ESR_NXDATA1_NXDATA1_F1_MSB 63u +#define D_HART_ESR_NXDATA1_NXDATA1_F1_LSB 32u +#define D_HART_ESR_NXDATA1_NXDATA1_F1_WIDTH 32u +#define D_HART_ESR_NXDATA1_NXDATA1_F1_READ_ACCESS 1u +#define D_HART_ESR_NXDATA1_NXDATA1_F1_WRITE_ACCESS 1u +#define D_HART_ESR_NXDATA1_NXDATA1_F1_RESET 0x0000000000000000ull +#define D_HART_ESR_NXDATA1_NXDATA1_F1_FIELD_MASK 0xFFFFFFFF00000000ull +#define D_HART_ESR_NXDATA1_NXDATA1_F1_GET(x) (((x) & 0xFFFFFFFF00000000ull) >> 32) +#define D_HART_ESR_NXDATA1_NXDATA1_F1_SET(x) (((x) << 32) & 0xFFFFFFFF00000000ull) +#define D_HART_ESR_NXDATA1_NXDATA1_F1_MODIFY(r, x) ((((x) << 32) & 0xFFFFFFFF00000000ull) | ((r) & 0x00000000FFFFFFFFull)) + +/* Register: D_HART_ESR.AXDATA0 */ +#define D_HART_ESR_AXDATA0_ADDRESS 0x0000F790ul +#define D_HART_ESR_AXDATA0_BYTE_ADDRESS 0x0000F790ul +#define D_HART_ESR_AXDATA0_OFFSET 0x0000F790ul +#define D_HART_ESR_AXDATA0_BYTE_OFFSET 0x0000F790ul +#define D_HART_ESR_AXDATA0_SIZE 0x00000008ul +#define D_HART_ESR_AXDATA0_BYTE_SIZE 0x00000008ul +#define D_HART_ESR_AXDATA0_READ_ACCESS 1u +#define D_HART_ESR_AXDATA0_WRITE_ACCESS 1u +#define D_HART_ESR_AXDATA0_RESET_VALUE 0x0000000000000000ull +#define D_HART_ESR_AXDATA0_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define D_HART_ESR_AXDATA0_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define D_HART_ESR_AXDATA0_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: D_HART_ESR_AXDATA0.AXDATA0_f0 */ +#define D_HART_ESR_AXDATA0_AXDATA0_F0_MSB 31u +#define D_HART_ESR_AXDATA0_AXDATA0_F0_LSB 0u +#define D_HART_ESR_AXDATA0_AXDATA0_F0_WIDTH 32u +#define D_HART_ESR_AXDATA0_AXDATA0_F0_READ_ACCESS 1u +#define D_HART_ESR_AXDATA0_AXDATA0_F0_WRITE_ACCESS 1u +#define D_HART_ESR_AXDATA0_AXDATA0_F0_RESET 0x0000000000000000ull +#define D_HART_ESR_AXDATA0_AXDATA0_F0_FIELD_MASK 0x00000000FFFFFFFFull +#define D_HART_ESR_AXDATA0_AXDATA0_F0_GET(x) ((x) & 0x00000000FFFFFFFFull) +#define D_HART_ESR_AXDATA0_AXDATA0_F0_SET(x) ((x) & 0x00000000FFFFFFFFull) +#define D_HART_ESR_AXDATA0_AXDATA0_F0_MODIFY(r, x) ((((x) << 0) & 0x00000000FFFFFFFFull) | ((r) & 0xFFFFFFFF00000000ull)) + +/* Field: D_HART_ESR_AXDATA0.AXDATA0_f1 */ +#define D_HART_ESR_AXDATA0_AXDATA0_F1_MSB 63u +#define D_HART_ESR_AXDATA0_AXDATA0_F1_LSB 32u +#define D_HART_ESR_AXDATA0_AXDATA0_F1_WIDTH 32u +#define D_HART_ESR_AXDATA0_AXDATA0_F1_READ_ACCESS 1u +#define D_HART_ESR_AXDATA0_AXDATA0_F1_WRITE_ACCESS 1u +#define D_HART_ESR_AXDATA0_AXDATA0_F1_RESET 0x0000000000000000ull +#define D_HART_ESR_AXDATA0_AXDATA0_F1_FIELD_MASK 0xFFFFFFFF00000000ull +#define D_HART_ESR_AXDATA0_AXDATA0_F1_GET(x) (((x) & 0xFFFFFFFF00000000ull) >> 32) +#define D_HART_ESR_AXDATA0_AXDATA0_F1_SET(x) (((x) << 32) & 0xFFFFFFFF00000000ull) +#define D_HART_ESR_AXDATA0_AXDATA0_F1_MODIFY(r, x) ((((x) << 32) & 0xFFFFFFFF00000000ull) | ((r) & 0x00000000FFFFFFFFull)) + +/* Register: D_HART_ESR.AXDATA1 */ +#define D_HART_ESR_AXDATA1_ADDRESS 0x0000F798ul +#define D_HART_ESR_AXDATA1_BYTE_ADDRESS 0x0000F798ul +#define D_HART_ESR_AXDATA1_OFFSET 0x0000F798ul +#define D_HART_ESR_AXDATA1_BYTE_OFFSET 0x0000F798ul +#define D_HART_ESR_AXDATA1_SIZE 0x00000008ul +#define D_HART_ESR_AXDATA1_BYTE_SIZE 0x00000008ul +#define D_HART_ESR_AXDATA1_READ_ACCESS 1u +#define D_HART_ESR_AXDATA1_WRITE_ACCESS 1u +#define D_HART_ESR_AXDATA1_RESET_VALUE 0x0000000000000000ull +#define D_HART_ESR_AXDATA1_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define D_HART_ESR_AXDATA1_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define D_HART_ESR_AXDATA1_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: D_HART_ESR_AXDATA1.AXDATA1_f0 */ +#define D_HART_ESR_AXDATA1_AXDATA1_F0_MSB 31u +#define D_HART_ESR_AXDATA1_AXDATA1_F0_LSB 0u +#define D_HART_ESR_AXDATA1_AXDATA1_F0_WIDTH 32u +#define D_HART_ESR_AXDATA1_AXDATA1_F0_READ_ACCESS 1u +#define D_HART_ESR_AXDATA1_AXDATA1_F0_WRITE_ACCESS 1u +#define D_HART_ESR_AXDATA1_AXDATA1_F0_RESET 0x0000000000000000ull +#define D_HART_ESR_AXDATA1_AXDATA1_F0_FIELD_MASK 0x00000000FFFFFFFFull +#define D_HART_ESR_AXDATA1_AXDATA1_F0_GET(x) ((x) & 0x00000000FFFFFFFFull) +#define D_HART_ESR_AXDATA1_AXDATA1_F0_SET(x) ((x) & 0x00000000FFFFFFFFull) +#define D_HART_ESR_AXDATA1_AXDATA1_F0_MODIFY(r, x) ((((x) << 0) & 0x00000000FFFFFFFFull) | ((r) & 0xFFFFFFFF00000000ull)) + +/* Field: D_HART_ESR_AXDATA1.AXDATA1_f1 */ +#define D_HART_ESR_AXDATA1_AXDATA1_F1_MSB 63u +#define D_HART_ESR_AXDATA1_AXDATA1_F1_LSB 32u +#define D_HART_ESR_AXDATA1_AXDATA1_F1_WIDTH 32u +#define D_HART_ESR_AXDATA1_AXDATA1_F1_READ_ACCESS 1u +#define D_HART_ESR_AXDATA1_AXDATA1_F1_WRITE_ACCESS 1u +#define D_HART_ESR_AXDATA1_AXDATA1_F1_RESET 0x0000000000000000ull +#define D_HART_ESR_AXDATA1_AXDATA1_F1_FIELD_MASK 0xFFFFFFFF00000000ull +#define D_HART_ESR_AXDATA1_AXDATA1_F1_GET(x) (((x) & 0xFFFFFFFF00000000ull) >> 32) +#define D_HART_ESR_AXDATA1_AXDATA1_F1_SET(x) (((x) << 32) & 0xFFFFFFFF00000000ull) +#define D_HART_ESR_AXDATA1_AXDATA1_F1_MODIFY(r, x) ((((x) << 32) & 0xFFFFFFFF00000000ull) | ((r) & 0x00000000FFFFFFFFull)) + +/* Register: D_HART_ESR.AXPROGBUFF0 */ +#define D_HART_ESR_AXPROGBUFF0_ADDRESS 0x0000F7A0ul +#define D_HART_ESR_AXPROGBUFF0_BYTE_ADDRESS 0x0000F7A0ul +#define D_HART_ESR_AXPROGBUFF0_OFFSET 0x0000F7A0ul +#define D_HART_ESR_AXPROGBUFF0_BYTE_OFFSET 0x0000F7A0ul +#define D_HART_ESR_AXPROGBUFF0_SIZE 0x00000008ul +#define D_HART_ESR_AXPROGBUFF0_BYTE_SIZE 0x00000008ul +#define D_HART_ESR_AXPROGBUFF0_READ_ACCESS 1u +#define D_HART_ESR_AXPROGBUFF0_WRITE_ACCESS 1u +#define D_HART_ESR_AXPROGBUFF0_RESET_VALUE 0x0000000000000000ull +#define D_HART_ESR_AXPROGBUFF0_RESET_MASK 0x00000000FFFFFFFFull +#define D_HART_ESR_AXPROGBUFF0_READ_MASK 0x00000000FFFFFFFFull +#define D_HART_ESR_AXPROGBUFF0_WRITE_MASK 0x00000000FFFFFFFFull + +/* Field: D_HART_ESR_AXPROGBUFF0.AXPROGBUFF0 */ +#define D_HART_ESR_AXPROGBUFF0_AXPROGBUFF0_MSB 31u +#define D_HART_ESR_AXPROGBUFF0_AXPROGBUFF0_LSB 0u +#define D_HART_ESR_AXPROGBUFF0_AXPROGBUFF0_WIDTH 32u +#define D_HART_ESR_AXPROGBUFF0_AXPROGBUFF0_READ_ACCESS 1u +#define D_HART_ESR_AXPROGBUFF0_AXPROGBUFF0_WRITE_ACCESS 1u +#define D_HART_ESR_AXPROGBUFF0_AXPROGBUFF0_RESET 0x0000000000000000ull +#define D_HART_ESR_AXPROGBUFF0_AXPROGBUFF0_FIELD_MASK 0x00000000FFFFFFFFull +#define D_HART_ESR_AXPROGBUFF0_AXPROGBUFF0_GET(x) ((x) & 0x00000000FFFFFFFFull) +#define D_HART_ESR_AXPROGBUFF0_AXPROGBUFF0_SET(x) ((x) & 0x00000000FFFFFFFFull) +#define D_HART_ESR_AXPROGBUFF0_AXPROGBUFF0_MODIFY(r, x) ((((x) << 0) & 0x00000000FFFFFFFFull) | ((r) & 0xFFFFFFFF00000000ull)) + +/* Register: D_HART_ESR.AXPROGBUFF1 */ +#define D_HART_ESR_AXPROGBUFF1_ADDRESS 0x0000F7A8ul +#define D_HART_ESR_AXPROGBUFF1_BYTE_ADDRESS 0x0000F7A8ul +#define D_HART_ESR_AXPROGBUFF1_OFFSET 0x0000F7A8ul +#define D_HART_ESR_AXPROGBUFF1_BYTE_OFFSET 0x0000F7A8ul +#define D_HART_ESR_AXPROGBUFF1_SIZE 0x00000008ul +#define D_HART_ESR_AXPROGBUFF1_BYTE_SIZE 0x00000008ul +#define D_HART_ESR_AXPROGBUFF1_READ_ACCESS 1u +#define D_HART_ESR_AXPROGBUFF1_WRITE_ACCESS 1u +#define D_HART_ESR_AXPROGBUFF1_RESET_VALUE 0x0000000000000000ull +#define D_HART_ESR_AXPROGBUFF1_RESET_MASK 0x00000000FFFFFFFFull +#define D_HART_ESR_AXPROGBUFF1_READ_MASK 0x00000000FFFFFFFFull +#define D_HART_ESR_AXPROGBUFF1_WRITE_MASK 0x00000000FFFFFFFFull + +/* Field: D_HART_ESR_AXPROGBUFF1.AXPROGBUFF1 */ +#define D_HART_ESR_AXPROGBUFF1_AXPROGBUFF1_MSB 31u +#define D_HART_ESR_AXPROGBUFF1_AXPROGBUFF1_LSB 0u +#define D_HART_ESR_AXPROGBUFF1_AXPROGBUFF1_WIDTH 32u +#define D_HART_ESR_AXPROGBUFF1_AXPROGBUFF1_READ_ACCESS 1u +#define D_HART_ESR_AXPROGBUFF1_AXPROGBUFF1_WRITE_ACCESS 1u +#define D_HART_ESR_AXPROGBUFF1_AXPROGBUFF1_RESET 0x0000000000000000ull +#define D_HART_ESR_AXPROGBUFF1_AXPROGBUFF1_FIELD_MASK 0x00000000FFFFFFFFull +#define D_HART_ESR_AXPROGBUFF1_AXPROGBUFF1_GET(x) ((x) & 0x00000000FFFFFFFFull) +#define D_HART_ESR_AXPROGBUFF1_AXPROGBUFF1_SET(x) ((x) & 0x00000000FFFFFFFFull) +#define D_HART_ESR_AXPROGBUFF1_AXPROGBUFF1_MODIFY(r, x) ((((x) << 0) & 0x00000000FFFFFFFFull) | ((r) & 0xFFFFFFFF00000000ull)) + +/* Register: D_HART_ESR.NXPROGBUFF0 */ +#define D_HART_ESR_NXPROGBUFF0_ADDRESS 0x0000F7B0ul +#define D_HART_ESR_NXPROGBUFF0_BYTE_ADDRESS 0x0000F7B0ul +#define D_HART_ESR_NXPROGBUFF0_OFFSET 0x0000F7B0ul +#define D_HART_ESR_NXPROGBUFF0_BYTE_OFFSET 0x0000F7B0ul +#define D_HART_ESR_NXPROGBUFF0_SIZE 0x00000008ul +#define D_HART_ESR_NXPROGBUFF0_BYTE_SIZE 0x00000008ul +#define D_HART_ESR_NXPROGBUFF0_READ_ACCESS 1u +#define D_HART_ESR_NXPROGBUFF0_WRITE_ACCESS 1u +#define D_HART_ESR_NXPROGBUFF0_RESET_VALUE 0x0000000000000000ull +#define D_HART_ESR_NXPROGBUFF0_RESET_MASK 0x00000000FFFFFFFFull +#define D_HART_ESR_NXPROGBUFF0_READ_MASK 0x00000000FFFFFFFFull +#define D_HART_ESR_NXPROGBUFF0_WRITE_MASK 0x00000000FFFFFFFFull + +/* Field: D_HART_ESR_NXPROGBUFF0.NXPROGBUFF0 */ +#define D_HART_ESR_NXPROGBUFF0_NXPROGBUFF0_MSB 31u +#define D_HART_ESR_NXPROGBUFF0_NXPROGBUFF0_LSB 0u +#define D_HART_ESR_NXPROGBUFF0_NXPROGBUFF0_WIDTH 32u +#define D_HART_ESR_NXPROGBUFF0_NXPROGBUFF0_READ_ACCESS 1u +#define D_HART_ESR_NXPROGBUFF0_NXPROGBUFF0_WRITE_ACCESS 1u +#define D_HART_ESR_NXPROGBUFF0_NXPROGBUFF0_RESET 0x0000000000000000ull +#define D_HART_ESR_NXPROGBUFF0_NXPROGBUFF0_FIELD_MASK 0x00000000FFFFFFFFull +#define D_HART_ESR_NXPROGBUFF0_NXPROGBUFF0_GET(x) ((x) & 0x00000000FFFFFFFFull) +#define D_HART_ESR_NXPROGBUFF0_NXPROGBUFF0_SET(x) ((x) & 0x00000000FFFFFFFFull) +#define D_HART_ESR_NXPROGBUFF0_NXPROGBUFF0_MODIFY(r, x) ((((x) << 0) & 0x00000000FFFFFFFFull) | ((r) & 0xFFFFFFFF00000000ull)) + +/* Register: D_HART_ESR.NXPROGBUFF1 */ +#define D_HART_ESR_NXPROGBUFF1_ADDRESS 0x0000F7B8ul +#define D_HART_ESR_NXPROGBUFF1_BYTE_ADDRESS 0x0000F7B8ul +#define D_HART_ESR_NXPROGBUFF1_OFFSET 0x0000F7B8ul +#define D_HART_ESR_NXPROGBUFF1_BYTE_OFFSET 0x0000F7B8ul +#define D_HART_ESR_NXPROGBUFF1_SIZE 0x00000008ul +#define D_HART_ESR_NXPROGBUFF1_BYTE_SIZE 0x00000008ul +#define D_HART_ESR_NXPROGBUFF1_READ_ACCESS 1u +#define D_HART_ESR_NXPROGBUFF1_WRITE_ACCESS 1u +#define D_HART_ESR_NXPROGBUFF1_RESET_VALUE 0x0000000000000000ull +#define D_HART_ESR_NXPROGBUFF1_RESET_MASK 0x00000000FFFFFFFFull +#define D_HART_ESR_NXPROGBUFF1_READ_MASK 0x00000000FFFFFFFFull +#define D_HART_ESR_NXPROGBUFF1_WRITE_MASK 0x00000000FFFFFFFFull + +/* Field: D_HART_ESR_NXPROGBUFF1.NXPROGBUFF1 */ +#define D_HART_ESR_NXPROGBUFF1_NXPROGBUFF1_MSB 31u +#define D_HART_ESR_NXPROGBUFF1_NXPROGBUFF1_LSB 0u +#define D_HART_ESR_NXPROGBUFF1_NXPROGBUFF1_WIDTH 32u +#define D_HART_ESR_NXPROGBUFF1_NXPROGBUFF1_READ_ACCESS 1u +#define D_HART_ESR_NXPROGBUFF1_NXPROGBUFF1_WRITE_ACCESS 1u +#define D_HART_ESR_NXPROGBUFF1_NXPROGBUFF1_RESET 0x0000000000000000ull +#define D_HART_ESR_NXPROGBUFF1_NXPROGBUFF1_FIELD_MASK 0x00000000FFFFFFFFull +#define D_HART_ESR_NXPROGBUFF1_NXPROGBUFF1_GET(x) ((x) & 0x00000000FFFFFFFFull) +#define D_HART_ESR_NXPROGBUFF1_NXPROGBUFF1_SET(x) ((x) & 0x00000000FFFFFFFFull) +#define D_HART_ESR_NXPROGBUFF1_NXPROGBUFF1_MODIFY(r, x) ((((x) << 0) & 0x00000000FFFFFFFFull) | ((r) & 0xFFFFFFFF00000000ull)) + +/* Register: D_HART_ESR.ABSCMD */ +#define D_HART_ESR_ABSCMD_ADDRESS 0x0000F7C0ul +#define D_HART_ESR_ABSCMD_BYTE_ADDRESS 0x0000F7C0ul +#define D_HART_ESR_ABSCMD_OFFSET 0x0000F7C0ul +#define D_HART_ESR_ABSCMD_BYTE_OFFSET 0x0000F7C0ul +#define D_HART_ESR_ABSCMD_SIZE 0x00000008ul +#define D_HART_ESR_ABSCMD_BYTE_SIZE 0x00000008ul +#define D_HART_ESR_ABSCMD_READ_ACCESS 1u +#define D_HART_ESR_ABSCMD_WRITE_ACCESS 1u +#define D_HART_ESR_ABSCMD_RESET_VALUE 0x0000000000000000ull +#define D_HART_ESR_ABSCMD_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define D_HART_ESR_ABSCMD_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define D_HART_ESR_ABSCMD_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: D_HART_ESR_ABSCMD.ABSCMD */ +#define D_HART_ESR_ABSCMD_ABSCMD_MSB 63u +#define D_HART_ESR_ABSCMD_ABSCMD_LSB 0u +#define D_HART_ESR_ABSCMD_ABSCMD_WIDTH 64u +#define D_HART_ESR_ABSCMD_ABSCMD_READ_ACCESS 1u +#define D_HART_ESR_ABSCMD_ABSCMD_WRITE_ACCESS 1u +#define D_HART_ESR_ABSCMD_ABSCMD_RESET 0x0000000000000000ull +#define D_HART_ESR_ABSCMD_ABSCMD_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define D_HART_ESR_ABSCMD_ABSCMD_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define D_HART_ESR_ABSCMD_ABSCMD_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define D_HART_ESR_ABSCMD_ABSCMD_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Block-level typedef: D_HART_ESR */ +typedef struct { + uint8_t _pad0[0xF780]; /* 0x0..0xF77F reserved */ + volatile uint64_t NXDATA0; /* Offset 0xF780 (R/W) */ + volatile uint64_t NXDATA1; /* Offset 0xF788 (R/W) */ + volatile uint64_t AXDATA0; /* Offset 0xF790 (R/W) */ + volatile uint64_t AXDATA1; /* Offset 0xF798 (R/W) */ + volatile uint64_t AXPROGBUFF0; /* Offset 0xF7A0 (R/W) */ + volatile uint64_t AXPROGBUFF1; /* Offset 0xF7A8 (R/W) */ + volatile uint64_t NXPROGBUFF0; /* Offset 0xF7B0 (R/W) */ + volatile uint64_t NXPROGBUFF1; /* Offset 0xF7B8 (R/W) */ + volatile uint64_t ABSCMD; /* Offset 0xF7C0 (R/W) */ +} D_hart_esr_t, *PTR_D_hart_esr_t; + +/* ============================================================ */ +/* Block: D_neigh (macro prefix: D_NEIGH) */ +/* ============================================================ */ + +/* Register: D_NEIGH.hactrl */ +#define D_NEIGH_HACTRL_ADDRESS 0x0000FF80ul +#define D_NEIGH_HACTRL_BYTE_ADDRESS 0x0000FF80ul +#define D_NEIGH_HACTRL_OFFSET 0x0000FF80ul +#define D_NEIGH_HACTRL_BYTE_OFFSET 0x0000FF80ul +#define D_NEIGH_HACTRL_SIZE 0x00000008ul +#define D_NEIGH_HACTRL_BYTE_SIZE 0x00000008ul +#define D_NEIGH_HACTRL_READ_ACCESS 1u +#define D_NEIGH_HACTRL_WRITE_ACCESS 1u +#define D_NEIGH_HACTRL_RESET_VALUE 0x0000000000000000ull +#define D_NEIGH_HACTRL_RESET_MASK 0x0000FFFFFFFFFFFFull +#define D_NEIGH_HACTRL_READ_MASK 0x0000FFFFFFFFFFFFull +#define D_NEIGH_HACTRL_WRITE_MASK 0x00000000FFFFFFFFull + +/* Field: D_NEIGH_HACTRL.hawindow */ +#define D_NEIGH_HACTRL_HAWINDOW_MSB 15u +#define D_NEIGH_HACTRL_HAWINDOW_LSB 0u +#define D_NEIGH_HACTRL_HAWINDOW_WIDTH 16u +#define D_NEIGH_HACTRL_HAWINDOW_READ_ACCESS 1u +#define D_NEIGH_HACTRL_HAWINDOW_WRITE_ACCESS 1u +#define D_NEIGH_HACTRL_HAWINDOW_RESET 0x0000000000000000ull +#define D_NEIGH_HACTRL_HAWINDOW_FIELD_MASK 0x000000000000FFFFull +#define D_NEIGH_HACTRL_HAWINDOW_GET(x) ((x) & 0x000000000000FFFFull) +#define D_NEIGH_HACTRL_HAWINDOW_SET(x) ((x) & 0x000000000000FFFFull) +#define D_NEIGH_HACTRL_HAWINDOW_MODIFY(r, x) ((((x) << 0) & 0x000000000000FFFFull) | ((r) & 0xFFFFFFFFFFFF0000ull)) + +/* Field: D_NEIGH_HACTRL.hart_mask */ +#define D_NEIGH_HACTRL_HART_MASK_MSB 31u +#define D_NEIGH_HACTRL_HART_MASK_LSB 16u +#define D_NEIGH_HACTRL_HART_MASK_WIDTH 16u +#define D_NEIGH_HACTRL_HART_MASK_READ_ACCESS 1u +#define D_NEIGH_HACTRL_HART_MASK_WRITE_ACCESS 1u +#define D_NEIGH_HACTRL_HART_MASK_RESET 0x0000000000000000ull +#define D_NEIGH_HACTRL_HART_MASK_FIELD_MASK 0x00000000FFFF0000ull +#define D_NEIGH_HACTRL_HART_MASK_GET(x) (((x) & 0x00000000FFFF0000ull) >> 16) +#define D_NEIGH_HACTRL_HART_MASK_SET(x) (((x) << 16) & 0x00000000FFFF0000ull) +#define D_NEIGH_HACTRL_HART_MASK_MODIFY(r, x) ((((x) << 16) & 0x00000000FFFF0000ull) | ((r) & 0xFFFFFFFF0000FFFFull)) + +/* Field: D_NEIGH_HACTRL.resethalt */ +#define D_NEIGH_HACTRL_RESETHALT_MSB 47u +#define D_NEIGH_HACTRL_RESETHALT_LSB 32u +#define D_NEIGH_HACTRL_RESETHALT_WIDTH 16u +#define D_NEIGH_HACTRL_RESETHALT_READ_ACCESS 1u +#define D_NEIGH_HACTRL_RESETHALT_WRITE_ACCESS 0u +#define D_NEIGH_HACTRL_RESETHALT_RESET 0x0000000000000000ull +#define D_NEIGH_HACTRL_RESETHALT_FIELD_MASK 0x0000FFFF00000000ull +#define D_NEIGH_HACTRL_RESETHALT_GET(x) (((x) & 0x0000FFFF00000000ull) >> 32) +#define D_NEIGH_HACTRL_RESETHALT_SET(x) (((x) << 32) & 0x0000FFFF00000000ull) +#define D_NEIGH_HACTRL_RESETHALT_MODIFY(r, x) ((((x) << 32) & 0x0000FFFF00000000ull) | ((r) & 0xFFFF0000FFFFFFFFull)) + +/* Register: D_NEIGH.hastatus0 */ +#define D_NEIGH_HASTATUS0_ADDRESS 0x0000FF88ul +#define D_NEIGH_HASTATUS0_BYTE_ADDRESS 0x0000FF88ul +#define D_NEIGH_HASTATUS0_OFFSET 0x0000FF88ul +#define D_NEIGH_HASTATUS0_BYTE_OFFSET 0x0000FF88ul +#define D_NEIGH_HASTATUS0_SIZE 0x00000008ul +#define D_NEIGH_HASTATUS0_BYTE_SIZE 0x00000008ul +#define D_NEIGH_HASTATUS0_READ_ACCESS 1u +#define D_NEIGH_HASTATUS0_WRITE_ACCESS 0u +#define D_NEIGH_HASTATUS0_RESET_VALUE 0x0000000000000000ull +#define D_NEIGH_HASTATUS0_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define D_NEIGH_HASTATUS0_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define D_NEIGH_HASTATUS0_WRITE_MASK 0x0000000000000000ull + +/* Field: D_NEIGH_HASTATUS0.halted */ +#define D_NEIGH_HASTATUS0_HALTED_MSB 15u +#define D_NEIGH_HASTATUS0_HALTED_LSB 0u +#define D_NEIGH_HASTATUS0_HALTED_WIDTH 16u +#define D_NEIGH_HASTATUS0_HALTED_READ_ACCESS 1u +#define D_NEIGH_HASTATUS0_HALTED_WRITE_ACCESS 0u +#define D_NEIGH_HASTATUS0_HALTED_RESET 0x0000000000000000ull +#define D_NEIGH_HASTATUS0_HALTED_FIELD_MASK 0x000000000000FFFFull +#define D_NEIGH_HASTATUS0_HALTED_GET(x) ((x) & 0x000000000000FFFFull) +#define D_NEIGH_HASTATUS0_HALTED_SET(x) ((x) & 0x000000000000FFFFull) +#define D_NEIGH_HASTATUS0_HALTED_MODIFY(r, x) ((((x) << 0) & 0x000000000000FFFFull) | ((r) & 0xFFFFFFFFFFFF0000ull)) + +/* Field: D_NEIGH_HASTATUS0.running */ +#define D_NEIGH_HASTATUS0_RUNNING_MSB 31u +#define D_NEIGH_HASTATUS0_RUNNING_LSB 16u +#define D_NEIGH_HASTATUS0_RUNNING_WIDTH 16u +#define D_NEIGH_HASTATUS0_RUNNING_READ_ACCESS 1u +#define D_NEIGH_HASTATUS0_RUNNING_WRITE_ACCESS 0u +#define D_NEIGH_HASTATUS0_RUNNING_RESET 0x0000000000000000ull +#define D_NEIGH_HASTATUS0_RUNNING_FIELD_MASK 0x00000000FFFF0000ull +#define D_NEIGH_HASTATUS0_RUNNING_GET(x) (((x) & 0x00000000FFFF0000ull) >> 16) +#define D_NEIGH_HASTATUS0_RUNNING_SET(x) (((x) << 16) & 0x00000000FFFF0000ull) +#define D_NEIGH_HASTATUS0_RUNNING_MODIFY(r, x) ((((x) << 16) & 0x00000000FFFF0000ull) | ((r) & 0xFFFFFFFF0000FFFFull)) + +/* Field: D_NEIGH_HASTATUS0.resumeack */ +#define D_NEIGH_HASTATUS0_RESUMEACK_MSB 47u +#define D_NEIGH_HASTATUS0_RESUMEACK_LSB 32u +#define D_NEIGH_HASTATUS0_RESUMEACK_WIDTH 16u +#define D_NEIGH_HASTATUS0_RESUMEACK_READ_ACCESS 1u +#define D_NEIGH_HASTATUS0_RESUMEACK_WRITE_ACCESS 0u +#define D_NEIGH_HASTATUS0_RESUMEACK_RESET 0x0000000000000000ull +#define D_NEIGH_HASTATUS0_RESUMEACK_FIELD_MASK 0x0000FFFF00000000ull +#define D_NEIGH_HASTATUS0_RESUMEACK_GET(x) (((x) & 0x0000FFFF00000000ull) >> 32) +#define D_NEIGH_HASTATUS0_RESUMEACK_SET(x) (((x) << 32) & 0x0000FFFF00000000ull) +#define D_NEIGH_HASTATUS0_RESUMEACK_MODIFY(r, x) ((((x) << 32) & 0x0000FFFF00000000ull) | ((r) & 0xFFFF0000FFFFFFFFull)) + +/* Field: D_NEIGH_HASTATUS0.havereset */ +#define D_NEIGH_HASTATUS0_HAVERESET_MSB 63u +#define D_NEIGH_HASTATUS0_HAVERESET_LSB 48u +#define D_NEIGH_HASTATUS0_HAVERESET_WIDTH 16u +#define D_NEIGH_HASTATUS0_HAVERESET_READ_ACCESS 1u +#define D_NEIGH_HASTATUS0_HAVERESET_WRITE_ACCESS 0u +#define D_NEIGH_HASTATUS0_HAVERESET_RESET 0x0000000000000000ull +#define D_NEIGH_HASTATUS0_HAVERESET_FIELD_MASK 0xFFFF000000000000ull +#define D_NEIGH_HASTATUS0_HAVERESET_GET(x) (((x) & 0xFFFF000000000000ull) >> 48) +#define D_NEIGH_HASTATUS0_HAVERESET_SET(x) (((x) << 48) & 0xFFFF000000000000ull) +#define D_NEIGH_HASTATUS0_HAVERESET_MODIFY(r, x) ((((x) << 48) & 0xFFFF000000000000ull) | ((r) & 0x0000FFFFFFFFFFFFull)) + +/* Register: D_NEIGH.hastatus1 */ +#define D_NEIGH_HASTATUS1_ADDRESS 0x0000FF90ul +#define D_NEIGH_HASTATUS1_BYTE_ADDRESS 0x0000FF90ul +#define D_NEIGH_HASTATUS1_OFFSET 0x0000FF90ul +#define D_NEIGH_HASTATUS1_BYTE_OFFSET 0x0000FF90ul +#define D_NEIGH_HASTATUS1_SIZE 0x00000008ul +#define D_NEIGH_HASTATUS1_BYTE_SIZE 0x00000008ul +#define D_NEIGH_HASTATUS1_READ_ACCESS 1u +#define D_NEIGH_HASTATUS1_WRITE_ACCESS 1u +#define D_NEIGH_HASTATUS1_RESET_VALUE 0x0000000000000000ull +#define D_NEIGH_HASTATUS1_RESET_MASK 0x0000FFFFFFFFFFFFull +#define D_NEIGH_HASTATUS1_READ_MASK 0x0000FFFFFFFFFFFFull +#define D_NEIGH_HASTATUS1_WRITE_MASK 0x0000FFFFFFFF0000ull + +/* Field: D_NEIGH_HASTATUS1.busy */ +#define D_NEIGH_HASTATUS1_BUSY_MSB 15u +#define D_NEIGH_HASTATUS1_BUSY_LSB 0u +#define D_NEIGH_HASTATUS1_BUSY_WIDTH 16u +#define D_NEIGH_HASTATUS1_BUSY_READ_ACCESS 1u +#define D_NEIGH_HASTATUS1_BUSY_WRITE_ACCESS 0u +#define D_NEIGH_HASTATUS1_BUSY_RESET 0x0000000000000000ull +#define D_NEIGH_HASTATUS1_BUSY_FIELD_MASK 0x000000000000FFFFull +#define D_NEIGH_HASTATUS1_BUSY_GET(x) ((x) & 0x000000000000FFFFull) +#define D_NEIGH_HASTATUS1_BUSY_SET(x) ((x) & 0x000000000000FFFFull) +#define D_NEIGH_HASTATUS1_BUSY_MODIFY(r, x) ((((x) << 0) & 0x000000000000FFFFull) | ((r) & 0xFFFFFFFFFFFF0000ull)) + +/* Field: D_NEIGH_HASTATUS1.exception */ +#define D_NEIGH_HASTATUS1_EXCEPTION_MSB 31u +#define D_NEIGH_HASTATUS1_EXCEPTION_LSB 16u +#define D_NEIGH_HASTATUS1_EXCEPTION_WIDTH 16u +#define D_NEIGH_HASTATUS1_EXCEPTION_READ_ACCESS 1u +#define D_NEIGH_HASTATUS1_EXCEPTION_WRITE_ACCESS 1u +#define D_NEIGH_HASTATUS1_EXCEPTION_RESET 0x0000000000000000ull +#define D_NEIGH_HASTATUS1_EXCEPTION_FIELD_MASK 0x00000000FFFF0000ull +#define D_NEIGH_HASTATUS1_EXCEPTION_GET(x) (((x) & 0x00000000FFFF0000ull) >> 16) +#define D_NEIGH_HASTATUS1_EXCEPTION_SET(x) (((x) << 16) & 0x00000000FFFF0000ull) +#define D_NEIGH_HASTATUS1_EXCEPTION_MODIFY(r, x) ((((x) << 16) & 0x00000000FFFF0000ull) | ((r) & 0xFFFFFFFF0000FFFFull)) + +/* Field: D_NEIGH_HASTATUS1.error */ +#define D_NEIGH_HASTATUS1_ERROR_MSB 47u +#define D_NEIGH_HASTATUS1_ERROR_LSB 32u +#define D_NEIGH_HASTATUS1_ERROR_WIDTH 16u +#define D_NEIGH_HASTATUS1_ERROR_READ_ACCESS 1u +#define D_NEIGH_HASTATUS1_ERROR_WRITE_ACCESS 1u +#define D_NEIGH_HASTATUS1_ERROR_RESET 0x0000000000000000ull +#define D_NEIGH_HASTATUS1_ERROR_FIELD_MASK 0x0000FFFF00000000ull +#define D_NEIGH_HASTATUS1_ERROR_GET(x) (((x) & 0x0000FFFF00000000ull) >> 32) +#define D_NEIGH_HASTATUS1_ERROR_SET(x) (((x) << 32) & 0x0000FFFF00000000ull) +#define D_NEIGH_HASTATUS1_ERROR_MODIFY(r, x) ((((x) << 32) & 0x0000FFFF00000000ull) | ((r) & 0xFFFF0000FFFFFFFFull)) + +/* Register: D_NEIGH.and_or_tree_IO */ +#define D_NEIGH_AND_OR_TREE_IO_ADDRESS 0x0000FF98ul +#define D_NEIGH_AND_OR_TREE_IO_BYTE_ADDRESS 0x0000FF98ul +#define D_NEIGH_AND_OR_TREE_IO_OFFSET 0x0000FF98ul +#define D_NEIGH_AND_OR_TREE_IO_BYTE_OFFSET 0x0000FF98ul +#define D_NEIGH_AND_OR_TREE_IO_SIZE 0x00000008ul +#define D_NEIGH_AND_OR_TREE_IO_BYTE_SIZE 0x00000008ul +#define D_NEIGH_AND_OR_TREE_IO_READ_ACCESS 1u +#define D_NEIGH_AND_OR_TREE_IO_WRITE_ACCESS 0u +#define D_NEIGH_AND_OR_TREE_IO_RESET_VALUE 0x0000000000000000ull +#define D_NEIGH_AND_OR_TREE_IO_RESET_MASK 0x00000000000003FFull +#define D_NEIGH_AND_OR_TREE_IO_READ_MASK 0x00000000000003FFull +#define D_NEIGH_AND_OR_TREE_IO_WRITE_MASK 0x0000000000000000ull + +/* Field: D_NEIGH_AND_OR_TREE_IO.anyhalted */ +#define D_NEIGH_AND_OR_TREE_IO_ANYHALTED_MSB 0u +#define D_NEIGH_AND_OR_TREE_IO_ANYHALTED_LSB 0u +#define D_NEIGH_AND_OR_TREE_IO_ANYHALTED_WIDTH 1u +#define D_NEIGH_AND_OR_TREE_IO_ANYHALTED_READ_ACCESS 1u +#define D_NEIGH_AND_OR_TREE_IO_ANYHALTED_WRITE_ACCESS 0u +#define D_NEIGH_AND_OR_TREE_IO_ANYHALTED_RESET 0x0000000000000000ull +#define D_NEIGH_AND_OR_TREE_IO_ANYHALTED_FIELD_MASK 0x0000000000000001ull +#define D_NEIGH_AND_OR_TREE_IO_ANYHALTED_GET(x) ((x) & 0x0000000000000001ull) +#define D_NEIGH_AND_OR_TREE_IO_ANYHALTED_SET(x) ((x) & 0x0000000000000001ull) +#define D_NEIGH_AND_OR_TREE_IO_ANYHALTED_MODIFY(r, x) ((((x) << 0) & 0x0000000000000001ull) | ((r) & 0xFFFFFFFFFFFFFFFEull)) + +/* Field: D_NEIGH_AND_OR_TREE_IO.allhalted */ +#define D_NEIGH_AND_OR_TREE_IO_ALLHALTED_MSB 1u +#define D_NEIGH_AND_OR_TREE_IO_ALLHALTED_LSB 1u +#define D_NEIGH_AND_OR_TREE_IO_ALLHALTED_WIDTH 1u +#define D_NEIGH_AND_OR_TREE_IO_ALLHALTED_READ_ACCESS 1u +#define D_NEIGH_AND_OR_TREE_IO_ALLHALTED_WRITE_ACCESS 0u +#define D_NEIGH_AND_OR_TREE_IO_ALLHALTED_RESET 0x0000000000000000ull +#define D_NEIGH_AND_OR_TREE_IO_ALLHALTED_FIELD_MASK 0x0000000000000002ull +#define D_NEIGH_AND_OR_TREE_IO_ALLHALTED_GET(x) (((x) & 0x0000000000000002ull) >> 1) +#define D_NEIGH_AND_OR_TREE_IO_ALLHALTED_SET(x) (((x) << 1) & 0x0000000000000002ull) +#define D_NEIGH_AND_OR_TREE_IO_ALLHALTED_MODIFY(r, x) ((((x) << 1) & 0x0000000000000002ull) | ((r) & 0xFFFFFFFFFFFFFFFDull)) + +/* Field: D_NEIGH_AND_OR_TREE_IO.anyrunning */ +#define D_NEIGH_AND_OR_TREE_IO_ANYRUNNING_MSB 2u +#define D_NEIGH_AND_OR_TREE_IO_ANYRUNNING_LSB 2u +#define D_NEIGH_AND_OR_TREE_IO_ANYRUNNING_WIDTH 1u +#define D_NEIGH_AND_OR_TREE_IO_ANYRUNNING_READ_ACCESS 1u +#define D_NEIGH_AND_OR_TREE_IO_ANYRUNNING_WRITE_ACCESS 0u +#define D_NEIGH_AND_OR_TREE_IO_ANYRUNNING_RESET 0x0000000000000000ull +#define D_NEIGH_AND_OR_TREE_IO_ANYRUNNING_FIELD_MASK 0x0000000000000004ull +#define D_NEIGH_AND_OR_TREE_IO_ANYRUNNING_GET(x) (((x) & 0x0000000000000004ull) >> 2) +#define D_NEIGH_AND_OR_TREE_IO_ANYRUNNING_SET(x) (((x) << 2) & 0x0000000000000004ull) +#define D_NEIGH_AND_OR_TREE_IO_ANYRUNNING_MODIFY(r, x) ((((x) << 2) & 0x0000000000000004ull) | ((r) & 0xFFFFFFFFFFFFFFFBull)) + +/* Field: D_NEIGH_AND_OR_TREE_IO.allrunning */ +#define D_NEIGH_AND_OR_TREE_IO_ALLRUNNING_MSB 3u +#define D_NEIGH_AND_OR_TREE_IO_ALLRUNNING_LSB 3u +#define D_NEIGH_AND_OR_TREE_IO_ALLRUNNING_WIDTH 1u +#define D_NEIGH_AND_OR_TREE_IO_ALLRUNNING_READ_ACCESS 1u +#define D_NEIGH_AND_OR_TREE_IO_ALLRUNNING_WRITE_ACCESS 0u +#define D_NEIGH_AND_OR_TREE_IO_ALLRUNNING_RESET 0x0000000000000000ull +#define D_NEIGH_AND_OR_TREE_IO_ALLRUNNING_FIELD_MASK 0x0000000000000008ull +#define D_NEIGH_AND_OR_TREE_IO_ALLRUNNING_GET(x) (((x) & 0x0000000000000008ull) >> 3) +#define D_NEIGH_AND_OR_TREE_IO_ALLRUNNING_SET(x) (((x) << 3) & 0x0000000000000008ull) +#define D_NEIGH_AND_OR_TREE_IO_ALLRUNNING_MODIFY(r, x) ((((x) << 3) & 0x0000000000000008ull) | ((r) & 0xFFFFFFFFFFFFFFF7ull)) + +/* Field: D_NEIGH_AND_OR_TREE_IO.anyresumeack */ +#define D_NEIGH_AND_OR_TREE_IO_ANYRESUMEACK_MSB 4u +#define D_NEIGH_AND_OR_TREE_IO_ANYRESUMEACK_LSB 4u +#define D_NEIGH_AND_OR_TREE_IO_ANYRESUMEACK_WIDTH 1u +#define D_NEIGH_AND_OR_TREE_IO_ANYRESUMEACK_READ_ACCESS 1u +#define D_NEIGH_AND_OR_TREE_IO_ANYRESUMEACK_WRITE_ACCESS 0u +#define D_NEIGH_AND_OR_TREE_IO_ANYRESUMEACK_RESET 0x0000000000000000ull +#define D_NEIGH_AND_OR_TREE_IO_ANYRESUMEACK_FIELD_MASK 0x0000000000000010ull +#define D_NEIGH_AND_OR_TREE_IO_ANYRESUMEACK_GET(x) (((x) & 0x0000000000000010ull) >> 4) +#define D_NEIGH_AND_OR_TREE_IO_ANYRESUMEACK_SET(x) (((x) << 4) & 0x0000000000000010ull) +#define D_NEIGH_AND_OR_TREE_IO_ANYRESUMEACK_MODIFY(r, x) ((((x) << 4) & 0x0000000000000010ull) | ((r) & 0xFFFFFFFFFFFFFFEFull)) + +/* Field: D_NEIGH_AND_OR_TREE_IO.allresumeack */ +#define D_NEIGH_AND_OR_TREE_IO_ALLRESUMEACK_MSB 5u +#define D_NEIGH_AND_OR_TREE_IO_ALLRESUMEACK_LSB 5u +#define D_NEIGH_AND_OR_TREE_IO_ALLRESUMEACK_WIDTH 1u +#define D_NEIGH_AND_OR_TREE_IO_ALLRESUMEACK_READ_ACCESS 1u +#define D_NEIGH_AND_OR_TREE_IO_ALLRESUMEACK_WRITE_ACCESS 0u +#define D_NEIGH_AND_OR_TREE_IO_ALLRESUMEACK_RESET 0x0000000000000000ull +#define D_NEIGH_AND_OR_TREE_IO_ALLRESUMEACK_FIELD_MASK 0x0000000000000020ull +#define D_NEIGH_AND_OR_TREE_IO_ALLRESUMEACK_GET(x) (((x) & 0x0000000000000020ull) >> 5) +#define D_NEIGH_AND_OR_TREE_IO_ALLRESUMEACK_SET(x) (((x) << 5) & 0x0000000000000020ull) +#define D_NEIGH_AND_OR_TREE_IO_ALLRESUMEACK_MODIFY(r, x) ((((x) << 5) & 0x0000000000000020ull) | ((r) & 0xFFFFFFFFFFFFFFDFull)) + +/* Field: D_NEIGH_AND_OR_TREE_IO.anyhavereset */ +#define D_NEIGH_AND_OR_TREE_IO_ANYHAVERESET_MSB 6u +#define D_NEIGH_AND_OR_TREE_IO_ANYHAVERESET_LSB 6u +#define D_NEIGH_AND_OR_TREE_IO_ANYHAVERESET_WIDTH 1u +#define D_NEIGH_AND_OR_TREE_IO_ANYHAVERESET_READ_ACCESS 1u +#define D_NEIGH_AND_OR_TREE_IO_ANYHAVERESET_WRITE_ACCESS 0u +#define D_NEIGH_AND_OR_TREE_IO_ANYHAVERESET_RESET 0x0000000000000000ull +#define D_NEIGH_AND_OR_TREE_IO_ANYHAVERESET_FIELD_MASK 0x0000000000000040ull +#define D_NEIGH_AND_OR_TREE_IO_ANYHAVERESET_GET(x) (((x) & 0x0000000000000040ull) >> 6) +#define D_NEIGH_AND_OR_TREE_IO_ANYHAVERESET_SET(x) (((x) << 6) & 0x0000000000000040ull) +#define D_NEIGH_AND_OR_TREE_IO_ANYHAVERESET_MODIFY(r, x) ((((x) << 6) & 0x0000000000000040ull) | ((r) & 0xFFFFFFFFFFFFFFBFull)) + +/* Field: D_NEIGH_AND_OR_TREE_IO.allhavereset */ +#define D_NEIGH_AND_OR_TREE_IO_ALLHAVERESET_MSB 7u +#define D_NEIGH_AND_OR_TREE_IO_ALLHAVERESET_LSB 7u +#define D_NEIGH_AND_OR_TREE_IO_ALLHAVERESET_WIDTH 1u +#define D_NEIGH_AND_OR_TREE_IO_ALLHAVERESET_READ_ACCESS 1u +#define D_NEIGH_AND_OR_TREE_IO_ALLHAVERESET_WRITE_ACCESS 0u +#define D_NEIGH_AND_OR_TREE_IO_ALLHAVERESET_RESET 0x0000000000000000ull +#define D_NEIGH_AND_OR_TREE_IO_ALLHAVERESET_FIELD_MASK 0x0000000000000080ull +#define D_NEIGH_AND_OR_TREE_IO_ALLHAVERESET_GET(x) (((x) & 0x0000000000000080ull) >> 7) +#define D_NEIGH_AND_OR_TREE_IO_ALLHAVERESET_SET(x) (((x) << 7) & 0x0000000000000080ull) +#define D_NEIGH_AND_OR_TREE_IO_ALLHAVERESET_MODIFY(r, x) ((((x) << 7) & 0x0000000000000080ull) | ((r) & 0xFFFFFFFFFFFFFF7Full)) + +/* Field: D_NEIGH_AND_OR_TREE_IO.anyunavailable */ +#define D_NEIGH_AND_OR_TREE_IO_ANYUNAVAILABLE_MSB 8u +#define D_NEIGH_AND_OR_TREE_IO_ANYUNAVAILABLE_LSB 8u +#define D_NEIGH_AND_OR_TREE_IO_ANYUNAVAILABLE_WIDTH 1u +#define D_NEIGH_AND_OR_TREE_IO_ANYUNAVAILABLE_READ_ACCESS 1u +#define D_NEIGH_AND_OR_TREE_IO_ANYUNAVAILABLE_WRITE_ACCESS 0u +#define D_NEIGH_AND_OR_TREE_IO_ANYUNAVAILABLE_RESET 0x0000000000000000ull +#define D_NEIGH_AND_OR_TREE_IO_ANYUNAVAILABLE_FIELD_MASK 0x0000000000000100ull +#define D_NEIGH_AND_OR_TREE_IO_ANYUNAVAILABLE_GET(x) (((x) & 0x0000000000000100ull) >> 8) +#define D_NEIGH_AND_OR_TREE_IO_ANYUNAVAILABLE_SET(x) (((x) << 8) & 0x0000000000000100ull) +#define D_NEIGH_AND_OR_TREE_IO_ANYUNAVAILABLE_MODIFY(r, x) ((((x) << 8) & 0x0000000000000100ull) | ((r) & 0xFFFFFFFFFFFFFEFFull)) + +/* Field: D_NEIGH_AND_OR_TREE_IO.anyselected */ +#define D_NEIGH_AND_OR_TREE_IO_ANYSELECTED_MSB 9u +#define D_NEIGH_AND_OR_TREE_IO_ANYSELECTED_LSB 9u +#define D_NEIGH_AND_OR_TREE_IO_ANYSELECTED_WIDTH 1u +#define D_NEIGH_AND_OR_TREE_IO_ANYSELECTED_READ_ACCESS 1u +#define D_NEIGH_AND_OR_TREE_IO_ANYSELECTED_WRITE_ACCESS 0u +#define D_NEIGH_AND_OR_TREE_IO_ANYSELECTED_RESET 0x0000000000000000ull +#define D_NEIGH_AND_OR_TREE_IO_ANYSELECTED_FIELD_MASK 0x0000000000000200ull +#define D_NEIGH_AND_OR_TREE_IO_ANYSELECTED_GET(x) (((x) & 0x0000000000000200ull) >> 9) +#define D_NEIGH_AND_OR_TREE_IO_ANYSELECTED_SET(x) (((x) << 9) & 0x0000000000000200ull) +#define D_NEIGH_AND_OR_TREE_IO_ANYSELECTED_MODIFY(r, x) ((((x) << 9) & 0x0000000000000200ull) | ((r) & 0xFFFFFFFFFFFFFDFFull)) + +/* Block-level typedef: D_NEIGH */ +typedef struct { + uint8_t _pad0[0xFF80]; /* 0x0..0xFF7F reserved */ + volatile uint64_t hactrl; /* Offset 0xFF80 (R/W) */ + volatile uint64_t hastatus0; /* Offset 0xFF88 (R) */ + volatile uint64_t hastatus1; /* Offset 0xFF90 (R/W) */ + volatile uint64_t and_or_tree_IO; /* Offset 0xFF98 (R) */ +} D_neigh_t, *PTR_D_neigh_t; + +/* ============================================================ */ +/* Block: D_cpu (macro prefix: D_CPU) */ +/* ============================================================ */ + +/* Register: D_CPU.dmctrl */ +#define D_CPU_DMCTRL_ADDRESS 0x00000F88ul +#define D_CPU_DMCTRL_BYTE_ADDRESS 0x00000F88ul +#define D_CPU_DMCTRL_OFFSET 0x00000F88ul +#define D_CPU_DMCTRL_BYTE_OFFSET 0x00000F88ul +#define D_CPU_DMCTRL_SIZE 0x00000008ul +#define D_CPU_DMCTRL_BYTE_SIZE 0x00000008ul +#define D_CPU_DMCTRL_READ_ACCESS 1u +#define D_CPU_DMCTRL_WRITE_ACCESS 1u +#define D_CPU_DMCTRL_RESET_VALUE 0x0000000000000000ull +#define D_CPU_DMCTRL_RESET_MASK 0x00000000FFFFFFFFull +#define D_CPU_DMCTRL_READ_MASK 0x00000000FFFFFFFFull +#define D_CPU_DMCTRL_WRITE_MASK 0x00000000F400000Full + +/* Field: D_CPU_DMCTRL.dmactive */ +#define D_CPU_DMCTRL_DMACTIVE_MSB 0u +#define D_CPU_DMCTRL_DMACTIVE_LSB 0u +#define D_CPU_DMCTRL_DMACTIVE_WIDTH 1u +#define D_CPU_DMCTRL_DMACTIVE_READ_ACCESS 1u +#define D_CPU_DMCTRL_DMACTIVE_WRITE_ACCESS 1u +#define D_CPU_DMCTRL_DMACTIVE_RESET 0x0000000000000000ull +#define D_CPU_DMCTRL_DMACTIVE_FIELD_MASK 0x0000000000000001ull +#define D_CPU_DMCTRL_DMACTIVE_GET(x) ((x) & 0x0000000000000001ull) +#define D_CPU_DMCTRL_DMACTIVE_SET(x) ((x) & 0x0000000000000001ull) +#define D_CPU_DMCTRL_DMACTIVE_MODIFY(r, x) ((((x) << 0) & 0x0000000000000001ull) | ((r) & 0xFFFFFFFFFFFFFFFEull)) + +/* Field: D_CPU_DMCTRL.ndmreset */ +#define D_CPU_DMCTRL_NDMRESET_MSB 1u +#define D_CPU_DMCTRL_NDMRESET_LSB 1u +#define D_CPU_DMCTRL_NDMRESET_WIDTH 1u +#define D_CPU_DMCTRL_NDMRESET_READ_ACCESS 1u +#define D_CPU_DMCTRL_NDMRESET_WRITE_ACCESS 1u +#define D_CPU_DMCTRL_NDMRESET_RESET 0x0000000000000000ull +#define D_CPU_DMCTRL_NDMRESET_FIELD_MASK 0x0000000000000002ull +#define D_CPU_DMCTRL_NDMRESET_GET(x) (((x) & 0x0000000000000002ull) >> 1) +#define D_CPU_DMCTRL_NDMRESET_SET(x) (((x) << 1) & 0x0000000000000002ull) +#define D_CPU_DMCTRL_NDMRESET_MODIFY(r, x) ((((x) << 1) & 0x0000000000000002ull) | ((r) & 0xFFFFFFFFFFFFFFFDull)) + +/* Field: D_CPU_DMCTRL.clrresethaltreq */ +#define D_CPU_DMCTRL_CLRRESETHALTREQ_MSB 2u +#define D_CPU_DMCTRL_CLRRESETHALTREQ_LSB 2u +#define D_CPU_DMCTRL_CLRRESETHALTREQ_WIDTH 1u +#define D_CPU_DMCTRL_CLRRESETHALTREQ_READ_ACCESS 1u +#define D_CPU_DMCTRL_CLRRESETHALTREQ_WRITE_ACCESS 1u +#define D_CPU_DMCTRL_CLRRESETHALTREQ_RESET 0x0000000000000000ull +#define D_CPU_DMCTRL_CLRRESETHALTREQ_FIELD_MASK 0x0000000000000004ull +#define D_CPU_DMCTRL_CLRRESETHALTREQ_GET(x) (((x) & 0x0000000000000004ull) >> 2) +#define D_CPU_DMCTRL_CLRRESETHALTREQ_SET(x) (((x) << 2) & 0x0000000000000004ull) +#define D_CPU_DMCTRL_CLRRESETHALTREQ_MODIFY(r, x) ((((x) << 2) & 0x0000000000000004ull) | ((r) & 0xFFFFFFFFFFFFFFFBull)) + +/* Field: D_CPU_DMCTRL.setresethaltreq */ +#define D_CPU_DMCTRL_SETRESETHALTREQ_MSB 3u +#define D_CPU_DMCTRL_SETRESETHALTREQ_LSB 3u +#define D_CPU_DMCTRL_SETRESETHALTREQ_WIDTH 1u +#define D_CPU_DMCTRL_SETRESETHALTREQ_READ_ACCESS 1u +#define D_CPU_DMCTRL_SETRESETHALTREQ_WRITE_ACCESS 1u +#define D_CPU_DMCTRL_SETRESETHALTREQ_RESET 0x0000000000000000ull +#define D_CPU_DMCTRL_SETRESETHALTREQ_FIELD_MASK 0x0000000000000008ull +#define D_CPU_DMCTRL_SETRESETHALTREQ_GET(x) (((x) & 0x0000000000000008ull) >> 3) +#define D_CPU_DMCTRL_SETRESETHALTREQ_SET(x) (((x) << 3) & 0x0000000000000008ull) +#define D_CPU_DMCTRL_SETRESETHALTREQ_MODIFY(r, x) ((((x) << 3) & 0x0000000000000008ull) | ((r) & 0xFFFFFFFFFFFFFFF7ull)) + +/* Field: D_CPU_DMCTRL.reserved25_4 */ +#define D_CPU_DMCTRL_RESERVED25_4_MSB 25u +#define D_CPU_DMCTRL_RESERVED25_4_LSB 4u +#define D_CPU_DMCTRL_RESERVED25_4_WIDTH 22u +#define D_CPU_DMCTRL_RESERVED25_4_READ_ACCESS 1u +#define D_CPU_DMCTRL_RESERVED25_4_WRITE_ACCESS 0u +#define D_CPU_DMCTRL_RESERVED25_4_RESET 0x0000000000000000ull +#define D_CPU_DMCTRL_RESERVED25_4_FIELD_MASK 0x0000000003FFFFF0ull +#define D_CPU_DMCTRL_RESERVED25_4_GET(x) (((x) & 0x0000000003FFFFF0ull) >> 4) +#define D_CPU_DMCTRL_RESERVED25_4_SET(x) (((x) << 4) & 0x0000000003FFFFF0ull) +#define D_CPU_DMCTRL_RESERVED25_4_MODIFY(r, x) ((((x) << 4) & 0x0000000003FFFFF0ull) | ((r) & 0xFFFFFFFFFC00000Full)) + +/* Field: D_CPU_DMCTRL.hasel */ +#define D_CPU_DMCTRL_HASEL_MSB 26u +#define D_CPU_DMCTRL_HASEL_LSB 26u +#define D_CPU_DMCTRL_HASEL_WIDTH 1u +#define D_CPU_DMCTRL_HASEL_READ_ACCESS 1u +#define D_CPU_DMCTRL_HASEL_WRITE_ACCESS 1u +#define D_CPU_DMCTRL_HASEL_RESET 0x0000000000000000ull +#define D_CPU_DMCTRL_HASEL_FIELD_MASK 0x0000000004000000ull +#define D_CPU_DMCTRL_HASEL_GET(x) (((x) & 0x0000000004000000ull) >> 26) +#define D_CPU_DMCTRL_HASEL_SET(x) (((x) << 26) & 0x0000000004000000ull) +#define D_CPU_DMCTRL_HASEL_MODIFY(r, x) ((((x) << 26) & 0x0000000004000000ull) | ((r) & 0xFFFFFFFFFBFFFFFFull)) + +/* Field: D_CPU_DMCTRL.reserved27 */ +#define D_CPU_DMCTRL_RESERVED27_MSB 27u +#define D_CPU_DMCTRL_RESERVED27_LSB 27u +#define D_CPU_DMCTRL_RESERVED27_WIDTH 1u +#define D_CPU_DMCTRL_RESERVED27_READ_ACCESS 1u +#define D_CPU_DMCTRL_RESERVED27_WRITE_ACCESS 0u +#define D_CPU_DMCTRL_RESERVED27_RESET 0x0000000000000000ull +#define D_CPU_DMCTRL_RESERVED27_FIELD_MASK 0x0000000008000000ull +#define D_CPU_DMCTRL_RESERVED27_GET(x) (((x) & 0x0000000008000000ull) >> 27) +#define D_CPU_DMCTRL_RESERVED27_SET(x) (((x) << 27) & 0x0000000008000000ull) +#define D_CPU_DMCTRL_RESERVED27_MODIFY(r, x) ((((x) << 27) & 0x0000000008000000ull) | ((r) & 0xFFFFFFFFF7FFFFFFull)) + +/* Field: D_CPU_DMCTRL.ackhavereset */ +#define D_CPU_DMCTRL_ACKHAVERESET_MSB 28u +#define D_CPU_DMCTRL_ACKHAVERESET_LSB 28u +#define D_CPU_DMCTRL_ACKHAVERESET_WIDTH 1u +#define D_CPU_DMCTRL_ACKHAVERESET_READ_ACCESS 1u +#define D_CPU_DMCTRL_ACKHAVERESET_WRITE_ACCESS 1u +#define D_CPU_DMCTRL_ACKHAVERESET_RESET 0x0000000000000000ull +#define D_CPU_DMCTRL_ACKHAVERESET_FIELD_MASK 0x0000000010000000ull +#define D_CPU_DMCTRL_ACKHAVERESET_GET(x) (((x) & 0x0000000010000000ull) >> 28) +#define D_CPU_DMCTRL_ACKHAVERESET_SET(x) (((x) << 28) & 0x0000000010000000ull) +#define D_CPU_DMCTRL_ACKHAVERESET_MODIFY(r, x) ((((x) << 28) & 0x0000000010000000ull) | ((r) & 0xFFFFFFFFEFFFFFFFull)) + +/* Field: D_CPU_DMCTRL.hartreset */ +#define D_CPU_DMCTRL_HARTRESET_MSB 29u +#define D_CPU_DMCTRL_HARTRESET_LSB 29u +#define D_CPU_DMCTRL_HARTRESET_WIDTH 1u +#define D_CPU_DMCTRL_HARTRESET_READ_ACCESS 1u +#define D_CPU_DMCTRL_HARTRESET_WRITE_ACCESS 1u +#define D_CPU_DMCTRL_HARTRESET_RESET 0x0000000000000000ull +#define D_CPU_DMCTRL_HARTRESET_FIELD_MASK 0x0000000020000000ull +#define D_CPU_DMCTRL_HARTRESET_GET(x) (((x) & 0x0000000020000000ull) >> 29) +#define D_CPU_DMCTRL_HARTRESET_SET(x) (((x) << 29) & 0x0000000020000000ull) +#define D_CPU_DMCTRL_HARTRESET_MODIFY(r, x) ((((x) << 29) & 0x0000000020000000ull) | ((r) & 0xFFFFFFFFDFFFFFFFull)) + +/* Field: D_CPU_DMCTRL.resumereq */ +#define D_CPU_DMCTRL_RESUMEREQ_MSB 30u +#define D_CPU_DMCTRL_RESUMEREQ_LSB 30u +#define D_CPU_DMCTRL_RESUMEREQ_WIDTH 1u +#define D_CPU_DMCTRL_RESUMEREQ_READ_ACCESS 1u +#define D_CPU_DMCTRL_RESUMEREQ_WRITE_ACCESS 1u +#define D_CPU_DMCTRL_RESUMEREQ_RESET 0x0000000000000000ull +#define D_CPU_DMCTRL_RESUMEREQ_FIELD_MASK 0x0000000040000000ull +#define D_CPU_DMCTRL_RESUMEREQ_GET(x) (((x) & 0x0000000040000000ull) >> 30) +#define D_CPU_DMCTRL_RESUMEREQ_SET(x) (((x) << 30) & 0x0000000040000000ull) +#define D_CPU_DMCTRL_RESUMEREQ_MODIFY(r, x) ((((x) << 30) & 0x0000000040000000ull) | ((r) & 0xFFFFFFFFBFFFFFFFull)) + +/* Field: D_CPU_DMCTRL.haltreq */ +#define D_CPU_DMCTRL_HALTREQ_MSB 31u +#define D_CPU_DMCTRL_HALTREQ_LSB 31u +#define D_CPU_DMCTRL_HALTREQ_WIDTH 1u +#define D_CPU_DMCTRL_HALTREQ_READ_ACCESS 1u +#define D_CPU_DMCTRL_HALTREQ_WRITE_ACCESS 1u +#define D_CPU_DMCTRL_HALTREQ_RESET 0x0000000000000000ull +#define D_CPU_DMCTRL_HALTREQ_FIELD_MASK 0x0000000080000000ull +#define D_CPU_DMCTRL_HALTREQ_GET(x) (((x) & 0x0000000080000000ull) >> 31) +#define D_CPU_DMCTRL_HALTREQ_SET(x) (((x) << 31) & 0x0000000080000000ull) +#define D_CPU_DMCTRL_HALTREQ_MODIFY(r, x) ((((x) << 31) & 0x0000000080000000ull) | ((r) & 0xFFFFFFFF7FFFFFFFull)) + +/* Register: D_CPU.sm_config */ +#define D_CPU_SM_CONFIG_ADDRESS 0x00000F90ul +#define D_CPU_SM_CONFIG_BYTE_ADDRESS 0x00000F90ul +#define D_CPU_SM_CONFIG_OFFSET 0x00000F90ul +#define D_CPU_SM_CONFIG_BYTE_OFFSET 0x00000F90ul +#define D_CPU_SM_CONFIG_SIZE 0x00000008ul +#define D_CPU_SM_CONFIG_BYTE_SIZE 0x00000008ul +#define D_CPU_SM_CONFIG_READ_ACCESS 1u +#define D_CPU_SM_CONFIG_WRITE_ACCESS 1u +#define D_CPU_SM_CONFIG_RESET_VALUE 0x0000000000000000ull +#define D_CPU_SM_CONFIG_RESET_MASK 0x0000000000000FFFull +#define D_CPU_SM_CONFIG_READ_MASK 0x0000000000000FFFull +#define D_CPU_SM_CONFIG_WRITE_MASK 0x0000000000000FFFull + +/* Field: D_CPU_SM_CONFIG.sm_data_sel */ +#define D_CPU_SM_CONFIG_SM_DATA_SEL_MSB 6u +#define D_CPU_SM_CONFIG_SM_DATA_SEL_LSB 0u +#define D_CPU_SM_CONFIG_SM_DATA_SEL_WIDTH 7u +#define D_CPU_SM_CONFIG_SM_DATA_SEL_READ_ACCESS 1u +#define D_CPU_SM_CONFIG_SM_DATA_SEL_WRITE_ACCESS 1u +#define D_CPU_SM_CONFIG_SM_DATA_SEL_RESET 0x0000000000000000ull +#define D_CPU_SM_CONFIG_SM_DATA_SEL_FIELD_MASK 0x000000000000007Full +#define D_CPU_SM_CONFIG_SM_DATA_SEL_GET(x) ((x) & 0x000000000000007Full) +#define D_CPU_SM_CONFIG_SM_DATA_SEL_SET(x) ((x) & 0x000000000000007Full) +#define D_CPU_SM_CONFIG_SM_DATA_SEL_MODIFY(r, x) ((((x) << 0) & 0x000000000000007Full) | ((r) & 0xFFFFFFFFFFFFFF80ull)) + +/* Field: D_CPU_SM_CONFIG.sm_target_sel */ +#define D_CPU_SM_CONFIG_SM_TARGET_SEL_MSB 10u +#define D_CPU_SM_CONFIG_SM_TARGET_SEL_LSB 7u +#define D_CPU_SM_CONFIG_SM_TARGET_SEL_WIDTH 4u +#define D_CPU_SM_CONFIG_SM_TARGET_SEL_READ_ACCESS 1u +#define D_CPU_SM_CONFIG_SM_TARGET_SEL_WRITE_ACCESS 1u +#define D_CPU_SM_CONFIG_SM_TARGET_SEL_RESET 0x0000000000000000ull +#define D_CPU_SM_CONFIG_SM_TARGET_SEL_FIELD_MASK 0x0000000000000780ull +#define D_CPU_SM_CONFIG_SM_TARGET_SEL_GET(x) (((x) & 0x0000000000000780ull) >> 7) +#define D_CPU_SM_CONFIG_SM_TARGET_SEL_SET(x) (((x) << 7) & 0x0000000000000780ull) +#define D_CPU_SM_CONFIG_SM_TARGET_SEL_MODIFY(r, x) ((((x) << 7) & 0x0000000000000780ull) | ((r) & 0xFFFFFFFFFFFFF87Full)) + +/* Field: D_CPU_SM_CONFIG.sm_enable */ +#define D_CPU_SM_CONFIG_SM_ENABLE_MSB 11u +#define D_CPU_SM_CONFIG_SM_ENABLE_LSB 11u +#define D_CPU_SM_CONFIG_SM_ENABLE_WIDTH 1u +#define D_CPU_SM_CONFIG_SM_ENABLE_READ_ACCESS 1u +#define D_CPU_SM_CONFIG_SM_ENABLE_WRITE_ACCESS 1u +#define D_CPU_SM_CONFIG_SM_ENABLE_RESET 0x0000000000000000ull +#define D_CPU_SM_CONFIG_SM_ENABLE_FIELD_MASK 0x0000000000000800ull +#define D_CPU_SM_CONFIG_SM_ENABLE_GET(x) (((x) & 0x0000000000000800ull) >> 11) +#define D_CPU_SM_CONFIG_SM_ENABLE_SET(x) (((x) << 11) & 0x0000000000000800ull) +#define D_CPU_SM_CONFIG_SM_ENABLE_MODIFY(r, x) ((((x) << 11) & 0x0000000000000800ull) | ((r) & 0xFFFFFFFFFFFFF7FFull)) + +/* Register: D_CPU.sm_trigger */ +#define D_CPU_SM_TRIGGER_ADDRESS 0x00000F98ul +#define D_CPU_SM_TRIGGER_BYTE_ADDRESS 0x00000F98ul +#define D_CPU_SM_TRIGGER_OFFSET 0x00000F98ul +#define D_CPU_SM_TRIGGER_BYTE_OFFSET 0x00000F98ul +#define D_CPU_SM_TRIGGER_SIZE 0x00000008ul +#define D_CPU_SM_TRIGGER_BYTE_SIZE 0x00000008ul +#define D_CPU_SM_TRIGGER_READ_ACCESS 1u +#define D_CPU_SM_TRIGGER_WRITE_ACCESS 0u +#define D_CPU_SM_TRIGGER_RESET_VALUE 0x0000000000000000ull +#define D_CPU_SM_TRIGGER_RESET_MASK 0x0000000000000001ull +#define D_CPU_SM_TRIGGER_READ_MASK 0x0000000000000001ull +#define D_CPU_SM_TRIGGER_WRITE_MASK 0x0000000000000000ull + +/* Field: D_CPU_SM_TRIGGER.sm_trigger */ +#define D_CPU_SM_TRIGGER_SM_TRIGGER_MSB 0u +#define D_CPU_SM_TRIGGER_SM_TRIGGER_LSB 0u +#define D_CPU_SM_TRIGGER_SM_TRIGGER_WIDTH 1u +#define D_CPU_SM_TRIGGER_SM_TRIGGER_READ_ACCESS 1u +#define D_CPU_SM_TRIGGER_SM_TRIGGER_WRITE_ACCESS 0u +#define D_CPU_SM_TRIGGER_SM_TRIGGER_RESET 0x0000000000000000ull +#define D_CPU_SM_TRIGGER_SM_TRIGGER_FIELD_MASK 0x0000000000000001ull +#define D_CPU_SM_TRIGGER_SM_TRIGGER_GET(x) ((x) & 0x0000000000000001ull) +#define D_CPU_SM_TRIGGER_SM_TRIGGER_SET(x) ((x) & 0x0000000000000001ull) +#define D_CPU_SM_TRIGGER_SM_TRIGGER_MODIFY(r, x) ((((x) << 0) & 0x0000000000000001ull) | ((r) & 0xFFFFFFFFFFFFFFFEull)) + +/* Register: D_CPU.sm_match */ +#define D_CPU_SM_MATCH_ADDRESS 0x00000FA8ul +#define D_CPU_SM_MATCH_BYTE_ADDRESS 0x00000FA8ul +#define D_CPU_SM_MATCH_OFFSET 0x00000FA8ul +#define D_CPU_SM_MATCH_BYTE_OFFSET 0x00000FA8ul +#define D_CPU_SM_MATCH_SIZE 0x00000008ul +#define D_CPU_SM_MATCH_BYTE_SIZE 0x00000008ul +#define D_CPU_SM_MATCH_READ_ACCESS 1u +#define D_CPU_SM_MATCH_WRITE_ACCESS 0u +#define D_CPU_SM_MATCH_RESET_VALUE 0x0000000000000000ull +#define D_CPU_SM_MATCH_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define D_CPU_SM_MATCH_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define D_CPU_SM_MATCH_WRITE_MASK 0x0000000000000000ull + +/* Field: D_CPU_SM_MATCH.sm_match */ +#define D_CPU_SM_MATCH_SM_MATCH_MSB 63u +#define D_CPU_SM_MATCH_SM_MATCH_LSB 0u +#define D_CPU_SM_MATCH_SM_MATCH_WIDTH 64u +#define D_CPU_SM_MATCH_SM_MATCH_READ_ACCESS 1u +#define D_CPU_SM_MATCH_SM_MATCH_WRITE_ACCESS 0u +#define D_CPU_SM_MATCH_SM_MATCH_RESET 0x0000000000000000ull +#define D_CPU_SM_MATCH_SM_MATCH_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define D_CPU_SM_MATCH_SM_MATCH_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define D_CPU_SM_MATCH_SM_MATCH_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define D_CPU_SM_MATCH_SM_MATCH_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: D_CPU.sm_filter0 */ +#define D_CPU_SM_FILTER0_ADDRESS 0x00000FB0ul +#define D_CPU_SM_FILTER0_BYTE_ADDRESS 0x00000FB0ul +#define D_CPU_SM_FILTER0_OFFSET 0x00000FB0ul +#define D_CPU_SM_FILTER0_BYTE_OFFSET 0x00000FB0ul +#define D_CPU_SM_FILTER0_SIZE 0x00000008ul +#define D_CPU_SM_FILTER0_BYTE_SIZE 0x00000008ul +#define D_CPU_SM_FILTER0_READ_ACCESS 1u +#define D_CPU_SM_FILTER0_WRITE_ACCESS 0u +#define D_CPU_SM_FILTER0_RESET_VALUE 0x0000000000000000ull +#define D_CPU_SM_FILTER0_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define D_CPU_SM_FILTER0_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define D_CPU_SM_FILTER0_WRITE_MASK 0x0000000000000000ull + +/* Field: D_CPU_SM_FILTER0.sm_filter0 */ +#define D_CPU_SM_FILTER0_SM_FILTER0_MSB 63u +#define D_CPU_SM_FILTER0_SM_FILTER0_LSB 0u +#define D_CPU_SM_FILTER0_SM_FILTER0_WIDTH 64u +#define D_CPU_SM_FILTER0_SM_FILTER0_READ_ACCESS 1u +#define D_CPU_SM_FILTER0_SM_FILTER0_WRITE_ACCESS 0u +#define D_CPU_SM_FILTER0_SM_FILTER0_RESET 0x0000000000000000ull +#define D_CPU_SM_FILTER0_SM_FILTER0_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define D_CPU_SM_FILTER0_SM_FILTER0_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define D_CPU_SM_FILTER0_SM_FILTER0_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define D_CPU_SM_FILTER0_SM_FILTER0_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: D_CPU.sm_filter1 */ +#define D_CPU_SM_FILTER1_ADDRESS 0x00000FB8ul +#define D_CPU_SM_FILTER1_BYTE_ADDRESS 0x00000FB8ul +#define D_CPU_SM_FILTER1_OFFSET 0x00000FB8ul +#define D_CPU_SM_FILTER1_BYTE_OFFSET 0x00000FB8ul +#define D_CPU_SM_FILTER1_SIZE 0x00000008ul +#define D_CPU_SM_FILTER1_BYTE_SIZE 0x00000008ul +#define D_CPU_SM_FILTER1_READ_ACCESS 1u +#define D_CPU_SM_FILTER1_WRITE_ACCESS 0u +#define D_CPU_SM_FILTER1_RESET_VALUE 0x0000000000000000ull +#define D_CPU_SM_FILTER1_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define D_CPU_SM_FILTER1_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define D_CPU_SM_FILTER1_WRITE_MASK 0x0000000000000000ull + +/* Field: D_CPU_SM_FILTER1.sm_filter1 */ +#define D_CPU_SM_FILTER1_SM_FILTER1_MSB 63u +#define D_CPU_SM_FILTER1_SM_FILTER1_LSB 0u +#define D_CPU_SM_FILTER1_SM_FILTER1_WIDTH 64u +#define D_CPU_SM_FILTER1_SM_FILTER1_READ_ACCESS 1u +#define D_CPU_SM_FILTER1_SM_FILTER1_WRITE_ACCESS 0u +#define D_CPU_SM_FILTER1_SM_FILTER1_RESET 0x0000000000000000ull +#define D_CPU_SM_FILTER1_SM_FILTER1_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define D_CPU_SM_FILTER1_SM_FILTER1_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define D_CPU_SM_FILTER1_SM_FILTER1_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define D_CPU_SM_FILTER1_SM_FILTER1_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: D_CPU.sm_filter2 */ +#define D_CPU_SM_FILTER2_ADDRESS 0x00000FC0ul +#define D_CPU_SM_FILTER2_BYTE_ADDRESS 0x00000FC0ul +#define D_CPU_SM_FILTER2_OFFSET 0x00000FC0ul +#define D_CPU_SM_FILTER2_BYTE_OFFSET 0x00000FC0ul +#define D_CPU_SM_FILTER2_SIZE 0x00000008ul +#define D_CPU_SM_FILTER2_BYTE_SIZE 0x00000008ul +#define D_CPU_SM_FILTER2_READ_ACCESS 1u +#define D_CPU_SM_FILTER2_WRITE_ACCESS 0u +#define D_CPU_SM_FILTER2_RESET_VALUE 0x0000000000000000ull +#define D_CPU_SM_FILTER2_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define D_CPU_SM_FILTER2_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define D_CPU_SM_FILTER2_WRITE_MASK 0x0000000000000000ull + +/* Field: D_CPU_SM_FILTER2.sm_filter2 */ +#define D_CPU_SM_FILTER2_SM_FILTER2_MSB 63u +#define D_CPU_SM_FILTER2_SM_FILTER2_LSB 0u +#define D_CPU_SM_FILTER2_SM_FILTER2_WIDTH 64u +#define D_CPU_SM_FILTER2_SM_FILTER2_READ_ACCESS 1u +#define D_CPU_SM_FILTER2_SM_FILTER2_WRITE_ACCESS 0u +#define D_CPU_SM_FILTER2_SM_FILTER2_RESET 0x0000000000000000ull +#define D_CPU_SM_FILTER2_SM_FILTER2_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define D_CPU_SM_FILTER2_SM_FILTER2_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define D_CPU_SM_FILTER2_SM_FILTER2_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define D_CPU_SM_FILTER2_SM_FILTER2_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: D_CPU.sm_data0 */ +#define D_CPU_SM_DATA0_ADDRESS 0x00000FC8ul +#define D_CPU_SM_DATA0_BYTE_ADDRESS 0x00000FC8ul +#define D_CPU_SM_DATA0_OFFSET 0x00000FC8ul +#define D_CPU_SM_DATA0_BYTE_OFFSET 0x00000FC8ul +#define D_CPU_SM_DATA0_SIZE 0x00000008ul +#define D_CPU_SM_DATA0_BYTE_SIZE 0x00000008ul +#define D_CPU_SM_DATA0_READ_ACCESS 1u +#define D_CPU_SM_DATA0_WRITE_ACCESS 0u +#define D_CPU_SM_DATA0_RESET_VALUE 0x0000000000000000ull +#define D_CPU_SM_DATA0_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define D_CPU_SM_DATA0_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define D_CPU_SM_DATA0_WRITE_MASK 0x0000000000000000ull + +/* Field: D_CPU_SM_DATA0.sm_data0 */ +#define D_CPU_SM_DATA0_SM_DATA0_MSB 63u +#define D_CPU_SM_DATA0_SM_DATA0_LSB 0u +#define D_CPU_SM_DATA0_SM_DATA0_WIDTH 64u +#define D_CPU_SM_DATA0_SM_DATA0_READ_ACCESS 1u +#define D_CPU_SM_DATA0_SM_DATA0_WRITE_ACCESS 0u +#define D_CPU_SM_DATA0_SM_DATA0_RESET 0x0000000000000000ull +#define D_CPU_SM_DATA0_SM_DATA0_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define D_CPU_SM_DATA0_SM_DATA0_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define D_CPU_SM_DATA0_SM_DATA0_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define D_CPU_SM_DATA0_SM_DATA0_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: D_CPU.sm_data1 */ +#define D_CPU_SM_DATA1_ADDRESS 0x00000FD0ul +#define D_CPU_SM_DATA1_BYTE_ADDRESS 0x00000FD0ul +#define D_CPU_SM_DATA1_OFFSET 0x00000FD0ul +#define D_CPU_SM_DATA1_BYTE_OFFSET 0x00000FD0ul +#define D_CPU_SM_DATA1_SIZE 0x00000008ul +#define D_CPU_SM_DATA1_BYTE_SIZE 0x00000008ul +#define D_CPU_SM_DATA1_READ_ACCESS 1u +#define D_CPU_SM_DATA1_WRITE_ACCESS 0u +#define D_CPU_SM_DATA1_RESET_VALUE 0x0000000000000000ull +#define D_CPU_SM_DATA1_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define D_CPU_SM_DATA1_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define D_CPU_SM_DATA1_WRITE_MASK 0x0000000000000000ull + +/* Field: D_CPU_SM_DATA1.sm_data1 */ +#define D_CPU_SM_DATA1_SM_DATA1_MSB 63u +#define D_CPU_SM_DATA1_SM_DATA1_LSB 0u +#define D_CPU_SM_DATA1_SM_DATA1_WIDTH 64u +#define D_CPU_SM_DATA1_SM_DATA1_READ_ACCESS 1u +#define D_CPU_SM_DATA1_SM_DATA1_WRITE_ACCESS 0u +#define D_CPU_SM_DATA1_SM_DATA1_RESET 0x0000000000000000ull +#define D_CPU_SM_DATA1_SM_DATA1_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define D_CPU_SM_DATA1_SM_DATA1_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define D_CPU_SM_DATA1_SM_DATA1_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define D_CPU_SM_DATA1_SM_DATA1_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Block-level typedef: D_CPU */ +typedef struct { + uint8_t _pad0[0xF88]; /* 0x0..0xF87 reserved */ + volatile uint64_t dmctrl; /* Offset 0xF88 (R/W) */ + volatile uint64_t sm_config; /* Offset 0xF90 (R/W) */ + volatile uint64_t sm_trigger; /* Offset 0xF98 (R) */ + uint8_t _pad1[0x8]; /* 0xFA0..0xFA7 reserved */ + volatile uint64_t sm_match; /* Offset 0xFA8 (R) */ + volatile uint64_t sm_filter0; /* Offset 0xFB0 (R) */ + volatile uint64_t sm_filter1; /* Offset 0xFB8 (R) */ + volatile uint64_t sm_filter2; /* Offset 0xFC0 (R) */ + volatile uint64_t sm_data0; /* Offset 0xFC8 (R) */ + volatile uint64_t sm_data1; /* Offset 0xFD0 (R) */ +} D_cpu_t, *PTR_D_cpu_t; + +/* ============================================================ */ +/* Block: Machine_neigh (macro prefix: MACHINE_NEIGH) */ +/* ============================================================ */ + +/* Register: MACHINE_NEIGH.minion_boot */ +#define MACHINE_NEIGH_MINION_BOOT_ADDRESS 0x00000018ul +#define MACHINE_NEIGH_MINION_BOOT_BYTE_ADDRESS 0x00000018ul +#define MACHINE_NEIGH_MINION_BOOT_OFFSET 0x00000018ul +#define MACHINE_NEIGH_MINION_BOOT_BYTE_OFFSET 0x00000018ul +#define MACHINE_NEIGH_MINION_BOOT_SIZE 0x00000008ul +#define MACHINE_NEIGH_MINION_BOOT_BYTE_SIZE 0x00000008ul +#define MACHINE_NEIGH_MINION_BOOT_READ_ACCESS 1u +#define MACHINE_NEIGH_MINION_BOOT_WRITE_ACCESS 1u +#define MACHINE_NEIGH_MINION_BOOT_RESET_VALUE 0x0000000002008000ull +#define MACHINE_NEIGH_MINION_BOOT_RESET_MASK 0x0000FFFFFFFFFFFFull +#define MACHINE_NEIGH_MINION_BOOT_READ_MASK 0x0000FFFFFFFFFFFFull +#define MACHINE_NEIGH_MINION_BOOT_WRITE_MASK 0x0000FFFFFFFFFFFFull + +/* Field: MACHINE_NEIGH_MINION_BOOT.minion_boot */ +#define MACHINE_NEIGH_MINION_BOOT_MINION_BOOT_MSB 47u +#define MACHINE_NEIGH_MINION_BOOT_MINION_BOOT_LSB 0u +#define MACHINE_NEIGH_MINION_BOOT_MINION_BOOT_WIDTH 48u +#define MACHINE_NEIGH_MINION_BOOT_MINION_BOOT_READ_ACCESS 1u +#define MACHINE_NEIGH_MINION_BOOT_MINION_BOOT_WRITE_ACCESS 1u +#define MACHINE_NEIGH_MINION_BOOT_MINION_BOOT_RESET 0x0000000002008000ull +#define MACHINE_NEIGH_MINION_BOOT_MINION_BOOT_FIELD_MASK 0x0000FFFFFFFFFFFFull +#define MACHINE_NEIGH_MINION_BOOT_MINION_BOOT_GET(x) ((x) & 0x0000FFFFFFFFFFFFull) +#define MACHINE_NEIGH_MINION_BOOT_MINION_BOOT_SET(x) ((x) & 0x0000FFFFFFFFFFFFull) +#define MACHINE_NEIGH_MINION_BOOT_MINION_BOOT_MODIFY(r, x) ((((x) << 0) & 0x0000FFFFFFFFFFFFull) | ((r) & 0xFFFF000000000000ull)) + +/* Register: MACHINE_NEIGH.mprot */ +#define MACHINE_NEIGH_MPROT_ADDRESS 0x00000038ul +#define MACHINE_NEIGH_MPROT_BYTE_ADDRESS 0x00000038ul +#define MACHINE_NEIGH_MPROT_OFFSET 0x00000038ul +#define MACHINE_NEIGH_MPROT_BYTE_OFFSET 0x00000038ul +#define MACHINE_NEIGH_MPROT_SIZE 0x00000008ul +#define MACHINE_NEIGH_MPROT_BYTE_SIZE 0x00000008ul +#define MACHINE_NEIGH_MPROT_READ_ACCESS 1u +#define MACHINE_NEIGH_MPROT_WRITE_ACCESS 1u +#define MACHINE_NEIGH_MPROT_RESET_VALUE 0x0000000000000000ull +#define MACHINE_NEIGH_MPROT_RESET_MASK 0x00000000000001FFull +#define MACHINE_NEIGH_MPROT_READ_MASK 0x00000000000001FFull +#define MACHINE_NEIGH_MPROT_WRITE_MASK 0x00000000000001FFull + +/* Field: MACHINE_NEIGH_MPROT.smode_size */ +#define MACHINE_NEIGH_MPROT_SMODE_SIZE_MSB 3u +#define MACHINE_NEIGH_MPROT_SMODE_SIZE_LSB 0u +#define MACHINE_NEIGH_MPROT_SMODE_SIZE_WIDTH 4u +#define MACHINE_NEIGH_MPROT_SMODE_SIZE_READ_ACCESS 1u +#define MACHINE_NEIGH_MPROT_SMODE_SIZE_WRITE_ACCESS 1u +#define MACHINE_NEIGH_MPROT_SMODE_SIZE_RESET 0x0000000000000000ull +#define MACHINE_NEIGH_MPROT_SMODE_SIZE_FIELD_MASK 0x000000000000000Full +#define MACHINE_NEIGH_MPROT_SMODE_SIZE_GET(x) ((x) & 0x000000000000000Full) +#define MACHINE_NEIGH_MPROT_SMODE_SIZE_SET(x) ((x) & 0x000000000000000Full) +#define MACHINE_NEIGH_MPROT_SMODE_SIZE_MODIFY(r, x) ((((x) << 0) & 0x000000000000000Full) | ((r) & 0xFFFFFFFFFFFFFFF0ull)) + +/* Field: MACHINE_NEIGH_MPROT.mmode_size */ +#define MACHINE_NEIGH_MPROT_MMODE_SIZE_MSB 7u +#define MACHINE_NEIGH_MPROT_MMODE_SIZE_LSB 4u +#define MACHINE_NEIGH_MPROT_MMODE_SIZE_WIDTH 4u +#define MACHINE_NEIGH_MPROT_MMODE_SIZE_READ_ACCESS 1u +#define MACHINE_NEIGH_MPROT_MMODE_SIZE_WRITE_ACCESS 1u +#define MACHINE_NEIGH_MPROT_MMODE_SIZE_RESET 0x0000000000000000ull +#define MACHINE_NEIGH_MPROT_MMODE_SIZE_FIELD_MASK 0x00000000000000F0ull +#define MACHINE_NEIGH_MPROT_MMODE_SIZE_GET(x) (((x) & 0x00000000000000F0ull) >> 4) +#define MACHINE_NEIGH_MPROT_MMODE_SIZE_SET(x) (((x) << 4) & 0x00000000000000F0ull) +#define MACHINE_NEIGH_MPROT_MMODE_SIZE_MODIFY(r, x) ((((x) << 4) & 0x00000000000000F0ull) | ((r) & 0xFFFFFFFFFFFFFF0Full)) + +/* Field: MACHINE_NEIGH_MPROT.mprot_en */ +#define MACHINE_NEIGH_MPROT_MPROT_EN_MSB 8u +#define MACHINE_NEIGH_MPROT_MPROT_EN_LSB 8u +#define MACHINE_NEIGH_MPROT_MPROT_EN_WIDTH 1u +#define MACHINE_NEIGH_MPROT_MPROT_EN_READ_ACCESS 1u +#define MACHINE_NEIGH_MPROT_MPROT_EN_WRITE_ACCESS 1u +#define MACHINE_NEIGH_MPROT_MPROT_EN_RESET 0x0000000000000000ull +#define MACHINE_NEIGH_MPROT_MPROT_EN_FIELD_MASK 0x0000000000000100ull +#define MACHINE_NEIGH_MPROT_MPROT_EN_GET(x) (((x) & 0x0000000000000100ull) >> 8) +#define MACHINE_NEIGH_MPROT_MPROT_EN_SET(x) (((x) << 8) & 0x0000000000000100ull) +#define MACHINE_NEIGH_MPROT_MPROT_EN_MODIFY(r, x) ((((x) << 8) & 0x0000000000000100ull) | ((r) & 0xFFFFFFFFFFFFFEFFull)) + +/* Register: MACHINE_NEIGH.pmu_ctrl */ +#define MACHINE_NEIGH_PMU_CTRL_ADDRESS 0x00000068ul +#define MACHINE_NEIGH_PMU_CTRL_BYTE_ADDRESS 0x00000068ul +#define MACHINE_NEIGH_PMU_CTRL_OFFSET 0x00000068ul +#define MACHINE_NEIGH_PMU_CTRL_BYTE_OFFSET 0x00000068ul +#define MACHINE_NEIGH_PMU_CTRL_SIZE 0x00000008ul +#define MACHINE_NEIGH_PMU_CTRL_BYTE_SIZE 0x00000008ul +#define MACHINE_NEIGH_PMU_CTRL_READ_ACCESS 1u +#define MACHINE_NEIGH_PMU_CTRL_WRITE_ACCESS 1u +#define MACHINE_NEIGH_PMU_CTRL_RESET_VALUE 0x0000000000000000ull +#define MACHINE_NEIGH_PMU_CTRL_RESET_MASK 0x0000000000000001ull +#define MACHINE_NEIGH_PMU_CTRL_READ_MASK 0x0000000000000001ull +#define MACHINE_NEIGH_PMU_CTRL_WRITE_MASK 0x0000000000000001ull + +/* Field: MACHINE_NEIGH_PMU_CTRL.disable_clock */ +#define MACHINE_NEIGH_PMU_CTRL_DISABLE_CLOCK_MSB 0u +#define MACHINE_NEIGH_PMU_CTRL_DISABLE_CLOCK_LSB 0u +#define MACHINE_NEIGH_PMU_CTRL_DISABLE_CLOCK_WIDTH 1u +#define MACHINE_NEIGH_PMU_CTRL_DISABLE_CLOCK_READ_ACCESS 1u +#define MACHINE_NEIGH_PMU_CTRL_DISABLE_CLOCK_WRITE_ACCESS 1u +#define MACHINE_NEIGH_PMU_CTRL_DISABLE_CLOCK_RESET 0x0000000000000000ull +#define MACHINE_NEIGH_PMU_CTRL_DISABLE_CLOCK_FIELD_MASK 0x0000000000000001ull +#define MACHINE_NEIGH_PMU_CTRL_DISABLE_CLOCK_GET(x) ((x) & 0x0000000000000001ull) +#define MACHINE_NEIGH_PMU_CTRL_DISABLE_CLOCK_SET(x) ((x) & 0x0000000000000001ull) +#define MACHINE_NEIGH_PMU_CTRL_DISABLE_CLOCK_MODIFY(r, x) ((((x) << 0) & 0x0000000000000001ull) | ((r) & 0xFFFFFFFFFFFFFFFEull)) + +/* Register: MACHINE_NEIGH.neigh_chicken */ +#define MACHINE_NEIGH_NEIGH_CHICKEN_ADDRESS 0x00000070ul +#define MACHINE_NEIGH_NEIGH_CHICKEN_BYTE_ADDRESS 0x00000070ul +#define MACHINE_NEIGH_NEIGH_CHICKEN_OFFSET 0x00000070ul +#define MACHINE_NEIGH_NEIGH_CHICKEN_BYTE_OFFSET 0x00000070ul +#define MACHINE_NEIGH_NEIGH_CHICKEN_SIZE 0x00000008ul +#define MACHINE_NEIGH_NEIGH_CHICKEN_BYTE_SIZE 0x00000008ul +#define MACHINE_NEIGH_NEIGH_CHICKEN_READ_ACCESS 1u +#define MACHINE_NEIGH_NEIGH_CHICKEN_WRITE_ACCESS 1u +#define MACHINE_NEIGH_NEIGH_CHICKEN_RESET_VALUE 0x0000000000000000ull +#define MACHINE_NEIGH_NEIGH_CHICKEN_RESET_MASK 0x000000000000007Full +#define MACHINE_NEIGH_NEIGH_CHICKEN_READ_MASK 0x000000000000007Full +#define MACHINE_NEIGH_NEIGH_CHICKEN_WRITE_MASK 0x000000000000007Full + +/* Field: MACHINE_NEIGH_NEIGH_CHICKEN.bypass_icache */ +#define MACHINE_NEIGH_NEIGH_CHICKEN_BYPASS_ICACHE_MSB 0u +#define MACHINE_NEIGH_NEIGH_CHICKEN_BYPASS_ICACHE_LSB 0u +#define MACHINE_NEIGH_NEIGH_CHICKEN_BYPASS_ICACHE_WIDTH 1u +#define MACHINE_NEIGH_NEIGH_CHICKEN_BYPASS_ICACHE_READ_ACCESS 1u +#define MACHINE_NEIGH_NEIGH_CHICKEN_BYPASS_ICACHE_WRITE_ACCESS 1u +#define MACHINE_NEIGH_NEIGH_CHICKEN_BYPASS_ICACHE_RESET 0x0000000000000000ull +#define MACHINE_NEIGH_NEIGH_CHICKEN_BYPASS_ICACHE_FIELD_MASK 0x0000000000000001ull +#define MACHINE_NEIGH_NEIGH_CHICKEN_BYPASS_ICACHE_GET(x) ((x) & 0x0000000000000001ull) +#define MACHINE_NEIGH_NEIGH_CHICKEN_BYPASS_ICACHE_SET(x) ((x) & 0x0000000000000001ull) +#define MACHINE_NEIGH_NEIGH_CHICKEN_BYPASS_ICACHE_MODIFY(r, x) ((((x) << 0) & 0x0000000000000001ull) | ((r) & 0xFFFFFFFFFFFFFFFEull)) + +/* Field: MACHINE_NEIGH_NEIGH_CHICKEN.bypass_dcache */ +#define MACHINE_NEIGH_NEIGH_CHICKEN_BYPASS_DCACHE_MSB 1u +#define MACHINE_NEIGH_NEIGH_CHICKEN_BYPASS_DCACHE_LSB 1u +#define MACHINE_NEIGH_NEIGH_CHICKEN_BYPASS_DCACHE_WIDTH 1u +#define MACHINE_NEIGH_NEIGH_CHICKEN_BYPASS_DCACHE_READ_ACCESS 1u +#define MACHINE_NEIGH_NEIGH_CHICKEN_BYPASS_DCACHE_WRITE_ACCESS 1u +#define MACHINE_NEIGH_NEIGH_CHICKEN_BYPASS_DCACHE_RESET 0x0000000000000000ull +#define MACHINE_NEIGH_NEIGH_CHICKEN_BYPASS_DCACHE_FIELD_MASK 0x0000000000000002ull +#define MACHINE_NEIGH_NEIGH_CHICKEN_BYPASS_DCACHE_GET(x) (((x) & 0x0000000000000002ull) >> 1) +#define MACHINE_NEIGH_NEIGH_CHICKEN_BYPASS_DCACHE_SET(x) (((x) << 1) & 0x0000000000000002ull) +#define MACHINE_NEIGH_NEIGH_CHICKEN_BYPASS_DCACHE_MODIFY(r, x) ((((x) << 1) & 0x0000000000000002ull) | ((r) & 0xFFFFFFFFFFFFFFFDull)) + +/* Field: MACHINE_NEIGH_NEIGH_CHICKEN.force_dest_fifo */ +#define MACHINE_NEIGH_NEIGH_CHICKEN_FORCE_DEST_FIFO_MSB 2u +#define MACHINE_NEIGH_NEIGH_CHICKEN_FORCE_DEST_FIFO_LSB 2u +#define MACHINE_NEIGH_NEIGH_CHICKEN_FORCE_DEST_FIFO_WIDTH 1u +#define MACHINE_NEIGH_NEIGH_CHICKEN_FORCE_DEST_FIFO_READ_ACCESS 1u +#define MACHINE_NEIGH_NEIGH_CHICKEN_FORCE_DEST_FIFO_WRITE_ACCESS 1u +#define MACHINE_NEIGH_NEIGH_CHICKEN_FORCE_DEST_FIFO_RESET 0x0000000000000000ull +#define MACHINE_NEIGH_NEIGH_CHICKEN_FORCE_DEST_FIFO_FIELD_MASK 0x0000000000000004ull +#define MACHINE_NEIGH_NEIGH_CHICKEN_FORCE_DEST_FIFO_GET(x) (((x) & 0x0000000000000004ull) >> 2) +#define MACHINE_NEIGH_NEIGH_CHICKEN_FORCE_DEST_FIFO_SET(x) (((x) << 2) & 0x0000000000000004ull) +#define MACHINE_NEIGH_NEIGH_CHICKEN_FORCE_DEST_FIFO_MODIFY(r, x) ((((x) << 2) & 0x0000000000000004ull) | ((r) & 0xFFFFFFFFFFFFFFFBull)) + +/* Field: MACHINE_NEIGH_NEIGH_CHICKEN.dest_fifo */ +#define MACHINE_NEIGH_NEIGH_CHICKEN_DEST_FIFO_MSB 4u +#define MACHINE_NEIGH_NEIGH_CHICKEN_DEST_FIFO_LSB 3u +#define MACHINE_NEIGH_NEIGH_CHICKEN_DEST_FIFO_WIDTH 2u +#define MACHINE_NEIGH_NEIGH_CHICKEN_DEST_FIFO_READ_ACCESS 1u +#define MACHINE_NEIGH_NEIGH_CHICKEN_DEST_FIFO_WRITE_ACCESS 1u +#define MACHINE_NEIGH_NEIGH_CHICKEN_DEST_FIFO_RESET 0x0000000000000000ull +#define MACHINE_NEIGH_NEIGH_CHICKEN_DEST_FIFO_FIELD_MASK 0x0000000000000018ull +#define MACHINE_NEIGH_NEIGH_CHICKEN_DEST_FIFO_GET(x) (((x) & 0x0000000000000018ull) >> 3) +#define MACHINE_NEIGH_NEIGH_CHICKEN_DEST_FIFO_SET(x) (((x) << 3) & 0x0000000000000018ull) +#define MACHINE_NEIGH_NEIGH_CHICKEN_DEST_FIFO_MODIFY(r, x) ((((x) << 3) & 0x0000000000000018ull) | ((r) & 0xFFFFFFFFFFFFFFE7ull)) + +/* Field: MACHINE_NEIGH_NEIGH_CHICKEN.force_all_agents */ +#define MACHINE_NEIGH_NEIGH_CHICKEN_FORCE_ALL_AGENTS_MSB 5u +#define MACHINE_NEIGH_NEIGH_CHICKEN_FORCE_ALL_AGENTS_LSB 5u +#define MACHINE_NEIGH_NEIGH_CHICKEN_FORCE_ALL_AGENTS_WIDTH 1u +#define MACHINE_NEIGH_NEIGH_CHICKEN_FORCE_ALL_AGENTS_READ_ACCESS 1u +#define MACHINE_NEIGH_NEIGH_CHICKEN_FORCE_ALL_AGENTS_WRITE_ACCESS 1u +#define MACHINE_NEIGH_NEIGH_CHICKEN_FORCE_ALL_AGENTS_RESET 0x0000000000000000ull +#define MACHINE_NEIGH_NEIGH_CHICKEN_FORCE_ALL_AGENTS_FIELD_MASK 0x0000000000000020ull +#define MACHINE_NEIGH_NEIGH_CHICKEN_FORCE_ALL_AGENTS_GET(x) (((x) & 0x0000000000000020ull) >> 5) +#define MACHINE_NEIGH_NEIGH_CHICKEN_FORCE_ALL_AGENTS_SET(x) (((x) << 5) & 0x0000000000000020ull) +#define MACHINE_NEIGH_NEIGH_CHICKEN_FORCE_ALL_AGENTS_MODIFY(r, x) ((((x) << 5) & 0x0000000000000020ull) | ((r) & 0xFFFFFFFFFFFFFFDFull)) + +/* Field: MACHINE_NEIGH_NEIGH_CHICKEN.agent_forced */ +#define MACHINE_NEIGH_NEIGH_CHICKEN_AGENT_FORCED_MSB 6u +#define MACHINE_NEIGH_NEIGH_CHICKEN_AGENT_FORCED_LSB 6u +#define MACHINE_NEIGH_NEIGH_CHICKEN_AGENT_FORCED_WIDTH 1u +#define MACHINE_NEIGH_NEIGH_CHICKEN_AGENT_FORCED_READ_ACCESS 1u +#define MACHINE_NEIGH_NEIGH_CHICKEN_AGENT_FORCED_WRITE_ACCESS 1u +#define MACHINE_NEIGH_NEIGH_CHICKEN_AGENT_FORCED_RESET 0x0000000000000000ull +#define MACHINE_NEIGH_NEIGH_CHICKEN_AGENT_FORCED_FIELD_MASK 0x0000000000000040ull +#define MACHINE_NEIGH_NEIGH_CHICKEN_AGENT_FORCED_GET(x) (((x) & 0x0000000000000040ull) >> 6) +#define MACHINE_NEIGH_NEIGH_CHICKEN_AGENT_FORCED_SET(x) (((x) << 6) & 0x0000000000000040ull) +#define MACHINE_NEIGH_NEIGH_CHICKEN_AGENT_FORCED_MODIFY(r, x) ((((x) << 6) & 0x0000000000000040ull) | ((r) & 0xFFFFFFFFFFFFFFBFull)) + +/* Register: MACHINE_NEIGH.icache_err_log_ctl */ +#define MACHINE_NEIGH_ICACHE_ERR_LOG_CTL_ADDRESS 0x00000078ul +#define MACHINE_NEIGH_ICACHE_ERR_LOG_CTL_BYTE_ADDRESS 0x00000078ul +#define MACHINE_NEIGH_ICACHE_ERR_LOG_CTL_OFFSET 0x00000078ul +#define MACHINE_NEIGH_ICACHE_ERR_LOG_CTL_BYTE_OFFSET 0x00000078ul +#define MACHINE_NEIGH_ICACHE_ERR_LOG_CTL_SIZE 0x00000008ul +#define MACHINE_NEIGH_ICACHE_ERR_LOG_CTL_BYTE_SIZE 0x00000008ul +#define MACHINE_NEIGH_ICACHE_ERR_LOG_CTL_READ_ACCESS 1u +#define MACHINE_NEIGH_ICACHE_ERR_LOG_CTL_WRITE_ACCESS 1u +#define MACHINE_NEIGH_ICACHE_ERR_LOG_CTL_RESET_VALUE 0x0000000000000006ull +#define MACHINE_NEIGH_ICACHE_ERR_LOG_CTL_RESET_MASK 0x0000000000000007ull +#define MACHINE_NEIGH_ICACHE_ERR_LOG_CTL_READ_MASK 0x0000000000000007ull +#define MACHINE_NEIGH_ICACHE_ERR_LOG_CTL_WRITE_MASK 0x0000000000000007ull + +/* Field: MACHINE_NEIGH_ICACHE_ERR_LOG_CTL.err_interrupt_enable */ +#define MACHINE_NEIGH_ICACHE_ERR_LOG_CTL_ERR_INTERRUPT_ENABLE_MSB 2u +#define MACHINE_NEIGH_ICACHE_ERR_LOG_CTL_ERR_INTERRUPT_ENABLE_LSB 0u +#define MACHINE_NEIGH_ICACHE_ERR_LOG_CTL_ERR_INTERRUPT_ENABLE_WIDTH 3u +#define MACHINE_NEIGH_ICACHE_ERR_LOG_CTL_ERR_INTERRUPT_ENABLE_READ_ACCESS 1u +#define MACHINE_NEIGH_ICACHE_ERR_LOG_CTL_ERR_INTERRUPT_ENABLE_WRITE_ACCESS 1u +#define MACHINE_NEIGH_ICACHE_ERR_LOG_CTL_ERR_INTERRUPT_ENABLE_RESET 0x0000000000000006ull +#define MACHINE_NEIGH_ICACHE_ERR_LOG_CTL_ERR_INTERRUPT_ENABLE_FIELD_MASK 0x0000000000000007ull +#define MACHINE_NEIGH_ICACHE_ERR_LOG_CTL_ERR_INTERRUPT_ENABLE_GET(x) ((x) & 0x0000000000000007ull) +#define MACHINE_NEIGH_ICACHE_ERR_LOG_CTL_ERR_INTERRUPT_ENABLE_SET(x) ((x) & 0x0000000000000007ull) +#define MACHINE_NEIGH_ICACHE_ERR_LOG_CTL_ERR_INTERRUPT_ENABLE_MODIFY(r, x) ((((x) << 0) & 0x0000000000000007ull) | ((r) & 0xFFFFFFFFFFFFFFF8ull)) + +/* Register: MACHINE_NEIGH.icache_err_log_info */ +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_ADDRESS 0x00000080ul +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_BYTE_ADDRESS 0x00000080ul +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_OFFSET 0x00000080ul +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_BYTE_OFFSET 0x00000080ul +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_SIZE 0x00000008ul +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_BYTE_SIZE 0x00000008ul +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_READ_ACCESS 1u +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_WRITE_ACCESS 1u +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_RESET_VALUE 0x0000000000000000ull +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_WRITE_MASK 0xFFFFFFFFFFFFFFF7ull + +/* Field: MACHINE_NEIGH_ICACHE_ERR_LOG_INFO.valid */ +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_VALID_MSB 0u +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_VALID_LSB 0u +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_VALID_WIDTH 1u +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_VALID_READ_ACCESS 1u +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_VALID_WRITE_ACCESS 1u +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_VALID_RESET 0x0000000000000000ull +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_VALID_FIELD_MASK 0x0000000000000001ull +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_VALID_GET(x) ((x) & 0x0000000000000001ull) +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_VALID_SET(x) ((x) & 0x0000000000000001ull) +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_VALID_MODIFY(r, x) ((((x) << 0) & 0x0000000000000001ull) | ((r) & 0xFFFFFFFFFFFFFFFEull)) + +/* Field: MACHINE_NEIGH_ICACHE_ERR_LOG_INFO.multi */ +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_MULTI_MSB 1u +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_MULTI_LSB 1u +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_MULTI_WIDTH 1u +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_MULTI_READ_ACCESS 1u +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_MULTI_WRITE_ACCESS 1u +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_MULTI_RESET 0x0000000000000000ull +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_MULTI_FIELD_MASK 0x0000000000000002ull +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_MULTI_GET(x) (((x) & 0x0000000000000002ull) >> 1) +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_MULTI_SET(x) (((x) << 1) & 0x0000000000000002ull) +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_MULTI_MODIFY(r, x) ((((x) << 1) & 0x0000000000000002ull) | ((r) & 0xFFFFFFFFFFFFFFFDull)) + +/* Field: MACHINE_NEIGH_ICACHE_ERR_LOG_INFO.enabled */ +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_ENABLED_MSB 2u +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_ENABLED_LSB 2u +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_ENABLED_WIDTH 1u +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_ENABLED_READ_ACCESS 1u +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_ENABLED_WRITE_ACCESS 1u +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_ENABLED_RESET 0x0000000000000000ull +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_ENABLED_FIELD_MASK 0x0000000000000004ull +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_ENABLED_GET(x) (((x) & 0x0000000000000004ull) >> 2) +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_ENABLED_SET(x) (((x) << 2) & 0x0000000000000004ull) +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_ENABLED_MODIFY(r, x) ((((x) << 2) & 0x0000000000000004ull) | ((r) & 0xFFFFFFFFFFFFFFFBull)) + +/* Field: MACHINE_NEIGH_ICACHE_ERR_LOG_INFO.reserved */ +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_RESERVED_MSB 3u +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_RESERVED_LSB 3u +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_RESERVED_WIDTH 1u +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_RESERVED_READ_ACCESS 1u +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_RESERVED_WRITE_ACCESS 0u +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_RESERVED_RESET 0x0000000000000000ull +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_RESERVED_FIELD_MASK 0x0000000000000008ull +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_RESERVED_GET(x) (((x) & 0x0000000000000008ull) >> 3) +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_RESERVED_SET(x) (((x) << 3) & 0x0000000000000008ull) +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_RESERVED_MODIFY(r, x) ((((x) << 3) & 0x0000000000000008ull) | ((r) & 0xFFFFFFFFFFFFFFF7ull)) + +/* Field: MACHINE_NEIGH_ICACHE_ERR_LOG_INFO.err_code */ +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_ERR_CODE_MSB 7u +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_ERR_CODE_LSB 4u +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_ERR_CODE_WIDTH 4u +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_ERR_CODE_READ_ACCESS 1u +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_ERR_CODE_WRITE_ACCESS 1u +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_ERR_CODE_RESET 0x0000000000000000ull +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_ERR_CODE_FIELD_MASK 0x00000000000000F0ull +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_ERR_CODE_GET(x) (((x) & 0x00000000000000F0ull) >> 4) +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_ERR_CODE_SET(x) (((x) << 4) & 0x00000000000000F0ull) +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_ERR_CODE_MODIFY(r, x) ((((x) << 4) & 0x00000000000000F0ull) | ((r) & 0xFFFFFFFFFFFFFF0Full)) + +/* Field: MACHINE_NEIGH_ICACHE_ERR_LOG_INFO.info */ +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_INFO_MSB 63u +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_INFO_LSB 8u +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_INFO_WIDTH 56u +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_INFO_READ_ACCESS 1u +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_INFO_WRITE_ACCESS 1u +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_INFO_RESET 0x0000000000000000ull +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_INFO_FIELD_MASK 0xFFFFFFFFFFFFFF00ull +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_INFO_GET(x) (((x) & 0xFFFFFFFFFFFFFF00ull) >> 8) +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_INFO_SET(x) (((x) << 8) & 0xFFFFFFFFFFFFFF00ull) +#define MACHINE_NEIGH_ICACHE_ERR_LOG_INFO_INFO_MODIFY(r, x) ((((x) << 8) & 0xFFFFFFFFFFFFFF00ull) | ((r) & 0x00000000000000FFull)) + +/* Register: MACHINE_NEIGH.icache_err_log_address */ +#define MACHINE_NEIGH_ICACHE_ERR_LOG_ADDRESS_ADDRESS 0x00000088ul +#define MACHINE_NEIGH_ICACHE_ERR_LOG_ADDRESS_BYTE_ADDRESS 0x00000088ul +#define MACHINE_NEIGH_ICACHE_ERR_LOG_ADDRESS_OFFSET 0x00000088ul +#define MACHINE_NEIGH_ICACHE_ERR_LOG_ADDRESS_BYTE_OFFSET 0x00000088ul +#define MACHINE_NEIGH_ICACHE_ERR_LOG_ADDRESS_SIZE 0x00000008ul +#define MACHINE_NEIGH_ICACHE_ERR_LOG_ADDRESS_BYTE_SIZE 0x00000008ul +#define MACHINE_NEIGH_ICACHE_ERR_LOG_ADDRESS_READ_ACCESS 1u +#define MACHINE_NEIGH_ICACHE_ERR_LOG_ADDRESS_WRITE_ACCESS 0u +#define MACHINE_NEIGH_ICACHE_ERR_LOG_ADDRESS_RESET_VALUE 0x0000000000000000ull +#define MACHINE_NEIGH_ICACHE_ERR_LOG_ADDRESS_RESET_MASK 0x00000003FFFFFFFFull +#define MACHINE_NEIGH_ICACHE_ERR_LOG_ADDRESS_READ_MASK 0x00000003FFFFFFFFull +#define MACHINE_NEIGH_ICACHE_ERR_LOG_ADDRESS_WRITE_MASK 0x0000000000000000ull + +/* Field: MACHINE_NEIGH_ICACHE_ERR_LOG_ADDRESS.icache_err_log_address_f0 */ +#define MACHINE_NEIGH_ICACHE_ERR_LOG_ADDRESS_ICACHE_ERR_LOG_ADDRESS_F0_MSB 33u +#define MACHINE_NEIGH_ICACHE_ERR_LOG_ADDRESS_ICACHE_ERR_LOG_ADDRESS_F0_LSB 0u +#define MACHINE_NEIGH_ICACHE_ERR_LOG_ADDRESS_ICACHE_ERR_LOG_ADDRESS_F0_WIDTH 34u +#define MACHINE_NEIGH_ICACHE_ERR_LOG_ADDRESS_ICACHE_ERR_LOG_ADDRESS_F0_READ_ACCESS 1u +#define MACHINE_NEIGH_ICACHE_ERR_LOG_ADDRESS_ICACHE_ERR_LOG_ADDRESS_F0_WRITE_ACCESS 0u +#define MACHINE_NEIGH_ICACHE_ERR_LOG_ADDRESS_ICACHE_ERR_LOG_ADDRESS_F0_RESET 0x0000000000000000ull +#define MACHINE_NEIGH_ICACHE_ERR_LOG_ADDRESS_ICACHE_ERR_LOG_ADDRESS_F0_FIELD_MASK 0x00000003FFFFFFFFull +#define MACHINE_NEIGH_ICACHE_ERR_LOG_ADDRESS_ICACHE_ERR_LOG_ADDRESS_F0_GET(x) ((x) & 0x00000003FFFFFFFFull) +#define MACHINE_NEIGH_ICACHE_ERR_LOG_ADDRESS_ICACHE_ERR_LOG_ADDRESS_F0_SET(x) ((x) & 0x00000003FFFFFFFFull) +#define MACHINE_NEIGH_ICACHE_ERR_LOG_ADDRESS_ICACHE_ERR_LOG_ADDRESS_F0_MODIFY(r, x) ((((x) << 0) & 0x00000003FFFFFFFFull) | ((r) & 0xFFFFFFFC00000000ull)) + +/* Register: MACHINE_NEIGH.icache_sbe_dbe_counts */ +#define MACHINE_NEIGH_ICACHE_SBE_DBE_COUNTS_ADDRESS 0x00000090ul +#define MACHINE_NEIGH_ICACHE_SBE_DBE_COUNTS_BYTE_ADDRESS 0x00000090ul +#define MACHINE_NEIGH_ICACHE_SBE_DBE_COUNTS_OFFSET 0x00000090ul +#define MACHINE_NEIGH_ICACHE_SBE_DBE_COUNTS_BYTE_OFFSET 0x00000090ul +#define MACHINE_NEIGH_ICACHE_SBE_DBE_COUNTS_SIZE 0x00000008ul +#define MACHINE_NEIGH_ICACHE_SBE_DBE_COUNTS_BYTE_SIZE 0x00000008ul +#define MACHINE_NEIGH_ICACHE_SBE_DBE_COUNTS_READ_ACCESS 1u +#define MACHINE_NEIGH_ICACHE_SBE_DBE_COUNTS_WRITE_ACCESS 1u +#define MACHINE_NEIGH_ICACHE_SBE_DBE_COUNTS_RESET_VALUE 0x0000000000000000ull +#define MACHINE_NEIGH_ICACHE_SBE_DBE_COUNTS_RESET_MASK 0x00000000000007FFull +#define MACHINE_NEIGH_ICACHE_SBE_DBE_COUNTS_READ_MASK 0x00000000000007FFull +#define MACHINE_NEIGH_ICACHE_SBE_DBE_COUNTS_WRITE_MASK 0x00000000000007FFull + +/* Field: MACHINE_NEIGH_ICACHE_SBE_DBE_COUNTS.sbe_counts */ +#define MACHINE_NEIGH_ICACHE_SBE_DBE_COUNTS_SBE_COUNTS_MSB 7u +#define MACHINE_NEIGH_ICACHE_SBE_DBE_COUNTS_SBE_COUNTS_LSB 0u +#define MACHINE_NEIGH_ICACHE_SBE_DBE_COUNTS_SBE_COUNTS_WIDTH 8u +#define MACHINE_NEIGH_ICACHE_SBE_DBE_COUNTS_SBE_COUNTS_READ_ACCESS 1u +#define MACHINE_NEIGH_ICACHE_SBE_DBE_COUNTS_SBE_COUNTS_WRITE_ACCESS 1u +#define MACHINE_NEIGH_ICACHE_SBE_DBE_COUNTS_SBE_COUNTS_RESET 0x0000000000000000ull +#define MACHINE_NEIGH_ICACHE_SBE_DBE_COUNTS_SBE_COUNTS_FIELD_MASK 0x00000000000000FFull +#define MACHINE_NEIGH_ICACHE_SBE_DBE_COUNTS_SBE_COUNTS_GET(x) ((x) & 0x00000000000000FFull) +#define MACHINE_NEIGH_ICACHE_SBE_DBE_COUNTS_SBE_COUNTS_SET(x) ((x) & 0x00000000000000FFull) +#define MACHINE_NEIGH_ICACHE_SBE_DBE_COUNTS_SBE_COUNTS_MODIFY(r, x) ((((x) << 0) & 0x00000000000000FFull) | ((r) & 0xFFFFFFFFFFFFFF00ull)) + +/* Field: MACHINE_NEIGH_ICACHE_SBE_DBE_COUNTS.dbe_counts */ +#define MACHINE_NEIGH_ICACHE_SBE_DBE_COUNTS_DBE_COUNTS_MSB 10u +#define MACHINE_NEIGH_ICACHE_SBE_DBE_COUNTS_DBE_COUNTS_LSB 8u +#define MACHINE_NEIGH_ICACHE_SBE_DBE_COUNTS_DBE_COUNTS_WIDTH 3u +#define MACHINE_NEIGH_ICACHE_SBE_DBE_COUNTS_DBE_COUNTS_READ_ACCESS 1u +#define MACHINE_NEIGH_ICACHE_SBE_DBE_COUNTS_DBE_COUNTS_WRITE_ACCESS 1u +#define MACHINE_NEIGH_ICACHE_SBE_DBE_COUNTS_DBE_COUNTS_RESET 0x0000000000000000ull +#define MACHINE_NEIGH_ICACHE_SBE_DBE_COUNTS_DBE_COUNTS_FIELD_MASK 0x0000000000000700ull +#define MACHINE_NEIGH_ICACHE_SBE_DBE_COUNTS_DBE_COUNTS_GET(x) (((x) & 0x0000000000000700ull) >> 8) +#define MACHINE_NEIGH_ICACHE_SBE_DBE_COUNTS_DBE_COUNTS_SET(x) (((x) << 8) & 0x0000000000000700ull) +#define MACHINE_NEIGH_ICACHE_SBE_DBE_COUNTS_DBE_COUNTS_MODIFY(r, x) ((((x) << 8) & 0x0000000000000700ull) | ((r) & 0xFFFFFFFFFFFFF8FFull)) + +/* Block-level typedef: MACHINE_NEIGH */ +typedef struct { + uint8_t _pad0[0x18]; /* 0x0..0x17 reserved */ + volatile uint64_t minion_boot; /* Offset 0x18 (R/W) */ + uint8_t _pad1[0x18]; /* 0x20..0x37 reserved */ + volatile uint64_t mprot; /* Offset 0x38 (R/W) */ + uint8_t _pad2[0x28]; /* 0x40..0x67 reserved */ + volatile uint64_t pmu_ctrl; /* Offset 0x68 (R/W) */ + volatile uint64_t neigh_chicken; /* Offset 0x70 (R/W) */ + volatile uint64_t icache_err_log_ctl; /* Offset 0x78 (R/W) */ + volatile uint64_t icache_err_log_info; /* Offset 0x80 (R/W) */ + volatile uint64_t icache_err_log_address; /* Offset 0x88 (R) */ + volatile uint64_t icache_sbe_dbe_counts; /* Offset 0x90 (R/W) */ +} Machine_neigh_t, *PTR_Machine_neigh_t; + +/* ============================================================ */ +/* Block: Machine_cpu (macro prefix: MACHINE_CPU) */ +/* ============================================================ */ + +/* Register: MACHINE_CPU.minion_feature */ +#define MACHINE_CPU_MINION_FEATURE_ADDRESS 0x00000000ul +#define MACHINE_CPU_MINION_FEATURE_BYTE_ADDRESS 0x00000000ul +#define MACHINE_CPU_MINION_FEATURE_OFFSET 0x00000000ul +#define MACHINE_CPU_MINION_FEATURE_BYTE_OFFSET 0x00000000ul +#define MACHINE_CPU_MINION_FEATURE_SIZE 0x00000008ul +#define MACHINE_CPU_MINION_FEATURE_BYTE_SIZE 0x00000008ul +#define MACHINE_CPU_MINION_FEATURE_READ_ACCESS 1u +#define MACHINE_CPU_MINION_FEATURE_WRITE_ACCESS 1u +#define MACHINE_CPU_MINION_FEATURE_RESET_VALUE 0x0000000000000001ull +#define MACHINE_CPU_MINION_FEATURE_RESET_MASK 0x000000000000003Full +#define MACHINE_CPU_MINION_FEATURE_READ_MASK 0x000000000000003Full +#define MACHINE_CPU_MINION_FEATURE_WRITE_MASK 0x000000000000003Full + +/* Field: MACHINE_CPU_MINION_FEATURE.trap_on_gfx */ +#define MACHINE_CPU_MINION_FEATURE_TRAP_ON_GFX_MSB 0u +#define MACHINE_CPU_MINION_FEATURE_TRAP_ON_GFX_LSB 0u +#define MACHINE_CPU_MINION_FEATURE_TRAP_ON_GFX_WIDTH 1u +#define MACHINE_CPU_MINION_FEATURE_TRAP_ON_GFX_READ_ACCESS 1u +#define MACHINE_CPU_MINION_FEATURE_TRAP_ON_GFX_WRITE_ACCESS 1u +#define MACHINE_CPU_MINION_FEATURE_TRAP_ON_GFX_RESET 0x0000000000000001ull +#define MACHINE_CPU_MINION_FEATURE_TRAP_ON_GFX_FIELD_MASK 0x0000000000000001ull +#define MACHINE_CPU_MINION_FEATURE_TRAP_ON_GFX_GET(x) ((x) & 0x0000000000000001ull) +#define MACHINE_CPU_MINION_FEATURE_TRAP_ON_GFX_SET(x) ((x) & 0x0000000000000001ull) +#define MACHINE_CPU_MINION_FEATURE_TRAP_ON_GFX_MODIFY(r, x) ((((x) << 0) & 0x0000000000000001ull) | ((r) & 0xFFFFFFFFFFFFFFFEull)) + +/* Field: MACHINE_CPU_MINION_FEATURE.trap_on_ml */ +#define MACHINE_CPU_MINION_FEATURE_TRAP_ON_ML_MSB 1u +#define MACHINE_CPU_MINION_FEATURE_TRAP_ON_ML_LSB 1u +#define MACHINE_CPU_MINION_FEATURE_TRAP_ON_ML_WIDTH 1u +#define MACHINE_CPU_MINION_FEATURE_TRAP_ON_ML_READ_ACCESS 1u +#define MACHINE_CPU_MINION_FEATURE_TRAP_ON_ML_WRITE_ACCESS 1u +#define MACHINE_CPU_MINION_FEATURE_TRAP_ON_ML_RESET 0x0000000000000000ull +#define MACHINE_CPU_MINION_FEATURE_TRAP_ON_ML_FIELD_MASK 0x0000000000000002ull +#define MACHINE_CPU_MINION_FEATURE_TRAP_ON_ML_GET(x) (((x) & 0x0000000000000002ull) >> 1) +#define MACHINE_CPU_MINION_FEATURE_TRAP_ON_ML_SET(x) (((x) << 1) & 0x0000000000000002ull) +#define MACHINE_CPU_MINION_FEATURE_TRAP_ON_ML_MODIFY(r, x) ((((x) << 1) & 0x0000000000000002ull) | ((r) & 0xFFFFFFFFFFFFFFFDull)) + +/* Field: MACHINE_CPU_MINION_FEATURE.trap_on_u_cacheops */ +#define MACHINE_CPU_MINION_FEATURE_TRAP_ON_U_CACHEOPS_MSB 2u +#define MACHINE_CPU_MINION_FEATURE_TRAP_ON_U_CACHEOPS_LSB 2u +#define MACHINE_CPU_MINION_FEATURE_TRAP_ON_U_CACHEOPS_WIDTH 1u +#define MACHINE_CPU_MINION_FEATURE_TRAP_ON_U_CACHEOPS_READ_ACCESS 1u +#define MACHINE_CPU_MINION_FEATURE_TRAP_ON_U_CACHEOPS_WRITE_ACCESS 1u +#define MACHINE_CPU_MINION_FEATURE_TRAP_ON_U_CACHEOPS_RESET 0x0000000000000000ull +#define MACHINE_CPU_MINION_FEATURE_TRAP_ON_U_CACHEOPS_FIELD_MASK 0x0000000000000004ull +#define MACHINE_CPU_MINION_FEATURE_TRAP_ON_U_CACHEOPS_GET(x) (((x) & 0x0000000000000004ull) >> 2) +#define MACHINE_CPU_MINION_FEATURE_TRAP_ON_U_CACHEOPS_SET(x) (((x) << 2) & 0x0000000000000004ull) +#define MACHINE_CPU_MINION_FEATURE_TRAP_ON_U_CACHEOPS_MODIFY(r, x) ((((x) << 2) & 0x0000000000000004ull) | ((r) & 0xFFFFFFFFFFFFFFFBull)) + +/* Field: MACHINE_CPU_MINION_FEATURE.trap_on_u_scp */ +#define MACHINE_CPU_MINION_FEATURE_TRAP_ON_U_SCP_MSB 3u +#define MACHINE_CPU_MINION_FEATURE_TRAP_ON_U_SCP_LSB 3u +#define MACHINE_CPU_MINION_FEATURE_TRAP_ON_U_SCP_WIDTH 1u +#define MACHINE_CPU_MINION_FEATURE_TRAP_ON_U_SCP_READ_ACCESS 1u +#define MACHINE_CPU_MINION_FEATURE_TRAP_ON_U_SCP_WRITE_ACCESS 1u +#define MACHINE_CPU_MINION_FEATURE_TRAP_ON_U_SCP_RESET 0x0000000000000000ull +#define MACHINE_CPU_MINION_FEATURE_TRAP_ON_U_SCP_FIELD_MASK 0x0000000000000008ull +#define MACHINE_CPU_MINION_FEATURE_TRAP_ON_U_SCP_GET(x) (((x) & 0x0000000000000008ull) >> 3) +#define MACHINE_CPU_MINION_FEATURE_TRAP_ON_U_SCP_SET(x) (((x) << 3) & 0x0000000000000008ull) +#define MACHINE_CPU_MINION_FEATURE_TRAP_ON_U_SCP_MODIFY(r, x) ((((x) << 3) & 0x0000000000000008ull) | ((r) & 0xFFFFFFFFFFFFFFF7ull)) + +/* Field: MACHINE_CPU_MINION_FEATURE.disable_multithreading */ +#define MACHINE_CPU_MINION_FEATURE_DISABLE_MULTITHREADING_MSB 4u +#define MACHINE_CPU_MINION_FEATURE_DISABLE_MULTITHREADING_LSB 4u +#define MACHINE_CPU_MINION_FEATURE_DISABLE_MULTITHREADING_WIDTH 1u +#define MACHINE_CPU_MINION_FEATURE_DISABLE_MULTITHREADING_READ_ACCESS 1u +#define MACHINE_CPU_MINION_FEATURE_DISABLE_MULTITHREADING_WRITE_ACCESS 1u +#define MACHINE_CPU_MINION_FEATURE_DISABLE_MULTITHREADING_RESET 0x0000000000000000ull +#define MACHINE_CPU_MINION_FEATURE_DISABLE_MULTITHREADING_FIELD_MASK 0x0000000000000010ull +#define MACHINE_CPU_MINION_FEATURE_DISABLE_MULTITHREADING_GET(x) (((x) & 0x0000000000000010ull) >> 4) +#define MACHINE_CPU_MINION_FEATURE_DISABLE_MULTITHREADING_SET(x) (((x) << 4) & 0x0000000000000010ull) +#define MACHINE_CPU_MINION_FEATURE_DISABLE_MULTITHREADING_MODIFY(r, x) ((((x) << 4) & 0x0000000000000010ull) | ((r) & 0xFFFFFFFFFFFFFFEFull)) + +/* Field: MACHINE_CPU_MINION_FEATURE.disable_lock_unlock */ +#define MACHINE_CPU_MINION_FEATURE_DISABLE_LOCK_UNLOCK_MSB 5u +#define MACHINE_CPU_MINION_FEATURE_DISABLE_LOCK_UNLOCK_LSB 5u +#define MACHINE_CPU_MINION_FEATURE_DISABLE_LOCK_UNLOCK_WIDTH 1u +#define MACHINE_CPU_MINION_FEATURE_DISABLE_LOCK_UNLOCK_READ_ACCESS 1u +#define MACHINE_CPU_MINION_FEATURE_DISABLE_LOCK_UNLOCK_WRITE_ACCESS 1u +#define MACHINE_CPU_MINION_FEATURE_DISABLE_LOCK_UNLOCK_RESET 0x0000000000000000ull +#define MACHINE_CPU_MINION_FEATURE_DISABLE_LOCK_UNLOCK_FIELD_MASK 0x0000000000000020ull +#define MACHINE_CPU_MINION_FEATURE_DISABLE_LOCK_UNLOCK_GET(x) (((x) & 0x0000000000000020ull) >> 5) +#define MACHINE_CPU_MINION_FEATURE_DISABLE_LOCK_UNLOCK_SET(x) (((x) << 5) & 0x0000000000000020ull) +#define MACHINE_CPU_MINION_FEATURE_DISABLE_LOCK_UNLOCK_MODIFY(r, x) ((((x) << 5) & 0x0000000000000020ull) | ((r) & 0xFFFFFFFFFFFFFFDFull)) + +/* Register: MACHINE_CPU.thread1_disable */ +#define MACHINE_CPU_THREAD1_DISABLE_ADDRESS 0x00000010ul +#define MACHINE_CPU_THREAD1_DISABLE_BYTE_ADDRESS 0x00000010ul +#define MACHINE_CPU_THREAD1_DISABLE_OFFSET 0x00000010ul +#define MACHINE_CPU_THREAD1_DISABLE_BYTE_OFFSET 0x00000010ul +#define MACHINE_CPU_THREAD1_DISABLE_SIZE 0x00000008ul +#define MACHINE_CPU_THREAD1_DISABLE_BYTE_SIZE 0x00000008ul +#define MACHINE_CPU_THREAD1_DISABLE_READ_ACCESS 1u +#define MACHINE_CPU_THREAD1_DISABLE_WRITE_ACCESS 1u +#define MACHINE_CPU_THREAD1_DISABLE_RESET_VALUE 0x00000000000000FFull +#define MACHINE_CPU_THREAD1_DISABLE_RESET_MASK 0x00000000000000FFull +#define MACHINE_CPU_THREAD1_DISABLE_READ_MASK 0x00000000000000FFull +#define MACHINE_CPU_THREAD1_DISABLE_WRITE_MASK 0x00000000000000FFull + +/* Field: MACHINE_CPU_THREAD1_DISABLE.thread1_disable_f0 */ +#define MACHINE_CPU_THREAD1_DISABLE_THREAD1_DISABLE_F0_MSB 7u +#define MACHINE_CPU_THREAD1_DISABLE_THREAD1_DISABLE_F0_LSB 0u +#define MACHINE_CPU_THREAD1_DISABLE_THREAD1_DISABLE_F0_WIDTH 8u +#define MACHINE_CPU_THREAD1_DISABLE_THREAD1_DISABLE_F0_READ_ACCESS 1u +#define MACHINE_CPU_THREAD1_DISABLE_THREAD1_DISABLE_F0_WRITE_ACCESS 1u +#define MACHINE_CPU_THREAD1_DISABLE_THREAD1_DISABLE_F0_RESET 0x00000000000000FFull +#define MACHINE_CPU_THREAD1_DISABLE_THREAD1_DISABLE_F0_FIELD_MASK 0x00000000000000FFull +#define MACHINE_CPU_THREAD1_DISABLE_THREAD1_DISABLE_F0_GET(x) ((x) & 0x00000000000000FFull) +#define MACHINE_CPU_THREAD1_DISABLE_THREAD1_DISABLE_F0_SET(x) ((x) & 0x00000000000000FFull) +#define MACHINE_CPU_THREAD1_DISABLE_THREAD1_DISABLE_F0_MODIFY(r, x) ((((x) << 0) & 0x00000000000000FFull) | ((r) & 0xFFFFFFFFFFFFFF00ull)) + +/* Register: MACHINE_CPU.ipi_redirect_filter */ +#define MACHINE_CPU_IPI_REDIRECT_FILTER_ADDRESS 0x00000088ul +#define MACHINE_CPU_IPI_REDIRECT_FILTER_BYTE_ADDRESS 0x00000088ul +#define MACHINE_CPU_IPI_REDIRECT_FILTER_OFFSET 0x00000088ul +#define MACHINE_CPU_IPI_REDIRECT_FILTER_BYTE_OFFSET 0x00000088ul +#define MACHINE_CPU_IPI_REDIRECT_FILTER_SIZE 0x00000008ul +#define MACHINE_CPU_IPI_REDIRECT_FILTER_BYTE_SIZE 0x00000008ul +#define MACHINE_CPU_IPI_REDIRECT_FILTER_READ_ACCESS 1u +#define MACHINE_CPU_IPI_REDIRECT_FILTER_WRITE_ACCESS 1u +#define MACHINE_CPU_IPI_REDIRECT_FILTER_RESET_VALUE 0x000000000000FFFFull +#define MACHINE_CPU_IPI_REDIRECT_FILTER_RESET_MASK 0x000000000000FFFFull +#define MACHINE_CPU_IPI_REDIRECT_FILTER_READ_MASK 0x000000000000FFFFull +#define MACHINE_CPU_IPI_REDIRECT_FILTER_WRITE_MASK 0x000000000000FFFFull + +/* Field: MACHINE_CPU_IPI_REDIRECT_FILTER.ipi_redirect_filter */ +#define MACHINE_CPU_IPI_REDIRECT_FILTER_IPI_REDIRECT_FILTER_MSB 15u +#define MACHINE_CPU_IPI_REDIRECT_FILTER_IPI_REDIRECT_FILTER_LSB 0u +#define MACHINE_CPU_IPI_REDIRECT_FILTER_IPI_REDIRECT_FILTER_WIDTH 16u +#define MACHINE_CPU_IPI_REDIRECT_FILTER_IPI_REDIRECT_FILTER_READ_ACCESS 1u +#define MACHINE_CPU_IPI_REDIRECT_FILTER_IPI_REDIRECT_FILTER_WRITE_ACCESS 1u +#define MACHINE_CPU_IPI_REDIRECT_FILTER_IPI_REDIRECT_FILTER_RESET 0x000000000000FFFFull +#define MACHINE_CPU_IPI_REDIRECT_FILTER_IPI_REDIRECT_FILTER_FIELD_MASK 0x000000000000FFFFull +#define MACHINE_CPU_IPI_REDIRECT_FILTER_IPI_REDIRECT_FILTER_GET(x) ((x) & 0x000000000000FFFFull) +#define MACHINE_CPU_IPI_REDIRECT_FILTER_IPI_REDIRECT_FILTER_SET(x) ((x) & 0x000000000000FFFFull) +#define MACHINE_CPU_IPI_REDIRECT_FILTER_IPI_REDIRECT_FILTER_MODIFY(r, x) ((((x) << 0) & 0x000000000000FFFFull) | ((r) & 0xFFFFFFFFFFFF0000ull)) + +/* Register: MACHINE_CPU.ipi_trigger */ +#define MACHINE_CPU_IPI_TRIGGER_ADDRESS 0x00000090ul +#define MACHINE_CPU_IPI_TRIGGER_BYTE_ADDRESS 0x00000090ul +#define MACHINE_CPU_IPI_TRIGGER_OFFSET 0x00000090ul +#define MACHINE_CPU_IPI_TRIGGER_BYTE_OFFSET 0x00000090ul +#define MACHINE_CPU_IPI_TRIGGER_SIZE 0x00000008ul +#define MACHINE_CPU_IPI_TRIGGER_BYTE_SIZE 0x00000008ul +#define MACHINE_CPU_IPI_TRIGGER_READ_ACCESS 1u +#define MACHINE_CPU_IPI_TRIGGER_WRITE_ACCESS 1u +#define MACHINE_CPU_IPI_TRIGGER_RESET_VALUE 0x0000000000000000ull +#define MACHINE_CPU_IPI_TRIGGER_RESET_MASK 0x000000000000FFFFull +#define MACHINE_CPU_IPI_TRIGGER_READ_MASK 0x000000000000FFFFull +#define MACHINE_CPU_IPI_TRIGGER_WRITE_MASK 0x000000000000FFFFull + +/* Field: MACHINE_CPU_IPI_TRIGGER.ipi_trigger */ +#define MACHINE_CPU_IPI_TRIGGER_IPI_TRIGGER_MSB 15u +#define MACHINE_CPU_IPI_TRIGGER_IPI_TRIGGER_LSB 0u +#define MACHINE_CPU_IPI_TRIGGER_IPI_TRIGGER_WIDTH 16u +#define MACHINE_CPU_IPI_TRIGGER_IPI_TRIGGER_READ_ACCESS 1u +#define MACHINE_CPU_IPI_TRIGGER_IPI_TRIGGER_WRITE_ACCESS 1u +#define MACHINE_CPU_IPI_TRIGGER_IPI_TRIGGER_RESET 0x0000000000000000ull +#define MACHINE_CPU_IPI_TRIGGER_IPI_TRIGGER_FIELD_MASK 0x000000000000FFFFull +#define MACHINE_CPU_IPI_TRIGGER_IPI_TRIGGER_GET(x) ((x) & 0x000000000000FFFFull) +#define MACHINE_CPU_IPI_TRIGGER_IPI_TRIGGER_SET(x) ((x) & 0x000000000000FFFFull) +#define MACHINE_CPU_IPI_TRIGGER_IPI_TRIGGER_MODIFY(r, x) ((((x) << 0) & 0x000000000000FFFFull) | ((r) & 0xFFFFFFFFFFFF0000ull)) + +/* Register: MACHINE_CPU.ipi_trigger_clear */ +#define MACHINE_CPU_IPI_TRIGGER_CLEAR_ADDRESS 0x00000098ul +#define MACHINE_CPU_IPI_TRIGGER_CLEAR_BYTE_ADDRESS 0x00000098ul +#define MACHINE_CPU_IPI_TRIGGER_CLEAR_OFFSET 0x00000098ul +#define MACHINE_CPU_IPI_TRIGGER_CLEAR_BYTE_OFFSET 0x00000098ul +#define MACHINE_CPU_IPI_TRIGGER_CLEAR_SIZE 0x00000008ul +#define MACHINE_CPU_IPI_TRIGGER_CLEAR_BYTE_SIZE 0x00000008ul +#define MACHINE_CPU_IPI_TRIGGER_CLEAR_READ_ACCESS 1u +#define MACHINE_CPU_IPI_TRIGGER_CLEAR_WRITE_ACCESS 0u +#define MACHINE_CPU_IPI_TRIGGER_CLEAR_RESET_VALUE 0x0000000000000000ull +#define MACHINE_CPU_IPI_TRIGGER_CLEAR_RESET_MASK 0x000000000000FFFFull +#define MACHINE_CPU_IPI_TRIGGER_CLEAR_READ_MASK 0x000000000000FFFFull +#define MACHINE_CPU_IPI_TRIGGER_CLEAR_WRITE_MASK 0x0000000000000000ull + +/* Field: MACHINE_CPU_IPI_TRIGGER_CLEAR.ipi_trigger_clear */ +#define MACHINE_CPU_IPI_TRIGGER_CLEAR_IPI_TRIGGER_CLEAR_MSB 15u +#define MACHINE_CPU_IPI_TRIGGER_CLEAR_IPI_TRIGGER_CLEAR_LSB 0u +#define MACHINE_CPU_IPI_TRIGGER_CLEAR_IPI_TRIGGER_CLEAR_WIDTH 16u +#define MACHINE_CPU_IPI_TRIGGER_CLEAR_IPI_TRIGGER_CLEAR_READ_ACCESS 1u +#define MACHINE_CPU_IPI_TRIGGER_CLEAR_IPI_TRIGGER_CLEAR_WRITE_ACCESS 0u +#define MACHINE_CPU_IPI_TRIGGER_CLEAR_IPI_TRIGGER_CLEAR_RESET 0x0000000000000000ull +#define MACHINE_CPU_IPI_TRIGGER_CLEAR_IPI_TRIGGER_CLEAR_FIELD_MASK 0x000000000000FFFFull +#define MACHINE_CPU_IPI_TRIGGER_CLEAR_IPI_TRIGGER_CLEAR_GET(x) ((x) & 0x000000000000FFFFull) +#define MACHINE_CPU_IPI_TRIGGER_CLEAR_IPI_TRIGGER_CLEAR_SET(x) ((x) & 0x000000000000FFFFull) +#define MACHINE_CPU_IPI_TRIGGER_CLEAR_IPI_TRIGGER_CLEAR_MODIFY(r, x) ((((x) << 0) & 0x000000000000FFFFull) | ((r) & 0xFFFFFFFFFFFF0000ull)) + +/* Register: MACHINE_CPU.mtime */ +#define MACHINE_CPU_MTIME_ADDRESS 0x00000200ul +#define MACHINE_CPU_MTIME_BYTE_ADDRESS 0x00000200ul +#define MACHINE_CPU_MTIME_OFFSET 0x00000200ul +#define MACHINE_CPU_MTIME_BYTE_OFFSET 0x00000200ul +#define MACHINE_CPU_MTIME_SIZE 0x00000008ul +#define MACHINE_CPU_MTIME_BYTE_SIZE 0x00000008ul +#define MACHINE_CPU_MTIME_READ_ACCESS 1u +#define MACHINE_CPU_MTIME_WRITE_ACCESS 1u +#define MACHINE_CPU_MTIME_RESET_VALUE 0x0000000000000000ull +#define MACHINE_CPU_MTIME_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MACHINE_CPU_MTIME_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MACHINE_CPU_MTIME_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MACHINE_CPU_MTIME.mtime */ +#define MACHINE_CPU_MTIME_MTIME_MSB 63u +#define MACHINE_CPU_MTIME_MTIME_LSB 0u +#define MACHINE_CPU_MTIME_MTIME_WIDTH 64u +#define MACHINE_CPU_MTIME_MTIME_READ_ACCESS 1u +#define MACHINE_CPU_MTIME_MTIME_WRITE_ACCESS 1u +#define MACHINE_CPU_MTIME_MTIME_RESET 0x0000000000000000ull +#define MACHINE_CPU_MTIME_MTIME_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MACHINE_CPU_MTIME_MTIME_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MACHINE_CPU_MTIME_MTIME_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MACHINE_CPU_MTIME_MTIME_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MACHINE_CPU.mtime_cmp */ +#define MACHINE_CPU_MTIME_CMP_ADDRESS 0x00000208ul +#define MACHINE_CPU_MTIME_CMP_BYTE_ADDRESS 0x00000208ul +#define MACHINE_CPU_MTIME_CMP_OFFSET 0x00000208ul +#define MACHINE_CPU_MTIME_CMP_BYTE_OFFSET 0x00000208ul +#define MACHINE_CPU_MTIME_CMP_SIZE 0x00000008ul +#define MACHINE_CPU_MTIME_CMP_BYTE_SIZE 0x00000008ul +#define MACHINE_CPU_MTIME_CMP_READ_ACCESS 1u +#define MACHINE_CPU_MTIME_CMP_WRITE_ACCESS 1u +#define MACHINE_CPU_MTIME_CMP_RESET_VALUE 0x0000000000000000ull +#define MACHINE_CPU_MTIME_CMP_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MACHINE_CPU_MTIME_CMP_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MACHINE_CPU_MTIME_CMP_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MACHINE_CPU_MTIME_CMP.mtime_cmp */ +#define MACHINE_CPU_MTIME_CMP_MTIME_CMP_MSB 63u +#define MACHINE_CPU_MTIME_CMP_MTIME_CMP_LSB 0u +#define MACHINE_CPU_MTIME_CMP_MTIME_CMP_WIDTH 64u +#define MACHINE_CPU_MTIME_CMP_MTIME_CMP_READ_ACCESS 1u +#define MACHINE_CPU_MTIME_CMP_MTIME_CMP_WRITE_ACCESS 1u +#define MACHINE_CPU_MTIME_CMP_MTIME_CMP_RESET 0x0000000000000000ull +#define MACHINE_CPU_MTIME_CMP_MTIME_CMP_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MACHINE_CPU_MTIME_CMP_MTIME_CMP_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MACHINE_CPU_MTIME_CMP_MTIME_CMP_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MACHINE_CPU_MTIME_CMP_MTIME_CMP_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MACHINE_CPU.time_config */ +#define MACHINE_CPU_TIME_CONFIG_ADDRESS 0x00000210ul +#define MACHINE_CPU_TIME_CONFIG_BYTE_ADDRESS 0x00000210ul +#define MACHINE_CPU_TIME_CONFIG_OFFSET 0x00000210ul +#define MACHINE_CPU_TIME_CONFIG_BYTE_OFFSET 0x00000210ul +#define MACHINE_CPU_TIME_CONFIG_SIZE 0x00000008ul +#define MACHINE_CPU_TIME_CONFIG_BYTE_SIZE 0x00000008ul +#define MACHINE_CPU_TIME_CONFIG_READ_ACCESS 1u +#define MACHINE_CPU_TIME_CONFIG_WRITE_ACCESS 1u +#define MACHINE_CPU_TIME_CONFIG_RESET_VALUE 0x0000000000000028ull +#define MACHINE_CPU_TIME_CONFIG_RESET_MASK 0x00000000000000FFull +#define MACHINE_CPU_TIME_CONFIG_READ_MASK 0x00000000000000FFull +#define MACHINE_CPU_TIME_CONFIG_WRITE_MASK 0x00000000000000FFull + +/* Field: MACHINE_CPU_TIME_CONFIG.prescalar_threshold */ +#define MACHINE_CPU_TIME_CONFIG_PRESCALAR_THRESHOLD_MSB 6u +#define MACHINE_CPU_TIME_CONFIG_PRESCALAR_THRESHOLD_LSB 0u +#define MACHINE_CPU_TIME_CONFIG_PRESCALAR_THRESHOLD_WIDTH 7u +#define MACHINE_CPU_TIME_CONFIG_PRESCALAR_THRESHOLD_READ_ACCESS 1u +#define MACHINE_CPU_TIME_CONFIG_PRESCALAR_THRESHOLD_WRITE_ACCESS 1u +#define MACHINE_CPU_TIME_CONFIG_PRESCALAR_THRESHOLD_RESET 0x0000000000000028ull +#define MACHINE_CPU_TIME_CONFIG_PRESCALAR_THRESHOLD_FIELD_MASK 0x000000000000007Full +#define MACHINE_CPU_TIME_CONFIG_PRESCALAR_THRESHOLD_GET(x) ((x) & 0x000000000000007Full) +#define MACHINE_CPU_TIME_CONFIG_PRESCALAR_THRESHOLD_SET(x) ((x) & 0x000000000000007Full) +#define MACHINE_CPU_TIME_CONFIG_PRESCALAR_THRESHOLD_MODIFY(r, x) ((((x) << 0) & 0x000000000000007Full) | ((r) & 0xFFFFFFFFFFFFFF80ull)) + +/* Field: MACHINE_CPU_TIME_CONFIG.ref_clock_mux */ +#define MACHINE_CPU_TIME_CONFIG_REF_CLOCK_MUX_MSB 7u +#define MACHINE_CPU_TIME_CONFIG_REF_CLOCK_MUX_LSB 7u +#define MACHINE_CPU_TIME_CONFIG_REF_CLOCK_MUX_WIDTH 1u +#define MACHINE_CPU_TIME_CONFIG_REF_CLOCK_MUX_READ_ACCESS 1u +#define MACHINE_CPU_TIME_CONFIG_REF_CLOCK_MUX_WRITE_ACCESS 1u +#define MACHINE_CPU_TIME_CONFIG_REF_CLOCK_MUX_RESET 0x0000000000000000ull +#define MACHINE_CPU_TIME_CONFIG_REF_CLOCK_MUX_FIELD_MASK 0x0000000000000080ull +#define MACHINE_CPU_TIME_CONFIG_REF_CLOCK_MUX_GET(x) (((x) & 0x0000000000000080ull) >> 7) +#define MACHINE_CPU_TIME_CONFIG_REF_CLOCK_MUX_SET(x) (((x) << 7) & 0x0000000000000080ull) +#define MACHINE_CPU_TIME_CONFIG_REF_CLOCK_MUX_MODIFY(r, x) ((((x) << 7) & 0x0000000000000080ull) | ((r) & 0xFFFFFFFFFFFFFF7Full)) + +/* Register: MACHINE_CPU.mtime_local_target */ +#define MACHINE_CPU_MTIME_LOCAL_TARGET_ADDRESS 0x00000218ul +#define MACHINE_CPU_MTIME_LOCAL_TARGET_BYTE_ADDRESS 0x00000218ul +#define MACHINE_CPU_MTIME_LOCAL_TARGET_OFFSET 0x00000218ul +#define MACHINE_CPU_MTIME_LOCAL_TARGET_BYTE_OFFSET 0x00000218ul +#define MACHINE_CPU_MTIME_LOCAL_TARGET_SIZE 0x00000008ul +#define MACHINE_CPU_MTIME_LOCAL_TARGET_BYTE_SIZE 0x00000008ul +#define MACHINE_CPU_MTIME_LOCAL_TARGET_READ_ACCESS 1u +#define MACHINE_CPU_MTIME_LOCAL_TARGET_WRITE_ACCESS 1u +#define MACHINE_CPU_MTIME_LOCAL_TARGET_RESET_VALUE 0x000000000000FFFFull +#define MACHINE_CPU_MTIME_LOCAL_TARGET_RESET_MASK 0x000000000000FFFFull +#define MACHINE_CPU_MTIME_LOCAL_TARGET_READ_MASK 0x000000000000FFFFull +#define MACHINE_CPU_MTIME_LOCAL_TARGET_WRITE_MASK 0x000000000000FFFFull + +/* Field: MACHINE_CPU_MTIME_LOCAL_TARGET.mtime_local_target */ +#define MACHINE_CPU_MTIME_LOCAL_TARGET_MTIME_LOCAL_TARGET_MSB 15u +#define MACHINE_CPU_MTIME_LOCAL_TARGET_MTIME_LOCAL_TARGET_LSB 0u +#define MACHINE_CPU_MTIME_LOCAL_TARGET_MTIME_LOCAL_TARGET_WIDTH 16u +#define MACHINE_CPU_MTIME_LOCAL_TARGET_MTIME_LOCAL_TARGET_READ_ACCESS 1u +#define MACHINE_CPU_MTIME_LOCAL_TARGET_MTIME_LOCAL_TARGET_WRITE_ACCESS 1u +#define MACHINE_CPU_MTIME_LOCAL_TARGET_MTIME_LOCAL_TARGET_RESET 0x000000000000FFFFull +#define MACHINE_CPU_MTIME_LOCAL_TARGET_MTIME_LOCAL_TARGET_FIELD_MASK 0x000000000000FFFFull +#define MACHINE_CPU_MTIME_LOCAL_TARGET_MTIME_LOCAL_TARGET_GET(x) ((x) & 0x000000000000FFFFull) +#define MACHINE_CPU_MTIME_LOCAL_TARGET_MTIME_LOCAL_TARGET_SET(x) ((x) & 0x000000000000FFFFull) +#define MACHINE_CPU_MTIME_LOCAL_TARGET_MTIME_LOCAL_TARGET_MODIFY(r, x) ((((x) << 0) & 0x000000000000FFFFull) | ((r) & 0xFFFFFFFFFFFF0000ull)) + +/* Register: MACHINE_CPU.thread0_disable */ +#define MACHINE_CPU_THREAD0_DISABLE_ADDRESS 0x00000240ul +#define MACHINE_CPU_THREAD0_DISABLE_BYTE_ADDRESS 0x00000240ul +#define MACHINE_CPU_THREAD0_DISABLE_OFFSET 0x00000240ul +#define MACHINE_CPU_THREAD0_DISABLE_BYTE_OFFSET 0x00000240ul +#define MACHINE_CPU_THREAD0_DISABLE_SIZE 0x00000008ul +#define MACHINE_CPU_THREAD0_DISABLE_BYTE_SIZE 0x00000008ul +#define MACHINE_CPU_THREAD0_DISABLE_READ_ACCESS 1u +#define MACHINE_CPU_THREAD0_DISABLE_WRITE_ACCESS 1u +#define MACHINE_CPU_THREAD0_DISABLE_RESET_VALUE 0x00000000000000FEull +#define MACHINE_CPU_THREAD0_DISABLE_RESET_MASK 0x00000000000000FFull +#define MACHINE_CPU_THREAD0_DISABLE_READ_MASK 0x00000000000000FFull +#define MACHINE_CPU_THREAD0_DISABLE_WRITE_MASK 0x00000000000000FFull + +/* Field: MACHINE_CPU_THREAD0_DISABLE.thread0_disable */ +#define MACHINE_CPU_THREAD0_DISABLE_THREAD0_DISABLE_MSB 7u +#define MACHINE_CPU_THREAD0_DISABLE_THREAD0_DISABLE_LSB 0u +#define MACHINE_CPU_THREAD0_DISABLE_THREAD0_DISABLE_WIDTH 8u +#define MACHINE_CPU_THREAD0_DISABLE_THREAD0_DISABLE_READ_ACCESS 1u +#define MACHINE_CPU_THREAD0_DISABLE_THREAD0_DISABLE_WRITE_ACCESS 1u +#define MACHINE_CPU_THREAD0_DISABLE_THREAD0_DISABLE_RESET 0x00000000000000FEull +#define MACHINE_CPU_THREAD0_DISABLE_THREAD0_DISABLE_FIELD_MASK 0x00000000000000FFull +#define MACHINE_CPU_THREAD0_DISABLE_THREAD0_DISABLE_GET(x) ((x) & 0x00000000000000FFull) +#define MACHINE_CPU_THREAD0_DISABLE_THREAD0_DISABLE_SET(x) ((x) & 0x00000000000000FFull) +#define MACHINE_CPU_THREAD0_DISABLE_THREAD0_DISABLE_MODIFY(r, x) ((((x) << 0) & 0x00000000000000FFull) | ((r) & 0xFFFFFFFFFFFFFF00ull)) + +/* Register: MACHINE_CPU.icache_mprefetch */ +#define MACHINE_CPU_ICACHE_MPREFETCH_ADDRESS 0x00000308ul +#define MACHINE_CPU_ICACHE_MPREFETCH_BYTE_ADDRESS 0x00000308ul +#define MACHINE_CPU_ICACHE_MPREFETCH_OFFSET 0x00000308ul +#define MACHINE_CPU_ICACHE_MPREFETCH_BYTE_OFFSET 0x00000308ul +#define MACHINE_CPU_ICACHE_MPREFETCH_SIZE 0x00000008ul +#define MACHINE_CPU_ICACHE_MPREFETCH_BYTE_SIZE 0x00000008ul +#define MACHINE_CPU_ICACHE_MPREFETCH_READ_ACCESS 1u +#define MACHINE_CPU_ICACHE_MPREFETCH_WRITE_ACCESS 1u +#define MACHINE_CPU_ICACHE_MPREFETCH_RESET_VALUE 0x0000000000000000ull +#define MACHINE_CPU_ICACHE_MPREFETCH_RESET_MASK 0x0000FFFFFFFFFFFFull +#define MACHINE_CPU_ICACHE_MPREFETCH_READ_MASK 0x0000FFFFFFFFFFFFull +#define MACHINE_CPU_ICACHE_MPREFETCH_WRITE_MASK 0x0000FFFFFFFFFFFFull + +/* Field: MACHINE_CPU_ICACHE_MPREFETCH.count */ +#define MACHINE_CPU_ICACHE_MPREFETCH_COUNT_MSB 5u +#define MACHINE_CPU_ICACHE_MPREFETCH_COUNT_LSB 0u +#define MACHINE_CPU_ICACHE_MPREFETCH_COUNT_WIDTH 6u +#define MACHINE_CPU_ICACHE_MPREFETCH_COUNT_READ_ACCESS 1u +#define MACHINE_CPU_ICACHE_MPREFETCH_COUNT_WRITE_ACCESS 1u +#define MACHINE_CPU_ICACHE_MPREFETCH_COUNT_RESET 0x0000000000000000ull +#define MACHINE_CPU_ICACHE_MPREFETCH_COUNT_FIELD_MASK 0x000000000000003Full +#define MACHINE_CPU_ICACHE_MPREFETCH_COUNT_GET(x) ((x) & 0x000000000000003Full) +#define MACHINE_CPU_ICACHE_MPREFETCH_COUNT_SET(x) ((x) & 0x000000000000003Full) +#define MACHINE_CPU_ICACHE_MPREFETCH_COUNT_MODIFY(r, x) ((((x) << 0) & 0x000000000000003Full) | ((r) & 0xFFFFFFFFFFFFFFC0ull)) + +/* Field: MACHINE_CPU_ICACHE_MPREFETCH.address */ +#define MACHINE_CPU_ICACHE_MPREFETCH_ADDRESS_MSB 47u +#define MACHINE_CPU_ICACHE_MPREFETCH_ADDRESS_LSB 6u +#define MACHINE_CPU_ICACHE_MPREFETCH_ADDRESS_WIDTH 42u +#define MACHINE_CPU_ICACHE_MPREFETCH_ADDRESS_READ_ACCESS 1u +#define MACHINE_CPU_ICACHE_MPREFETCH_ADDRESS_WRITE_ACCESS 1u +#define MACHINE_CPU_ICACHE_MPREFETCH_ADDRESS_RESET 0x0000000000000000ull +#define MACHINE_CPU_ICACHE_MPREFETCH_ADDRESS_FIELD_MASK 0x0000FFFFFFFFFFC0ull +#define MACHINE_CPU_ICACHE_MPREFETCH_ADDRESS_GET(x) (((x) & 0x0000FFFFFFFFFFC0ull) >> 6) +#define MACHINE_CPU_ICACHE_MPREFETCH_ADDRESS_SET(x) (((x) << 6) & 0x0000FFFFFFFFFFC0ull) +#define MACHINE_CPU_ICACHE_MPREFETCH_ADDRESS_MODIFY(r, x) ((((x) << 6) & 0x0000FFFFFFFFFFC0ull) | ((r) & 0xFFFF00000000003Full)) + +/* Register: MACHINE_CPU.clk_gate_ctrl */ +#define MACHINE_CPU_CLK_GATE_CTRL_ADDRESS 0x00000310ul +#define MACHINE_CPU_CLK_GATE_CTRL_BYTE_ADDRESS 0x00000310ul +#define MACHINE_CPU_CLK_GATE_CTRL_OFFSET 0x00000310ul +#define MACHINE_CPU_CLK_GATE_CTRL_BYTE_OFFSET 0x00000310ul +#define MACHINE_CPU_CLK_GATE_CTRL_SIZE 0x00000008ul +#define MACHINE_CPU_CLK_GATE_CTRL_BYTE_SIZE 0x00000008ul +#define MACHINE_CPU_CLK_GATE_CTRL_READ_ACCESS 1u +#define MACHINE_CPU_CLK_GATE_CTRL_WRITE_ACCESS 1u +#define MACHINE_CPU_CLK_GATE_CTRL_RESET_VALUE 0x0000000000000000ull +#define MACHINE_CPU_CLK_GATE_CTRL_RESET_MASK 0x00000000000007FFull +#define MACHINE_CPU_CLK_GATE_CTRL_READ_MASK 0x00000000000007FFull +#define MACHINE_CPU_CLK_GATE_CTRL_WRITE_MASK 0x000000000000005Full + +/* Field: MACHINE_CPU_CLK_GATE_CTRL.min_intpipe_clock_gate_disable */ +#define MACHINE_CPU_CLK_GATE_CTRL_MIN_INTPIPE_CLOCK_GATE_DISABLE_MSB 0u +#define MACHINE_CPU_CLK_GATE_CTRL_MIN_INTPIPE_CLOCK_GATE_DISABLE_LSB 0u +#define MACHINE_CPU_CLK_GATE_CTRL_MIN_INTPIPE_CLOCK_GATE_DISABLE_WIDTH 1u +#define MACHINE_CPU_CLK_GATE_CTRL_MIN_INTPIPE_CLOCK_GATE_DISABLE_READ_ACCESS 1u +#define MACHINE_CPU_CLK_GATE_CTRL_MIN_INTPIPE_CLOCK_GATE_DISABLE_WRITE_ACCESS 1u +#define MACHINE_CPU_CLK_GATE_CTRL_MIN_INTPIPE_CLOCK_GATE_DISABLE_RESET 0x0000000000000000ull +#define MACHINE_CPU_CLK_GATE_CTRL_MIN_INTPIPE_CLOCK_GATE_DISABLE_FIELD_MASK 0x0000000000000001ull +#define MACHINE_CPU_CLK_GATE_CTRL_MIN_INTPIPE_CLOCK_GATE_DISABLE_GET(x) ((x) & 0x0000000000000001ull) +#define MACHINE_CPU_CLK_GATE_CTRL_MIN_INTPIPE_CLOCK_GATE_DISABLE_SET(x) ((x) & 0x0000000000000001ull) +#define MACHINE_CPU_CLK_GATE_CTRL_MIN_INTPIPE_CLOCK_GATE_DISABLE_MODIFY(r, x) ((((x) << 0) & 0x0000000000000001ull) | ((r) & 0xFFFFFFFFFFFFFFFEull)) + +/* Field: MACHINE_CPU_CLK_GATE_CTRL.min_vpulane_clock_gate_disable */ +#define MACHINE_CPU_CLK_GATE_CTRL_MIN_VPULANE_CLOCK_GATE_DISABLE_MSB 1u +#define MACHINE_CPU_CLK_GATE_CTRL_MIN_VPULANE_CLOCK_GATE_DISABLE_LSB 1u +#define MACHINE_CPU_CLK_GATE_CTRL_MIN_VPULANE_CLOCK_GATE_DISABLE_WIDTH 1u +#define MACHINE_CPU_CLK_GATE_CTRL_MIN_VPULANE_CLOCK_GATE_DISABLE_READ_ACCESS 1u +#define MACHINE_CPU_CLK_GATE_CTRL_MIN_VPULANE_CLOCK_GATE_DISABLE_WRITE_ACCESS 1u +#define MACHINE_CPU_CLK_GATE_CTRL_MIN_VPULANE_CLOCK_GATE_DISABLE_RESET 0x0000000000000000ull +#define MACHINE_CPU_CLK_GATE_CTRL_MIN_VPULANE_CLOCK_GATE_DISABLE_FIELD_MASK 0x0000000000000002ull +#define MACHINE_CPU_CLK_GATE_CTRL_MIN_VPULANE_CLOCK_GATE_DISABLE_GET(x) (((x) & 0x0000000000000002ull) >> 1) +#define MACHINE_CPU_CLK_GATE_CTRL_MIN_VPULANE_CLOCK_GATE_DISABLE_SET(x) (((x) << 1) & 0x0000000000000002ull) +#define MACHINE_CPU_CLK_GATE_CTRL_MIN_VPULANE_CLOCK_GATE_DISABLE_MODIFY(r, x) ((((x) << 1) & 0x0000000000000002ull) | ((r) & 0xFFFFFFFFFFFFFFFDull)) + +/* Field: MACHINE_CPU_CLK_GATE_CTRL.min_vputima_clock_gate_disable */ +#define MACHINE_CPU_CLK_GATE_CTRL_MIN_VPUTIMA_CLOCK_GATE_DISABLE_MSB 2u +#define MACHINE_CPU_CLK_GATE_CTRL_MIN_VPUTIMA_CLOCK_GATE_DISABLE_LSB 2u +#define MACHINE_CPU_CLK_GATE_CTRL_MIN_VPUTIMA_CLOCK_GATE_DISABLE_WIDTH 1u +#define MACHINE_CPU_CLK_GATE_CTRL_MIN_VPUTIMA_CLOCK_GATE_DISABLE_READ_ACCESS 1u +#define MACHINE_CPU_CLK_GATE_CTRL_MIN_VPUTIMA_CLOCK_GATE_DISABLE_WRITE_ACCESS 1u +#define MACHINE_CPU_CLK_GATE_CTRL_MIN_VPUTIMA_CLOCK_GATE_DISABLE_RESET 0x0000000000000000ull +#define MACHINE_CPU_CLK_GATE_CTRL_MIN_VPUTIMA_CLOCK_GATE_DISABLE_FIELD_MASK 0x0000000000000004ull +#define MACHINE_CPU_CLK_GATE_CTRL_MIN_VPUTIMA_CLOCK_GATE_DISABLE_GET(x) (((x) & 0x0000000000000004ull) >> 2) +#define MACHINE_CPU_CLK_GATE_CTRL_MIN_VPUTIMA_CLOCK_GATE_DISABLE_SET(x) (((x) << 2) & 0x0000000000000004ull) +#define MACHINE_CPU_CLK_GATE_CTRL_MIN_VPUTIMA_CLOCK_GATE_DISABLE_MODIFY(r, x) ((((x) << 2) & 0x0000000000000004ull) | ((r) & 0xFFFFFFFFFFFFFFFBull)) + +/* Field: MACHINE_CPU_CLK_GATE_CTRL.min_vputrans_clock_gate_disable */ +#define MACHINE_CPU_CLK_GATE_CTRL_MIN_VPUTRANS_CLOCK_GATE_DISABLE_MSB 3u +#define MACHINE_CPU_CLK_GATE_CTRL_MIN_VPUTRANS_CLOCK_GATE_DISABLE_LSB 3u +#define MACHINE_CPU_CLK_GATE_CTRL_MIN_VPUTRANS_CLOCK_GATE_DISABLE_WIDTH 1u +#define MACHINE_CPU_CLK_GATE_CTRL_MIN_VPUTRANS_CLOCK_GATE_DISABLE_READ_ACCESS 1u +#define MACHINE_CPU_CLK_GATE_CTRL_MIN_VPUTRANS_CLOCK_GATE_DISABLE_WRITE_ACCESS 1u +#define MACHINE_CPU_CLK_GATE_CTRL_MIN_VPUTRANS_CLOCK_GATE_DISABLE_RESET 0x0000000000000000ull +#define MACHINE_CPU_CLK_GATE_CTRL_MIN_VPUTRANS_CLOCK_GATE_DISABLE_FIELD_MASK 0x0000000000000008ull +#define MACHINE_CPU_CLK_GATE_CTRL_MIN_VPUTRANS_CLOCK_GATE_DISABLE_GET(x) (((x) & 0x0000000000000008ull) >> 3) +#define MACHINE_CPU_CLK_GATE_CTRL_MIN_VPUTRANS_CLOCK_GATE_DISABLE_SET(x) (((x) << 3) & 0x0000000000000008ull) +#define MACHINE_CPU_CLK_GATE_CTRL_MIN_VPUTRANS_CLOCK_GATE_DISABLE_MODIFY(r, x) ((((x) << 3) & 0x0000000000000008ull) | ((r) & 0xFFFFFFFFFFFFFFF7ull)) + +/* Field: MACHINE_CPU_CLK_GATE_CTRL.min_dcache_clock_gate_disable */ +#define MACHINE_CPU_CLK_GATE_CTRL_MIN_DCACHE_CLOCK_GATE_DISABLE_MSB 4u +#define MACHINE_CPU_CLK_GATE_CTRL_MIN_DCACHE_CLOCK_GATE_DISABLE_LSB 4u +#define MACHINE_CPU_CLK_GATE_CTRL_MIN_DCACHE_CLOCK_GATE_DISABLE_WIDTH 1u +#define MACHINE_CPU_CLK_GATE_CTRL_MIN_DCACHE_CLOCK_GATE_DISABLE_READ_ACCESS 1u +#define MACHINE_CPU_CLK_GATE_CTRL_MIN_DCACHE_CLOCK_GATE_DISABLE_WRITE_ACCESS 1u +#define MACHINE_CPU_CLK_GATE_CTRL_MIN_DCACHE_CLOCK_GATE_DISABLE_RESET 0x0000000000000000ull +#define MACHINE_CPU_CLK_GATE_CTRL_MIN_DCACHE_CLOCK_GATE_DISABLE_FIELD_MASK 0x0000000000000010ull +#define MACHINE_CPU_CLK_GATE_CTRL_MIN_DCACHE_CLOCK_GATE_DISABLE_GET(x) (((x) & 0x0000000000000010ull) >> 4) +#define MACHINE_CPU_CLK_GATE_CTRL_MIN_DCACHE_CLOCK_GATE_DISABLE_SET(x) (((x) << 4) & 0x0000000000000010ull) +#define MACHINE_CPU_CLK_GATE_CTRL_MIN_DCACHE_CLOCK_GATE_DISABLE_MODIFY(r, x) ((((x) << 4) & 0x0000000000000010ull) | ((r) & 0xFFFFFFFFFFFFFFEFull)) + +/* Field: MACHINE_CPU_CLK_GATE_CTRL.reserved0 */ +#define MACHINE_CPU_CLK_GATE_CTRL_RESERVED0_MSB 5u +#define MACHINE_CPU_CLK_GATE_CTRL_RESERVED0_LSB 5u +#define MACHINE_CPU_CLK_GATE_CTRL_RESERVED0_WIDTH 1u +#define MACHINE_CPU_CLK_GATE_CTRL_RESERVED0_READ_ACCESS 1u +#define MACHINE_CPU_CLK_GATE_CTRL_RESERVED0_WRITE_ACCESS 0u +#define MACHINE_CPU_CLK_GATE_CTRL_RESERVED0_RESET 0x0000000000000000ull +#define MACHINE_CPU_CLK_GATE_CTRL_RESERVED0_FIELD_MASK 0x0000000000000020ull +#define MACHINE_CPU_CLK_GATE_CTRL_RESERVED0_GET(x) (((x) & 0x0000000000000020ull) >> 5) +#define MACHINE_CPU_CLK_GATE_CTRL_RESERVED0_SET(x) (((x) << 5) & 0x0000000000000020ull) +#define MACHINE_CPU_CLK_GATE_CTRL_RESERVED0_MODIFY(r, x) ((((x) << 5) & 0x0000000000000020ull) | ((r) & 0xFFFFFFFFFFFFFFDFull)) + +/* Field: MACHINE_CPU_CLK_GATE_CTRL.min_frontend_clock_gate_disable */ +#define MACHINE_CPU_CLK_GATE_CTRL_MIN_FRONTEND_CLOCK_GATE_DISABLE_MSB 6u +#define MACHINE_CPU_CLK_GATE_CTRL_MIN_FRONTEND_CLOCK_GATE_DISABLE_LSB 6u +#define MACHINE_CPU_CLK_GATE_CTRL_MIN_FRONTEND_CLOCK_GATE_DISABLE_WIDTH 1u +#define MACHINE_CPU_CLK_GATE_CTRL_MIN_FRONTEND_CLOCK_GATE_DISABLE_READ_ACCESS 1u +#define MACHINE_CPU_CLK_GATE_CTRL_MIN_FRONTEND_CLOCK_GATE_DISABLE_WRITE_ACCESS 1u +#define MACHINE_CPU_CLK_GATE_CTRL_MIN_FRONTEND_CLOCK_GATE_DISABLE_RESET 0x0000000000000000ull +#define MACHINE_CPU_CLK_GATE_CTRL_MIN_FRONTEND_CLOCK_GATE_DISABLE_FIELD_MASK 0x0000000000000040ull +#define MACHINE_CPU_CLK_GATE_CTRL_MIN_FRONTEND_CLOCK_GATE_DISABLE_GET(x) (((x) & 0x0000000000000040ull) >> 6) +#define MACHINE_CPU_CLK_GATE_CTRL_MIN_FRONTEND_CLOCK_GATE_DISABLE_SET(x) (((x) << 6) & 0x0000000000000040ull) +#define MACHINE_CPU_CLK_GATE_CTRL_MIN_FRONTEND_CLOCK_GATE_DISABLE_MODIFY(r, x) ((((x) << 6) & 0x0000000000000040ull) | ((r) & 0xFFFFFFFFFFFFFFBFull)) + +/* Field: MACHINE_CPU_CLK_GATE_CTRL.reserved1 */ +#define MACHINE_CPU_CLK_GATE_CTRL_RESERVED1_MSB 10u +#define MACHINE_CPU_CLK_GATE_CTRL_RESERVED1_LSB 7u +#define MACHINE_CPU_CLK_GATE_CTRL_RESERVED1_WIDTH 4u +#define MACHINE_CPU_CLK_GATE_CTRL_RESERVED1_READ_ACCESS 1u +#define MACHINE_CPU_CLK_GATE_CTRL_RESERVED1_WRITE_ACCESS 0u +#define MACHINE_CPU_CLK_GATE_CTRL_RESERVED1_RESET 0x0000000000000000ull +#define MACHINE_CPU_CLK_GATE_CTRL_RESERVED1_FIELD_MASK 0x0000000000000780ull +#define MACHINE_CPU_CLK_GATE_CTRL_RESERVED1_GET(x) (((x) & 0x0000000000000780ull) >> 7) +#define MACHINE_CPU_CLK_GATE_CTRL_RESERVED1_SET(x) (((x) << 7) & 0x0000000000000780ull) +#define MACHINE_CPU_CLK_GATE_CTRL_RESERVED1_MODIFY(r, x) ((((x) << 7) & 0x0000000000000780ull) | ((r) & 0xFFFFFFFFFFFFF87Full)) + +/* Block-level typedef: MACHINE_CPU */ +typedef struct { + volatile uint64_t minion_feature; /* Offset 0x0 (R/W) */ + uint8_t _pad0[0x8]; /* 0x8..0xF reserved */ + volatile uint64_t thread1_disable; /* Offset 0x10 (R/W) */ + uint8_t _pad1[0x70]; /* 0x18..0x87 reserved */ + volatile uint64_t ipi_redirect_filter; /* Offset 0x88 (R/W) */ + volatile uint64_t ipi_trigger; /* Offset 0x90 (R/W) */ + volatile uint64_t ipi_trigger_clear; /* Offset 0x98 (R) */ + uint8_t _pad2[0x160]; /* 0xA0..0x1FF reserved */ + volatile uint64_t mtime; /* Offset 0x200 (R/W) */ + volatile uint64_t mtime_cmp; /* Offset 0x208 (R/W) */ + volatile uint64_t time_config; /* Offset 0x210 (R/W) */ + volatile uint64_t mtime_local_target; /* Offset 0x218 (R/W) */ + uint8_t _pad3[0x20]; /* 0x220..0x23F reserved */ + volatile uint64_t thread0_disable; /* Offset 0x240 (R/W) */ + uint8_t _pad4[0xC0]; /* 0x248..0x307 reserved */ + volatile uint64_t icache_mprefetch; /* Offset 0x308 (R/W) */ + volatile uint64_t clk_gate_ctrl; /* Offset 0x310 (R/W) */ +} Machine_cpu_t, *PTR_Machine_cpu_t; + +#ifdef __cplusplus +} +#endif + +#endif /* _ESR_H_ */ diff --git a/erbium-hal/include/hwinc/i2c.h b/erbium-hal/include/hwinc/i2c.h new file mode 100644 index 000000000..370b3440c --- /dev/null +++ b/erbium-hal/include/hwinc/i2c.h @@ -0,0 +1,294 @@ +/* Auto-generated by rdl2hal.py from SystemRDL. Do not edit. */ +#ifndef _I2C_H_ +#define _I2C_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* ============================================================ */ +/* Block: I2C_Reg (macro prefix: I2C) */ +/* ============================================================ */ + +/* Register: I2C.Commands */ +#define I2C_COMMANDS_ADDRESS 0x00000000ul +#define I2C_COMMANDS_BYTE_ADDRESS 0x00000000ul +#define I2C_COMMANDS_OFFSET 0x00000000ul +#define I2C_COMMANDS_BYTE_OFFSET 0x00000000ul +#define I2C_COMMANDS_SIZE 0x00000004ul +#define I2C_COMMANDS_BYTE_SIZE 0x00000004ul +#define I2C_COMMANDS_READ_ACCESS 1u +#define I2C_COMMANDS_WRITE_ACCESS 1u +#define I2C_COMMANDS_RESET_VALUE 0x00000000ul +#define I2C_COMMANDS_RESET_MASK 0x00007F1Ful +#define I2C_COMMANDS_READ_MASK 0x00007F1Ful +#define I2C_COMMANDS_WRITE_MASK 0x00007F1Ful + +/* Field: I2C_COMMANDS.start */ +#define I2C_COMMANDS_START_MSB 0u +#define I2C_COMMANDS_START_LSB 0u +#define I2C_COMMANDS_START_WIDTH 1u +#define I2C_COMMANDS_START_READ_ACCESS 1u +#define I2C_COMMANDS_START_WRITE_ACCESS 1u +#define I2C_COMMANDS_START_RESET 0x00000000ul +#define I2C_COMMANDS_START_FIELD_MASK 0x00000001ul +#define I2C_COMMANDS_START_GET(x) ((x) & 0x00000001ul) +#define I2C_COMMANDS_START_SET(x) ((x) & 0x00000001ul) +#define I2C_COMMANDS_START_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Field: I2C_COMMANDS.read */ +#define I2C_COMMANDS_READ_MSB 1u +#define I2C_COMMANDS_READ_LSB 1u +#define I2C_COMMANDS_READ_WIDTH 1u +#define I2C_COMMANDS_READ_READ_ACCESS 1u +#define I2C_COMMANDS_READ_WRITE_ACCESS 1u +#define I2C_COMMANDS_READ_RESET 0x00000000ul +#define I2C_COMMANDS_READ_FIELD_MASK 0x00000002ul +#define I2C_COMMANDS_READ_GET(x) (((x) & 0x00000002ul) >> 1) +#define I2C_COMMANDS_READ_SET(x) (((x) << 1) & 0x00000002ul) +#define I2C_COMMANDS_READ_MODIFY(r, x) ((((x) << 1) & 0x00000002ul) | ((r) & 0xFFFFFFFDul)) + +/* Field: I2C_COMMANDS.write */ +#define I2C_COMMANDS_WRITE_MSB 2u +#define I2C_COMMANDS_WRITE_LSB 2u +#define I2C_COMMANDS_WRITE_WIDTH 1u +#define I2C_COMMANDS_WRITE_READ_ACCESS 1u +#define I2C_COMMANDS_WRITE_WRITE_ACCESS 1u +#define I2C_COMMANDS_WRITE_RESET 0x00000000ul +#define I2C_COMMANDS_WRITE_FIELD_MASK 0x00000004ul +#define I2C_COMMANDS_WRITE_GET(x) (((x) & 0x00000004ul) >> 2) +#define I2C_COMMANDS_WRITE_SET(x) (((x) << 2) & 0x00000004ul) +#define I2C_COMMANDS_WRITE_MODIFY(r, x) ((((x) << 2) & 0x00000004ul) | ((r) & 0xFFFFFFFBul)) + +/* Field: I2C_COMMANDS.write_multiple */ +#define I2C_COMMANDS_WRITE_MULTIPLE_MSB 3u +#define I2C_COMMANDS_WRITE_MULTIPLE_LSB 3u +#define I2C_COMMANDS_WRITE_MULTIPLE_WIDTH 1u +#define I2C_COMMANDS_WRITE_MULTIPLE_READ_ACCESS 1u +#define I2C_COMMANDS_WRITE_MULTIPLE_WRITE_ACCESS 1u +#define I2C_COMMANDS_WRITE_MULTIPLE_RESET 0x00000000ul +#define I2C_COMMANDS_WRITE_MULTIPLE_FIELD_MASK 0x00000008ul +#define I2C_COMMANDS_WRITE_MULTIPLE_GET(x) (((x) & 0x00000008ul) >> 3) +#define I2C_COMMANDS_WRITE_MULTIPLE_SET(x) (((x) << 3) & 0x00000008ul) +#define I2C_COMMANDS_WRITE_MULTIPLE_MODIFY(r, x) ((((x) << 3) & 0x00000008ul) | ((r) & 0xFFFFFFF7ul)) + +/* Field: I2C_COMMANDS.stop */ +#define I2C_COMMANDS_STOP_MSB 4u +#define I2C_COMMANDS_STOP_LSB 4u +#define I2C_COMMANDS_STOP_WIDTH 1u +#define I2C_COMMANDS_STOP_READ_ACCESS 1u +#define I2C_COMMANDS_STOP_WRITE_ACCESS 1u +#define I2C_COMMANDS_STOP_RESET 0x00000000ul +#define I2C_COMMANDS_STOP_FIELD_MASK 0x00000010ul +#define I2C_COMMANDS_STOP_GET(x) (((x) & 0x00000010ul) >> 4) +#define I2C_COMMANDS_STOP_SET(x) (((x) << 4) & 0x00000010ul) +#define I2C_COMMANDS_STOP_MODIFY(r, x) ((((x) << 4) & 0x00000010ul) | ((r) & 0xFFFFFFEFul)) + +/* Field: I2C_COMMANDS.address */ +#define I2C_COMMANDS_ADDRESS_MSB 14u +#define I2C_COMMANDS_ADDRESS_LSB 8u +#define I2C_COMMANDS_ADDRESS_WIDTH 7u +#define I2C_COMMANDS_ADDRESS_READ_ACCESS 1u +#define I2C_COMMANDS_ADDRESS_WRITE_ACCESS 1u +#define I2C_COMMANDS_ADDRESS_RESET 0x00000000ul +#define I2C_COMMANDS_ADDRESS_FIELD_MASK 0x00007F00ul +#define I2C_COMMANDS_ADDRESS_GET(x) (((x) & 0x00007F00ul) >> 8) +#define I2C_COMMANDS_ADDRESS_SET(x) (((x) << 8) & 0x00007F00ul) +#define I2C_COMMANDS_ADDRESS_MODIFY(r, x) ((((x) << 8) & 0x00007F00ul) | ((r) & 0xFFFF80FFul)) + +/* Register: I2C.Status */ +#define I2C_STATUS_ADDRESS 0x00000008ul +#define I2C_STATUS_BYTE_ADDRESS 0x00000008ul +#define I2C_STATUS_OFFSET 0x00000008ul +#define I2C_STATUS_BYTE_OFFSET 0x00000008ul +#define I2C_STATUS_SIZE 0x00000004ul +#define I2C_STATUS_BYTE_SIZE 0x00000004ul +#define I2C_STATUS_READ_ACCESS 1u +#define I2C_STATUS_WRITE_ACCESS 0u +#define I2C_STATUS_RESET_VALUE 0x00000000ul +#define I2C_STATUS_RESET_MASK 0x0000000Ful +#define I2C_STATUS_READ_MASK 0x0000000Ful +#define I2C_STATUS_WRITE_MASK 0x00000000ul + +/* Field: I2C_STATUS.busy */ +#define I2C_STATUS_BUSY_MSB 0u +#define I2C_STATUS_BUSY_LSB 0u +#define I2C_STATUS_BUSY_WIDTH 1u +#define I2C_STATUS_BUSY_READ_ACCESS 1u +#define I2C_STATUS_BUSY_WRITE_ACCESS 0u +#define I2C_STATUS_BUSY_RESET 0x00000000ul +#define I2C_STATUS_BUSY_FIELD_MASK 0x00000001ul +#define I2C_STATUS_BUSY_GET(x) ((x) & 0x00000001ul) +#define I2C_STATUS_BUSY_SET(x) ((x) & 0x00000001ul) +#define I2C_STATUS_BUSY_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Field: I2C_STATUS.bus_control */ +#define I2C_STATUS_BUS_CONTROL_MSB 1u +#define I2C_STATUS_BUS_CONTROL_LSB 1u +#define I2C_STATUS_BUS_CONTROL_WIDTH 1u +#define I2C_STATUS_BUS_CONTROL_READ_ACCESS 1u +#define I2C_STATUS_BUS_CONTROL_WRITE_ACCESS 0u +#define I2C_STATUS_BUS_CONTROL_RESET 0x00000000ul +#define I2C_STATUS_BUS_CONTROL_FIELD_MASK 0x00000002ul +#define I2C_STATUS_BUS_CONTROL_GET(x) (((x) & 0x00000002ul) >> 1) +#define I2C_STATUS_BUS_CONTROL_SET(x) (((x) << 1) & 0x00000002ul) +#define I2C_STATUS_BUS_CONTROL_MODIFY(r, x) ((((x) << 1) & 0x00000002ul) | ((r) & 0xFFFFFFFDul)) + +/* Field: I2C_STATUS.bus_active */ +#define I2C_STATUS_BUS_ACTIVE_MSB 2u +#define I2C_STATUS_BUS_ACTIVE_LSB 2u +#define I2C_STATUS_BUS_ACTIVE_WIDTH 1u +#define I2C_STATUS_BUS_ACTIVE_READ_ACCESS 1u +#define I2C_STATUS_BUS_ACTIVE_WRITE_ACCESS 0u +#define I2C_STATUS_BUS_ACTIVE_RESET 0x00000000ul +#define I2C_STATUS_BUS_ACTIVE_FIELD_MASK 0x00000004ul +#define I2C_STATUS_BUS_ACTIVE_GET(x) (((x) & 0x00000004ul) >> 2) +#define I2C_STATUS_BUS_ACTIVE_SET(x) (((x) << 2) & 0x00000004ul) +#define I2C_STATUS_BUS_ACTIVE_MODIFY(r, x) ((((x) << 2) & 0x00000004ul) | ((r) & 0xFFFFFFFBul)) + +/* Field: I2C_STATUS.missed_ack */ +#define I2C_STATUS_MISSED_ACK_MSB 3u +#define I2C_STATUS_MISSED_ACK_LSB 3u +#define I2C_STATUS_MISSED_ACK_WIDTH 1u +#define I2C_STATUS_MISSED_ACK_READ_ACCESS 1u +#define I2C_STATUS_MISSED_ACK_WRITE_ACCESS 0u +#define I2C_STATUS_MISSED_ACK_RESET 0x00000000ul +#define I2C_STATUS_MISSED_ACK_FIELD_MASK 0x00000008ul +#define I2C_STATUS_MISSED_ACK_GET(x) (((x) & 0x00000008ul) >> 3) +#define I2C_STATUS_MISSED_ACK_SET(x) (((x) << 3) & 0x00000008ul) +#define I2C_STATUS_MISSED_ACK_MODIFY(r, x) ((((x) << 3) & 0x00000008ul) | ((r) & 0xFFFFFFF7ul)) + +/* Register: I2C.Cfg */ +#define I2C_CFG_ADDRESS 0x00000010ul +#define I2C_CFG_BYTE_ADDRESS 0x00000010ul +#define I2C_CFG_OFFSET 0x00000010ul +#define I2C_CFG_BYTE_OFFSET 0x00000010ul +#define I2C_CFG_SIZE 0x00000004ul +#define I2C_CFG_BYTE_SIZE 0x00000004ul +#define I2C_CFG_READ_ACCESS 1u +#define I2C_CFG_WRITE_ACCESS 1u +#define I2C_CFG_RESET_VALUE 0x00000000ul +#define I2C_CFG_RESET_MASK 0x0001FFFFul +#define I2C_CFG_READ_MASK 0x0001FFFFul +#define I2C_CFG_WRITE_MASK 0x0001FFFFul + +/* Field: I2C_CFG.prescale */ +#define I2C_CFG_PRESCALE_MSB 15u +#define I2C_CFG_PRESCALE_LSB 0u +#define I2C_CFG_PRESCALE_WIDTH 16u +#define I2C_CFG_PRESCALE_READ_ACCESS 1u +#define I2C_CFG_PRESCALE_WRITE_ACCESS 1u +#define I2C_CFG_PRESCALE_RESET 0x00000000ul +#define I2C_CFG_PRESCALE_FIELD_MASK 0x0000FFFFul +#define I2C_CFG_PRESCALE_GET(x) ((x) & 0x0000FFFFul) +#define I2C_CFG_PRESCALE_SET(x) ((x) & 0x0000FFFFul) +#define I2C_CFG_PRESCALE_MODIFY(r, x) ((((x) << 0) & 0x0000FFFFul) | ((r) & 0xFFFF0000ul)) + +/* Field: I2C_CFG.stop_on_idle */ +#define I2C_CFG_STOP_ON_IDLE_MSB 16u +#define I2C_CFG_STOP_ON_IDLE_LSB 16u +#define I2C_CFG_STOP_ON_IDLE_WIDTH 1u +#define I2C_CFG_STOP_ON_IDLE_READ_ACCESS 1u +#define I2C_CFG_STOP_ON_IDLE_WRITE_ACCESS 1u +#define I2C_CFG_STOP_ON_IDLE_RESET 0x00000000ul +#define I2C_CFG_STOP_ON_IDLE_FIELD_MASK 0x00010000ul +#define I2C_CFG_STOP_ON_IDLE_GET(x) (((x) & 0x00010000ul) >> 16) +#define I2C_CFG_STOP_ON_IDLE_SET(x) (((x) << 16) & 0x00010000ul) +#define I2C_CFG_STOP_ON_IDLE_MODIFY(r, x) ((((x) << 16) & 0x00010000ul) | ((r) & 0xFFFEFFFFul)) + +/* Register: I2C.Wdata */ +#define I2C_WDATA_ADDRESS 0x00000018ul +#define I2C_WDATA_BYTE_ADDRESS 0x00000018ul +#define I2C_WDATA_OFFSET 0x00000018ul +#define I2C_WDATA_BYTE_OFFSET 0x00000018ul +#define I2C_WDATA_SIZE 0x00000004ul +#define I2C_WDATA_BYTE_SIZE 0x00000004ul +#define I2C_WDATA_READ_ACCESS 1u +#define I2C_WDATA_WRITE_ACCESS 1u +#define I2C_WDATA_RESET_VALUE 0x00000000ul +#define I2C_WDATA_RESET_MASK 0x000001FFul +#define I2C_WDATA_READ_MASK 0x000001FFul +#define I2C_WDATA_WRITE_MASK 0x000001FFul + +/* Field: I2C_WDATA.wdata */ +#define I2C_WDATA_WDATA_MSB 7u +#define I2C_WDATA_WDATA_LSB 0u +#define I2C_WDATA_WDATA_WIDTH 8u +#define I2C_WDATA_WDATA_READ_ACCESS 1u +#define I2C_WDATA_WDATA_WRITE_ACCESS 1u +#define I2C_WDATA_WDATA_RESET 0x00000000ul +#define I2C_WDATA_WDATA_FIELD_MASK 0x000000FFul +#define I2C_WDATA_WDATA_GET(x) ((x) & 0x000000FFul) +#define I2C_WDATA_WDATA_SET(x) ((x) & 0x000000FFul) +#define I2C_WDATA_WDATA_MODIFY(r, x) ((((x) << 0) & 0x000000FFul) | ((r) & 0xFFFFFF00ul)) + +/* Field: I2C_WDATA.wlast */ +#define I2C_WDATA_WLAST_MSB 8u +#define I2C_WDATA_WLAST_LSB 8u +#define I2C_WDATA_WLAST_WIDTH 1u +#define I2C_WDATA_WLAST_READ_ACCESS 1u +#define I2C_WDATA_WLAST_WRITE_ACCESS 1u +#define I2C_WDATA_WLAST_RESET 0x00000000ul +#define I2C_WDATA_WLAST_FIELD_MASK 0x00000100ul +#define I2C_WDATA_WLAST_GET(x) (((x) & 0x00000100ul) >> 8) +#define I2C_WDATA_WLAST_SET(x) (((x) << 8) & 0x00000100ul) +#define I2C_WDATA_WLAST_MODIFY(r, x) ((((x) << 8) & 0x00000100ul) | ((r) & 0xFFFFFEFFul)) + +/* Register: I2C.Rdata */ +#define I2C_RDATA_ADDRESS 0x00000020ul +#define I2C_RDATA_BYTE_ADDRESS 0x00000020ul +#define I2C_RDATA_OFFSET 0x00000020ul +#define I2C_RDATA_BYTE_OFFSET 0x00000020ul +#define I2C_RDATA_SIZE 0x00000004ul +#define I2C_RDATA_BYTE_SIZE 0x00000004ul +#define I2C_RDATA_READ_ACCESS 1u +#define I2C_RDATA_WRITE_ACCESS 1u +#define I2C_RDATA_RESET_VALUE 0x00000000ul +#define I2C_RDATA_RESET_MASK 0x000001FFul +#define I2C_RDATA_READ_MASK 0x000001FFul +#define I2C_RDATA_WRITE_MASK 0x000001FFul + +/* Field: I2C_RDATA.rdata */ +#define I2C_RDATA_RDATA_MSB 7u +#define I2C_RDATA_RDATA_LSB 0u +#define I2C_RDATA_RDATA_WIDTH 8u +#define I2C_RDATA_RDATA_READ_ACCESS 1u +#define I2C_RDATA_RDATA_WRITE_ACCESS 1u +#define I2C_RDATA_RDATA_RESET 0x00000000ul +#define I2C_RDATA_RDATA_FIELD_MASK 0x000000FFul +#define I2C_RDATA_RDATA_GET(x) ((x) & 0x000000FFul) +#define I2C_RDATA_RDATA_SET(x) ((x) & 0x000000FFul) +#define I2C_RDATA_RDATA_MODIFY(r, x) ((((x) << 0) & 0x000000FFul) | ((r) & 0xFFFFFF00ul)) + +/* Field: I2C_RDATA.rlast */ +#define I2C_RDATA_RLAST_MSB 8u +#define I2C_RDATA_RLAST_LSB 8u +#define I2C_RDATA_RLAST_WIDTH 1u +#define I2C_RDATA_RLAST_READ_ACCESS 1u +#define I2C_RDATA_RLAST_WRITE_ACCESS 1u +#define I2C_RDATA_RLAST_RESET 0x00000000ul +#define I2C_RDATA_RLAST_FIELD_MASK 0x00000100ul +#define I2C_RDATA_RLAST_GET(x) (((x) & 0x00000100ul) >> 8) +#define I2C_RDATA_RLAST_SET(x) (((x) << 8) & 0x00000100ul) +#define I2C_RDATA_RLAST_MODIFY(r, x) ((((x) << 8) & 0x00000100ul) | ((r) & 0xFFFFFEFFul)) + +/* Block-level typedef: I2C */ +typedef struct { + volatile uint32_t Commands; /* Offset 0x0 (R/W) */ + uint8_t _pad0[0x4]; /* 0x4..0x7 reserved */ + volatile uint32_t Status; /* Offset 0x8 (R) */ + uint8_t _pad1[0x4]; /* 0xC..0xF reserved */ + volatile uint32_t Cfg; /* Offset 0x10 (R/W) */ + uint8_t _pad2[0x4]; /* 0x14..0x17 reserved */ + volatile uint32_t Wdata; /* Offset 0x18 (R/W) */ + uint8_t _pad3[0x4]; /* 0x1C..0x1F reserved */ + volatile uint32_t Rdata; /* Offset 0x20 (R/W) */ +} I2c_t, *PTR_I2c_t; + +#ifdef __cplusplus +} +#endif + +#endif /* _I2C_H_ */ diff --git a/erbium-hal/include/hwinc/minion_csr.h b/erbium-hal/include/hwinc/minion_csr.h new file mode 100644 index 000000000..76a9c1c05 --- /dev/null +++ b/erbium-hal/include/hwinc/minion_csr.h @@ -0,0 +1,8142 @@ +/* Auto-generated by rdl2hal.py from SystemRDL. Do not edit. */ +#ifndef _MINION_CSR_H_ +#define _MINION_CSR_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* ============================================================ */ +/* Block: minion_csr (macro prefix: MINION_CSR) */ +/* ============================================================ */ + +/* Register: MINION_CSR.ustatus */ +#define MINION_CSR_USTATUS_ADDRESS 0x00000000ul +#define MINION_CSR_USTATUS_BYTE_ADDRESS 0x00000000ul +#define MINION_CSR_USTATUS_OFFSET 0x00000000ul +#define MINION_CSR_USTATUS_BYTE_OFFSET 0x00000000ul +#define MINION_CSR_USTATUS_SIZE 0x00000008ul +#define MINION_CSR_USTATUS_BYTE_SIZE 0x00000008ul +#define MINION_CSR_USTATUS_READ_ACCESS 1u +#define MINION_CSR_USTATUS_WRITE_ACCESS 0u +#define MINION_CSR_USTATUS_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_USTATUS_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_USTATUS_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_USTATUS_WRITE_MASK 0x0000000000000000ull + +/* Field: MINION_CSR_USTATUS.ustatus */ +#define MINION_CSR_USTATUS_USTATUS_MSB 63u +#define MINION_CSR_USTATUS_USTATUS_LSB 0u +#define MINION_CSR_USTATUS_USTATUS_WIDTH 64u +#define MINION_CSR_USTATUS_USTATUS_READ_ACCESS 1u +#define MINION_CSR_USTATUS_USTATUS_WRITE_ACCESS 0u +#define MINION_CSR_USTATUS_USTATUS_RESET 0x0000000000000000ull +#define MINION_CSR_USTATUS_USTATUS_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_USTATUS_USTATUS_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_USTATUS_USTATUS_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_USTATUS_USTATUS_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.fflags */ +#define MINION_CSR_FFLAGS_ADDRESS 0x00000008ul +#define MINION_CSR_FFLAGS_BYTE_ADDRESS 0x00000008ul +#define MINION_CSR_FFLAGS_OFFSET 0x00000008ul +#define MINION_CSR_FFLAGS_BYTE_OFFSET 0x00000008ul +#define MINION_CSR_FFLAGS_SIZE 0x00000008ul +#define MINION_CSR_FFLAGS_BYTE_SIZE 0x00000008ul +#define MINION_CSR_FFLAGS_READ_ACCESS 1u +#define MINION_CSR_FFLAGS_WRITE_ACCESS 1u +#define MINION_CSR_FFLAGS_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_FFLAGS_RESET_MASK 0x000000008000001Full +#define MINION_CSR_FFLAGS_READ_MASK 0x000000008000001Full +#define MINION_CSR_FFLAGS_WRITE_MASK 0x000000008000001Full + +/* Field: MINION_CSR_FFLAGS.nx */ +#define MINION_CSR_FFLAGS_NX_MSB 0u +#define MINION_CSR_FFLAGS_NX_LSB 0u +#define MINION_CSR_FFLAGS_NX_WIDTH 1u +#define MINION_CSR_FFLAGS_NX_READ_ACCESS 1u +#define MINION_CSR_FFLAGS_NX_WRITE_ACCESS 1u +#define MINION_CSR_FFLAGS_NX_RESET 0x0000000000000000ull +#define MINION_CSR_FFLAGS_NX_FIELD_MASK 0x0000000000000001ull +#define MINION_CSR_FFLAGS_NX_GET(x) ((x) & 0x0000000000000001ull) +#define MINION_CSR_FFLAGS_NX_SET(x) ((x) & 0x0000000000000001ull) +#define MINION_CSR_FFLAGS_NX_MODIFY(r, x) ((((x) << 0) & 0x0000000000000001ull) | ((r) & 0xFFFFFFFFFFFFFFFEull)) + +/* Field: MINION_CSR_FFLAGS.uf */ +#define MINION_CSR_FFLAGS_UF_MSB 1u +#define MINION_CSR_FFLAGS_UF_LSB 1u +#define MINION_CSR_FFLAGS_UF_WIDTH 1u +#define MINION_CSR_FFLAGS_UF_READ_ACCESS 1u +#define MINION_CSR_FFLAGS_UF_WRITE_ACCESS 1u +#define MINION_CSR_FFLAGS_UF_RESET 0x0000000000000000ull +#define MINION_CSR_FFLAGS_UF_FIELD_MASK 0x0000000000000002ull +#define MINION_CSR_FFLAGS_UF_GET(x) (((x) & 0x0000000000000002ull) >> 1) +#define MINION_CSR_FFLAGS_UF_SET(x) (((x) << 1) & 0x0000000000000002ull) +#define MINION_CSR_FFLAGS_UF_MODIFY(r, x) ((((x) << 1) & 0x0000000000000002ull) | ((r) & 0xFFFFFFFFFFFFFFFDull)) + +/* Field: MINION_CSR_FFLAGS.of */ +#define MINION_CSR_FFLAGS_OF_MSB 2u +#define MINION_CSR_FFLAGS_OF_LSB 2u +#define MINION_CSR_FFLAGS_OF_WIDTH 1u +#define MINION_CSR_FFLAGS_OF_READ_ACCESS 1u +#define MINION_CSR_FFLAGS_OF_WRITE_ACCESS 1u +#define MINION_CSR_FFLAGS_OF_RESET 0x0000000000000000ull +#define MINION_CSR_FFLAGS_OF_FIELD_MASK 0x0000000000000004ull +#define MINION_CSR_FFLAGS_OF_GET(x) (((x) & 0x0000000000000004ull) >> 2) +#define MINION_CSR_FFLAGS_OF_SET(x) (((x) << 2) & 0x0000000000000004ull) +#define MINION_CSR_FFLAGS_OF_MODIFY(r, x) ((((x) << 2) & 0x0000000000000004ull) | ((r) & 0xFFFFFFFFFFFFFFFBull)) + +/* Field: MINION_CSR_FFLAGS.dz */ +#define MINION_CSR_FFLAGS_DZ_MSB 3u +#define MINION_CSR_FFLAGS_DZ_LSB 3u +#define MINION_CSR_FFLAGS_DZ_WIDTH 1u +#define MINION_CSR_FFLAGS_DZ_READ_ACCESS 1u +#define MINION_CSR_FFLAGS_DZ_WRITE_ACCESS 1u +#define MINION_CSR_FFLAGS_DZ_RESET 0x0000000000000000ull +#define MINION_CSR_FFLAGS_DZ_FIELD_MASK 0x0000000000000008ull +#define MINION_CSR_FFLAGS_DZ_GET(x) (((x) & 0x0000000000000008ull) >> 3) +#define MINION_CSR_FFLAGS_DZ_SET(x) (((x) << 3) & 0x0000000000000008ull) +#define MINION_CSR_FFLAGS_DZ_MODIFY(r, x) ((((x) << 3) & 0x0000000000000008ull) | ((r) & 0xFFFFFFFFFFFFFFF7ull)) + +/* Field: MINION_CSR_FFLAGS.nv */ +#define MINION_CSR_FFLAGS_NV_MSB 4u +#define MINION_CSR_FFLAGS_NV_LSB 4u +#define MINION_CSR_FFLAGS_NV_WIDTH 1u +#define MINION_CSR_FFLAGS_NV_READ_ACCESS 1u +#define MINION_CSR_FFLAGS_NV_WRITE_ACCESS 1u +#define MINION_CSR_FFLAGS_NV_RESET 0x0000000000000000ull +#define MINION_CSR_FFLAGS_NV_FIELD_MASK 0x0000000000000010ull +#define MINION_CSR_FFLAGS_NV_GET(x) (((x) & 0x0000000000000010ull) >> 4) +#define MINION_CSR_FFLAGS_NV_SET(x) (((x) << 4) & 0x0000000000000010ull) +#define MINION_CSR_FFLAGS_NV_MODIFY(r, x) ((((x) << 4) & 0x0000000000000010ull) | ((r) & 0xFFFFFFFFFFFFFFEFull)) + +/* Field: MINION_CSR_FFLAGS.eflags */ +#define MINION_CSR_FFLAGS_EFLAGS_MSB 31u +#define MINION_CSR_FFLAGS_EFLAGS_LSB 31u +#define MINION_CSR_FFLAGS_EFLAGS_WIDTH 1u +#define MINION_CSR_FFLAGS_EFLAGS_READ_ACCESS 1u +#define MINION_CSR_FFLAGS_EFLAGS_WRITE_ACCESS 1u +#define MINION_CSR_FFLAGS_EFLAGS_RESET 0x0000000000000000ull +#define MINION_CSR_FFLAGS_EFLAGS_FIELD_MASK 0x0000000080000000ull +#define MINION_CSR_FFLAGS_EFLAGS_GET(x) (((x) & 0x0000000080000000ull) >> 31) +#define MINION_CSR_FFLAGS_EFLAGS_SET(x) (((x) << 31) & 0x0000000080000000ull) +#define MINION_CSR_FFLAGS_EFLAGS_MODIFY(r, x) ((((x) << 31) & 0x0000000080000000ull) | ((r) & 0xFFFFFFFF7FFFFFFFull)) + +/* Register: MINION_CSR.frm */ +#define MINION_CSR_FRM_ADDRESS 0x00000010ul +#define MINION_CSR_FRM_BYTE_ADDRESS 0x00000010ul +#define MINION_CSR_FRM_OFFSET 0x00000010ul +#define MINION_CSR_FRM_BYTE_OFFSET 0x00000010ul +#define MINION_CSR_FRM_SIZE 0x00000008ul +#define MINION_CSR_FRM_BYTE_SIZE 0x00000008ul +#define MINION_CSR_FRM_READ_ACCESS 1u +#define MINION_CSR_FRM_WRITE_ACCESS 1u +#define MINION_CSR_FRM_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_FRM_RESET_MASK 0x0000000000000007ull +#define MINION_CSR_FRM_READ_MASK 0x0000000000000007ull +#define MINION_CSR_FRM_WRITE_MASK 0x0000000000000007ull + +/* Field: MINION_CSR_FRM.frm */ +#define MINION_CSR_FRM_FRM_MSB 2u +#define MINION_CSR_FRM_FRM_LSB 0u +#define MINION_CSR_FRM_FRM_WIDTH 3u +#define MINION_CSR_FRM_FRM_READ_ACCESS 1u +#define MINION_CSR_FRM_FRM_WRITE_ACCESS 1u +#define MINION_CSR_FRM_FRM_RESET 0x0000000000000000ull +#define MINION_CSR_FRM_FRM_FIELD_MASK 0x0000000000000007ull +#define MINION_CSR_FRM_FRM_GET(x) ((x) & 0x0000000000000007ull) +#define MINION_CSR_FRM_FRM_SET(x) ((x) & 0x0000000000000007ull) +#define MINION_CSR_FRM_FRM_MODIFY(r, x) ((((x) << 0) & 0x0000000000000007ull) | ((r) & 0xFFFFFFFFFFFFFFF8ull)) + +/* Register: MINION_CSR.fcsr */ +#define MINION_CSR_FCSR_ADDRESS 0x00000018ul +#define MINION_CSR_FCSR_BYTE_ADDRESS 0x00000018ul +#define MINION_CSR_FCSR_OFFSET 0x00000018ul +#define MINION_CSR_FCSR_BYTE_OFFSET 0x00000018ul +#define MINION_CSR_FCSR_SIZE 0x00000008ul +#define MINION_CSR_FCSR_BYTE_SIZE 0x00000008ul +#define MINION_CSR_FCSR_READ_ACCESS 1u +#define MINION_CSR_FCSR_WRITE_ACCESS 1u +#define MINION_CSR_FCSR_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_FCSR_RESET_MASK 0x00000000800000FFull +#define MINION_CSR_FCSR_READ_MASK 0x00000000800000FFull +#define MINION_CSR_FCSR_WRITE_MASK 0x00000000800000FFull + +/* Field: MINION_CSR_FCSR.nx */ +#define MINION_CSR_FCSR_NX_MSB 0u +#define MINION_CSR_FCSR_NX_LSB 0u +#define MINION_CSR_FCSR_NX_WIDTH 1u +#define MINION_CSR_FCSR_NX_READ_ACCESS 1u +#define MINION_CSR_FCSR_NX_WRITE_ACCESS 1u +#define MINION_CSR_FCSR_NX_RESET 0x0000000000000000ull +#define MINION_CSR_FCSR_NX_FIELD_MASK 0x0000000000000001ull +#define MINION_CSR_FCSR_NX_GET(x) ((x) & 0x0000000000000001ull) +#define MINION_CSR_FCSR_NX_SET(x) ((x) & 0x0000000000000001ull) +#define MINION_CSR_FCSR_NX_MODIFY(r, x) ((((x) << 0) & 0x0000000000000001ull) | ((r) & 0xFFFFFFFFFFFFFFFEull)) + +/* Field: MINION_CSR_FCSR.uf */ +#define MINION_CSR_FCSR_UF_MSB 1u +#define MINION_CSR_FCSR_UF_LSB 1u +#define MINION_CSR_FCSR_UF_WIDTH 1u +#define MINION_CSR_FCSR_UF_READ_ACCESS 1u +#define MINION_CSR_FCSR_UF_WRITE_ACCESS 1u +#define MINION_CSR_FCSR_UF_RESET 0x0000000000000000ull +#define MINION_CSR_FCSR_UF_FIELD_MASK 0x0000000000000002ull +#define MINION_CSR_FCSR_UF_GET(x) (((x) & 0x0000000000000002ull) >> 1) +#define MINION_CSR_FCSR_UF_SET(x) (((x) << 1) & 0x0000000000000002ull) +#define MINION_CSR_FCSR_UF_MODIFY(r, x) ((((x) << 1) & 0x0000000000000002ull) | ((r) & 0xFFFFFFFFFFFFFFFDull)) + +/* Field: MINION_CSR_FCSR.of */ +#define MINION_CSR_FCSR_OF_MSB 2u +#define MINION_CSR_FCSR_OF_LSB 2u +#define MINION_CSR_FCSR_OF_WIDTH 1u +#define MINION_CSR_FCSR_OF_READ_ACCESS 1u +#define MINION_CSR_FCSR_OF_WRITE_ACCESS 1u +#define MINION_CSR_FCSR_OF_RESET 0x0000000000000000ull +#define MINION_CSR_FCSR_OF_FIELD_MASK 0x0000000000000004ull +#define MINION_CSR_FCSR_OF_GET(x) (((x) & 0x0000000000000004ull) >> 2) +#define MINION_CSR_FCSR_OF_SET(x) (((x) << 2) & 0x0000000000000004ull) +#define MINION_CSR_FCSR_OF_MODIFY(r, x) ((((x) << 2) & 0x0000000000000004ull) | ((r) & 0xFFFFFFFFFFFFFFFBull)) + +/* Field: MINION_CSR_FCSR.dz */ +#define MINION_CSR_FCSR_DZ_MSB 3u +#define MINION_CSR_FCSR_DZ_LSB 3u +#define MINION_CSR_FCSR_DZ_WIDTH 1u +#define MINION_CSR_FCSR_DZ_READ_ACCESS 1u +#define MINION_CSR_FCSR_DZ_WRITE_ACCESS 1u +#define MINION_CSR_FCSR_DZ_RESET 0x0000000000000000ull +#define MINION_CSR_FCSR_DZ_FIELD_MASK 0x0000000000000008ull +#define MINION_CSR_FCSR_DZ_GET(x) (((x) & 0x0000000000000008ull) >> 3) +#define MINION_CSR_FCSR_DZ_SET(x) (((x) << 3) & 0x0000000000000008ull) +#define MINION_CSR_FCSR_DZ_MODIFY(r, x) ((((x) << 3) & 0x0000000000000008ull) | ((r) & 0xFFFFFFFFFFFFFFF7ull)) + +/* Field: MINION_CSR_FCSR.nv */ +#define MINION_CSR_FCSR_NV_MSB 4u +#define MINION_CSR_FCSR_NV_LSB 4u +#define MINION_CSR_FCSR_NV_WIDTH 1u +#define MINION_CSR_FCSR_NV_READ_ACCESS 1u +#define MINION_CSR_FCSR_NV_WRITE_ACCESS 1u +#define MINION_CSR_FCSR_NV_RESET 0x0000000000000000ull +#define MINION_CSR_FCSR_NV_FIELD_MASK 0x0000000000000010ull +#define MINION_CSR_FCSR_NV_GET(x) (((x) & 0x0000000000000010ull) >> 4) +#define MINION_CSR_FCSR_NV_SET(x) (((x) << 4) & 0x0000000000000010ull) +#define MINION_CSR_FCSR_NV_MODIFY(r, x) ((((x) << 4) & 0x0000000000000010ull) | ((r) & 0xFFFFFFFFFFFFFFEFull)) + +/* Field: MINION_CSR_FCSR.frm */ +#define MINION_CSR_FCSR_FRM_MSB 7u +#define MINION_CSR_FCSR_FRM_LSB 5u +#define MINION_CSR_FCSR_FRM_WIDTH 3u +#define MINION_CSR_FCSR_FRM_READ_ACCESS 1u +#define MINION_CSR_FCSR_FRM_WRITE_ACCESS 1u +#define MINION_CSR_FCSR_FRM_RESET 0x0000000000000000ull +#define MINION_CSR_FCSR_FRM_FIELD_MASK 0x00000000000000E0ull +#define MINION_CSR_FCSR_FRM_GET(x) (((x) & 0x00000000000000E0ull) >> 5) +#define MINION_CSR_FCSR_FRM_SET(x) (((x) << 5) & 0x00000000000000E0ull) +#define MINION_CSR_FCSR_FRM_MODIFY(r, x) ((((x) << 5) & 0x00000000000000E0ull) | ((r) & 0xFFFFFFFFFFFFFF1Full)) + +/* Field: MINION_CSR_FCSR.eflags */ +#define MINION_CSR_FCSR_EFLAGS_MSB 31u +#define MINION_CSR_FCSR_EFLAGS_LSB 31u +#define MINION_CSR_FCSR_EFLAGS_WIDTH 1u +#define MINION_CSR_FCSR_EFLAGS_READ_ACCESS 1u +#define MINION_CSR_FCSR_EFLAGS_WRITE_ACCESS 1u +#define MINION_CSR_FCSR_EFLAGS_RESET 0x0000000000000000ull +#define MINION_CSR_FCSR_EFLAGS_FIELD_MASK 0x0000000080000000ull +#define MINION_CSR_FCSR_EFLAGS_GET(x) (((x) & 0x0000000080000000ull) >> 31) +#define MINION_CSR_FCSR_EFLAGS_SET(x) (((x) << 31) & 0x0000000080000000ull) +#define MINION_CSR_FCSR_EFLAGS_MODIFY(r, x) ((((x) << 31) & 0x0000000080000000ull) | ((r) & 0xFFFFFFFF7FFFFFFFull)) + +/* Register: MINION_CSR.uie */ +#define MINION_CSR_UIE_ADDRESS 0x00000020ul +#define MINION_CSR_UIE_BYTE_ADDRESS 0x00000020ul +#define MINION_CSR_UIE_OFFSET 0x00000020ul +#define MINION_CSR_UIE_BYTE_OFFSET 0x00000020ul +#define MINION_CSR_UIE_SIZE 0x00000008ul +#define MINION_CSR_UIE_BYTE_SIZE 0x00000008ul +#define MINION_CSR_UIE_READ_ACCESS 1u +#define MINION_CSR_UIE_WRITE_ACCESS 0u +#define MINION_CSR_UIE_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_UIE_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_UIE_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_UIE_WRITE_MASK 0x0000000000000000ull + +/* Field: MINION_CSR_UIE.uie */ +#define MINION_CSR_UIE_UIE_MSB 63u +#define MINION_CSR_UIE_UIE_LSB 0u +#define MINION_CSR_UIE_UIE_WIDTH 64u +#define MINION_CSR_UIE_UIE_READ_ACCESS 1u +#define MINION_CSR_UIE_UIE_WRITE_ACCESS 0u +#define MINION_CSR_UIE_UIE_RESET 0x0000000000000000ull +#define MINION_CSR_UIE_UIE_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_UIE_UIE_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_UIE_UIE_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_UIE_UIE_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.utvec */ +#define MINION_CSR_UTVEC_ADDRESS 0x00000028ul +#define MINION_CSR_UTVEC_BYTE_ADDRESS 0x00000028ul +#define MINION_CSR_UTVEC_OFFSET 0x00000028ul +#define MINION_CSR_UTVEC_BYTE_OFFSET 0x00000028ul +#define MINION_CSR_UTVEC_SIZE 0x00000008ul +#define MINION_CSR_UTVEC_BYTE_SIZE 0x00000008ul +#define MINION_CSR_UTVEC_READ_ACCESS 1u +#define MINION_CSR_UTVEC_WRITE_ACCESS 0u +#define MINION_CSR_UTVEC_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_UTVEC_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_UTVEC_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_UTVEC_WRITE_MASK 0x0000000000000000ull + +/* Field: MINION_CSR_UTVEC.utvec */ +#define MINION_CSR_UTVEC_UTVEC_MSB 63u +#define MINION_CSR_UTVEC_UTVEC_LSB 0u +#define MINION_CSR_UTVEC_UTVEC_WIDTH 64u +#define MINION_CSR_UTVEC_UTVEC_READ_ACCESS 1u +#define MINION_CSR_UTVEC_UTVEC_WRITE_ACCESS 0u +#define MINION_CSR_UTVEC_UTVEC_RESET 0x0000000000000000ull +#define MINION_CSR_UTVEC_UTVEC_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_UTVEC_UTVEC_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_UTVEC_UTVEC_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_UTVEC_UTVEC_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.uscratch */ +#define MINION_CSR_USCRATCH_ADDRESS 0x00000200ul +#define MINION_CSR_USCRATCH_BYTE_ADDRESS 0x00000200ul +#define MINION_CSR_USCRATCH_OFFSET 0x00000200ul +#define MINION_CSR_USCRATCH_BYTE_OFFSET 0x00000200ul +#define MINION_CSR_USCRATCH_SIZE 0x00000008ul +#define MINION_CSR_USCRATCH_BYTE_SIZE 0x00000008ul +#define MINION_CSR_USCRATCH_READ_ACCESS 1u +#define MINION_CSR_USCRATCH_WRITE_ACCESS 0u +#define MINION_CSR_USCRATCH_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_USCRATCH_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_USCRATCH_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_USCRATCH_WRITE_MASK 0x0000000000000000ull + +/* Field: MINION_CSR_USCRATCH.uscratch */ +#define MINION_CSR_USCRATCH_USCRATCH_MSB 63u +#define MINION_CSR_USCRATCH_USCRATCH_LSB 0u +#define MINION_CSR_USCRATCH_USCRATCH_WIDTH 64u +#define MINION_CSR_USCRATCH_USCRATCH_READ_ACCESS 1u +#define MINION_CSR_USCRATCH_USCRATCH_WRITE_ACCESS 0u +#define MINION_CSR_USCRATCH_USCRATCH_RESET 0x0000000000000000ull +#define MINION_CSR_USCRATCH_USCRATCH_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_USCRATCH_USCRATCH_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_USCRATCH_USCRATCH_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_USCRATCH_USCRATCH_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.uepc */ +#define MINION_CSR_UEPC_ADDRESS 0x00000208ul +#define MINION_CSR_UEPC_BYTE_ADDRESS 0x00000208ul +#define MINION_CSR_UEPC_OFFSET 0x00000208ul +#define MINION_CSR_UEPC_BYTE_OFFSET 0x00000208ul +#define MINION_CSR_UEPC_SIZE 0x00000008ul +#define MINION_CSR_UEPC_BYTE_SIZE 0x00000008ul +#define MINION_CSR_UEPC_READ_ACCESS 1u +#define MINION_CSR_UEPC_WRITE_ACCESS 0u +#define MINION_CSR_UEPC_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_UEPC_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_UEPC_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_UEPC_WRITE_MASK 0x0000000000000000ull + +/* Field: MINION_CSR_UEPC.uepc */ +#define MINION_CSR_UEPC_UEPC_MSB 63u +#define MINION_CSR_UEPC_UEPC_LSB 0u +#define MINION_CSR_UEPC_UEPC_WIDTH 64u +#define MINION_CSR_UEPC_UEPC_READ_ACCESS 1u +#define MINION_CSR_UEPC_UEPC_WRITE_ACCESS 0u +#define MINION_CSR_UEPC_UEPC_RESET 0x0000000000000000ull +#define MINION_CSR_UEPC_UEPC_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_UEPC_UEPC_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_UEPC_UEPC_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_UEPC_UEPC_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.ucause */ +#define MINION_CSR_UCAUSE_ADDRESS 0x00000210ul +#define MINION_CSR_UCAUSE_BYTE_ADDRESS 0x00000210ul +#define MINION_CSR_UCAUSE_OFFSET 0x00000210ul +#define MINION_CSR_UCAUSE_BYTE_OFFSET 0x00000210ul +#define MINION_CSR_UCAUSE_SIZE 0x00000008ul +#define MINION_CSR_UCAUSE_BYTE_SIZE 0x00000008ul +#define MINION_CSR_UCAUSE_READ_ACCESS 1u +#define MINION_CSR_UCAUSE_WRITE_ACCESS 0u +#define MINION_CSR_UCAUSE_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_UCAUSE_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_UCAUSE_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_UCAUSE_WRITE_MASK 0x0000000000000000ull + +/* Field: MINION_CSR_UCAUSE.ucause */ +#define MINION_CSR_UCAUSE_UCAUSE_MSB 63u +#define MINION_CSR_UCAUSE_UCAUSE_LSB 0u +#define MINION_CSR_UCAUSE_UCAUSE_WIDTH 64u +#define MINION_CSR_UCAUSE_UCAUSE_READ_ACCESS 1u +#define MINION_CSR_UCAUSE_UCAUSE_WRITE_ACCESS 0u +#define MINION_CSR_UCAUSE_UCAUSE_RESET 0x0000000000000000ull +#define MINION_CSR_UCAUSE_UCAUSE_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_UCAUSE_UCAUSE_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_UCAUSE_UCAUSE_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_UCAUSE_UCAUSE_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.utval */ +#define MINION_CSR_UTVAL_ADDRESS 0x00000218ul +#define MINION_CSR_UTVAL_BYTE_ADDRESS 0x00000218ul +#define MINION_CSR_UTVAL_OFFSET 0x00000218ul +#define MINION_CSR_UTVAL_BYTE_OFFSET 0x00000218ul +#define MINION_CSR_UTVAL_SIZE 0x00000008ul +#define MINION_CSR_UTVAL_BYTE_SIZE 0x00000008ul +#define MINION_CSR_UTVAL_READ_ACCESS 1u +#define MINION_CSR_UTVAL_WRITE_ACCESS 0u +#define MINION_CSR_UTVAL_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_UTVAL_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_UTVAL_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_UTVAL_WRITE_MASK 0x0000000000000000ull + +/* Field: MINION_CSR_UTVAL.utval */ +#define MINION_CSR_UTVAL_UTVAL_MSB 63u +#define MINION_CSR_UTVAL_UTVAL_LSB 0u +#define MINION_CSR_UTVAL_UTVAL_WIDTH 64u +#define MINION_CSR_UTVAL_UTVAL_READ_ACCESS 1u +#define MINION_CSR_UTVAL_UTVAL_WRITE_ACCESS 0u +#define MINION_CSR_UTVAL_UTVAL_RESET 0x0000000000000000ull +#define MINION_CSR_UTVAL_UTVAL_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_UTVAL_UTVAL_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_UTVAL_UTVAL_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_UTVAL_UTVAL_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.uip */ +#define MINION_CSR_UIP_ADDRESS 0x00000220ul +#define MINION_CSR_UIP_BYTE_ADDRESS 0x00000220ul +#define MINION_CSR_UIP_OFFSET 0x00000220ul +#define MINION_CSR_UIP_BYTE_OFFSET 0x00000220ul +#define MINION_CSR_UIP_SIZE 0x00000008ul +#define MINION_CSR_UIP_BYTE_SIZE 0x00000008ul +#define MINION_CSR_UIP_READ_ACCESS 1u +#define MINION_CSR_UIP_WRITE_ACCESS 0u +#define MINION_CSR_UIP_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_UIP_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_UIP_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_UIP_WRITE_MASK 0x0000000000000000ull + +/* Field: MINION_CSR_UIP.uip */ +#define MINION_CSR_UIP_UIP_MSB 63u +#define MINION_CSR_UIP_UIP_LSB 0u +#define MINION_CSR_UIP_UIP_WIDTH 64u +#define MINION_CSR_UIP_UIP_READ_ACCESS 1u +#define MINION_CSR_UIP_UIP_WRITE_ACCESS 0u +#define MINION_CSR_UIP_UIP_RESET 0x0000000000000000ull +#define MINION_CSR_UIP_UIP_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_UIP_UIP_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_UIP_UIP_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_UIP_UIP_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.sstatus */ +#define MINION_CSR_SSTATUS_ADDRESS 0x00000800ul +#define MINION_CSR_SSTATUS_BYTE_ADDRESS 0x00000800ul +#define MINION_CSR_SSTATUS_OFFSET 0x00000800ul +#define MINION_CSR_SSTATUS_BYTE_OFFSET 0x00000800ul +#define MINION_CSR_SSTATUS_SIZE 0x00000008ul +#define MINION_CSR_SSTATUS_BYTE_SIZE 0x00000008ul +#define MINION_CSR_SSTATUS_READ_ACCESS 1u +#define MINION_CSR_SSTATUS_WRITE_ACCESS 1u +#define MINION_CSR_SSTATUS_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_SSTATUS_RESET_MASK 0x80000003000DE122ull +#define MINION_CSR_SSTATUS_READ_MASK 0x80000003000DE122ull +#define MINION_CSR_SSTATUS_WRITE_MASK 0x800000030009E122ull + +/* Field: MINION_CSR_SSTATUS.sie */ +#define MINION_CSR_SSTATUS_SIE_MSB 1u +#define MINION_CSR_SSTATUS_SIE_LSB 1u +#define MINION_CSR_SSTATUS_SIE_WIDTH 1u +#define MINION_CSR_SSTATUS_SIE_READ_ACCESS 1u +#define MINION_CSR_SSTATUS_SIE_WRITE_ACCESS 1u +#define MINION_CSR_SSTATUS_SIE_RESET 0x0000000000000000ull +#define MINION_CSR_SSTATUS_SIE_FIELD_MASK 0x0000000000000002ull +#define MINION_CSR_SSTATUS_SIE_GET(x) (((x) & 0x0000000000000002ull) >> 1) +#define MINION_CSR_SSTATUS_SIE_SET(x) (((x) << 1) & 0x0000000000000002ull) +#define MINION_CSR_SSTATUS_SIE_MODIFY(r, x) ((((x) << 1) & 0x0000000000000002ull) | ((r) & 0xFFFFFFFFFFFFFFFDull)) + +/* Field: MINION_CSR_SSTATUS.spie */ +#define MINION_CSR_SSTATUS_SPIE_MSB 5u +#define MINION_CSR_SSTATUS_SPIE_LSB 5u +#define MINION_CSR_SSTATUS_SPIE_WIDTH 1u +#define MINION_CSR_SSTATUS_SPIE_READ_ACCESS 1u +#define MINION_CSR_SSTATUS_SPIE_WRITE_ACCESS 1u +#define MINION_CSR_SSTATUS_SPIE_RESET 0x0000000000000000ull +#define MINION_CSR_SSTATUS_SPIE_FIELD_MASK 0x0000000000000020ull +#define MINION_CSR_SSTATUS_SPIE_GET(x) (((x) & 0x0000000000000020ull) >> 5) +#define MINION_CSR_SSTATUS_SPIE_SET(x) (((x) << 5) & 0x0000000000000020ull) +#define MINION_CSR_SSTATUS_SPIE_MODIFY(r, x) ((((x) << 5) & 0x0000000000000020ull) | ((r) & 0xFFFFFFFFFFFFFFDFull)) + +/* Field: MINION_CSR_SSTATUS.spp */ +#define MINION_CSR_SSTATUS_SPP_MSB 8u +#define MINION_CSR_SSTATUS_SPP_LSB 8u +#define MINION_CSR_SSTATUS_SPP_WIDTH 1u +#define MINION_CSR_SSTATUS_SPP_READ_ACCESS 1u +#define MINION_CSR_SSTATUS_SPP_WRITE_ACCESS 1u +#define MINION_CSR_SSTATUS_SPP_RESET 0x0000000000000000ull +#define MINION_CSR_SSTATUS_SPP_FIELD_MASK 0x0000000000000100ull +#define MINION_CSR_SSTATUS_SPP_GET(x) (((x) & 0x0000000000000100ull) >> 8) +#define MINION_CSR_SSTATUS_SPP_SET(x) (((x) << 8) & 0x0000000000000100ull) +#define MINION_CSR_SSTATUS_SPP_MODIFY(r, x) ((((x) << 8) & 0x0000000000000100ull) | ((r) & 0xFFFFFFFFFFFFFEFFull)) + +/* Field: MINION_CSR_SSTATUS.fs */ +#define MINION_CSR_SSTATUS_FS_MSB 14u +#define MINION_CSR_SSTATUS_FS_LSB 13u +#define MINION_CSR_SSTATUS_FS_WIDTH 2u +#define MINION_CSR_SSTATUS_FS_READ_ACCESS 1u +#define MINION_CSR_SSTATUS_FS_WRITE_ACCESS 1u +#define MINION_CSR_SSTATUS_FS_RESET 0x0000000000000000ull +#define MINION_CSR_SSTATUS_FS_FIELD_MASK 0x0000000000006000ull +#define MINION_CSR_SSTATUS_FS_GET(x) (((x) & 0x0000000000006000ull) >> 13) +#define MINION_CSR_SSTATUS_FS_SET(x) (((x) << 13) & 0x0000000000006000ull) +#define MINION_CSR_SSTATUS_FS_MODIFY(r, x) ((((x) << 13) & 0x0000000000006000ull) | ((r) & 0xFFFFFFFFFFFF9FFFull)) + +/* Field: MINION_CSR_SSTATUS.xs */ +#define MINION_CSR_SSTATUS_XS_MSB 16u +#define MINION_CSR_SSTATUS_XS_LSB 15u +#define MINION_CSR_SSTATUS_XS_WIDTH 2u +#define MINION_CSR_SSTATUS_XS_READ_ACCESS 1u +#define MINION_CSR_SSTATUS_XS_WRITE_ACCESS 1u +#define MINION_CSR_SSTATUS_XS_RESET 0x0000000000000000ull +#define MINION_CSR_SSTATUS_XS_FIELD_MASK 0x0000000000018000ull +#define MINION_CSR_SSTATUS_XS_GET(x) (((x) & 0x0000000000018000ull) >> 15) +#define MINION_CSR_SSTATUS_XS_SET(x) (((x) << 15) & 0x0000000000018000ull) +#define MINION_CSR_SSTATUS_XS_MODIFY(r, x) ((((x) << 15) & 0x0000000000018000ull) | ((r) & 0xFFFFFFFFFFFE7FFFull)) + +/* Field: MINION_CSR_SSTATUS.sum */ +#define MINION_CSR_SSTATUS_SUM_MSB 18u +#define MINION_CSR_SSTATUS_SUM_LSB 18u +#define MINION_CSR_SSTATUS_SUM_WIDTH 1u +#define MINION_CSR_SSTATUS_SUM_READ_ACCESS 1u +#define MINION_CSR_SSTATUS_SUM_WRITE_ACCESS 0u +#define MINION_CSR_SSTATUS_SUM_RESET 0x0000000000000000ull +#define MINION_CSR_SSTATUS_SUM_FIELD_MASK 0x0000000000040000ull +#define MINION_CSR_SSTATUS_SUM_GET(x) (((x) & 0x0000000000040000ull) >> 18) +#define MINION_CSR_SSTATUS_SUM_SET(x) (((x) << 18) & 0x0000000000040000ull) +#define MINION_CSR_SSTATUS_SUM_MODIFY(r, x) ((((x) << 18) & 0x0000000000040000ull) | ((r) & 0xFFFFFFFFFFFBFFFFull)) + +/* Field: MINION_CSR_SSTATUS.mxr */ +#define MINION_CSR_SSTATUS_MXR_MSB 19u +#define MINION_CSR_SSTATUS_MXR_LSB 19u +#define MINION_CSR_SSTATUS_MXR_WIDTH 1u +#define MINION_CSR_SSTATUS_MXR_READ_ACCESS 1u +#define MINION_CSR_SSTATUS_MXR_WRITE_ACCESS 1u +#define MINION_CSR_SSTATUS_MXR_RESET 0x0000000000000000ull +#define MINION_CSR_SSTATUS_MXR_FIELD_MASK 0x0000000000080000ull +#define MINION_CSR_SSTATUS_MXR_GET(x) (((x) & 0x0000000000080000ull) >> 19) +#define MINION_CSR_SSTATUS_MXR_SET(x) (((x) << 19) & 0x0000000000080000ull) +#define MINION_CSR_SSTATUS_MXR_MODIFY(r, x) ((((x) << 19) & 0x0000000000080000ull) | ((r) & 0xFFFFFFFFFFF7FFFFull)) + +/* Field: MINION_CSR_SSTATUS.uxl */ +#define MINION_CSR_SSTATUS_UXL_MSB 33u +#define MINION_CSR_SSTATUS_UXL_LSB 32u +#define MINION_CSR_SSTATUS_UXL_WIDTH 2u +#define MINION_CSR_SSTATUS_UXL_READ_ACCESS 1u +#define MINION_CSR_SSTATUS_UXL_WRITE_ACCESS 1u +#define MINION_CSR_SSTATUS_UXL_RESET 0x0000000000000000ull +#define MINION_CSR_SSTATUS_UXL_FIELD_MASK 0x0000000300000000ull +#define MINION_CSR_SSTATUS_UXL_GET(x) (((x) & 0x0000000300000000ull) >> 32) +#define MINION_CSR_SSTATUS_UXL_SET(x) (((x) << 32) & 0x0000000300000000ull) +#define MINION_CSR_SSTATUS_UXL_MODIFY(r, x) ((((x) << 32) & 0x0000000300000000ull) | ((r) & 0xFFFFFFFCFFFFFFFFull)) + +/* Field: MINION_CSR_SSTATUS.sd */ +#define MINION_CSR_SSTATUS_SD_MSB 63u +#define MINION_CSR_SSTATUS_SD_LSB 63u +#define MINION_CSR_SSTATUS_SD_WIDTH 1u +#define MINION_CSR_SSTATUS_SD_READ_ACCESS 1u +#define MINION_CSR_SSTATUS_SD_WRITE_ACCESS 1u +#define MINION_CSR_SSTATUS_SD_RESET 0x0000000000000000ull +#define MINION_CSR_SSTATUS_SD_FIELD_MASK 0x8000000000000000ull +#define MINION_CSR_SSTATUS_SD_GET(x) (((x) & 0x8000000000000000ull) >> 63) +#define MINION_CSR_SSTATUS_SD_SET(x) (((x) << 63) & 0x8000000000000000ull) +#define MINION_CSR_SSTATUS_SD_MODIFY(r, x) ((((x) << 63) & 0x8000000000000000ull) | ((r) & 0x7FFFFFFFFFFFFFFFull)) + +/* Register: MINION_CSR.sedeleg */ +#define MINION_CSR_SEDELEG_ADDRESS 0x00000810ul +#define MINION_CSR_SEDELEG_BYTE_ADDRESS 0x00000810ul +#define MINION_CSR_SEDELEG_OFFSET 0x00000810ul +#define MINION_CSR_SEDELEG_BYTE_OFFSET 0x00000810ul +#define MINION_CSR_SEDELEG_SIZE 0x00000008ul +#define MINION_CSR_SEDELEG_BYTE_SIZE 0x00000008ul +#define MINION_CSR_SEDELEG_READ_ACCESS 1u +#define MINION_CSR_SEDELEG_WRITE_ACCESS 1u +#define MINION_CSR_SEDELEG_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_SEDELEG_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_SEDELEG_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_SEDELEG_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_SEDELEG.sedeleg */ +#define MINION_CSR_SEDELEG_SEDELEG_MSB 63u +#define MINION_CSR_SEDELEG_SEDELEG_LSB 0u +#define MINION_CSR_SEDELEG_SEDELEG_WIDTH 64u +#define MINION_CSR_SEDELEG_SEDELEG_READ_ACCESS 1u +#define MINION_CSR_SEDELEG_SEDELEG_WRITE_ACCESS 1u +#define MINION_CSR_SEDELEG_SEDELEG_RESET 0x0000000000000000ull +#define MINION_CSR_SEDELEG_SEDELEG_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_SEDELEG_SEDELEG_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_SEDELEG_SEDELEG_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_SEDELEG_SEDELEG_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.sideleg */ +#define MINION_CSR_SIDELEG_ADDRESS 0x00000818ul +#define MINION_CSR_SIDELEG_BYTE_ADDRESS 0x00000818ul +#define MINION_CSR_SIDELEG_OFFSET 0x00000818ul +#define MINION_CSR_SIDELEG_BYTE_OFFSET 0x00000818ul +#define MINION_CSR_SIDELEG_SIZE 0x00000008ul +#define MINION_CSR_SIDELEG_BYTE_SIZE 0x00000008ul +#define MINION_CSR_SIDELEG_READ_ACCESS 1u +#define MINION_CSR_SIDELEG_WRITE_ACCESS 1u +#define MINION_CSR_SIDELEG_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_SIDELEG_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_SIDELEG_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_SIDELEG_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_SIDELEG.sideleg */ +#define MINION_CSR_SIDELEG_SIDELEG_MSB 63u +#define MINION_CSR_SIDELEG_SIDELEG_LSB 0u +#define MINION_CSR_SIDELEG_SIDELEG_WIDTH 64u +#define MINION_CSR_SIDELEG_SIDELEG_READ_ACCESS 1u +#define MINION_CSR_SIDELEG_SIDELEG_WRITE_ACCESS 1u +#define MINION_CSR_SIDELEG_SIDELEG_RESET 0x0000000000000000ull +#define MINION_CSR_SIDELEG_SIDELEG_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_SIDELEG_SIDELEG_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_SIDELEG_SIDELEG_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_SIDELEG_SIDELEG_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.sie */ +#define MINION_CSR_SIE_ADDRESS 0x00000820ul +#define MINION_CSR_SIE_BYTE_ADDRESS 0x00000820ul +#define MINION_CSR_SIE_OFFSET 0x00000820ul +#define MINION_CSR_SIE_BYTE_OFFSET 0x00000820ul +#define MINION_CSR_SIE_SIZE 0x00000008ul +#define MINION_CSR_SIE_BYTE_SIZE 0x00000008ul +#define MINION_CSR_SIE_READ_ACCESS 1u +#define MINION_CSR_SIE_WRITE_ACCESS 1u +#define MINION_CSR_SIE_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_SIE_RESET_MASK 0x0000000000000222ull +#define MINION_CSR_SIE_READ_MASK 0x0000000000000222ull +#define MINION_CSR_SIE_WRITE_MASK 0x0000000000000222ull + +/* Field: MINION_CSR_SIE.ssie */ +#define MINION_CSR_SIE_SSIE_MSB 1u +#define MINION_CSR_SIE_SSIE_LSB 1u +#define MINION_CSR_SIE_SSIE_WIDTH 1u +#define MINION_CSR_SIE_SSIE_READ_ACCESS 1u +#define MINION_CSR_SIE_SSIE_WRITE_ACCESS 1u +#define MINION_CSR_SIE_SSIE_RESET 0x0000000000000000ull +#define MINION_CSR_SIE_SSIE_FIELD_MASK 0x0000000000000002ull +#define MINION_CSR_SIE_SSIE_GET(x) (((x) & 0x0000000000000002ull) >> 1) +#define MINION_CSR_SIE_SSIE_SET(x) (((x) << 1) & 0x0000000000000002ull) +#define MINION_CSR_SIE_SSIE_MODIFY(r, x) ((((x) << 1) & 0x0000000000000002ull) | ((r) & 0xFFFFFFFFFFFFFFFDull)) + +/* Field: MINION_CSR_SIE.stie */ +#define MINION_CSR_SIE_STIE_MSB 5u +#define MINION_CSR_SIE_STIE_LSB 5u +#define MINION_CSR_SIE_STIE_WIDTH 1u +#define MINION_CSR_SIE_STIE_READ_ACCESS 1u +#define MINION_CSR_SIE_STIE_WRITE_ACCESS 1u +#define MINION_CSR_SIE_STIE_RESET 0x0000000000000000ull +#define MINION_CSR_SIE_STIE_FIELD_MASK 0x0000000000000020ull +#define MINION_CSR_SIE_STIE_GET(x) (((x) & 0x0000000000000020ull) >> 5) +#define MINION_CSR_SIE_STIE_SET(x) (((x) << 5) & 0x0000000000000020ull) +#define MINION_CSR_SIE_STIE_MODIFY(r, x) ((((x) << 5) & 0x0000000000000020ull) | ((r) & 0xFFFFFFFFFFFFFFDFull)) + +/* Field: MINION_CSR_SIE.seie */ +#define MINION_CSR_SIE_SEIE_MSB 9u +#define MINION_CSR_SIE_SEIE_LSB 9u +#define MINION_CSR_SIE_SEIE_WIDTH 1u +#define MINION_CSR_SIE_SEIE_READ_ACCESS 1u +#define MINION_CSR_SIE_SEIE_WRITE_ACCESS 1u +#define MINION_CSR_SIE_SEIE_RESET 0x0000000000000000ull +#define MINION_CSR_SIE_SEIE_FIELD_MASK 0x0000000000000200ull +#define MINION_CSR_SIE_SEIE_GET(x) (((x) & 0x0000000000000200ull) >> 9) +#define MINION_CSR_SIE_SEIE_SET(x) (((x) << 9) & 0x0000000000000200ull) +#define MINION_CSR_SIE_SEIE_MODIFY(r, x) ((((x) << 9) & 0x0000000000000200ull) | ((r) & 0xFFFFFFFFFFFFFDFFull)) + +/* Register: MINION_CSR.stvec */ +#define MINION_CSR_STVEC_ADDRESS 0x00000828ul +#define MINION_CSR_STVEC_BYTE_ADDRESS 0x00000828ul +#define MINION_CSR_STVEC_OFFSET 0x00000828ul +#define MINION_CSR_STVEC_BYTE_OFFSET 0x00000828ul +#define MINION_CSR_STVEC_SIZE 0x00000008ul +#define MINION_CSR_STVEC_BYTE_SIZE 0x00000008ul +#define MINION_CSR_STVEC_READ_ACCESS 1u +#define MINION_CSR_STVEC_WRITE_ACCESS 1u +#define MINION_CSR_STVEC_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_STVEC_RESET_MASK 0x0000FFFFFFFFFFFDull +#define MINION_CSR_STVEC_READ_MASK 0x0000FFFFFFFFFFFDull +#define MINION_CSR_STVEC_WRITE_MASK 0x0000FFFFFFFFFFFDull + +/* Field: MINION_CSR_STVEC.mode */ +#define MINION_CSR_STVEC_MODE_MSB 0u +#define MINION_CSR_STVEC_MODE_LSB 0u +#define MINION_CSR_STVEC_MODE_WIDTH 1u +#define MINION_CSR_STVEC_MODE_READ_ACCESS 1u +#define MINION_CSR_STVEC_MODE_WRITE_ACCESS 1u +#define MINION_CSR_STVEC_MODE_RESET 0x0000000000000000ull +#define MINION_CSR_STVEC_MODE_FIELD_MASK 0x0000000000000001ull +#define MINION_CSR_STVEC_MODE_GET(x) ((x) & 0x0000000000000001ull) +#define MINION_CSR_STVEC_MODE_SET(x) ((x) & 0x0000000000000001ull) +#define MINION_CSR_STVEC_MODE_MODIFY(r, x) ((((x) << 0) & 0x0000000000000001ull) | ((r) & 0xFFFFFFFFFFFFFFFEull)) + +/* Field: MINION_CSR_STVEC.base */ +#define MINION_CSR_STVEC_BASE_MSB 47u +#define MINION_CSR_STVEC_BASE_LSB 2u +#define MINION_CSR_STVEC_BASE_WIDTH 46u +#define MINION_CSR_STVEC_BASE_READ_ACCESS 1u +#define MINION_CSR_STVEC_BASE_WRITE_ACCESS 1u +#define MINION_CSR_STVEC_BASE_RESET 0x0000000000000000ull +#define MINION_CSR_STVEC_BASE_FIELD_MASK 0x0000FFFFFFFFFFFCull +#define MINION_CSR_STVEC_BASE_GET(x) (((x) & 0x0000FFFFFFFFFFFCull) >> 2) +#define MINION_CSR_STVEC_BASE_SET(x) (((x) << 2) & 0x0000FFFFFFFFFFFCull) +#define MINION_CSR_STVEC_BASE_MODIFY(r, x) ((((x) << 2) & 0x0000FFFFFFFFFFFCull) | ((r) & 0xFFFF000000000003ull)) + +/* Register: MINION_CSR.scounteren */ +#define MINION_CSR_SCOUNTEREN_ADDRESS 0x00000830ul +#define MINION_CSR_SCOUNTEREN_BYTE_ADDRESS 0x00000830ul +#define MINION_CSR_SCOUNTEREN_OFFSET 0x00000830ul +#define MINION_CSR_SCOUNTEREN_BYTE_OFFSET 0x00000830ul +#define MINION_CSR_SCOUNTEREN_SIZE 0x00000008ul +#define MINION_CSR_SCOUNTEREN_BYTE_SIZE 0x00000008ul +#define MINION_CSR_SCOUNTEREN_READ_ACCESS 1u +#define MINION_CSR_SCOUNTEREN_WRITE_ACCESS 1u +#define MINION_CSR_SCOUNTEREN_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_SCOUNTEREN_RESET_MASK 0x00000000000001FFull +#define MINION_CSR_SCOUNTEREN_READ_MASK 0x00000000000001FFull +#define MINION_CSR_SCOUNTEREN_WRITE_MASK 0x00000000000001FFull + +/* Field: MINION_CSR_SCOUNTEREN.scounteren */ +#define MINION_CSR_SCOUNTEREN_SCOUNTEREN_MSB 8u +#define MINION_CSR_SCOUNTEREN_SCOUNTEREN_LSB 0u +#define MINION_CSR_SCOUNTEREN_SCOUNTEREN_WIDTH 9u +#define MINION_CSR_SCOUNTEREN_SCOUNTEREN_READ_ACCESS 1u +#define MINION_CSR_SCOUNTEREN_SCOUNTEREN_WRITE_ACCESS 1u +#define MINION_CSR_SCOUNTEREN_SCOUNTEREN_RESET 0x0000000000000000ull +#define MINION_CSR_SCOUNTEREN_SCOUNTEREN_FIELD_MASK 0x00000000000001FFull +#define MINION_CSR_SCOUNTEREN_SCOUNTEREN_GET(x) ((x) & 0x00000000000001FFull) +#define MINION_CSR_SCOUNTEREN_SCOUNTEREN_SET(x) ((x) & 0x00000000000001FFull) +#define MINION_CSR_SCOUNTEREN_SCOUNTEREN_MODIFY(r, x) ((((x) << 0) & 0x00000000000001FFull) | ((r) & 0xFFFFFFFFFFFFFE00ull)) + +/* Register: MINION_CSR.sscratch */ +#define MINION_CSR_SSCRATCH_ADDRESS 0x00000A00ul +#define MINION_CSR_SSCRATCH_BYTE_ADDRESS 0x00000A00ul +#define MINION_CSR_SSCRATCH_OFFSET 0x00000A00ul +#define MINION_CSR_SSCRATCH_BYTE_OFFSET 0x00000A00ul +#define MINION_CSR_SSCRATCH_SIZE 0x00000008ul +#define MINION_CSR_SSCRATCH_BYTE_SIZE 0x00000008ul +#define MINION_CSR_SSCRATCH_READ_ACCESS 1u +#define MINION_CSR_SSCRATCH_WRITE_ACCESS 1u +#define MINION_CSR_SSCRATCH_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_SSCRATCH_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_SSCRATCH_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_SSCRATCH_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_SSCRATCH.sscratch */ +#define MINION_CSR_SSCRATCH_SSCRATCH_MSB 63u +#define MINION_CSR_SSCRATCH_SSCRATCH_LSB 0u +#define MINION_CSR_SSCRATCH_SSCRATCH_WIDTH 64u +#define MINION_CSR_SSCRATCH_SSCRATCH_READ_ACCESS 1u +#define MINION_CSR_SSCRATCH_SSCRATCH_WRITE_ACCESS 1u +#define MINION_CSR_SSCRATCH_SSCRATCH_RESET 0x0000000000000000ull +#define MINION_CSR_SSCRATCH_SSCRATCH_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_SSCRATCH_SSCRATCH_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_SSCRATCH_SSCRATCH_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_SSCRATCH_SSCRATCH_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.sepc */ +#define MINION_CSR_SEPC_ADDRESS 0x00000A08ul +#define MINION_CSR_SEPC_BYTE_ADDRESS 0x00000A08ul +#define MINION_CSR_SEPC_OFFSET 0x00000A08ul +#define MINION_CSR_SEPC_BYTE_OFFSET 0x00000A08ul +#define MINION_CSR_SEPC_SIZE 0x00000008ul +#define MINION_CSR_SEPC_BYTE_SIZE 0x00000008ul +#define MINION_CSR_SEPC_READ_ACCESS 1u +#define MINION_CSR_SEPC_WRITE_ACCESS 1u +#define MINION_CSR_SEPC_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_SEPC_RESET_MASK 0x0001FFFFFFFFFFFEull +#define MINION_CSR_SEPC_READ_MASK 0x0001FFFFFFFFFFFEull +#define MINION_CSR_SEPC_WRITE_MASK 0x0001FFFFFFFFFFFEull + +/* Field: MINION_CSR_SEPC.base */ +#define MINION_CSR_SEPC_BASE_MSB 47u +#define MINION_CSR_SEPC_BASE_LSB 1u +#define MINION_CSR_SEPC_BASE_WIDTH 47u +#define MINION_CSR_SEPC_BASE_READ_ACCESS 1u +#define MINION_CSR_SEPC_BASE_WRITE_ACCESS 1u +#define MINION_CSR_SEPC_BASE_RESET 0x0000000000000000ull +#define MINION_CSR_SEPC_BASE_FIELD_MASK 0x0000FFFFFFFFFFFEull +#define MINION_CSR_SEPC_BASE_GET(x) (((x) & 0x0000FFFFFFFFFFFEull) >> 1) +#define MINION_CSR_SEPC_BASE_SET(x) (((x) << 1) & 0x0000FFFFFFFFFFFEull) +#define MINION_CSR_SEPC_BASE_MODIFY(r, x) ((((x) << 1) & 0x0000FFFFFFFFFFFEull) | ((r) & 0xFFFF000000000001ull)) + +/* Field: MINION_CSR_SEPC.sign_ext */ +#define MINION_CSR_SEPC_SIGN_EXT_MSB 48u +#define MINION_CSR_SEPC_SIGN_EXT_LSB 48u +#define MINION_CSR_SEPC_SIGN_EXT_WIDTH 1u +#define MINION_CSR_SEPC_SIGN_EXT_READ_ACCESS 1u +#define MINION_CSR_SEPC_SIGN_EXT_WRITE_ACCESS 1u +#define MINION_CSR_SEPC_SIGN_EXT_RESET 0x0000000000000000ull +#define MINION_CSR_SEPC_SIGN_EXT_FIELD_MASK 0x0001000000000000ull +#define MINION_CSR_SEPC_SIGN_EXT_GET(x) (((x) & 0x0001000000000000ull) >> 48) +#define MINION_CSR_SEPC_SIGN_EXT_SET(x) (((x) << 48) & 0x0001000000000000ull) +#define MINION_CSR_SEPC_SIGN_EXT_MODIFY(r, x) ((((x) << 48) & 0x0001000000000000ull) | ((r) & 0xFFFEFFFFFFFFFFFFull)) + +/* Register: MINION_CSR.scause */ +#define MINION_CSR_SCAUSE_ADDRESS 0x00000A10ul +#define MINION_CSR_SCAUSE_BYTE_ADDRESS 0x00000A10ul +#define MINION_CSR_SCAUSE_OFFSET 0x00000A10ul +#define MINION_CSR_SCAUSE_BYTE_OFFSET 0x00000A10ul +#define MINION_CSR_SCAUSE_SIZE 0x00000008ul +#define MINION_CSR_SCAUSE_BYTE_SIZE 0x00000008ul +#define MINION_CSR_SCAUSE_READ_ACCESS 1u +#define MINION_CSR_SCAUSE_WRITE_ACCESS 1u +#define MINION_CSR_SCAUSE_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_SCAUSE_RESET_MASK 0x800000000000001Full +#define MINION_CSR_SCAUSE_READ_MASK 0x800000000000001Full +#define MINION_CSR_SCAUSE_WRITE_MASK 0x800000000000001Full + +/* Field: MINION_CSR_SCAUSE.cause */ +#define MINION_CSR_SCAUSE_CAUSE_MSB 4u +#define MINION_CSR_SCAUSE_CAUSE_LSB 0u +#define MINION_CSR_SCAUSE_CAUSE_WIDTH 5u +#define MINION_CSR_SCAUSE_CAUSE_READ_ACCESS 1u +#define MINION_CSR_SCAUSE_CAUSE_WRITE_ACCESS 1u +#define MINION_CSR_SCAUSE_CAUSE_RESET 0x0000000000000000ull +#define MINION_CSR_SCAUSE_CAUSE_FIELD_MASK 0x000000000000001Full +#define MINION_CSR_SCAUSE_CAUSE_GET(x) ((x) & 0x000000000000001Full) +#define MINION_CSR_SCAUSE_CAUSE_SET(x) ((x) & 0x000000000000001Full) +#define MINION_CSR_SCAUSE_CAUSE_MODIFY(r, x) ((((x) << 0) & 0x000000000000001Full) | ((r) & 0xFFFFFFFFFFFFFFE0ull)) + +/* Field: MINION_CSR_SCAUSE.interrupt_x */ +#define MINION_CSR_SCAUSE_INTERRUPT_X_MSB 63u +#define MINION_CSR_SCAUSE_INTERRUPT_X_LSB 63u +#define MINION_CSR_SCAUSE_INTERRUPT_X_WIDTH 1u +#define MINION_CSR_SCAUSE_INTERRUPT_X_READ_ACCESS 1u +#define MINION_CSR_SCAUSE_INTERRUPT_X_WRITE_ACCESS 1u +#define MINION_CSR_SCAUSE_INTERRUPT_X_RESET 0x0000000000000000ull +#define MINION_CSR_SCAUSE_INTERRUPT_X_FIELD_MASK 0x8000000000000000ull +#define MINION_CSR_SCAUSE_INTERRUPT_X_GET(x) (((x) & 0x8000000000000000ull) >> 63) +#define MINION_CSR_SCAUSE_INTERRUPT_X_SET(x) (((x) << 63) & 0x8000000000000000ull) +#define MINION_CSR_SCAUSE_INTERRUPT_X_MODIFY(r, x) ((((x) << 63) & 0x8000000000000000ull) | ((r) & 0x7FFFFFFFFFFFFFFFull)) + +/* Register: MINION_CSR.stval */ +#define MINION_CSR_STVAL_ADDRESS 0x00000A18ul +#define MINION_CSR_STVAL_BYTE_ADDRESS 0x00000A18ul +#define MINION_CSR_STVAL_OFFSET 0x00000A18ul +#define MINION_CSR_STVAL_BYTE_OFFSET 0x00000A18ul +#define MINION_CSR_STVAL_SIZE 0x00000008ul +#define MINION_CSR_STVAL_BYTE_SIZE 0x00000008ul +#define MINION_CSR_STVAL_READ_ACCESS 1u +#define MINION_CSR_STVAL_WRITE_ACCESS 1u +#define MINION_CSR_STVAL_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_STVAL_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_STVAL_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_STVAL_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_STVAL.stval */ +#define MINION_CSR_STVAL_STVAL_MSB 63u +#define MINION_CSR_STVAL_STVAL_LSB 0u +#define MINION_CSR_STVAL_STVAL_WIDTH 64u +#define MINION_CSR_STVAL_STVAL_READ_ACCESS 1u +#define MINION_CSR_STVAL_STVAL_WRITE_ACCESS 1u +#define MINION_CSR_STVAL_STVAL_RESET 0x0000000000000000ull +#define MINION_CSR_STVAL_STVAL_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_STVAL_STVAL_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_STVAL_STVAL_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_STVAL_STVAL_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.sip */ +#define MINION_CSR_SIP_ADDRESS 0x00000A20ul +#define MINION_CSR_SIP_BYTE_ADDRESS 0x00000A20ul +#define MINION_CSR_SIP_OFFSET 0x00000A20ul +#define MINION_CSR_SIP_BYTE_OFFSET 0x00000A20ul +#define MINION_CSR_SIP_SIZE 0x00000008ul +#define MINION_CSR_SIP_BYTE_SIZE 0x00000008ul +#define MINION_CSR_SIP_READ_ACCESS 1u +#define MINION_CSR_SIP_WRITE_ACCESS 1u +#define MINION_CSR_SIP_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_SIP_RESET_MASK 0x0000000000000222ull +#define MINION_CSR_SIP_READ_MASK 0x0000000000000222ull +#define MINION_CSR_SIP_WRITE_MASK 0x0000000000000222ull + +/* Field: MINION_CSR_SIP.ssip */ +#define MINION_CSR_SIP_SSIP_MSB 1u +#define MINION_CSR_SIP_SSIP_LSB 1u +#define MINION_CSR_SIP_SSIP_WIDTH 1u +#define MINION_CSR_SIP_SSIP_READ_ACCESS 1u +#define MINION_CSR_SIP_SSIP_WRITE_ACCESS 1u +#define MINION_CSR_SIP_SSIP_RESET 0x0000000000000000ull +#define MINION_CSR_SIP_SSIP_FIELD_MASK 0x0000000000000002ull +#define MINION_CSR_SIP_SSIP_GET(x) (((x) & 0x0000000000000002ull) >> 1) +#define MINION_CSR_SIP_SSIP_SET(x) (((x) << 1) & 0x0000000000000002ull) +#define MINION_CSR_SIP_SSIP_MODIFY(r, x) ((((x) << 1) & 0x0000000000000002ull) | ((r) & 0xFFFFFFFFFFFFFFFDull)) + +/* Field: MINION_CSR_SIP.stip */ +#define MINION_CSR_SIP_STIP_MSB 5u +#define MINION_CSR_SIP_STIP_LSB 5u +#define MINION_CSR_SIP_STIP_WIDTH 1u +#define MINION_CSR_SIP_STIP_READ_ACCESS 1u +#define MINION_CSR_SIP_STIP_WRITE_ACCESS 1u +#define MINION_CSR_SIP_STIP_RESET 0x0000000000000000ull +#define MINION_CSR_SIP_STIP_FIELD_MASK 0x0000000000000020ull +#define MINION_CSR_SIP_STIP_GET(x) (((x) & 0x0000000000000020ull) >> 5) +#define MINION_CSR_SIP_STIP_SET(x) (((x) << 5) & 0x0000000000000020ull) +#define MINION_CSR_SIP_STIP_MODIFY(r, x) ((((x) << 5) & 0x0000000000000020ull) | ((r) & 0xFFFFFFFFFFFFFFDFull)) + +/* Field: MINION_CSR_SIP.seip */ +#define MINION_CSR_SIP_SEIP_MSB 9u +#define MINION_CSR_SIP_SEIP_LSB 9u +#define MINION_CSR_SIP_SEIP_WIDTH 1u +#define MINION_CSR_SIP_SEIP_READ_ACCESS 1u +#define MINION_CSR_SIP_SEIP_WRITE_ACCESS 1u +#define MINION_CSR_SIP_SEIP_RESET 0x0000000000000000ull +#define MINION_CSR_SIP_SEIP_FIELD_MASK 0x0000000000000200ull +#define MINION_CSR_SIP_SEIP_GET(x) (((x) & 0x0000000000000200ull) >> 9) +#define MINION_CSR_SIP_SEIP_SET(x) (((x) << 9) & 0x0000000000000200ull) +#define MINION_CSR_SIP_SEIP_MODIFY(r, x) ((((x) << 9) & 0x0000000000000200ull) | ((r) & 0xFFFFFFFFFFFFFDFFull)) + +/* Register: MINION_CSR.satp */ +#define MINION_CSR_SATP_ADDRESS 0x00000C00ul +#define MINION_CSR_SATP_BYTE_ADDRESS 0x00000C00ul +#define MINION_CSR_SATP_OFFSET 0x00000C00ul +#define MINION_CSR_SATP_BYTE_OFFSET 0x00000C00ul +#define MINION_CSR_SATP_SIZE 0x00000008ul +#define MINION_CSR_SATP_BYTE_SIZE 0x00000008ul +#define MINION_CSR_SATP_READ_ACCESS 1u +#define MINION_CSR_SATP_WRITE_ACCESS 0u +#define MINION_CSR_SATP_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_SATP_RESET_MASK 0xF00000000FFFFFFFull +#define MINION_CSR_SATP_READ_MASK 0xF00000000FFFFFFFull +#define MINION_CSR_SATP_WRITE_MASK 0x0000000000000000ull + +/* Field: MINION_CSR_SATP.ppn */ +#define MINION_CSR_SATP_PPN_MSB 27u +#define MINION_CSR_SATP_PPN_LSB 0u +#define MINION_CSR_SATP_PPN_WIDTH 28u +#define MINION_CSR_SATP_PPN_READ_ACCESS 1u +#define MINION_CSR_SATP_PPN_WRITE_ACCESS 0u +#define MINION_CSR_SATP_PPN_RESET 0x0000000000000000ull +#define MINION_CSR_SATP_PPN_FIELD_MASK 0x000000000FFFFFFFull +#define MINION_CSR_SATP_PPN_GET(x) ((x) & 0x000000000FFFFFFFull) +#define MINION_CSR_SATP_PPN_SET(x) ((x) & 0x000000000FFFFFFFull) +#define MINION_CSR_SATP_PPN_MODIFY(r, x) ((((x) << 0) & 0x000000000FFFFFFFull) | ((r) & 0xFFFFFFFFF0000000ull)) + +/* Field: MINION_CSR_SATP.mode */ +#define MINION_CSR_SATP_MODE_MSB 63u +#define MINION_CSR_SATP_MODE_LSB 60u +#define MINION_CSR_SATP_MODE_WIDTH 4u +#define MINION_CSR_SATP_MODE_READ_ACCESS 1u +#define MINION_CSR_SATP_MODE_WRITE_ACCESS 0u +#define MINION_CSR_SATP_MODE_RESET 0x0000000000000000ull +#define MINION_CSR_SATP_MODE_FIELD_MASK 0xF000000000000000ull +#define MINION_CSR_SATP_MODE_GET(x) (((x) & 0xF000000000000000ull) >> 60) +#define MINION_CSR_SATP_MODE_SET(x) (((x) << 60) & 0xF000000000000000ull) +#define MINION_CSR_SATP_MODE_MODIFY(r, x) ((((x) << 60) & 0xF000000000000000ull) | ((r) & 0x0FFFFFFFFFFFFFFFull)) + +/* Register: MINION_CSR.mstatus */ +#define MINION_CSR_MSTATUS_ADDRESS 0x00001800ul +#define MINION_CSR_MSTATUS_BYTE_ADDRESS 0x00001800ul +#define MINION_CSR_MSTATUS_OFFSET 0x00001800ul +#define MINION_CSR_MSTATUS_BYTE_OFFSET 0x00001800ul +#define MINION_CSR_MSTATUS_SIZE 0x00000008ul +#define MINION_CSR_MSTATUS_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MSTATUS_READ_ACCESS 1u +#define MINION_CSR_MSTATUS_WRITE_ACCESS 1u +#define MINION_CSR_MSTATUS_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MSTATUS_RESET_MASK 0x8000000F007FF9AAull +#define MINION_CSR_MSTATUS_READ_MASK 0x8000000F007FF9AAull +#define MINION_CSR_MSTATUS_WRITE_MASK 0x00000000007A79AAull + +/* Field: MINION_CSR_MSTATUS.sie */ +#define MINION_CSR_MSTATUS_SIE_MSB 1u +#define MINION_CSR_MSTATUS_SIE_LSB 1u +#define MINION_CSR_MSTATUS_SIE_WIDTH 1u +#define MINION_CSR_MSTATUS_SIE_READ_ACCESS 1u +#define MINION_CSR_MSTATUS_SIE_WRITE_ACCESS 1u +#define MINION_CSR_MSTATUS_SIE_RESET 0x0000000000000000ull +#define MINION_CSR_MSTATUS_SIE_FIELD_MASK 0x0000000000000002ull +#define MINION_CSR_MSTATUS_SIE_GET(x) (((x) & 0x0000000000000002ull) >> 1) +#define MINION_CSR_MSTATUS_SIE_SET(x) (((x) << 1) & 0x0000000000000002ull) +#define MINION_CSR_MSTATUS_SIE_MODIFY(r, x) ((((x) << 1) & 0x0000000000000002ull) | ((r) & 0xFFFFFFFFFFFFFFFDull)) + +/* Field: MINION_CSR_MSTATUS.mie */ +#define MINION_CSR_MSTATUS_MIE_MSB 3u +#define MINION_CSR_MSTATUS_MIE_LSB 3u +#define MINION_CSR_MSTATUS_MIE_WIDTH 1u +#define MINION_CSR_MSTATUS_MIE_READ_ACCESS 1u +#define MINION_CSR_MSTATUS_MIE_WRITE_ACCESS 1u +#define MINION_CSR_MSTATUS_MIE_RESET 0x0000000000000000ull +#define MINION_CSR_MSTATUS_MIE_FIELD_MASK 0x0000000000000008ull +#define MINION_CSR_MSTATUS_MIE_GET(x) (((x) & 0x0000000000000008ull) >> 3) +#define MINION_CSR_MSTATUS_MIE_SET(x) (((x) << 3) & 0x0000000000000008ull) +#define MINION_CSR_MSTATUS_MIE_MODIFY(r, x) ((((x) << 3) & 0x0000000000000008ull) | ((r) & 0xFFFFFFFFFFFFFFF7ull)) + +/* Field: MINION_CSR_MSTATUS.spie */ +#define MINION_CSR_MSTATUS_SPIE_MSB 5u +#define MINION_CSR_MSTATUS_SPIE_LSB 5u +#define MINION_CSR_MSTATUS_SPIE_WIDTH 1u +#define MINION_CSR_MSTATUS_SPIE_READ_ACCESS 1u +#define MINION_CSR_MSTATUS_SPIE_WRITE_ACCESS 1u +#define MINION_CSR_MSTATUS_SPIE_RESET 0x0000000000000000ull +#define MINION_CSR_MSTATUS_SPIE_FIELD_MASK 0x0000000000000020ull +#define MINION_CSR_MSTATUS_SPIE_GET(x) (((x) & 0x0000000000000020ull) >> 5) +#define MINION_CSR_MSTATUS_SPIE_SET(x) (((x) << 5) & 0x0000000000000020ull) +#define MINION_CSR_MSTATUS_SPIE_MODIFY(r, x) ((((x) << 5) & 0x0000000000000020ull) | ((r) & 0xFFFFFFFFFFFFFFDFull)) + +/* Field: MINION_CSR_MSTATUS.mpie */ +#define MINION_CSR_MSTATUS_MPIE_MSB 7u +#define MINION_CSR_MSTATUS_MPIE_LSB 7u +#define MINION_CSR_MSTATUS_MPIE_WIDTH 1u +#define MINION_CSR_MSTATUS_MPIE_READ_ACCESS 1u +#define MINION_CSR_MSTATUS_MPIE_WRITE_ACCESS 1u +#define MINION_CSR_MSTATUS_MPIE_RESET 0x0000000000000000ull +#define MINION_CSR_MSTATUS_MPIE_FIELD_MASK 0x0000000000000080ull +#define MINION_CSR_MSTATUS_MPIE_GET(x) (((x) & 0x0000000000000080ull) >> 7) +#define MINION_CSR_MSTATUS_MPIE_SET(x) (((x) << 7) & 0x0000000000000080ull) +#define MINION_CSR_MSTATUS_MPIE_MODIFY(r, x) ((((x) << 7) & 0x0000000000000080ull) | ((r) & 0xFFFFFFFFFFFFFF7Full)) + +/* Field: MINION_CSR_MSTATUS.spp */ +#define MINION_CSR_MSTATUS_SPP_MSB 8u +#define MINION_CSR_MSTATUS_SPP_LSB 8u +#define MINION_CSR_MSTATUS_SPP_WIDTH 1u +#define MINION_CSR_MSTATUS_SPP_READ_ACCESS 1u +#define MINION_CSR_MSTATUS_SPP_WRITE_ACCESS 1u +#define MINION_CSR_MSTATUS_SPP_RESET 0x0000000000000000ull +#define MINION_CSR_MSTATUS_SPP_FIELD_MASK 0x0000000000000100ull +#define MINION_CSR_MSTATUS_SPP_GET(x) (((x) & 0x0000000000000100ull) >> 8) +#define MINION_CSR_MSTATUS_SPP_SET(x) (((x) << 8) & 0x0000000000000100ull) +#define MINION_CSR_MSTATUS_SPP_MODIFY(r, x) ((((x) << 8) & 0x0000000000000100ull) | ((r) & 0xFFFFFFFFFFFFFEFFull)) + +/* Field: MINION_CSR_MSTATUS.mpp */ +#define MINION_CSR_MSTATUS_MPP_MSB 12u +#define MINION_CSR_MSTATUS_MPP_LSB 11u +#define MINION_CSR_MSTATUS_MPP_WIDTH 2u +#define MINION_CSR_MSTATUS_MPP_READ_ACCESS 1u +#define MINION_CSR_MSTATUS_MPP_WRITE_ACCESS 1u +#define MINION_CSR_MSTATUS_MPP_RESET 0x0000000000000000ull +#define MINION_CSR_MSTATUS_MPP_FIELD_MASK 0x0000000000001800ull +#define MINION_CSR_MSTATUS_MPP_GET(x) (((x) & 0x0000000000001800ull) >> 11) +#define MINION_CSR_MSTATUS_MPP_SET(x) (((x) << 11) & 0x0000000000001800ull) +#define MINION_CSR_MSTATUS_MPP_MODIFY(r, x) ((((x) << 11) & 0x0000000000001800ull) | ((r) & 0xFFFFFFFFFFFFE7FFull)) + +/* Field: MINION_CSR_MSTATUS.fs */ +#define MINION_CSR_MSTATUS_FS_MSB 14u +#define MINION_CSR_MSTATUS_FS_LSB 13u +#define MINION_CSR_MSTATUS_FS_WIDTH 2u +#define MINION_CSR_MSTATUS_FS_READ_ACCESS 1u +#define MINION_CSR_MSTATUS_FS_WRITE_ACCESS 1u +#define MINION_CSR_MSTATUS_FS_RESET 0x0000000000000000ull +#define MINION_CSR_MSTATUS_FS_FIELD_MASK 0x0000000000006000ull +#define MINION_CSR_MSTATUS_FS_GET(x) (((x) & 0x0000000000006000ull) >> 13) +#define MINION_CSR_MSTATUS_FS_SET(x) (((x) << 13) & 0x0000000000006000ull) +#define MINION_CSR_MSTATUS_FS_MODIFY(r, x) ((((x) << 13) & 0x0000000000006000ull) | ((r) & 0xFFFFFFFFFFFF9FFFull)) + +/* Field: MINION_CSR_MSTATUS.xs */ +#define MINION_CSR_MSTATUS_XS_MSB 16u +#define MINION_CSR_MSTATUS_XS_LSB 15u +#define MINION_CSR_MSTATUS_XS_WIDTH 2u +#define MINION_CSR_MSTATUS_XS_READ_ACCESS 1u +#define MINION_CSR_MSTATUS_XS_WRITE_ACCESS 0u +#define MINION_CSR_MSTATUS_XS_RESET 0x0000000000000000ull +#define MINION_CSR_MSTATUS_XS_FIELD_MASK 0x0000000000018000ull +#define MINION_CSR_MSTATUS_XS_GET(x) (((x) & 0x0000000000018000ull) >> 15) +#define MINION_CSR_MSTATUS_XS_SET(x) (((x) << 15) & 0x0000000000018000ull) +#define MINION_CSR_MSTATUS_XS_MODIFY(r, x) ((((x) << 15) & 0x0000000000018000ull) | ((r) & 0xFFFFFFFFFFFE7FFFull)) + +/* Field: MINION_CSR_MSTATUS.mprv */ +#define MINION_CSR_MSTATUS_MPRV_MSB 17u +#define MINION_CSR_MSTATUS_MPRV_LSB 17u +#define MINION_CSR_MSTATUS_MPRV_WIDTH 1u +#define MINION_CSR_MSTATUS_MPRV_READ_ACCESS 1u +#define MINION_CSR_MSTATUS_MPRV_WRITE_ACCESS 1u +#define MINION_CSR_MSTATUS_MPRV_RESET 0x0000000000000000ull +#define MINION_CSR_MSTATUS_MPRV_FIELD_MASK 0x0000000000020000ull +#define MINION_CSR_MSTATUS_MPRV_GET(x) (((x) & 0x0000000000020000ull) >> 17) +#define MINION_CSR_MSTATUS_MPRV_SET(x) (((x) << 17) & 0x0000000000020000ull) +#define MINION_CSR_MSTATUS_MPRV_MODIFY(r, x) ((((x) << 17) & 0x0000000000020000ull) | ((r) & 0xFFFFFFFFFFFDFFFFull)) + +/* Field: MINION_CSR_MSTATUS.sum */ +#define MINION_CSR_MSTATUS_SUM_MSB 18u +#define MINION_CSR_MSTATUS_SUM_LSB 18u +#define MINION_CSR_MSTATUS_SUM_WIDTH 1u +#define MINION_CSR_MSTATUS_SUM_READ_ACCESS 1u +#define MINION_CSR_MSTATUS_SUM_WRITE_ACCESS 0u +#define MINION_CSR_MSTATUS_SUM_RESET 0x0000000000000000ull +#define MINION_CSR_MSTATUS_SUM_FIELD_MASK 0x0000000000040000ull +#define MINION_CSR_MSTATUS_SUM_GET(x) (((x) & 0x0000000000040000ull) >> 18) +#define MINION_CSR_MSTATUS_SUM_SET(x) (((x) << 18) & 0x0000000000040000ull) +#define MINION_CSR_MSTATUS_SUM_MODIFY(r, x) ((((x) << 18) & 0x0000000000040000ull) | ((r) & 0xFFFFFFFFFFFBFFFFull)) + +/* Field: MINION_CSR_MSTATUS.mxr */ +#define MINION_CSR_MSTATUS_MXR_MSB 19u +#define MINION_CSR_MSTATUS_MXR_LSB 19u +#define MINION_CSR_MSTATUS_MXR_WIDTH 1u +#define MINION_CSR_MSTATUS_MXR_READ_ACCESS 1u +#define MINION_CSR_MSTATUS_MXR_WRITE_ACCESS 1u +#define MINION_CSR_MSTATUS_MXR_RESET 0x0000000000000000ull +#define MINION_CSR_MSTATUS_MXR_FIELD_MASK 0x0000000000080000ull +#define MINION_CSR_MSTATUS_MXR_GET(x) (((x) & 0x0000000000080000ull) >> 19) +#define MINION_CSR_MSTATUS_MXR_SET(x) (((x) << 19) & 0x0000000000080000ull) +#define MINION_CSR_MSTATUS_MXR_MODIFY(r, x) ((((x) << 19) & 0x0000000000080000ull) | ((r) & 0xFFFFFFFFFFF7FFFFull)) + +/* Field: MINION_CSR_MSTATUS.tvm */ +#define MINION_CSR_MSTATUS_TVM_MSB 20u +#define MINION_CSR_MSTATUS_TVM_LSB 20u +#define MINION_CSR_MSTATUS_TVM_WIDTH 1u +#define MINION_CSR_MSTATUS_TVM_READ_ACCESS 1u +#define MINION_CSR_MSTATUS_TVM_WRITE_ACCESS 1u +#define MINION_CSR_MSTATUS_TVM_RESET 0x0000000000000000ull +#define MINION_CSR_MSTATUS_TVM_FIELD_MASK 0x0000000000100000ull +#define MINION_CSR_MSTATUS_TVM_GET(x) (((x) & 0x0000000000100000ull) >> 20) +#define MINION_CSR_MSTATUS_TVM_SET(x) (((x) << 20) & 0x0000000000100000ull) +#define MINION_CSR_MSTATUS_TVM_MODIFY(r, x) ((((x) << 20) & 0x0000000000100000ull) | ((r) & 0xFFFFFFFFFFEFFFFFull)) + +/* Field: MINION_CSR_MSTATUS.tw */ +#define MINION_CSR_MSTATUS_TW_MSB 21u +#define MINION_CSR_MSTATUS_TW_LSB 21u +#define MINION_CSR_MSTATUS_TW_WIDTH 1u +#define MINION_CSR_MSTATUS_TW_READ_ACCESS 1u +#define MINION_CSR_MSTATUS_TW_WRITE_ACCESS 1u +#define MINION_CSR_MSTATUS_TW_RESET 0x0000000000000000ull +#define MINION_CSR_MSTATUS_TW_FIELD_MASK 0x0000000000200000ull +#define MINION_CSR_MSTATUS_TW_GET(x) (((x) & 0x0000000000200000ull) >> 21) +#define MINION_CSR_MSTATUS_TW_SET(x) (((x) << 21) & 0x0000000000200000ull) +#define MINION_CSR_MSTATUS_TW_MODIFY(r, x) ((((x) << 21) & 0x0000000000200000ull) | ((r) & 0xFFFFFFFFFFDFFFFFull)) + +/* Field: MINION_CSR_MSTATUS.tsr */ +#define MINION_CSR_MSTATUS_TSR_MSB 22u +#define MINION_CSR_MSTATUS_TSR_LSB 22u +#define MINION_CSR_MSTATUS_TSR_WIDTH 1u +#define MINION_CSR_MSTATUS_TSR_READ_ACCESS 1u +#define MINION_CSR_MSTATUS_TSR_WRITE_ACCESS 1u +#define MINION_CSR_MSTATUS_TSR_RESET 0x0000000000000000ull +#define MINION_CSR_MSTATUS_TSR_FIELD_MASK 0x0000000000400000ull +#define MINION_CSR_MSTATUS_TSR_GET(x) (((x) & 0x0000000000400000ull) >> 22) +#define MINION_CSR_MSTATUS_TSR_SET(x) (((x) << 22) & 0x0000000000400000ull) +#define MINION_CSR_MSTATUS_TSR_MODIFY(r, x) ((((x) << 22) & 0x0000000000400000ull) | ((r) & 0xFFFFFFFFFFBFFFFFull)) + +/* Field: MINION_CSR_MSTATUS.uxl */ +#define MINION_CSR_MSTATUS_UXL_MSB 33u +#define MINION_CSR_MSTATUS_UXL_LSB 32u +#define MINION_CSR_MSTATUS_UXL_WIDTH 2u +#define MINION_CSR_MSTATUS_UXL_READ_ACCESS 1u +#define MINION_CSR_MSTATUS_UXL_WRITE_ACCESS 0u +#define MINION_CSR_MSTATUS_UXL_RESET 0x0000000000000000ull +#define MINION_CSR_MSTATUS_UXL_FIELD_MASK 0x0000000300000000ull +#define MINION_CSR_MSTATUS_UXL_GET(x) (((x) & 0x0000000300000000ull) >> 32) +#define MINION_CSR_MSTATUS_UXL_SET(x) (((x) << 32) & 0x0000000300000000ull) +#define MINION_CSR_MSTATUS_UXL_MODIFY(r, x) ((((x) << 32) & 0x0000000300000000ull) | ((r) & 0xFFFFFFFCFFFFFFFFull)) + +/* Field: MINION_CSR_MSTATUS.sxl */ +#define MINION_CSR_MSTATUS_SXL_MSB 35u +#define MINION_CSR_MSTATUS_SXL_LSB 34u +#define MINION_CSR_MSTATUS_SXL_WIDTH 2u +#define MINION_CSR_MSTATUS_SXL_READ_ACCESS 1u +#define MINION_CSR_MSTATUS_SXL_WRITE_ACCESS 0u +#define MINION_CSR_MSTATUS_SXL_RESET 0x0000000000000000ull +#define MINION_CSR_MSTATUS_SXL_FIELD_MASK 0x0000000C00000000ull +#define MINION_CSR_MSTATUS_SXL_GET(x) (((x) & 0x0000000C00000000ull) >> 34) +#define MINION_CSR_MSTATUS_SXL_SET(x) (((x) << 34) & 0x0000000C00000000ull) +#define MINION_CSR_MSTATUS_SXL_MODIFY(r, x) ((((x) << 34) & 0x0000000C00000000ull) | ((r) & 0xFFFFFFF3FFFFFFFFull)) + +/* Field: MINION_CSR_MSTATUS.sd */ +#define MINION_CSR_MSTATUS_SD_MSB 63u +#define MINION_CSR_MSTATUS_SD_LSB 63u +#define MINION_CSR_MSTATUS_SD_WIDTH 1u +#define MINION_CSR_MSTATUS_SD_READ_ACCESS 1u +#define MINION_CSR_MSTATUS_SD_WRITE_ACCESS 0u +#define MINION_CSR_MSTATUS_SD_RESET 0x0000000000000000ull +#define MINION_CSR_MSTATUS_SD_FIELD_MASK 0x8000000000000000ull +#define MINION_CSR_MSTATUS_SD_GET(x) (((x) & 0x8000000000000000ull) >> 63) +#define MINION_CSR_MSTATUS_SD_SET(x) (((x) << 63) & 0x8000000000000000ull) +#define MINION_CSR_MSTATUS_SD_MODIFY(r, x) ((((x) << 63) & 0x8000000000000000ull) | ((r) & 0x7FFFFFFFFFFFFFFFull)) + +/* Register: MINION_CSR.misa */ +#define MINION_CSR_MISA_ADDRESS 0x00001808ul +#define MINION_CSR_MISA_BYTE_ADDRESS 0x00001808ul +#define MINION_CSR_MISA_OFFSET 0x00001808ul +#define MINION_CSR_MISA_BYTE_OFFSET 0x00001808ul +#define MINION_CSR_MISA_SIZE 0x00000008ul +#define MINION_CSR_MISA_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MISA_READ_ACCESS 1u +#define MINION_CSR_MISA_WRITE_ACCESS 1u +#define MINION_CSR_MISA_RESET_VALUE 0x8000000000941124ull +#define MINION_CSR_MISA_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MISA_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MISA_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MISA.misa */ +#define MINION_CSR_MISA_MISA_MSB 63u +#define MINION_CSR_MISA_MISA_LSB 0u +#define MINION_CSR_MISA_MISA_WIDTH 64u +#define MINION_CSR_MISA_MISA_READ_ACCESS 1u +#define MINION_CSR_MISA_MISA_WRITE_ACCESS 1u +#define MINION_CSR_MISA_MISA_RESET 0x8000000000941124ull +#define MINION_CSR_MISA_MISA_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MISA_MISA_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MISA_MISA_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MISA_MISA_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.medeleg */ +#define MINION_CSR_MEDELEG_ADDRESS 0x00001810ul +#define MINION_CSR_MEDELEG_BYTE_ADDRESS 0x00001810ul +#define MINION_CSR_MEDELEG_OFFSET 0x00001810ul +#define MINION_CSR_MEDELEG_BYTE_OFFSET 0x00001810ul +#define MINION_CSR_MEDELEG_SIZE 0x00000008ul +#define MINION_CSR_MEDELEG_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MEDELEG_READ_ACCESS 1u +#define MINION_CSR_MEDELEG_WRITE_ACCESS 1u +#define MINION_CSR_MEDELEG_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MEDELEG_RESET_MASK 0x000000000000B108ull +#define MINION_CSR_MEDELEG_READ_MASK 0x000000000000B108ull +#define MINION_CSR_MEDELEG_WRITE_MASK 0x000000000000B108ull + +/* Field: MINION_CSR_MEDELEG.breakpoint */ +#define MINION_CSR_MEDELEG_BREAKPOINT_MSB 3u +#define MINION_CSR_MEDELEG_BREAKPOINT_LSB 3u +#define MINION_CSR_MEDELEG_BREAKPOINT_WIDTH 1u +#define MINION_CSR_MEDELEG_BREAKPOINT_READ_ACCESS 1u +#define MINION_CSR_MEDELEG_BREAKPOINT_WRITE_ACCESS 1u +#define MINION_CSR_MEDELEG_BREAKPOINT_RESET 0x0000000000000000ull +#define MINION_CSR_MEDELEG_BREAKPOINT_FIELD_MASK 0x0000000000000008ull +#define MINION_CSR_MEDELEG_BREAKPOINT_GET(x) (((x) & 0x0000000000000008ull) >> 3) +#define MINION_CSR_MEDELEG_BREAKPOINT_SET(x) (((x) << 3) & 0x0000000000000008ull) +#define MINION_CSR_MEDELEG_BREAKPOINT_MODIFY(r, x) ((((x) << 3) & 0x0000000000000008ull) | ((r) & 0xFFFFFFFFFFFFFFF7ull)) + +/* Field: MINION_CSR_MEDELEG.user_ecall */ +#define MINION_CSR_MEDELEG_USER_ECALL_MSB 8u +#define MINION_CSR_MEDELEG_USER_ECALL_LSB 8u +#define MINION_CSR_MEDELEG_USER_ECALL_WIDTH 1u +#define MINION_CSR_MEDELEG_USER_ECALL_READ_ACCESS 1u +#define MINION_CSR_MEDELEG_USER_ECALL_WRITE_ACCESS 1u +#define MINION_CSR_MEDELEG_USER_ECALL_RESET 0x0000000000000000ull +#define MINION_CSR_MEDELEG_USER_ECALL_FIELD_MASK 0x0000000000000100ull +#define MINION_CSR_MEDELEG_USER_ECALL_GET(x) (((x) & 0x0000000000000100ull) >> 8) +#define MINION_CSR_MEDELEG_USER_ECALL_SET(x) (((x) << 8) & 0x0000000000000100ull) +#define MINION_CSR_MEDELEG_USER_ECALL_MODIFY(r, x) ((((x) << 8) & 0x0000000000000100ull) | ((r) & 0xFFFFFFFFFFFFFEFFull)) + +/* Field: MINION_CSR_MEDELEG.fetch_page_fault */ +#define MINION_CSR_MEDELEG_FETCH_PAGE_FAULT_MSB 12u +#define MINION_CSR_MEDELEG_FETCH_PAGE_FAULT_LSB 12u +#define MINION_CSR_MEDELEG_FETCH_PAGE_FAULT_WIDTH 1u +#define MINION_CSR_MEDELEG_FETCH_PAGE_FAULT_READ_ACCESS 1u +#define MINION_CSR_MEDELEG_FETCH_PAGE_FAULT_WRITE_ACCESS 1u +#define MINION_CSR_MEDELEG_FETCH_PAGE_FAULT_RESET 0x0000000000000000ull +#define MINION_CSR_MEDELEG_FETCH_PAGE_FAULT_FIELD_MASK 0x0000000000001000ull +#define MINION_CSR_MEDELEG_FETCH_PAGE_FAULT_GET(x) (((x) & 0x0000000000001000ull) >> 12) +#define MINION_CSR_MEDELEG_FETCH_PAGE_FAULT_SET(x) (((x) << 12) & 0x0000000000001000ull) +#define MINION_CSR_MEDELEG_FETCH_PAGE_FAULT_MODIFY(r, x) ((((x) << 12) & 0x0000000000001000ull) | ((r) & 0xFFFFFFFFFFFFEFFFull)) + +/* Field: MINION_CSR_MEDELEG.load_page_fault */ +#define MINION_CSR_MEDELEG_LOAD_PAGE_FAULT_MSB 13u +#define MINION_CSR_MEDELEG_LOAD_PAGE_FAULT_LSB 13u +#define MINION_CSR_MEDELEG_LOAD_PAGE_FAULT_WIDTH 1u +#define MINION_CSR_MEDELEG_LOAD_PAGE_FAULT_READ_ACCESS 1u +#define MINION_CSR_MEDELEG_LOAD_PAGE_FAULT_WRITE_ACCESS 1u +#define MINION_CSR_MEDELEG_LOAD_PAGE_FAULT_RESET 0x0000000000000000ull +#define MINION_CSR_MEDELEG_LOAD_PAGE_FAULT_FIELD_MASK 0x0000000000002000ull +#define MINION_CSR_MEDELEG_LOAD_PAGE_FAULT_GET(x) (((x) & 0x0000000000002000ull) >> 13) +#define MINION_CSR_MEDELEG_LOAD_PAGE_FAULT_SET(x) (((x) << 13) & 0x0000000000002000ull) +#define MINION_CSR_MEDELEG_LOAD_PAGE_FAULT_MODIFY(r, x) ((((x) << 13) & 0x0000000000002000ull) | ((r) & 0xFFFFFFFFFFFFDFFFull)) + +/* Field: MINION_CSR_MEDELEG.store_page_fault */ +#define MINION_CSR_MEDELEG_STORE_PAGE_FAULT_MSB 15u +#define MINION_CSR_MEDELEG_STORE_PAGE_FAULT_LSB 15u +#define MINION_CSR_MEDELEG_STORE_PAGE_FAULT_WIDTH 1u +#define MINION_CSR_MEDELEG_STORE_PAGE_FAULT_READ_ACCESS 1u +#define MINION_CSR_MEDELEG_STORE_PAGE_FAULT_WRITE_ACCESS 1u +#define MINION_CSR_MEDELEG_STORE_PAGE_FAULT_RESET 0x0000000000000000ull +#define MINION_CSR_MEDELEG_STORE_PAGE_FAULT_FIELD_MASK 0x0000000000008000ull +#define MINION_CSR_MEDELEG_STORE_PAGE_FAULT_GET(x) (((x) & 0x0000000000008000ull) >> 15) +#define MINION_CSR_MEDELEG_STORE_PAGE_FAULT_SET(x) (((x) << 15) & 0x0000000000008000ull) +#define MINION_CSR_MEDELEG_STORE_PAGE_FAULT_MODIFY(r, x) ((((x) << 15) & 0x0000000000008000ull) | ((r) & 0xFFFFFFFFFFFF7FFFull)) + +/* Register: MINION_CSR.mideleg */ +#define MINION_CSR_MIDELEG_ADDRESS 0x00001818ul +#define MINION_CSR_MIDELEG_BYTE_ADDRESS 0x00001818ul +#define MINION_CSR_MIDELEG_OFFSET 0x00001818ul +#define MINION_CSR_MIDELEG_BYTE_OFFSET 0x00001818ul +#define MINION_CSR_MIDELEG_SIZE 0x00000008ul +#define MINION_CSR_MIDELEG_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MIDELEG_READ_ACCESS 1u +#define MINION_CSR_MIDELEG_WRITE_ACCESS 1u +#define MINION_CSR_MIDELEG_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MIDELEG_RESET_MASK 0x0000000000000222ull +#define MINION_CSR_MIDELEG_READ_MASK 0x0000000000000222ull +#define MINION_CSR_MIDELEG_WRITE_MASK 0x0000000000000222ull + +/* Field: MINION_CSR_MIDELEG.ssip */ +#define MINION_CSR_MIDELEG_SSIP_MSB 1u +#define MINION_CSR_MIDELEG_SSIP_LSB 1u +#define MINION_CSR_MIDELEG_SSIP_WIDTH 1u +#define MINION_CSR_MIDELEG_SSIP_READ_ACCESS 1u +#define MINION_CSR_MIDELEG_SSIP_WRITE_ACCESS 1u +#define MINION_CSR_MIDELEG_SSIP_RESET 0x0000000000000000ull +#define MINION_CSR_MIDELEG_SSIP_FIELD_MASK 0x0000000000000002ull +#define MINION_CSR_MIDELEG_SSIP_GET(x) (((x) & 0x0000000000000002ull) >> 1) +#define MINION_CSR_MIDELEG_SSIP_SET(x) (((x) << 1) & 0x0000000000000002ull) +#define MINION_CSR_MIDELEG_SSIP_MODIFY(r, x) ((((x) << 1) & 0x0000000000000002ull) | ((r) & 0xFFFFFFFFFFFFFFFDull)) + +/* Field: MINION_CSR_MIDELEG.stip */ +#define MINION_CSR_MIDELEG_STIP_MSB 5u +#define MINION_CSR_MIDELEG_STIP_LSB 5u +#define MINION_CSR_MIDELEG_STIP_WIDTH 1u +#define MINION_CSR_MIDELEG_STIP_READ_ACCESS 1u +#define MINION_CSR_MIDELEG_STIP_WRITE_ACCESS 1u +#define MINION_CSR_MIDELEG_STIP_RESET 0x0000000000000000ull +#define MINION_CSR_MIDELEG_STIP_FIELD_MASK 0x0000000000000020ull +#define MINION_CSR_MIDELEG_STIP_GET(x) (((x) & 0x0000000000000020ull) >> 5) +#define MINION_CSR_MIDELEG_STIP_SET(x) (((x) << 5) & 0x0000000000000020ull) +#define MINION_CSR_MIDELEG_STIP_MODIFY(r, x) ((((x) << 5) & 0x0000000000000020ull) | ((r) & 0xFFFFFFFFFFFFFFDFull)) + +/* Field: MINION_CSR_MIDELEG.seip */ +#define MINION_CSR_MIDELEG_SEIP_MSB 9u +#define MINION_CSR_MIDELEG_SEIP_LSB 9u +#define MINION_CSR_MIDELEG_SEIP_WIDTH 1u +#define MINION_CSR_MIDELEG_SEIP_READ_ACCESS 1u +#define MINION_CSR_MIDELEG_SEIP_WRITE_ACCESS 1u +#define MINION_CSR_MIDELEG_SEIP_RESET 0x0000000000000000ull +#define MINION_CSR_MIDELEG_SEIP_FIELD_MASK 0x0000000000000200ull +#define MINION_CSR_MIDELEG_SEIP_GET(x) (((x) & 0x0000000000000200ull) >> 9) +#define MINION_CSR_MIDELEG_SEIP_SET(x) (((x) << 9) & 0x0000000000000200ull) +#define MINION_CSR_MIDELEG_SEIP_MODIFY(r, x) ((((x) << 9) & 0x0000000000000200ull) | ((r) & 0xFFFFFFFFFFFFFDFFull)) + +/* Register: MINION_CSR.mie */ +#define MINION_CSR_MIE_ADDRESS 0x00001820ul +#define MINION_CSR_MIE_BYTE_ADDRESS 0x00001820ul +#define MINION_CSR_MIE_OFFSET 0x00001820ul +#define MINION_CSR_MIE_BYTE_OFFSET 0x00001820ul +#define MINION_CSR_MIE_SIZE 0x00000008ul +#define MINION_CSR_MIE_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MIE_READ_ACCESS 1u +#define MINION_CSR_MIE_WRITE_ACCESS 1u +#define MINION_CSR_MIE_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MIE_RESET_MASK 0x0000000000890AAAull +#define MINION_CSR_MIE_READ_MASK 0x0000000000890AAAull +#define MINION_CSR_MIE_WRITE_MASK 0x0000000000890AAAull + +/* Field: MINION_CSR_MIE.ssie */ +#define MINION_CSR_MIE_SSIE_MSB 1u +#define MINION_CSR_MIE_SSIE_LSB 1u +#define MINION_CSR_MIE_SSIE_WIDTH 1u +#define MINION_CSR_MIE_SSIE_READ_ACCESS 1u +#define MINION_CSR_MIE_SSIE_WRITE_ACCESS 1u +#define MINION_CSR_MIE_SSIE_RESET 0x0000000000000000ull +#define MINION_CSR_MIE_SSIE_FIELD_MASK 0x0000000000000002ull +#define MINION_CSR_MIE_SSIE_GET(x) (((x) & 0x0000000000000002ull) >> 1) +#define MINION_CSR_MIE_SSIE_SET(x) (((x) << 1) & 0x0000000000000002ull) +#define MINION_CSR_MIE_SSIE_MODIFY(r, x) ((((x) << 1) & 0x0000000000000002ull) | ((r) & 0xFFFFFFFFFFFFFFFDull)) + +/* Field: MINION_CSR_MIE.msie */ +#define MINION_CSR_MIE_MSIE_MSB 3u +#define MINION_CSR_MIE_MSIE_LSB 3u +#define MINION_CSR_MIE_MSIE_WIDTH 1u +#define MINION_CSR_MIE_MSIE_READ_ACCESS 1u +#define MINION_CSR_MIE_MSIE_WRITE_ACCESS 1u +#define MINION_CSR_MIE_MSIE_RESET 0x0000000000000000ull +#define MINION_CSR_MIE_MSIE_FIELD_MASK 0x0000000000000008ull +#define MINION_CSR_MIE_MSIE_GET(x) (((x) & 0x0000000000000008ull) >> 3) +#define MINION_CSR_MIE_MSIE_SET(x) (((x) << 3) & 0x0000000000000008ull) +#define MINION_CSR_MIE_MSIE_MODIFY(r, x) ((((x) << 3) & 0x0000000000000008ull) | ((r) & 0xFFFFFFFFFFFFFFF7ull)) + +/* Field: MINION_CSR_MIE.stie */ +#define MINION_CSR_MIE_STIE_MSB 5u +#define MINION_CSR_MIE_STIE_LSB 5u +#define MINION_CSR_MIE_STIE_WIDTH 1u +#define MINION_CSR_MIE_STIE_READ_ACCESS 1u +#define MINION_CSR_MIE_STIE_WRITE_ACCESS 1u +#define MINION_CSR_MIE_STIE_RESET 0x0000000000000000ull +#define MINION_CSR_MIE_STIE_FIELD_MASK 0x0000000000000020ull +#define MINION_CSR_MIE_STIE_GET(x) (((x) & 0x0000000000000020ull) >> 5) +#define MINION_CSR_MIE_STIE_SET(x) (((x) << 5) & 0x0000000000000020ull) +#define MINION_CSR_MIE_STIE_MODIFY(r, x) ((((x) << 5) & 0x0000000000000020ull) | ((r) & 0xFFFFFFFFFFFFFFDFull)) + +/* Field: MINION_CSR_MIE.mtie */ +#define MINION_CSR_MIE_MTIE_MSB 7u +#define MINION_CSR_MIE_MTIE_LSB 7u +#define MINION_CSR_MIE_MTIE_WIDTH 1u +#define MINION_CSR_MIE_MTIE_READ_ACCESS 1u +#define MINION_CSR_MIE_MTIE_WRITE_ACCESS 1u +#define MINION_CSR_MIE_MTIE_RESET 0x0000000000000000ull +#define MINION_CSR_MIE_MTIE_FIELD_MASK 0x0000000000000080ull +#define MINION_CSR_MIE_MTIE_GET(x) (((x) & 0x0000000000000080ull) >> 7) +#define MINION_CSR_MIE_MTIE_SET(x) (((x) << 7) & 0x0000000000000080ull) +#define MINION_CSR_MIE_MTIE_MODIFY(r, x) ((((x) << 7) & 0x0000000000000080ull) | ((r) & 0xFFFFFFFFFFFFFF7Full)) + +/* Field: MINION_CSR_MIE.seie */ +#define MINION_CSR_MIE_SEIE_MSB 9u +#define MINION_CSR_MIE_SEIE_LSB 9u +#define MINION_CSR_MIE_SEIE_WIDTH 1u +#define MINION_CSR_MIE_SEIE_READ_ACCESS 1u +#define MINION_CSR_MIE_SEIE_WRITE_ACCESS 1u +#define MINION_CSR_MIE_SEIE_RESET 0x0000000000000000ull +#define MINION_CSR_MIE_SEIE_FIELD_MASK 0x0000000000000200ull +#define MINION_CSR_MIE_SEIE_GET(x) (((x) & 0x0000000000000200ull) >> 9) +#define MINION_CSR_MIE_SEIE_SET(x) (((x) << 9) & 0x0000000000000200ull) +#define MINION_CSR_MIE_SEIE_MODIFY(r, x) ((((x) << 9) & 0x0000000000000200ull) | ((r) & 0xFFFFFFFFFFFFFDFFull)) + +/* Field: MINION_CSR_MIE.meie */ +#define MINION_CSR_MIE_MEIE_MSB 11u +#define MINION_CSR_MIE_MEIE_LSB 11u +#define MINION_CSR_MIE_MEIE_WIDTH 1u +#define MINION_CSR_MIE_MEIE_READ_ACCESS 1u +#define MINION_CSR_MIE_MEIE_WRITE_ACCESS 1u +#define MINION_CSR_MIE_MEIE_RESET 0x0000000000000000ull +#define MINION_CSR_MIE_MEIE_FIELD_MASK 0x0000000000000800ull +#define MINION_CSR_MIE_MEIE_GET(x) (((x) & 0x0000000000000800ull) >> 11) +#define MINION_CSR_MIE_MEIE_SET(x) (((x) << 11) & 0x0000000000000800ull) +#define MINION_CSR_MIE_MEIE_MODIFY(r, x) ((((x) << 11) & 0x0000000000000800ull) | ((r) & 0xFFFFFFFFFFFFF7FFull)) + +/* Field: MINION_CSR_MIE.mbad_red */ +#define MINION_CSR_MIE_MBAD_RED_MSB 16u +#define MINION_CSR_MIE_MBAD_RED_LSB 16u +#define MINION_CSR_MIE_MBAD_RED_WIDTH 1u +#define MINION_CSR_MIE_MBAD_RED_READ_ACCESS 1u +#define MINION_CSR_MIE_MBAD_RED_WRITE_ACCESS 1u +#define MINION_CSR_MIE_MBAD_RED_RESET 0x0000000000000000ull +#define MINION_CSR_MIE_MBAD_RED_FIELD_MASK 0x0000000000010000ull +#define MINION_CSR_MIE_MBAD_RED_GET(x) (((x) & 0x0000000000010000ull) >> 16) +#define MINION_CSR_MIE_MBAD_RED_SET(x) (((x) << 16) & 0x0000000000010000ull) +#define MINION_CSR_MIE_MBAD_RED_MODIFY(r, x) ((((x) << 16) & 0x0000000000010000ull) | ((r) & 0xFFFFFFFFFFFEFFFFull)) + +/* Field: MINION_CSR_MIE.mieco */ +#define MINION_CSR_MIE_MIECO_MSB 19u +#define MINION_CSR_MIE_MIECO_LSB 19u +#define MINION_CSR_MIE_MIECO_WIDTH 1u +#define MINION_CSR_MIE_MIECO_READ_ACCESS 1u +#define MINION_CSR_MIE_MIECO_WRITE_ACCESS 1u +#define MINION_CSR_MIE_MIECO_RESET 0x0000000000000000ull +#define MINION_CSR_MIE_MIECO_FIELD_MASK 0x0000000000080000ull +#define MINION_CSR_MIE_MIECO_GET(x) (((x) & 0x0000000000080000ull) >> 19) +#define MINION_CSR_MIE_MIECO_SET(x) (((x) << 19) & 0x0000000000080000ull) +#define MINION_CSR_MIE_MIECO_MODIFY(r, x) ((((x) << 19) & 0x0000000000080000ull) | ((r) & 0xFFFFFFFFFFF7FFFFull)) + +/* Field: MINION_CSR_MIE.bus_err */ +#define MINION_CSR_MIE_BUS_ERR_MSB 23u +#define MINION_CSR_MIE_BUS_ERR_LSB 23u +#define MINION_CSR_MIE_BUS_ERR_WIDTH 1u +#define MINION_CSR_MIE_BUS_ERR_READ_ACCESS 1u +#define MINION_CSR_MIE_BUS_ERR_WRITE_ACCESS 1u +#define MINION_CSR_MIE_BUS_ERR_RESET 0x0000000000000000ull +#define MINION_CSR_MIE_BUS_ERR_FIELD_MASK 0x0000000000800000ull +#define MINION_CSR_MIE_BUS_ERR_GET(x) (((x) & 0x0000000000800000ull) >> 23) +#define MINION_CSR_MIE_BUS_ERR_SET(x) (((x) << 23) & 0x0000000000800000ull) +#define MINION_CSR_MIE_BUS_ERR_MODIFY(r, x) ((((x) << 23) & 0x0000000000800000ull) | ((r) & 0xFFFFFFFFFF7FFFFFull)) + +/* Register: MINION_CSR.mtvec */ +#define MINION_CSR_MTVEC_ADDRESS 0x00001828ul +#define MINION_CSR_MTVEC_BYTE_ADDRESS 0x00001828ul +#define MINION_CSR_MTVEC_OFFSET 0x00001828ul +#define MINION_CSR_MTVEC_BYTE_OFFSET 0x00001828ul +#define MINION_CSR_MTVEC_SIZE 0x00000008ul +#define MINION_CSR_MTVEC_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MTVEC_READ_ACCESS 1u +#define MINION_CSR_MTVEC_WRITE_ACCESS 1u +#define MINION_CSR_MTVEC_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MTVEC_RESET_MASK 0x0000FFFFFFFFFFFDull +#define MINION_CSR_MTVEC_READ_MASK 0x0000FFFFFFFFFFFDull +#define MINION_CSR_MTVEC_WRITE_MASK 0x0000FFFFFFFFFFFDull + +/* Field: MINION_CSR_MTVEC.mode */ +#define MINION_CSR_MTVEC_MODE_MSB 0u +#define MINION_CSR_MTVEC_MODE_LSB 0u +#define MINION_CSR_MTVEC_MODE_WIDTH 1u +#define MINION_CSR_MTVEC_MODE_READ_ACCESS 1u +#define MINION_CSR_MTVEC_MODE_WRITE_ACCESS 1u +#define MINION_CSR_MTVEC_MODE_RESET 0x0000000000000000ull +#define MINION_CSR_MTVEC_MODE_FIELD_MASK 0x0000000000000001ull +#define MINION_CSR_MTVEC_MODE_GET(x) ((x) & 0x0000000000000001ull) +#define MINION_CSR_MTVEC_MODE_SET(x) ((x) & 0x0000000000000001ull) +#define MINION_CSR_MTVEC_MODE_MODIFY(r, x) ((((x) << 0) & 0x0000000000000001ull) | ((r) & 0xFFFFFFFFFFFFFFFEull)) + +/* Field: MINION_CSR_MTVEC.base */ +#define MINION_CSR_MTVEC_BASE_MSB 47u +#define MINION_CSR_MTVEC_BASE_LSB 2u +#define MINION_CSR_MTVEC_BASE_WIDTH 46u +#define MINION_CSR_MTVEC_BASE_READ_ACCESS 1u +#define MINION_CSR_MTVEC_BASE_WRITE_ACCESS 1u +#define MINION_CSR_MTVEC_BASE_RESET 0x0000000000000000ull +#define MINION_CSR_MTVEC_BASE_FIELD_MASK 0x0000FFFFFFFFFFFCull +#define MINION_CSR_MTVEC_BASE_GET(x) (((x) & 0x0000FFFFFFFFFFFCull) >> 2) +#define MINION_CSR_MTVEC_BASE_SET(x) (((x) << 2) & 0x0000FFFFFFFFFFFCull) +#define MINION_CSR_MTVEC_BASE_MODIFY(r, x) ((((x) << 2) & 0x0000FFFFFFFFFFFCull) | ((r) & 0xFFFF000000000003ull)) + +/* Register: MINION_CSR.mcounteren */ +#define MINION_CSR_MCOUNTEREN_ADDRESS 0x00001830ul +#define MINION_CSR_MCOUNTEREN_BYTE_ADDRESS 0x00001830ul +#define MINION_CSR_MCOUNTEREN_OFFSET 0x00001830ul +#define MINION_CSR_MCOUNTEREN_BYTE_OFFSET 0x00001830ul +#define MINION_CSR_MCOUNTEREN_SIZE 0x00000008ul +#define MINION_CSR_MCOUNTEREN_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MCOUNTEREN_READ_ACCESS 1u +#define MINION_CSR_MCOUNTEREN_WRITE_ACCESS 1u +#define MINION_CSR_MCOUNTEREN_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MCOUNTEREN_RESET_MASK 0x00000000000001FFull +#define MINION_CSR_MCOUNTEREN_READ_MASK 0x00000000000001FFull +#define MINION_CSR_MCOUNTEREN_WRITE_MASK 0x00000000000001FFull + +/* Field: MINION_CSR_MCOUNTEREN.mcounteren */ +#define MINION_CSR_MCOUNTEREN_MCOUNTEREN_MSB 8u +#define MINION_CSR_MCOUNTEREN_MCOUNTEREN_LSB 0u +#define MINION_CSR_MCOUNTEREN_MCOUNTEREN_WIDTH 9u +#define MINION_CSR_MCOUNTEREN_MCOUNTEREN_READ_ACCESS 1u +#define MINION_CSR_MCOUNTEREN_MCOUNTEREN_WRITE_ACCESS 1u +#define MINION_CSR_MCOUNTEREN_MCOUNTEREN_RESET 0x0000000000000000ull +#define MINION_CSR_MCOUNTEREN_MCOUNTEREN_FIELD_MASK 0x00000000000001FFull +#define MINION_CSR_MCOUNTEREN_MCOUNTEREN_GET(x) ((x) & 0x00000000000001FFull) +#define MINION_CSR_MCOUNTEREN_MCOUNTEREN_SET(x) ((x) & 0x00000000000001FFull) +#define MINION_CSR_MCOUNTEREN_MCOUNTEREN_MODIFY(r, x) ((((x) << 0) & 0x00000000000001FFull) | ((r) & 0xFFFFFFFFFFFFFE00ull)) + +/* Register: MINION_CSR.mhpmevent3 */ +#define MINION_CSR_MHPMEVENT3_ADDRESS 0x00001918ul +#define MINION_CSR_MHPMEVENT3_BYTE_ADDRESS 0x00001918ul +#define MINION_CSR_MHPMEVENT3_OFFSET 0x00001918ul +#define MINION_CSR_MHPMEVENT3_BYTE_OFFSET 0x00001918ul +#define MINION_CSR_MHPMEVENT3_SIZE 0x00000008ul +#define MINION_CSR_MHPMEVENT3_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MHPMEVENT3_READ_ACCESS 1u +#define MINION_CSR_MHPMEVENT3_WRITE_ACCESS 1u +#define MINION_CSR_MHPMEVENT3_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MHPMEVENT3_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT3_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT3_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MHPMEVENT3.mhpmevent3 */ +#define MINION_CSR_MHPMEVENT3_MHPMEVENT3_MSB 63u +#define MINION_CSR_MHPMEVENT3_MHPMEVENT3_LSB 0u +#define MINION_CSR_MHPMEVENT3_MHPMEVENT3_WIDTH 64u +#define MINION_CSR_MHPMEVENT3_MHPMEVENT3_READ_ACCESS 1u +#define MINION_CSR_MHPMEVENT3_MHPMEVENT3_WRITE_ACCESS 1u +#define MINION_CSR_MHPMEVENT3_MHPMEVENT3_RESET 0x0000000000000000ull +#define MINION_CSR_MHPMEVENT3_MHPMEVENT3_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT3_MHPMEVENT3_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMEVENT3_MHPMEVENT3_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMEVENT3_MHPMEVENT3_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mhpmevent4 */ +#define MINION_CSR_MHPMEVENT4_ADDRESS 0x00001920ul +#define MINION_CSR_MHPMEVENT4_BYTE_ADDRESS 0x00001920ul +#define MINION_CSR_MHPMEVENT4_OFFSET 0x00001920ul +#define MINION_CSR_MHPMEVENT4_BYTE_OFFSET 0x00001920ul +#define MINION_CSR_MHPMEVENT4_SIZE 0x00000008ul +#define MINION_CSR_MHPMEVENT4_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MHPMEVENT4_READ_ACCESS 1u +#define MINION_CSR_MHPMEVENT4_WRITE_ACCESS 1u +#define MINION_CSR_MHPMEVENT4_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MHPMEVENT4_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT4_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT4_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MHPMEVENT4.mhpmevent4 */ +#define MINION_CSR_MHPMEVENT4_MHPMEVENT4_MSB 63u +#define MINION_CSR_MHPMEVENT4_MHPMEVENT4_LSB 0u +#define MINION_CSR_MHPMEVENT4_MHPMEVENT4_WIDTH 64u +#define MINION_CSR_MHPMEVENT4_MHPMEVENT4_READ_ACCESS 1u +#define MINION_CSR_MHPMEVENT4_MHPMEVENT4_WRITE_ACCESS 1u +#define MINION_CSR_MHPMEVENT4_MHPMEVENT4_RESET 0x0000000000000000ull +#define MINION_CSR_MHPMEVENT4_MHPMEVENT4_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT4_MHPMEVENT4_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMEVENT4_MHPMEVENT4_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMEVENT4_MHPMEVENT4_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mhpmevent5 */ +#define MINION_CSR_MHPMEVENT5_ADDRESS 0x00001928ul +#define MINION_CSR_MHPMEVENT5_BYTE_ADDRESS 0x00001928ul +#define MINION_CSR_MHPMEVENT5_OFFSET 0x00001928ul +#define MINION_CSR_MHPMEVENT5_BYTE_OFFSET 0x00001928ul +#define MINION_CSR_MHPMEVENT5_SIZE 0x00000008ul +#define MINION_CSR_MHPMEVENT5_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MHPMEVENT5_READ_ACCESS 1u +#define MINION_CSR_MHPMEVENT5_WRITE_ACCESS 1u +#define MINION_CSR_MHPMEVENT5_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MHPMEVENT5_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT5_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT5_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MHPMEVENT5.mhpmevent5 */ +#define MINION_CSR_MHPMEVENT5_MHPMEVENT5_MSB 63u +#define MINION_CSR_MHPMEVENT5_MHPMEVENT5_LSB 0u +#define MINION_CSR_MHPMEVENT5_MHPMEVENT5_WIDTH 64u +#define MINION_CSR_MHPMEVENT5_MHPMEVENT5_READ_ACCESS 1u +#define MINION_CSR_MHPMEVENT5_MHPMEVENT5_WRITE_ACCESS 1u +#define MINION_CSR_MHPMEVENT5_MHPMEVENT5_RESET 0x0000000000000000ull +#define MINION_CSR_MHPMEVENT5_MHPMEVENT5_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT5_MHPMEVENT5_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMEVENT5_MHPMEVENT5_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMEVENT5_MHPMEVENT5_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mhpmevent6 */ +#define MINION_CSR_MHPMEVENT6_ADDRESS 0x00001930ul +#define MINION_CSR_MHPMEVENT6_BYTE_ADDRESS 0x00001930ul +#define MINION_CSR_MHPMEVENT6_OFFSET 0x00001930ul +#define MINION_CSR_MHPMEVENT6_BYTE_OFFSET 0x00001930ul +#define MINION_CSR_MHPMEVENT6_SIZE 0x00000008ul +#define MINION_CSR_MHPMEVENT6_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MHPMEVENT6_READ_ACCESS 1u +#define MINION_CSR_MHPMEVENT6_WRITE_ACCESS 1u +#define MINION_CSR_MHPMEVENT6_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MHPMEVENT6_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT6_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT6_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MHPMEVENT6.mhpmevent6 */ +#define MINION_CSR_MHPMEVENT6_MHPMEVENT6_MSB 63u +#define MINION_CSR_MHPMEVENT6_MHPMEVENT6_LSB 0u +#define MINION_CSR_MHPMEVENT6_MHPMEVENT6_WIDTH 64u +#define MINION_CSR_MHPMEVENT6_MHPMEVENT6_READ_ACCESS 1u +#define MINION_CSR_MHPMEVENT6_MHPMEVENT6_WRITE_ACCESS 1u +#define MINION_CSR_MHPMEVENT6_MHPMEVENT6_RESET 0x0000000000000000ull +#define MINION_CSR_MHPMEVENT6_MHPMEVENT6_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT6_MHPMEVENT6_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMEVENT6_MHPMEVENT6_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMEVENT6_MHPMEVENT6_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mhpmevent7 */ +#define MINION_CSR_MHPMEVENT7_ADDRESS 0x00001938ul +#define MINION_CSR_MHPMEVENT7_BYTE_ADDRESS 0x00001938ul +#define MINION_CSR_MHPMEVENT7_OFFSET 0x00001938ul +#define MINION_CSR_MHPMEVENT7_BYTE_OFFSET 0x00001938ul +#define MINION_CSR_MHPMEVENT7_SIZE 0x00000008ul +#define MINION_CSR_MHPMEVENT7_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MHPMEVENT7_READ_ACCESS 1u +#define MINION_CSR_MHPMEVENT7_WRITE_ACCESS 1u +#define MINION_CSR_MHPMEVENT7_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MHPMEVENT7_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT7_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT7_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MHPMEVENT7.mhpmevent7 */ +#define MINION_CSR_MHPMEVENT7_MHPMEVENT7_MSB 63u +#define MINION_CSR_MHPMEVENT7_MHPMEVENT7_LSB 0u +#define MINION_CSR_MHPMEVENT7_MHPMEVENT7_WIDTH 64u +#define MINION_CSR_MHPMEVENT7_MHPMEVENT7_READ_ACCESS 1u +#define MINION_CSR_MHPMEVENT7_MHPMEVENT7_WRITE_ACCESS 1u +#define MINION_CSR_MHPMEVENT7_MHPMEVENT7_RESET 0x0000000000000000ull +#define MINION_CSR_MHPMEVENT7_MHPMEVENT7_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT7_MHPMEVENT7_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMEVENT7_MHPMEVENT7_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMEVENT7_MHPMEVENT7_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mhpmevent8 */ +#define MINION_CSR_MHPMEVENT8_ADDRESS 0x00001940ul +#define MINION_CSR_MHPMEVENT8_BYTE_ADDRESS 0x00001940ul +#define MINION_CSR_MHPMEVENT8_OFFSET 0x00001940ul +#define MINION_CSR_MHPMEVENT8_BYTE_OFFSET 0x00001940ul +#define MINION_CSR_MHPMEVENT8_SIZE 0x00000008ul +#define MINION_CSR_MHPMEVENT8_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MHPMEVENT8_READ_ACCESS 1u +#define MINION_CSR_MHPMEVENT8_WRITE_ACCESS 1u +#define MINION_CSR_MHPMEVENT8_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MHPMEVENT8_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT8_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT8_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MHPMEVENT8.mhpmevent8 */ +#define MINION_CSR_MHPMEVENT8_MHPMEVENT8_MSB 63u +#define MINION_CSR_MHPMEVENT8_MHPMEVENT8_LSB 0u +#define MINION_CSR_MHPMEVENT8_MHPMEVENT8_WIDTH 64u +#define MINION_CSR_MHPMEVENT8_MHPMEVENT8_READ_ACCESS 1u +#define MINION_CSR_MHPMEVENT8_MHPMEVENT8_WRITE_ACCESS 1u +#define MINION_CSR_MHPMEVENT8_MHPMEVENT8_RESET 0x0000000000000000ull +#define MINION_CSR_MHPMEVENT8_MHPMEVENT8_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT8_MHPMEVENT8_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMEVENT8_MHPMEVENT8_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMEVENT8_MHPMEVENT8_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mhpmevent9 */ +#define MINION_CSR_MHPMEVENT9_ADDRESS 0x00001948ul +#define MINION_CSR_MHPMEVENT9_BYTE_ADDRESS 0x00001948ul +#define MINION_CSR_MHPMEVENT9_OFFSET 0x00001948ul +#define MINION_CSR_MHPMEVENT9_BYTE_OFFSET 0x00001948ul +#define MINION_CSR_MHPMEVENT9_SIZE 0x00000008ul +#define MINION_CSR_MHPMEVENT9_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MHPMEVENT9_READ_ACCESS 1u +#define MINION_CSR_MHPMEVENT9_WRITE_ACCESS 1u +#define MINION_CSR_MHPMEVENT9_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MHPMEVENT9_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT9_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT9_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MHPMEVENT9.mhpmevent9 */ +#define MINION_CSR_MHPMEVENT9_MHPMEVENT9_MSB 63u +#define MINION_CSR_MHPMEVENT9_MHPMEVENT9_LSB 0u +#define MINION_CSR_MHPMEVENT9_MHPMEVENT9_WIDTH 64u +#define MINION_CSR_MHPMEVENT9_MHPMEVENT9_READ_ACCESS 1u +#define MINION_CSR_MHPMEVENT9_MHPMEVENT9_WRITE_ACCESS 1u +#define MINION_CSR_MHPMEVENT9_MHPMEVENT9_RESET 0x0000000000000000ull +#define MINION_CSR_MHPMEVENT9_MHPMEVENT9_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT9_MHPMEVENT9_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMEVENT9_MHPMEVENT9_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMEVENT9_MHPMEVENT9_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mhpmevent10 */ +#define MINION_CSR_MHPMEVENT10_ADDRESS 0x00001950ul +#define MINION_CSR_MHPMEVENT10_BYTE_ADDRESS 0x00001950ul +#define MINION_CSR_MHPMEVENT10_OFFSET 0x00001950ul +#define MINION_CSR_MHPMEVENT10_BYTE_OFFSET 0x00001950ul +#define MINION_CSR_MHPMEVENT10_SIZE 0x00000008ul +#define MINION_CSR_MHPMEVENT10_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MHPMEVENT10_READ_ACCESS 1u +#define MINION_CSR_MHPMEVENT10_WRITE_ACCESS 1u +#define MINION_CSR_MHPMEVENT10_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MHPMEVENT10_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT10_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT10_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MHPMEVENT10.mhpmevent10 */ +#define MINION_CSR_MHPMEVENT10_MHPMEVENT10_MSB 63u +#define MINION_CSR_MHPMEVENT10_MHPMEVENT10_LSB 0u +#define MINION_CSR_MHPMEVENT10_MHPMEVENT10_WIDTH 64u +#define MINION_CSR_MHPMEVENT10_MHPMEVENT10_READ_ACCESS 1u +#define MINION_CSR_MHPMEVENT10_MHPMEVENT10_WRITE_ACCESS 1u +#define MINION_CSR_MHPMEVENT10_MHPMEVENT10_RESET 0x0000000000000000ull +#define MINION_CSR_MHPMEVENT10_MHPMEVENT10_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT10_MHPMEVENT10_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMEVENT10_MHPMEVENT10_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMEVENT10_MHPMEVENT10_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mhpmevent11 */ +#define MINION_CSR_MHPMEVENT11_ADDRESS 0x00001958ul +#define MINION_CSR_MHPMEVENT11_BYTE_ADDRESS 0x00001958ul +#define MINION_CSR_MHPMEVENT11_OFFSET 0x00001958ul +#define MINION_CSR_MHPMEVENT11_BYTE_OFFSET 0x00001958ul +#define MINION_CSR_MHPMEVENT11_SIZE 0x00000008ul +#define MINION_CSR_MHPMEVENT11_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MHPMEVENT11_READ_ACCESS 1u +#define MINION_CSR_MHPMEVENT11_WRITE_ACCESS 1u +#define MINION_CSR_MHPMEVENT11_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MHPMEVENT11_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT11_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT11_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MHPMEVENT11.mhpmevent11 */ +#define MINION_CSR_MHPMEVENT11_MHPMEVENT11_MSB 63u +#define MINION_CSR_MHPMEVENT11_MHPMEVENT11_LSB 0u +#define MINION_CSR_MHPMEVENT11_MHPMEVENT11_WIDTH 64u +#define MINION_CSR_MHPMEVENT11_MHPMEVENT11_READ_ACCESS 1u +#define MINION_CSR_MHPMEVENT11_MHPMEVENT11_WRITE_ACCESS 1u +#define MINION_CSR_MHPMEVENT11_MHPMEVENT11_RESET 0x0000000000000000ull +#define MINION_CSR_MHPMEVENT11_MHPMEVENT11_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT11_MHPMEVENT11_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMEVENT11_MHPMEVENT11_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMEVENT11_MHPMEVENT11_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mhpmevent12 */ +#define MINION_CSR_MHPMEVENT12_ADDRESS 0x00001960ul +#define MINION_CSR_MHPMEVENT12_BYTE_ADDRESS 0x00001960ul +#define MINION_CSR_MHPMEVENT12_OFFSET 0x00001960ul +#define MINION_CSR_MHPMEVENT12_BYTE_OFFSET 0x00001960ul +#define MINION_CSR_MHPMEVENT12_SIZE 0x00000008ul +#define MINION_CSR_MHPMEVENT12_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MHPMEVENT12_READ_ACCESS 1u +#define MINION_CSR_MHPMEVENT12_WRITE_ACCESS 1u +#define MINION_CSR_MHPMEVENT12_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MHPMEVENT12_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT12_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT12_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MHPMEVENT12.mhpmevent12 */ +#define MINION_CSR_MHPMEVENT12_MHPMEVENT12_MSB 63u +#define MINION_CSR_MHPMEVENT12_MHPMEVENT12_LSB 0u +#define MINION_CSR_MHPMEVENT12_MHPMEVENT12_WIDTH 64u +#define MINION_CSR_MHPMEVENT12_MHPMEVENT12_READ_ACCESS 1u +#define MINION_CSR_MHPMEVENT12_MHPMEVENT12_WRITE_ACCESS 1u +#define MINION_CSR_MHPMEVENT12_MHPMEVENT12_RESET 0x0000000000000000ull +#define MINION_CSR_MHPMEVENT12_MHPMEVENT12_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT12_MHPMEVENT12_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMEVENT12_MHPMEVENT12_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMEVENT12_MHPMEVENT12_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mhpmevent13 */ +#define MINION_CSR_MHPMEVENT13_ADDRESS 0x00001968ul +#define MINION_CSR_MHPMEVENT13_BYTE_ADDRESS 0x00001968ul +#define MINION_CSR_MHPMEVENT13_OFFSET 0x00001968ul +#define MINION_CSR_MHPMEVENT13_BYTE_OFFSET 0x00001968ul +#define MINION_CSR_MHPMEVENT13_SIZE 0x00000008ul +#define MINION_CSR_MHPMEVENT13_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MHPMEVENT13_READ_ACCESS 1u +#define MINION_CSR_MHPMEVENT13_WRITE_ACCESS 1u +#define MINION_CSR_MHPMEVENT13_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MHPMEVENT13_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT13_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT13_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MHPMEVENT13.mhpmevent13 */ +#define MINION_CSR_MHPMEVENT13_MHPMEVENT13_MSB 63u +#define MINION_CSR_MHPMEVENT13_MHPMEVENT13_LSB 0u +#define MINION_CSR_MHPMEVENT13_MHPMEVENT13_WIDTH 64u +#define MINION_CSR_MHPMEVENT13_MHPMEVENT13_READ_ACCESS 1u +#define MINION_CSR_MHPMEVENT13_MHPMEVENT13_WRITE_ACCESS 1u +#define MINION_CSR_MHPMEVENT13_MHPMEVENT13_RESET 0x0000000000000000ull +#define MINION_CSR_MHPMEVENT13_MHPMEVENT13_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT13_MHPMEVENT13_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMEVENT13_MHPMEVENT13_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMEVENT13_MHPMEVENT13_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mhpmevent14 */ +#define MINION_CSR_MHPMEVENT14_ADDRESS 0x00001970ul +#define MINION_CSR_MHPMEVENT14_BYTE_ADDRESS 0x00001970ul +#define MINION_CSR_MHPMEVENT14_OFFSET 0x00001970ul +#define MINION_CSR_MHPMEVENT14_BYTE_OFFSET 0x00001970ul +#define MINION_CSR_MHPMEVENT14_SIZE 0x00000008ul +#define MINION_CSR_MHPMEVENT14_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MHPMEVENT14_READ_ACCESS 1u +#define MINION_CSR_MHPMEVENT14_WRITE_ACCESS 1u +#define MINION_CSR_MHPMEVENT14_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MHPMEVENT14_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT14_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT14_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MHPMEVENT14.mhpmevent14 */ +#define MINION_CSR_MHPMEVENT14_MHPMEVENT14_MSB 63u +#define MINION_CSR_MHPMEVENT14_MHPMEVENT14_LSB 0u +#define MINION_CSR_MHPMEVENT14_MHPMEVENT14_WIDTH 64u +#define MINION_CSR_MHPMEVENT14_MHPMEVENT14_READ_ACCESS 1u +#define MINION_CSR_MHPMEVENT14_MHPMEVENT14_WRITE_ACCESS 1u +#define MINION_CSR_MHPMEVENT14_MHPMEVENT14_RESET 0x0000000000000000ull +#define MINION_CSR_MHPMEVENT14_MHPMEVENT14_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT14_MHPMEVENT14_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMEVENT14_MHPMEVENT14_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMEVENT14_MHPMEVENT14_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mhpmevent15 */ +#define MINION_CSR_MHPMEVENT15_ADDRESS 0x00001978ul +#define MINION_CSR_MHPMEVENT15_BYTE_ADDRESS 0x00001978ul +#define MINION_CSR_MHPMEVENT15_OFFSET 0x00001978ul +#define MINION_CSR_MHPMEVENT15_BYTE_OFFSET 0x00001978ul +#define MINION_CSR_MHPMEVENT15_SIZE 0x00000008ul +#define MINION_CSR_MHPMEVENT15_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MHPMEVENT15_READ_ACCESS 1u +#define MINION_CSR_MHPMEVENT15_WRITE_ACCESS 1u +#define MINION_CSR_MHPMEVENT15_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MHPMEVENT15_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT15_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT15_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MHPMEVENT15.mhpmevent15 */ +#define MINION_CSR_MHPMEVENT15_MHPMEVENT15_MSB 63u +#define MINION_CSR_MHPMEVENT15_MHPMEVENT15_LSB 0u +#define MINION_CSR_MHPMEVENT15_MHPMEVENT15_WIDTH 64u +#define MINION_CSR_MHPMEVENT15_MHPMEVENT15_READ_ACCESS 1u +#define MINION_CSR_MHPMEVENT15_MHPMEVENT15_WRITE_ACCESS 1u +#define MINION_CSR_MHPMEVENT15_MHPMEVENT15_RESET 0x0000000000000000ull +#define MINION_CSR_MHPMEVENT15_MHPMEVENT15_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT15_MHPMEVENT15_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMEVENT15_MHPMEVENT15_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMEVENT15_MHPMEVENT15_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mhpmevent16 */ +#define MINION_CSR_MHPMEVENT16_ADDRESS 0x00001980ul +#define MINION_CSR_MHPMEVENT16_BYTE_ADDRESS 0x00001980ul +#define MINION_CSR_MHPMEVENT16_OFFSET 0x00001980ul +#define MINION_CSR_MHPMEVENT16_BYTE_OFFSET 0x00001980ul +#define MINION_CSR_MHPMEVENT16_SIZE 0x00000008ul +#define MINION_CSR_MHPMEVENT16_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MHPMEVENT16_READ_ACCESS 1u +#define MINION_CSR_MHPMEVENT16_WRITE_ACCESS 1u +#define MINION_CSR_MHPMEVENT16_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MHPMEVENT16_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT16_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT16_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MHPMEVENT16.mhpmevent16 */ +#define MINION_CSR_MHPMEVENT16_MHPMEVENT16_MSB 63u +#define MINION_CSR_MHPMEVENT16_MHPMEVENT16_LSB 0u +#define MINION_CSR_MHPMEVENT16_MHPMEVENT16_WIDTH 64u +#define MINION_CSR_MHPMEVENT16_MHPMEVENT16_READ_ACCESS 1u +#define MINION_CSR_MHPMEVENT16_MHPMEVENT16_WRITE_ACCESS 1u +#define MINION_CSR_MHPMEVENT16_MHPMEVENT16_RESET 0x0000000000000000ull +#define MINION_CSR_MHPMEVENT16_MHPMEVENT16_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT16_MHPMEVENT16_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMEVENT16_MHPMEVENT16_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMEVENT16_MHPMEVENT16_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mhpmevent17 */ +#define MINION_CSR_MHPMEVENT17_ADDRESS 0x00001988ul +#define MINION_CSR_MHPMEVENT17_BYTE_ADDRESS 0x00001988ul +#define MINION_CSR_MHPMEVENT17_OFFSET 0x00001988ul +#define MINION_CSR_MHPMEVENT17_BYTE_OFFSET 0x00001988ul +#define MINION_CSR_MHPMEVENT17_SIZE 0x00000008ul +#define MINION_CSR_MHPMEVENT17_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MHPMEVENT17_READ_ACCESS 1u +#define MINION_CSR_MHPMEVENT17_WRITE_ACCESS 1u +#define MINION_CSR_MHPMEVENT17_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MHPMEVENT17_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT17_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT17_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MHPMEVENT17.mhpmevent17 */ +#define MINION_CSR_MHPMEVENT17_MHPMEVENT17_MSB 63u +#define MINION_CSR_MHPMEVENT17_MHPMEVENT17_LSB 0u +#define MINION_CSR_MHPMEVENT17_MHPMEVENT17_WIDTH 64u +#define MINION_CSR_MHPMEVENT17_MHPMEVENT17_READ_ACCESS 1u +#define MINION_CSR_MHPMEVENT17_MHPMEVENT17_WRITE_ACCESS 1u +#define MINION_CSR_MHPMEVENT17_MHPMEVENT17_RESET 0x0000000000000000ull +#define MINION_CSR_MHPMEVENT17_MHPMEVENT17_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT17_MHPMEVENT17_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMEVENT17_MHPMEVENT17_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMEVENT17_MHPMEVENT17_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mhpmevent18 */ +#define MINION_CSR_MHPMEVENT18_ADDRESS 0x00001990ul +#define MINION_CSR_MHPMEVENT18_BYTE_ADDRESS 0x00001990ul +#define MINION_CSR_MHPMEVENT18_OFFSET 0x00001990ul +#define MINION_CSR_MHPMEVENT18_BYTE_OFFSET 0x00001990ul +#define MINION_CSR_MHPMEVENT18_SIZE 0x00000008ul +#define MINION_CSR_MHPMEVENT18_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MHPMEVENT18_READ_ACCESS 1u +#define MINION_CSR_MHPMEVENT18_WRITE_ACCESS 1u +#define MINION_CSR_MHPMEVENT18_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MHPMEVENT18_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT18_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT18_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MHPMEVENT18.mhpmevent18 */ +#define MINION_CSR_MHPMEVENT18_MHPMEVENT18_MSB 63u +#define MINION_CSR_MHPMEVENT18_MHPMEVENT18_LSB 0u +#define MINION_CSR_MHPMEVENT18_MHPMEVENT18_WIDTH 64u +#define MINION_CSR_MHPMEVENT18_MHPMEVENT18_READ_ACCESS 1u +#define MINION_CSR_MHPMEVENT18_MHPMEVENT18_WRITE_ACCESS 1u +#define MINION_CSR_MHPMEVENT18_MHPMEVENT18_RESET 0x0000000000000000ull +#define MINION_CSR_MHPMEVENT18_MHPMEVENT18_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT18_MHPMEVENT18_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMEVENT18_MHPMEVENT18_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMEVENT18_MHPMEVENT18_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mhpmevent19 */ +#define MINION_CSR_MHPMEVENT19_ADDRESS 0x00001998ul +#define MINION_CSR_MHPMEVENT19_BYTE_ADDRESS 0x00001998ul +#define MINION_CSR_MHPMEVENT19_OFFSET 0x00001998ul +#define MINION_CSR_MHPMEVENT19_BYTE_OFFSET 0x00001998ul +#define MINION_CSR_MHPMEVENT19_SIZE 0x00000008ul +#define MINION_CSR_MHPMEVENT19_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MHPMEVENT19_READ_ACCESS 1u +#define MINION_CSR_MHPMEVENT19_WRITE_ACCESS 1u +#define MINION_CSR_MHPMEVENT19_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MHPMEVENT19_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT19_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT19_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MHPMEVENT19.mhpmevent19 */ +#define MINION_CSR_MHPMEVENT19_MHPMEVENT19_MSB 63u +#define MINION_CSR_MHPMEVENT19_MHPMEVENT19_LSB 0u +#define MINION_CSR_MHPMEVENT19_MHPMEVENT19_WIDTH 64u +#define MINION_CSR_MHPMEVENT19_MHPMEVENT19_READ_ACCESS 1u +#define MINION_CSR_MHPMEVENT19_MHPMEVENT19_WRITE_ACCESS 1u +#define MINION_CSR_MHPMEVENT19_MHPMEVENT19_RESET 0x0000000000000000ull +#define MINION_CSR_MHPMEVENT19_MHPMEVENT19_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT19_MHPMEVENT19_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMEVENT19_MHPMEVENT19_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMEVENT19_MHPMEVENT19_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mhpmevent20 */ +#define MINION_CSR_MHPMEVENT20_ADDRESS 0x000019A0ul +#define MINION_CSR_MHPMEVENT20_BYTE_ADDRESS 0x000019A0ul +#define MINION_CSR_MHPMEVENT20_OFFSET 0x000019A0ul +#define MINION_CSR_MHPMEVENT20_BYTE_OFFSET 0x000019A0ul +#define MINION_CSR_MHPMEVENT20_SIZE 0x00000008ul +#define MINION_CSR_MHPMEVENT20_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MHPMEVENT20_READ_ACCESS 1u +#define MINION_CSR_MHPMEVENT20_WRITE_ACCESS 1u +#define MINION_CSR_MHPMEVENT20_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MHPMEVENT20_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT20_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT20_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MHPMEVENT20.mhpmevent20 */ +#define MINION_CSR_MHPMEVENT20_MHPMEVENT20_MSB 63u +#define MINION_CSR_MHPMEVENT20_MHPMEVENT20_LSB 0u +#define MINION_CSR_MHPMEVENT20_MHPMEVENT20_WIDTH 64u +#define MINION_CSR_MHPMEVENT20_MHPMEVENT20_READ_ACCESS 1u +#define MINION_CSR_MHPMEVENT20_MHPMEVENT20_WRITE_ACCESS 1u +#define MINION_CSR_MHPMEVENT20_MHPMEVENT20_RESET 0x0000000000000000ull +#define MINION_CSR_MHPMEVENT20_MHPMEVENT20_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT20_MHPMEVENT20_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMEVENT20_MHPMEVENT20_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMEVENT20_MHPMEVENT20_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mhpmevent21 */ +#define MINION_CSR_MHPMEVENT21_ADDRESS 0x000019A8ul +#define MINION_CSR_MHPMEVENT21_BYTE_ADDRESS 0x000019A8ul +#define MINION_CSR_MHPMEVENT21_OFFSET 0x000019A8ul +#define MINION_CSR_MHPMEVENT21_BYTE_OFFSET 0x000019A8ul +#define MINION_CSR_MHPMEVENT21_SIZE 0x00000008ul +#define MINION_CSR_MHPMEVENT21_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MHPMEVENT21_READ_ACCESS 1u +#define MINION_CSR_MHPMEVENT21_WRITE_ACCESS 1u +#define MINION_CSR_MHPMEVENT21_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MHPMEVENT21_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT21_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT21_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MHPMEVENT21.mhpmevent21 */ +#define MINION_CSR_MHPMEVENT21_MHPMEVENT21_MSB 63u +#define MINION_CSR_MHPMEVENT21_MHPMEVENT21_LSB 0u +#define MINION_CSR_MHPMEVENT21_MHPMEVENT21_WIDTH 64u +#define MINION_CSR_MHPMEVENT21_MHPMEVENT21_READ_ACCESS 1u +#define MINION_CSR_MHPMEVENT21_MHPMEVENT21_WRITE_ACCESS 1u +#define MINION_CSR_MHPMEVENT21_MHPMEVENT21_RESET 0x0000000000000000ull +#define MINION_CSR_MHPMEVENT21_MHPMEVENT21_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT21_MHPMEVENT21_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMEVENT21_MHPMEVENT21_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMEVENT21_MHPMEVENT21_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mhpmevent22 */ +#define MINION_CSR_MHPMEVENT22_ADDRESS 0x000019B0ul +#define MINION_CSR_MHPMEVENT22_BYTE_ADDRESS 0x000019B0ul +#define MINION_CSR_MHPMEVENT22_OFFSET 0x000019B0ul +#define MINION_CSR_MHPMEVENT22_BYTE_OFFSET 0x000019B0ul +#define MINION_CSR_MHPMEVENT22_SIZE 0x00000008ul +#define MINION_CSR_MHPMEVENT22_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MHPMEVENT22_READ_ACCESS 1u +#define MINION_CSR_MHPMEVENT22_WRITE_ACCESS 1u +#define MINION_CSR_MHPMEVENT22_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MHPMEVENT22_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT22_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT22_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MHPMEVENT22.mhpmevent22 */ +#define MINION_CSR_MHPMEVENT22_MHPMEVENT22_MSB 63u +#define MINION_CSR_MHPMEVENT22_MHPMEVENT22_LSB 0u +#define MINION_CSR_MHPMEVENT22_MHPMEVENT22_WIDTH 64u +#define MINION_CSR_MHPMEVENT22_MHPMEVENT22_READ_ACCESS 1u +#define MINION_CSR_MHPMEVENT22_MHPMEVENT22_WRITE_ACCESS 1u +#define MINION_CSR_MHPMEVENT22_MHPMEVENT22_RESET 0x0000000000000000ull +#define MINION_CSR_MHPMEVENT22_MHPMEVENT22_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT22_MHPMEVENT22_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMEVENT22_MHPMEVENT22_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMEVENT22_MHPMEVENT22_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mhpmevent23 */ +#define MINION_CSR_MHPMEVENT23_ADDRESS 0x000019B8ul +#define MINION_CSR_MHPMEVENT23_BYTE_ADDRESS 0x000019B8ul +#define MINION_CSR_MHPMEVENT23_OFFSET 0x000019B8ul +#define MINION_CSR_MHPMEVENT23_BYTE_OFFSET 0x000019B8ul +#define MINION_CSR_MHPMEVENT23_SIZE 0x00000008ul +#define MINION_CSR_MHPMEVENT23_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MHPMEVENT23_READ_ACCESS 1u +#define MINION_CSR_MHPMEVENT23_WRITE_ACCESS 1u +#define MINION_CSR_MHPMEVENT23_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MHPMEVENT23_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT23_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT23_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MHPMEVENT23.mhpmevent23 */ +#define MINION_CSR_MHPMEVENT23_MHPMEVENT23_MSB 63u +#define MINION_CSR_MHPMEVENT23_MHPMEVENT23_LSB 0u +#define MINION_CSR_MHPMEVENT23_MHPMEVENT23_WIDTH 64u +#define MINION_CSR_MHPMEVENT23_MHPMEVENT23_READ_ACCESS 1u +#define MINION_CSR_MHPMEVENT23_MHPMEVENT23_WRITE_ACCESS 1u +#define MINION_CSR_MHPMEVENT23_MHPMEVENT23_RESET 0x0000000000000000ull +#define MINION_CSR_MHPMEVENT23_MHPMEVENT23_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT23_MHPMEVENT23_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMEVENT23_MHPMEVENT23_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMEVENT23_MHPMEVENT23_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mhpmevent24 */ +#define MINION_CSR_MHPMEVENT24_ADDRESS 0x000019C0ul +#define MINION_CSR_MHPMEVENT24_BYTE_ADDRESS 0x000019C0ul +#define MINION_CSR_MHPMEVENT24_OFFSET 0x000019C0ul +#define MINION_CSR_MHPMEVENT24_BYTE_OFFSET 0x000019C0ul +#define MINION_CSR_MHPMEVENT24_SIZE 0x00000008ul +#define MINION_CSR_MHPMEVENT24_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MHPMEVENT24_READ_ACCESS 1u +#define MINION_CSR_MHPMEVENT24_WRITE_ACCESS 1u +#define MINION_CSR_MHPMEVENT24_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MHPMEVENT24_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT24_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT24_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MHPMEVENT24.mhpmevent24 */ +#define MINION_CSR_MHPMEVENT24_MHPMEVENT24_MSB 63u +#define MINION_CSR_MHPMEVENT24_MHPMEVENT24_LSB 0u +#define MINION_CSR_MHPMEVENT24_MHPMEVENT24_WIDTH 64u +#define MINION_CSR_MHPMEVENT24_MHPMEVENT24_READ_ACCESS 1u +#define MINION_CSR_MHPMEVENT24_MHPMEVENT24_WRITE_ACCESS 1u +#define MINION_CSR_MHPMEVENT24_MHPMEVENT24_RESET 0x0000000000000000ull +#define MINION_CSR_MHPMEVENT24_MHPMEVENT24_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT24_MHPMEVENT24_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMEVENT24_MHPMEVENT24_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMEVENT24_MHPMEVENT24_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mhpmevent25 */ +#define MINION_CSR_MHPMEVENT25_ADDRESS 0x000019C8ul +#define MINION_CSR_MHPMEVENT25_BYTE_ADDRESS 0x000019C8ul +#define MINION_CSR_MHPMEVENT25_OFFSET 0x000019C8ul +#define MINION_CSR_MHPMEVENT25_BYTE_OFFSET 0x000019C8ul +#define MINION_CSR_MHPMEVENT25_SIZE 0x00000008ul +#define MINION_CSR_MHPMEVENT25_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MHPMEVENT25_READ_ACCESS 1u +#define MINION_CSR_MHPMEVENT25_WRITE_ACCESS 1u +#define MINION_CSR_MHPMEVENT25_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MHPMEVENT25_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT25_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT25_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MHPMEVENT25.mhpmevent25 */ +#define MINION_CSR_MHPMEVENT25_MHPMEVENT25_MSB 63u +#define MINION_CSR_MHPMEVENT25_MHPMEVENT25_LSB 0u +#define MINION_CSR_MHPMEVENT25_MHPMEVENT25_WIDTH 64u +#define MINION_CSR_MHPMEVENT25_MHPMEVENT25_READ_ACCESS 1u +#define MINION_CSR_MHPMEVENT25_MHPMEVENT25_WRITE_ACCESS 1u +#define MINION_CSR_MHPMEVENT25_MHPMEVENT25_RESET 0x0000000000000000ull +#define MINION_CSR_MHPMEVENT25_MHPMEVENT25_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT25_MHPMEVENT25_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMEVENT25_MHPMEVENT25_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMEVENT25_MHPMEVENT25_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mhpmevent26 */ +#define MINION_CSR_MHPMEVENT26_ADDRESS 0x000019D0ul +#define MINION_CSR_MHPMEVENT26_BYTE_ADDRESS 0x000019D0ul +#define MINION_CSR_MHPMEVENT26_OFFSET 0x000019D0ul +#define MINION_CSR_MHPMEVENT26_BYTE_OFFSET 0x000019D0ul +#define MINION_CSR_MHPMEVENT26_SIZE 0x00000008ul +#define MINION_CSR_MHPMEVENT26_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MHPMEVENT26_READ_ACCESS 1u +#define MINION_CSR_MHPMEVENT26_WRITE_ACCESS 1u +#define MINION_CSR_MHPMEVENT26_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MHPMEVENT26_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT26_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT26_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MHPMEVENT26.mhpmevent26 */ +#define MINION_CSR_MHPMEVENT26_MHPMEVENT26_MSB 63u +#define MINION_CSR_MHPMEVENT26_MHPMEVENT26_LSB 0u +#define MINION_CSR_MHPMEVENT26_MHPMEVENT26_WIDTH 64u +#define MINION_CSR_MHPMEVENT26_MHPMEVENT26_READ_ACCESS 1u +#define MINION_CSR_MHPMEVENT26_MHPMEVENT26_WRITE_ACCESS 1u +#define MINION_CSR_MHPMEVENT26_MHPMEVENT26_RESET 0x0000000000000000ull +#define MINION_CSR_MHPMEVENT26_MHPMEVENT26_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT26_MHPMEVENT26_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMEVENT26_MHPMEVENT26_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMEVENT26_MHPMEVENT26_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mhpmevent27 */ +#define MINION_CSR_MHPMEVENT27_ADDRESS 0x000019D8ul +#define MINION_CSR_MHPMEVENT27_BYTE_ADDRESS 0x000019D8ul +#define MINION_CSR_MHPMEVENT27_OFFSET 0x000019D8ul +#define MINION_CSR_MHPMEVENT27_BYTE_OFFSET 0x000019D8ul +#define MINION_CSR_MHPMEVENT27_SIZE 0x00000008ul +#define MINION_CSR_MHPMEVENT27_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MHPMEVENT27_READ_ACCESS 1u +#define MINION_CSR_MHPMEVENT27_WRITE_ACCESS 1u +#define MINION_CSR_MHPMEVENT27_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MHPMEVENT27_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT27_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT27_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MHPMEVENT27.mhpmevent27 */ +#define MINION_CSR_MHPMEVENT27_MHPMEVENT27_MSB 63u +#define MINION_CSR_MHPMEVENT27_MHPMEVENT27_LSB 0u +#define MINION_CSR_MHPMEVENT27_MHPMEVENT27_WIDTH 64u +#define MINION_CSR_MHPMEVENT27_MHPMEVENT27_READ_ACCESS 1u +#define MINION_CSR_MHPMEVENT27_MHPMEVENT27_WRITE_ACCESS 1u +#define MINION_CSR_MHPMEVENT27_MHPMEVENT27_RESET 0x0000000000000000ull +#define MINION_CSR_MHPMEVENT27_MHPMEVENT27_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT27_MHPMEVENT27_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMEVENT27_MHPMEVENT27_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMEVENT27_MHPMEVENT27_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mhpmevent28 */ +#define MINION_CSR_MHPMEVENT28_ADDRESS 0x000019E0ul +#define MINION_CSR_MHPMEVENT28_BYTE_ADDRESS 0x000019E0ul +#define MINION_CSR_MHPMEVENT28_OFFSET 0x000019E0ul +#define MINION_CSR_MHPMEVENT28_BYTE_OFFSET 0x000019E0ul +#define MINION_CSR_MHPMEVENT28_SIZE 0x00000008ul +#define MINION_CSR_MHPMEVENT28_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MHPMEVENT28_READ_ACCESS 1u +#define MINION_CSR_MHPMEVENT28_WRITE_ACCESS 1u +#define MINION_CSR_MHPMEVENT28_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MHPMEVENT28_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT28_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT28_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MHPMEVENT28.mhpmevent28 */ +#define MINION_CSR_MHPMEVENT28_MHPMEVENT28_MSB 63u +#define MINION_CSR_MHPMEVENT28_MHPMEVENT28_LSB 0u +#define MINION_CSR_MHPMEVENT28_MHPMEVENT28_WIDTH 64u +#define MINION_CSR_MHPMEVENT28_MHPMEVENT28_READ_ACCESS 1u +#define MINION_CSR_MHPMEVENT28_MHPMEVENT28_WRITE_ACCESS 1u +#define MINION_CSR_MHPMEVENT28_MHPMEVENT28_RESET 0x0000000000000000ull +#define MINION_CSR_MHPMEVENT28_MHPMEVENT28_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT28_MHPMEVENT28_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMEVENT28_MHPMEVENT28_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMEVENT28_MHPMEVENT28_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mhpmevent29 */ +#define MINION_CSR_MHPMEVENT29_ADDRESS 0x000019E8ul +#define MINION_CSR_MHPMEVENT29_BYTE_ADDRESS 0x000019E8ul +#define MINION_CSR_MHPMEVENT29_OFFSET 0x000019E8ul +#define MINION_CSR_MHPMEVENT29_BYTE_OFFSET 0x000019E8ul +#define MINION_CSR_MHPMEVENT29_SIZE 0x00000008ul +#define MINION_CSR_MHPMEVENT29_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MHPMEVENT29_READ_ACCESS 1u +#define MINION_CSR_MHPMEVENT29_WRITE_ACCESS 1u +#define MINION_CSR_MHPMEVENT29_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MHPMEVENT29_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT29_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT29_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MHPMEVENT29.mhpmevent29 */ +#define MINION_CSR_MHPMEVENT29_MHPMEVENT29_MSB 63u +#define MINION_CSR_MHPMEVENT29_MHPMEVENT29_LSB 0u +#define MINION_CSR_MHPMEVENT29_MHPMEVENT29_WIDTH 64u +#define MINION_CSR_MHPMEVENT29_MHPMEVENT29_READ_ACCESS 1u +#define MINION_CSR_MHPMEVENT29_MHPMEVENT29_WRITE_ACCESS 1u +#define MINION_CSR_MHPMEVENT29_MHPMEVENT29_RESET 0x0000000000000000ull +#define MINION_CSR_MHPMEVENT29_MHPMEVENT29_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT29_MHPMEVENT29_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMEVENT29_MHPMEVENT29_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMEVENT29_MHPMEVENT29_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mhpmevent30 */ +#define MINION_CSR_MHPMEVENT30_ADDRESS 0x000019F0ul +#define MINION_CSR_MHPMEVENT30_BYTE_ADDRESS 0x000019F0ul +#define MINION_CSR_MHPMEVENT30_OFFSET 0x000019F0ul +#define MINION_CSR_MHPMEVENT30_BYTE_OFFSET 0x000019F0ul +#define MINION_CSR_MHPMEVENT30_SIZE 0x00000008ul +#define MINION_CSR_MHPMEVENT30_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MHPMEVENT30_READ_ACCESS 1u +#define MINION_CSR_MHPMEVENT30_WRITE_ACCESS 1u +#define MINION_CSR_MHPMEVENT30_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MHPMEVENT30_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT30_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT30_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MHPMEVENT30.mhpmevent30 */ +#define MINION_CSR_MHPMEVENT30_MHPMEVENT30_MSB 63u +#define MINION_CSR_MHPMEVENT30_MHPMEVENT30_LSB 0u +#define MINION_CSR_MHPMEVENT30_MHPMEVENT30_WIDTH 64u +#define MINION_CSR_MHPMEVENT30_MHPMEVENT30_READ_ACCESS 1u +#define MINION_CSR_MHPMEVENT30_MHPMEVENT30_WRITE_ACCESS 1u +#define MINION_CSR_MHPMEVENT30_MHPMEVENT30_RESET 0x0000000000000000ull +#define MINION_CSR_MHPMEVENT30_MHPMEVENT30_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT30_MHPMEVENT30_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMEVENT30_MHPMEVENT30_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMEVENT30_MHPMEVENT30_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mhpmevent31 */ +#define MINION_CSR_MHPMEVENT31_ADDRESS 0x000019F8ul +#define MINION_CSR_MHPMEVENT31_BYTE_ADDRESS 0x000019F8ul +#define MINION_CSR_MHPMEVENT31_OFFSET 0x000019F8ul +#define MINION_CSR_MHPMEVENT31_BYTE_OFFSET 0x000019F8ul +#define MINION_CSR_MHPMEVENT31_SIZE 0x00000008ul +#define MINION_CSR_MHPMEVENT31_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MHPMEVENT31_READ_ACCESS 1u +#define MINION_CSR_MHPMEVENT31_WRITE_ACCESS 1u +#define MINION_CSR_MHPMEVENT31_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MHPMEVENT31_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT31_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT31_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MHPMEVENT31.mhpmevent31 */ +#define MINION_CSR_MHPMEVENT31_MHPMEVENT31_MSB 63u +#define MINION_CSR_MHPMEVENT31_MHPMEVENT31_LSB 0u +#define MINION_CSR_MHPMEVENT31_MHPMEVENT31_WIDTH 64u +#define MINION_CSR_MHPMEVENT31_MHPMEVENT31_READ_ACCESS 1u +#define MINION_CSR_MHPMEVENT31_MHPMEVENT31_WRITE_ACCESS 1u +#define MINION_CSR_MHPMEVENT31_MHPMEVENT31_RESET 0x0000000000000000ull +#define MINION_CSR_MHPMEVENT31_MHPMEVENT31_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMEVENT31_MHPMEVENT31_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMEVENT31_MHPMEVENT31_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMEVENT31_MHPMEVENT31_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mscratch */ +#define MINION_CSR_MSCRATCH_ADDRESS 0x00001A00ul +#define MINION_CSR_MSCRATCH_BYTE_ADDRESS 0x00001A00ul +#define MINION_CSR_MSCRATCH_OFFSET 0x00001A00ul +#define MINION_CSR_MSCRATCH_BYTE_OFFSET 0x00001A00ul +#define MINION_CSR_MSCRATCH_SIZE 0x00000008ul +#define MINION_CSR_MSCRATCH_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MSCRATCH_READ_ACCESS 1u +#define MINION_CSR_MSCRATCH_WRITE_ACCESS 1u +#define MINION_CSR_MSCRATCH_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MSCRATCH_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MSCRATCH_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MSCRATCH_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MSCRATCH.mscratch */ +#define MINION_CSR_MSCRATCH_MSCRATCH_MSB 63u +#define MINION_CSR_MSCRATCH_MSCRATCH_LSB 0u +#define MINION_CSR_MSCRATCH_MSCRATCH_WIDTH 64u +#define MINION_CSR_MSCRATCH_MSCRATCH_READ_ACCESS 1u +#define MINION_CSR_MSCRATCH_MSCRATCH_WRITE_ACCESS 1u +#define MINION_CSR_MSCRATCH_MSCRATCH_RESET 0x0000000000000000ull +#define MINION_CSR_MSCRATCH_MSCRATCH_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MSCRATCH_MSCRATCH_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MSCRATCH_MSCRATCH_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MSCRATCH_MSCRATCH_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mepc */ +#define MINION_CSR_MEPC_ADDRESS 0x00001A08ul +#define MINION_CSR_MEPC_BYTE_ADDRESS 0x00001A08ul +#define MINION_CSR_MEPC_OFFSET 0x00001A08ul +#define MINION_CSR_MEPC_BYTE_OFFSET 0x00001A08ul +#define MINION_CSR_MEPC_SIZE 0x00000008ul +#define MINION_CSR_MEPC_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MEPC_READ_ACCESS 1u +#define MINION_CSR_MEPC_WRITE_ACCESS 1u +#define MINION_CSR_MEPC_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MEPC_RESET_MASK 0x0001FFFFFFFFFFFEull +#define MINION_CSR_MEPC_READ_MASK 0x0001FFFFFFFFFFFEull +#define MINION_CSR_MEPC_WRITE_MASK 0x0001FFFFFFFFFFFEull + +/* Field: MINION_CSR_MEPC.base */ +#define MINION_CSR_MEPC_BASE_MSB 47u +#define MINION_CSR_MEPC_BASE_LSB 1u +#define MINION_CSR_MEPC_BASE_WIDTH 47u +#define MINION_CSR_MEPC_BASE_READ_ACCESS 1u +#define MINION_CSR_MEPC_BASE_WRITE_ACCESS 1u +#define MINION_CSR_MEPC_BASE_RESET 0x0000000000000000ull +#define MINION_CSR_MEPC_BASE_FIELD_MASK 0x0000FFFFFFFFFFFEull +#define MINION_CSR_MEPC_BASE_GET(x) (((x) & 0x0000FFFFFFFFFFFEull) >> 1) +#define MINION_CSR_MEPC_BASE_SET(x) (((x) << 1) & 0x0000FFFFFFFFFFFEull) +#define MINION_CSR_MEPC_BASE_MODIFY(r, x) ((((x) << 1) & 0x0000FFFFFFFFFFFEull) | ((r) & 0xFFFF000000000001ull)) + +/* Field: MINION_CSR_MEPC.sign_ext */ +#define MINION_CSR_MEPC_SIGN_EXT_MSB 48u +#define MINION_CSR_MEPC_SIGN_EXT_LSB 48u +#define MINION_CSR_MEPC_SIGN_EXT_WIDTH 1u +#define MINION_CSR_MEPC_SIGN_EXT_READ_ACCESS 1u +#define MINION_CSR_MEPC_SIGN_EXT_WRITE_ACCESS 1u +#define MINION_CSR_MEPC_SIGN_EXT_RESET 0x0000000000000000ull +#define MINION_CSR_MEPC_SIGN_EXT_FIELD_MASK 0x0001000000000000ull +#define MINION_CSR_MEPC_SIGN_EXT_GET(x) (((x) & 0x0001000000000000ull) >> 48) +#define MINION_CSR_MEPC_SIGN_EXT_SET(x) (((x) << 48) & 0x0001000000000000ull) +#define MINION_CSR_MEPC_SIGN_EXT_MODIFY(r, x) ((((x) << 48) & 0x0001000000000000ull) | ((r) & 0xFFFEFFFFFFFFFFFFull)) + +/* Register: MINION_CSR.mcause */ +#define MINION_CSR_MCAUSE_ADDRESS 0x00001A10ul +#define MINION_CSR_MCAUSE_BYTE_ADDRESS 0x00001A10ul +#define MINION_CSR_MCAUSE_OFFSET 0x00001A10ul +#define MINION_CSR_MCAUSE_BYTE_OFFSET 0x00001A10ul +#define MINION_CSR_MCAUSE_SIZE 0x00000008ul +#define MINION_CSR_MCAUSE_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MCAUSE_READ_ACCESS 1u +#define MINION_CSR_MCAUSE_WRITE_ACCESS 1u +#define MINION_CSR_MCAUSE_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MCAUSE_RESET_MASK 0x800000000000001Full +#define MINION_CSR_MCAUSE_READ_MASK 0x800000000000001Full +#define MINION_CSR_MCAUSE_WRITE_MASK 0x800000000000001Full + +/* Field: MINION_CSR_MCAUSE.cause */ +#define MINION_CSR_MCAUSE_CAUSE_MSB 4u +#define MINION_CSR_MCAUSE_CAUSE_LSB 0u +#define MINION_CSR_MCAUSE_CAUSE_WIDTH 5u +#define MINION_CSR_MCAUSE_CAUSE_READ_ACCESS 1u +#define MINION_CSR_MCAUSE_CAUSE_WRITE_ACCESS 1u +#define MINION_CSR_MCAUSE_CAUSE_RESET 0x0000000000000000ull +#define MINION_CSR_MCAUSE_CAUSE_FIELD_MASK 0x000000000000001Full +#define MINION_CSR_MCAUSE_CAUSE_GET(x) ((x) & 0x000000000000001Full) +#define MINION_CSR_MCAUSE_CAUSE_SET(x) ((x) & 0x000000000000001Full) +#define MINION_CSR_MCAUSE_CAUSE_MODIFY(r, x) ((((x) << 0) & 0x000000000000001Full) | ((r) & 0xFFFFFFFFFFFFFFE0ull)) + +/* Field: MINION_CSR_MCAUSE.interrupt_x */ +#define MINION_CSR_MCAUSE_INTERRUPT_X_MSB 63u +#define MINION_CSR_MCAUSE_INTERRUPT_X_LSB 63u +#define MINION_CSR_MCAUSE_INTERRUPT_X_WIDTH 1u +#define MINION_CSR_MCAUSE_INTERRUPT_X_READ_ACCESS 1u +#define MINION_CSR_MCAUSE_INTERRUPT_X_WRITE_ACCESS 1u +#define MINION_CSR_MCAUSE_INTERRUPT_X_RESET 0x0000000000000000ull +#define MINION_CSR_MCAUSE_INTERRUPT_X_FIELD_MASK 0x8000000000000000ull +#define MINION_CSR_MCAUSE_INTERRUPT_X_GET(x) (((x) & 0x8000000000000000ull) >> 63) +#define MINION_CSR_MCAUSE_INTERRUPT_X_SET(x) (((x) << 63) & 0x8000000000000000ull) +#define MINION_CSR_MCAUSE_INTERRUPT_X_MODIFY(r, x) ((((x) << 63) & 0x8000000000000000ull) | ((r) & 0x7FFFFFFFFFFFFFFFull)) + +/* Register: MINION_CSR.mtval */ +#define MINION_CSR_MTVAL_ADDRESS 0x00001A18ul +#define MINION_CSR_MTVAL_BYTE_ADDRESS 0x00001A18ul +#define MINION_CSR_MTVAL_OFFSET 0x00001A18ul +#define MINION_CSR_MTVAL_BYTE_OFFSET 0x00001A18ul +#define MINION_CSR_MTVAL_SIZE 0x00000008ul +#define MINION_CSR_MTVAL_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MTVAL_READ_ACCESS 1u +#define MINION_CSR_MTVAL_WRITE_ACCESS 1u +#define MINION_CSR_MTVAL_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MTVAL_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MTVAL_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MTVAL_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MTVAL.mtval */ +#define MINION_CSR_MTVAL_MTVAL_MSB 63u +#define MINION_CSR_MTVAL_MTVAL_LSB 0u +#define MINION_CSR_MTVAL_MTVAL_WIDTH 64u +#define MINION_CSR_MTVAL_MTVAL_READ_ACCESS 1u +#define MINION_CSR_MTVAL_MTVAL_WRITE_ACCESS 1u +#define MINION_CSR_MTVAL_MTVAL_RESET 0x0000000000000000ull +#define MINION_CSR_MTVAL_MTVAL_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MTVAL_MTVAL_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MTVAL_MTVAL_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MTVAL_MTVAL_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mip */ +#define MINION_CSR_MIP_ADDRESS 0x00001A20ul +#define MINION_CSR_MIP_BYTE_ADDRESS 0x00001A20ul +#define MINION_CSR_MIP_OFFSET 0x00001A20ul +#define MINION_CSR_MIP_BYTE_OFFSET 0x00001A20ul +#define MINION_CSR_MIP_SIZE 0x00000008ul +#define MINION_CSR_MIP_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MIP_READ_ACCESS 1u +#define MINION_CSR_MIP_WRITE_ACCESS 1u +#define MINION_CSR_MIP_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MIP_RESET_MASK 0x0000000000890AAAull +#define MINION_CSR_MIP_READ_MASK 0x0000000000890AAAull +#define MINION_CSR_MIP_WRITE_MASK 0x0000000000810222ull + +/* Field: MINION_CSR_MIP.ssip */ +#define MINION_CSR_MIP_SSIP_MSB 1u +#define MINION_CSR_MIP_SSIP_LSB 1u +#define MINION_CSR_MIP_SSIP_WIDTH 1u +#define MINION_CSR_MIP_SSIP_READ_ACCESS 1u +#define MINION_CSR_MIP_SSIP_WRITE_ACCESS 1u +#define MINION_CSR_MIP_SSIP_RESET 0x0000000000000000ull +#define MINION_CSR_MIP_SSIP_FIELD_MASK 0x0000000000000002ull +#define MINION_CSR_MIP_SSIP_GET(x) (((x) & 0x0000000000000002ull) >> 1) +#define MINION_CSR_MIP_SSIP_SET(x) (((x) << 1) & 0x0000000000000002ull) +#define MINION_CSR_MIP_SSIP_MODIFY(r, x) ((((x) << 1) & 0x0000000000000002ull) | ((r) & 0xFFFFFFFFFFFFFFFDull)) + +/* Field: MINION_CSR_MIP.msip */ +#define MINION_CSR_MIP_MSIP_MSB 3u +#define MINION_CSR_MIP_MSIP_LSB 3u +#define MINION_CSR_MIP_MSIP_WIDTH 1u +#define MINION_CSR_MIP_MSIP_READ_ACCESS 1u +#define MINION_CSR_MIP_MSIP_WRITE_ACCESS 0u +#define MINION_CSR_MIP_MSIP_RESET 0x0000000000000000ull +#define MINION_CSR_MIP_MSIP_FIELD_MASK 0x0000000000000008ull +#define MINION_CSR_MIP_MSIP_GET(x) (((x) & 0x0000000000000008ull) >> 3) +#define MINION_CSR_MIP_MSIP_SET(x) (((x) << 3) & 0x0000000000000008ull) +#define MINION_CSR_MIP_MSIP_MODIFY(r, x) ((((x) << 3) & 0x0000000000000008ull) | ((r) & 0xFFFFFFFFFFFFFFF7ull)) + +/* Field: MINION_CSR_MIP.stip */ +#define MINION_CSR_MIP_STIP_MSB 5u +#define MINION_CSR_MIP_STIP_LSB 5u +#define MINION_CSR_MIP_STIP_WIDTH 1u +#define MINION_CSR_MIP_STIP_READ_ACCESS 1u +#define MINION_CSR_MIP_STIP_WRITE_ACCESS 1u +#define MINION_CSR_MIP_STIP_RESET 0x0000000000000000ull +#define MINION_CSR_MIP_STIP_FIELD_MASK 0x0000000000000020ull +#define MINION_CSR_MIP_STIP_GET(x) (((x) & 0x0000000000000020ull) >> 5) +#define MINION_CSR_MIP_STIP_SET(x) (((x) << 5) & 0x0000000000000020ull) +#define MINION_CSR_MIP_STIP_MODIFY(r, x) ((((x) << 5) & 0x0000000000000020ull) | ((r) & 0xFFFFFFFFFFFFFFDFull)) + +/* Field: MINION_CSR_MIP.mtip */ +#define MINION_CSR_MIP_MTIP_MSB 7u +#define MINION_CSR_MIP_MTIP_LSB 7u +#define MINION_CSR_MIP_MTIP_WIDTH 1u +#define MINION_CSR_MIP_MTIP_READ_ACCESS 1u +#define MINION_CSR_MIP_MTIP_WRITE_ACCESS 0u +#define MINION_CSR_MIP_MTIP_RESET 0x0000000000000000ull +#define MINION_CSR_MIP_MTIP_FIELD_MASK 0x0000000000000080ull +#define MINION_CSR_MIP_MTIP_GET(x) (((x) & 0x0000000000000080ull) >> 7) +#define MINION_CSR_MIP_MTIP_SET(x) (((x) << 7) & 0x0000000000000080ull) +#define MINION_CSR_MIP_MTIP_MODIFY(r, x) ((((x) << 7) & 0x0000000000000080ull) | ((r) & 0xFFFFFFFFFFFFFF7Full)) + +/* Field: MINION_CSR_MIP.seip */ +#define MINION_CSR_MIP_SEIP_MSB 9u +#define MINION_CSR_MIP_SEIP_LSB 9u +#define MINION_CSR_MIP_SEIP_WIDTH 1u +#define MINION_CSR_MIP_SEIP_READ_ACCESS 1u +#define MINION_CSR_MIP_SEIP_WRITE_ACCESS 1u +#define MINION_CSR_MIP_SEIP_RESET 0x0000000000000000ull +#define MINION_CSR_MIP_SEIP_FIELD_MASK 0x0000000000000200ull +#define MINION_CSR_MIP_SEIP_GET(x) (((x) & 0x0000000000000200ull) >> 9) +#define MINION_CSR_MIP_SEIP_SET(x) (((x) << 9) & 0x0000000000000200ull) +#define MINION_CSR_MIP_SEIP_MODIFY(r, x) ((((x) << 9) & 0x0000000000000200ull) | ((r) & 0xFFFFFFFFFFFFFDFFull)) + +/* Field: MINION_CSR_MIP.meip */ +#define MINION_CSR_MIP_MEIP_MSB 11u +#define MINION_CSR_MIP_MEIP_LSB 11u +#define MINION_CSR_MIP_MEIP_WIDTH 1u +#define MINION_CSR_MIP_MEIP_READ_ACCESS 1u +#define MINION_CSR_MIP_MEIP_WRITE_ACCESS 0u +#define MINION_CSR_MIP_MEIP_RESET 0x0000000000000000ull +#define MINION_CSR_MIP_MEIP_FIELD_MASK 0x0000000000000800ull +#define MINION_CSR_MIP_MEIP_GET(x) (((x) & 0x0000000000000800ull) >> 11) +#define MINION_CSR_MIP_MEIP_SET(x) (((x) << 11) & 0x0000000000000800ull) +#define MINION_CSR_MIP_MEIP_MODIFY(r, x) ((((x) << 11) & 0x0000000000000800ull) | ((r) & 0xFFFFFFFFFFFFF7FFull)) + +/* Field: MINION_CSR_MIP.mbad_red */ +#define MINION_CSR_MIP_MBAD_RED_MSB 16u +#define MINION_CSR_MIP_MBAD_RED_LSB 16u +#define MINION_CSR_MIP_MBAD_RED_WIDTH 1u +#define MINION_CSR_MIP_MBAD_RED_READ_ACCESS 1u +#define MINION_CSR_MIP_MBAD_RED_WRITE_ACCESS 1u +#define MINION_CSR_MIP_MBAD_RED_RESET 0x0000000000000000ull +#define MINION_CSR_MIP_MBAD_RED_FIELD_MASK 0x0000000000010000ull +#define MINION_CSR_MIP_MBAD_RED_GET(x) (((x) & 0x0000000000010000ull) >> 16) +#define MINION_CSR_MIP_MBAD_RED_SET(x) (((x) << 16) & 0x0000000000010000ull) +#define MINION_CSR_MIP_MBAD_RED_MODIFY(r, x) ((((x) << 16) & 0x0000000000010000ull) | ((r) & 0xFFFFFFFFFFFEFFFFull)) + +/* Field: MINION_CSR_MIP.mieco */ +#define MINION_CSR_MIP_MIECO_MSB 19u +#define MINION_CSR_MIP_MIECO_LSB 19u +#define MINION_CSR_MIP_MIECO_WIDTH 1u +#define MINION_CSR_MIP_MIECO_READ_ACCESS 1u +#define MINION_CSR_MIP_MIECO_WRITE_ACCESS 0u +#define MINION_CSR_MIP_MIECO_RESET 0x0000000000000000ull +#define MINION_CSR_MIP_MIECO_FIELD_MASK 0x0000000000080000ull +#define MINION_CSR_MIP_MIECO_GET(x) (((x) & 0x0000000000080000ull) >> 19) +#define MINION_CSR_MIP_MIECO_SET(x) (((x) << 19) & 0x0000000000080000ull) +#define MINION_CSR_MIP_MIECO_MODIFY(r, x) ((((x) << 19) & 0x0000000000080000ull) | ((r) & 0xFFFFFFFFFFF7FFFFull)) + +/* Field: MINION_CSR_MIP.bus_err */ +#define MINION_CSR_MIP_BUS_ERR_MSB 23u +#define MINION_CSR_MIP_BUS_ERR_LSB 23u +#define MINION_CSR_MIP_BUS_ERR_WIDTH 1u +#define MINION_CSR_MIP_BUS_ERR_READ_ACCESS 1u +#define MINION_CSR_MIP_BUS_ERR_WRITE_ACCESS 1u +#define MINION_CSR_MIP_BUS_ERR_RESET 0x0000000000000000ull +#define MINION_CSR_MIP_BUS_ERR_FIELD_MASK 0x0000000000800000ull +#define MINION_CSR_MIP_BUS_ERR_GET(x) (((x) & 0x0000000000800000ull) >> 23) +#define MINION_CSR_MIP_BUS_ERR_SET(x) (((x) << 23) & 0x0000000000800000ull) +#define MINION_CSR_MIP_BUS_ERR_MODIFY(r, x) ((((x) << 23) & 0x0000000000800000ull) | ((r) & 0xFFFFFFFFFF7FFFFFull)) + +/* Register: MINION_CSR.pmpcfg0 */ +#define MINION_CSR_PMPCFG0_ADDRESS 0x00001D00ul +#define MINION_CSR_PMPCFG0_BYTE_ADDRESS 0x00001D00ul +#define MINION_CSR_PMPCFG0_OFFSET 0x00001D00ul +#define MINION_CSR_PMPCFG0_BYTE_OFFSET 0x00001D00ul +#define MINION_CSR_PMPCFG0_SIZE 0x00000008ul +#define MINION_CSR_PMPCFG0_BYTE_SIZE 0x00000008ul +#define MINION_CSR_PMPCFG0_READ_ACCESS 1u +#define MINION_CSR_PMPCFG0_WRITE_ACCESS 1u +#define MINION_CSR_PMPCFG0_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_PMPCFG0_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PMPCFG0_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PMPCFG0_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_PMPCFG0.pmpcfg0 */ +#define MINION_CSR_PMPCFG0_PMPCFG0_MSB 63u +#define MINION_CSR_PMPCFG0_PMPCFG0_LSB 0u +#define MINION_CSR_PMPCFG0_PMPCFG0_WIDTH 64u +#define MINION_CSR_PMPCFG0_PMPCFG0_READ_ACCESS 1u +#define MINION_CSR_PMPCFG0_PMPCFG0_WRITE_ACCESS 1u +#define MINION_CSR_PMPCFG0_PMPCFG0_RESET 0x0000000000000000ull +#define MINION_CSR_PMPCFG0_PMPCFG0_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PMPCFG0_PMPCFG0_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_PMPCFG0_PMPCFG0_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_PMPCFG0_PMPCFG0_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.pmpcfg2 */ +#define MINION_CSR_PMPCFG2_ADDRESS 0x00001D10ul +#define MINION_CSR_PMPCFG2_BYTE_ADDRESS 0x00001D10ul +#define MINION_CSR_PMPCFG2_OFFSET 0x00001D10ul +#define MINION_CSR_PMPCFG2_BYTE_OFFSET 0x00001D10ul +#define MINION_CSR_PMPCFG2_SIZE 0x00000008ul +#define MINION_CSR_PMPCFG2_BYTE_SIZE 0x00000008ul +#define MINION_CSR_PMPCFG2_READ_ACCESS 1u +#define MINION_CSR_PMPCFG2_WRITE_ACCESS 1u +#define MINION_CSR_PMPCFG2_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_PMPCFG2_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PMPCFG2_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PMPCFG2_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_PMPCFG2.pmpcfg2 */ +#define MINION_CSR_PMPCFG2_PMPCFG2_MSB 63u +#define MINION_CSR_PMPCFG2_PMPCFG2_LSB 0u +#define MINION_CSR_PMPCFG2_PMPCFG2_WIDTH 64u +#define MINION_CSR_PMPCFG2_PMPCFG2_READ_ACCESS 1u +#define MINION_CSR_PMPCFG2_PMPCFG2_WRITE_ACCESS 1u +#define MINION_CSR_PMPCFG2_PMPCFG2_RESET 0x0000000000000000ull +#define MINION_CSR_PMPCFG2_PMPCFG2_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PMPCFG2_PMPCFG2_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_PMPCFG2_PMPCFG2_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_PMPCFG2_PMPCFG2_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.pmpaddr0 */ +#define MINION_CSR_PMPADDR0_ADDRESS 0x00001D80ul +#define MINION_CSR_PMPADDR0_BYTE_ADDRESS 0x00001D80ul +#define MINION_CSR_PMPADDR0_OFFSET 0x00001D80ul +#define MINION_CSR_PMPADDR0_BYTE_OFFSET 0x00001D80ul +#define MINION_CSR_PMPADDR0_SIZE 0x00000008ul +#define MINION_CSR_PMPADDR0_BYTE_SIZE 0x00000008ul +#define MINION_CSR_PMPADDR0_READ_ACCESS 1u +#define MINION_CSR_PMPADDR0_WRITE_ACCESS 1u +#define MINION_CSR_PMPADDR0_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_PMPADDR0_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PMPADDR0_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PMPADDR0_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_PMPADDR0.pmpaddr0 */ +#define MINION_CSR_PMPADDR0_PMPADDR0_MSB 63u +#define MINION_CSR_PMPADDR0_PMPADDR0_LSB 0u +#define MINION_CSR_PMPADDR0_PMPADDR0_WIDTH 64u +#define MINION_CSR_PMPADDR0_PMPADDR0_READ_ACCESS 1u +#define MINION_CSR_PMPADDR0_PMPADDR0_WRITE_ACCESS 1u +#define MINION_CSR_PMPADDR0_PMPADDR0_RESET 0x0000000000000000ull +#define MINION_CSR_PMPADDR0_PMPADDR0_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PMPADDR0_PMPADDR0_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_PMPADDR0_PMPADDR0_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_PMPADDR0_PMPADDR0_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.pmpaddr1 */ +#define MINION_CSR_PMPADDR1_ADDRESS 0x00001D88ul +#define MINION_CSR_PMPADDR1_BYTE_ADDRESS 0x00001D88ul +#define MINION_CSR_PMPADDR1_OFFSET 0x00001D88ul +#define MINION_CSR_PMPADDR1_BYTE_OFFSET 0x00001D88ul +#define MINION_CSR_PMPADDR1_SIZE 0x00000008ul +#define MINION_CSR_PMPADDR1_BYTE_SIZE 0x00000008ul +#define MINION_CSR_PMPADDR1_READ_ACCESS 1u +#define MINION_CSR_PMPADDR1_WRITE_ACCESS 1u +#define MINION_CSR_PMPADDR1_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_PMPADDR1_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PMPADDR1_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PMPADDR1_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_PMPADDR1.pmpaddr1 */ +#define MINION_CSR_PMPADDR1_PMPADDR1_MSB 63u +#define MINION_CSR_PMPADDR1_PMPADDR1_LSB 0u +#define MINION_CSR_PMPADDR1_PMPADDR1_WIDTH 64u +#define MINION_CSR_PMPADDR1_PMPADDR1_READ_ACCESS 1u +#define MINION_CSR_PMPADDR1_PMPADDR1_WRITE_ACCESS 1u +#define MINION_CSR_PMPADDR1_PMPADDR1_RESET 0x0000000000000000ull +#define MINION_CSR_PMPADDR1_PMPADDR1_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PMPADDR1_PMPADDR1_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_PMPADDR1_PMPADDR1_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_PMPADDR1_PMPADDR1_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.pmpaddr2 */ +#define MINION_CSR_PMPADDR2_ADDRESS 0x00001D90ul +#define MINION_CSR_PMPADDR2_BYTE_ADDRESS 0x00001D90ul +#define MINION_CSR_PMPADDR2_OFFSET 0x00001D90ul +#define MINION_CSR_PMPADDR2_BYTE_OFFSET 0x00001D90ul +#define MINION_CSR_PMPADDR2_SIZE 0x00000008ul +#define MINION_CSR_PMPADDR2_BYTE_SIZE 0x00000008ul +#define MINION_CSR_PMPADDR2_READ_ACCESS 1u +#define MINION_CSR_PMPADDR2_WRITE_ACCESS 1u +#define MINION_CSR_PMPADDR2_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_PMPADDR2_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PMPADDR2_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PMPADDR2_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_PMPADDR2.pmpaddr2 */ +#define MINION_CSR_PMPADDR2_PMPADDR2_MSB 63u +#define MINION_CSR_PMPADDR2_PMPADDR2_LSB 0u +#define MINION_CSR_PMPADDR2_PMPADDR2_WIDTH 64u +#define MINION_CSR_PMPADDR2_PMPADDR2_READ_ACCESS 1u +#define MINION_CSR_PMPADDR2_PMPADDR2_WRITE_ACCESS 1u +#define MINION_CSR_PMPADDR2_PMPADDR2_RESET 0x0000000000000000ull +#define MINION_CSR_PMPADDR2_PMPADDR2_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PMPADDR2_PMPADDR2_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_PMPADDR2_PMPADDR2_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_PMPADDR2_PMPADDR2_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.pmpaddr3 */ +#define MINION_CSR_PMPADDR3_ADDRESS 0x00001D98ul +#define MINION_CSR_PMPADDR3_BYTE_ADDRESS 0x00001D98ul +#define MINION_CSR_PMPADDR3_OFFSET 0x00001D98ul +#define MINION_CSR_PMPADDR3_BYTE_OFFSET 0x00001D98ul +#define MINION_CSR_PMPADDR3_SIZE 0x00000008ul +#define MINION_CSR_PMPADDR3_BYTE_SIZE 0x00000008ul +#define MINION_CSR_PMPADDR3_READ_ACCESS 1u +#define MINION_CSR_PMPADDR3_WRITE_ACCESS 1u +#define MINION_CSR_PMPADDR3_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_PMPADDR3_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PMPADDR3_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PMPADDR3_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_PMPADDR3.pmpaddr3 */ +#define MINION_CSR_PMPADDR3_PMPADDR3_MSB 63u +#define MINION_CSR_PMPADDR3_PMPADDR3_LSB 0u +#define MINION_CSR_PMPADDR3_PMPADDR3_WIDTH 64u +#define MINION_CSR_PMPADDR3_PMPADDR3_READ_ACCESS 1u +#define MINION_CSR_PMPADDR3_PMPADDR3_WRITE_ACCESS 1u +#define MINION_CSR_PMPADDR3_PMPADDR3_RESET 0x0000000000000000ull +#define MINION_CSR_PMPADDR3_PMPADDR3_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PMPADDR3_PMPADDR3_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_PMPADDR3_PMPADDR3_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_PMPADDR3_PMPADDR3_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.pmpaddr4 */ +#define MINION_CSR_PMPADDR4_ADDRESS 0x00001DA0ul +#define MINION_CSR_PMPADDR4_BYTE_ADDRESS 0x00001DA0ul +#define MINION_CSR_PMPADDR4_OFFSET 0x00001DA0ul +#define MINION_CSR_PMPADDR4_BYTE_OFFSET 0x00001DA0ul +#define MINION_CSR_PMPADDR4_SIZE 0x00000008ul +#define MINION_CSR_PMPADDR4_BYTE_SIZE 0x00000008ul +#define MINION_CSR_PMPADDR4_READ_ACCESS 1u +#define MINION_CSR_PMPADDR4_WRITE_ACCESS 1u +#define MINION_CSR_PMPADDR4_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_PMPADDR4_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PMPADDR4_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PMPADDR4_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_PMPADDR4.pmpaddr4 */ +#define MINION_CSR_PMPADDR4_PMPADDR4_MSB 63u +#define MINION_CSR_PMPADDR4_PMPADDR4_LSB 0u +#define MINION_CSR_PMPADDR4_PMPADDR4_WIDTH 64u +#define MINION_CSR_PMPADDR4_PMPADDR4_READ_ACCESS 1u +#define MINION_CSR_PMPADDR4_PMPADDR4_WRITE_ACCESS 1u +#define MINION_CSR_PMPADDR4_PMPADDR4_RESET 0x0000000000000000ull +#define MINION_CSR_PMPADDR4_PMPADDR4_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PMPADDR4_PMPADDR4_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_PMPADDR4_PMPADDR4_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_PMPADDR4_PMPADDR4_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.pmpaddr5 */ +#define MINION_CSR_PMPADDR5_ADDRESS 0x00001DA8ul +#define MINION_CSR_PMPADDR5_BYTE_ADDRESS 0x00001DA8ul +#define MINION_CSR_PMPADDR5_OFFSET 0x00001DA8ul +#define MINION_CSR_PMPADDR5_BYTE_OFFSET 0x00001DA8ul +#define MINION_CSR_PMPADDR5_SIZE 0x00000008ul +#define MINION_CSR_PMPADDR5_BYTE_SIZE 0x00000008ul +#define MINION_CSR_PMPADDR5_READ_ACCESS 1u +#define MINION_CSR_PMPADDR5_WRITE_ACCESS 1u +#define MINION_CSR_PMPADDR5_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_PMPADDR5_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PMPADDR5_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PMPADDR5_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_PMPADDR5.pmpaddr5 */ +#define MINION_CSR_PMPADDR5_PMPADDR5_MSB 63u +#define MINION_CSR_PMPADDR5_PMPADDR5_LSB 0u +#define MINION_CSR_PMPADDR5_PMPADDR5_WIDTH 64u +#define MINION_CSR_PMPADDR5_PMPADDR5_READ_ACCESS 1u +#define MINION_CSR_PMPADDR5_PMPADDR5_WRITE_ACCESS 1u +#define MINION_CSR_PMPADDR5_PMPADDR5_RESET 0x0000000000000000ull +#define MINION_CSR_PMPADDR5_PMPADDR5_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PMPADDR5_PMPADDR5_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_PMPADDR5_PMPADDR5_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_PMPADDR5_PMPADDR5_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.pmpaddr6 */ +#define MINION_CSR_PMPADDR6_ADDRESS 0x00001DB0ul +#define MINION_CSR_PMPADDR6_BYTE_ADDRESS 0x00001DB0ul +#define MINION_CSR_PMPADDR6_OFFSET 0x00001DB0ul +#define MINION_CSR_PMPADDR6_BYTE_OFFSET 0x00001DB0ul +#define MINION_CSR_PMPADDR6_SIZE 0x00000008ul +#define MINION_CSR_PMPADDR6_BYTE_SIZE 0x00000008ul +#define MINION_CSR_PMPADDR6_READ_ACCESS 1u +#define MINION_CSR_PMPADDR6_WRITE_ACCESS 1u +#define MINION_CSR_PMPADDR6_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_PMPADDR6_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PMPADDR6_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PMPADDR6_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_PMPADDR6.pmpaddr6 */ +#define MINION_CSR_PMPADDR6_PMPADDR6_MSB 63u +#define MINION_CSR_PMPADDR6_PMPADDR6_LSB 0u +#define MINION_CSR_PMPADDR6_PMPADDR6_WIDTH 64u +#define MINION_CSR_PMPADDR6_PMPADDR6_READ_ACCESS 1u +#define MINION_CSR_PMPADDR6_PMPADDR6_WRITE_ACCESS 1u +#define MINION_CSR_PMPADDR6_PMPADDR6_RESET 0x0000000000000000ull +#define MINION_CSR_PMPADDR6_PMPADDR6_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PMPADDR6_PMPADDR6_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_PMPADDR6_PMPADDR6_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_PMPADDR6_PMPADDR6_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.pmpaddr7 */ +#define MINION_CSR_PMPADDR7_ADDRESS 0x00001DB8ul +#define MINION_CSR_PMPADDR7_BYTE_ADDRESS 0x00001DB8ul +#define MINION_CSR_PMPADDR7_OFFSET 0x00001DB8ul +#define MINION_CSR_PMPADDR7_BYTE_OFFSET 0x00001DB8ul +#define MINION_CSR_PMPADDR7_SIZE 0x00000008ul +#define MINION_CSR_PMPADDR7_BYTE_SIZE 0x00000008ul +#define MINION_CSR_PMPADDR7_READ_ACCESS 1u +#define MINION_CSR_PMPADDR7_WRITE_ACCESS 1u +#define MINION_CSR_PMPADDR7_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_PMPADDR7_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PMPADDR7_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PMPADDR7_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_PMPADDR7.pmpaddr7 */ +#define MINION_CSR_PMPADDR7_PMPADDR7_MSB 63u +#define MINION_CSR_PMPADDR7_PMPADDR7_LSB 0u +#define MINION_CSR_PMPADDR7_PMPADDR7_WIDTH 64u +#define MINION_CSR_PMPADDR7_PMPADDR7_READ_ACCESS 1u +#define MINION_CSR_PMPADDR7_PMPADDR7_WRITE_ACCESS 1u +#define MINION_CSR_PMPADDR7_PMPADDR7_RESET 0x0000000000000000ull +#define MINION_CSR_PMPADDR7_PMPADDR7_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PMPADDR7_PMPADDR7_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_PMPADDR7_PMPADDR7_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_PMPADDR7_PMPADDR7_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.pmpaddr8 */ +#define MINION_CSR_PMPADDR8_ADDRESS 0x00001DC0ul +#define MINION_CSR_PMPADDR8_BYTE_ADDRESS 0x00001DC0ul +#define MINION_CSR_PMPADDR8_OFFSET 0x00001DC0ul +#define MINION_CSR_PMPADDR8_BYTE_OFFSET 0x00001DC0ul +#define MINION_CSR_PMPADDR8_SIZE 0x00000008ul +#define MINION_CSR_PMPADDR8_BYTE_SIZE 0x00000008ul +#define MINION_CSR_PMPADDR8_READ_ACCESS 1u +#define MINION_CSR_PMPADDR8_WRITE_ACCESS 1u +#define MINION_CSR_PMPADDR8_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_PMPADDR8_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PMPADDR8_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PMPADDR8_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_PMPADDR8.pmpaddr8 */ +#define MINION_CSR_PMPADDR8_PMPADDR8_MSB 63u +#define MINION_CSR_PMPADDR8_PMPADDR8_LSB 0u +#define MINION_CSR_PMPADDR8_PMPADDR8_WIDTH 64u +#define MINION_CSR_PMPADDR8_PMPADDR8_READ_ACCESS 1u +#define MINION_CSR_PMPADDR8_PMPADDR8_WRITE_ACCESS 1u +#define MINION_CSR_PMPADDR8_PMPADDR8_RESET 0x0000000000000000ull +#define MINION_CSR_PMPADDR8_PMPADDR8_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PMPADDR8_PMPADDR8_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_PMPADDR8_PMPADDR8_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_PMPADDR8_PMPADDR8_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.pmpaddr9 */ +#define MINION_CSR_PMPADDR9_ADDRESS 0x00001DC8ul +#define MINION_CSR_PMPADDR9_BYTE_ADDRESS 0x00001DC8ul +#define MINION_CSR_PMPADDR9_OFFSET 0x00001DC8ul +#define MINION_CSR_PMPADDR9_BYTE_OFFSET 0x00001DC8ul +#define MINION_CSR_PMPADDR9_SIZE 0x00000008ul +#define MINION_CSR_PMPADDR9_BYTE_SIZE 0x00000008ul +#define MINION_CSR_PMPADDR9_READ_ACCESS 1u +#define MINION_CSR_PMPADDR9_WRITE_ACCESS 1u +#define MINION_CSR_PMPADDR9_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_PMPADDR9_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PMPADDR9_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PMPADDR9_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_PMPADDR9.pmpaddr9 */ +#define MINION_CSR_PMPADDR9_PMPADDR9_MSB 63u +#define MINION_CSR_PMPADDR9_PMPADDR9_LSB 0u +#define MINION_CSR_PMPADDR9_PMPADDR9_WIDTH 64u +#define MINION_CSR_PMPADDR9_PMPADDR9_READ_ACCESS 1u +#define MINION_CSR_PMPADDR9_PMPADDR9_WRITE_ACCESS 1u +#define MINION_CSR_PMPADDR9_PMPADDR9_RESET 0x0000000000000000ull +#define MINION_CSR_PMPADDR9_PMPADDR9_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PMPADDR9_PMPADDR9_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_PMPADDR9_PMPADDR9_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_PMPADDR9_PMPADDR9_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.pmpaddr10 */ +#define MINION_CSR_PMPADDR10_ADDRESS 0x00001DD0ul +#define MINION_CSR_PMPADDR10_BYTE_ADDRESS 0x00001DD0ul +#define MINION_CSR_PMPADDR10_OFFSET 0x00001DD0ul +#define MINION_CSR_PMPADDR10_BYTE_OFFSET 0x00001DD0ul +#define MINION_CSR_PMPADDR10_SIZE 0x00000008ul +#define MINION_CSR_PMPADDR10_BYTE_SIZE 0x00000008ul +#define MINION_CSR_PMPADDR10_READ_ACCESS 1u +#define MINION_CSR_PMPADDR10_WRITE_ACCESS 1u +#define MINION_CSR_PMPADDR10_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_PMPADDR10_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PMPADDR10_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PMPADDR10_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_PMPADDR10.pmpaddr10 */ +#define MINION_CSR_PMPADDR10_PMPADDR10_MSB 63u +#define MINION_CSR_PMPADDR10_PMPADDR10_LSB 0u +#define MINION_CSR_PMPADDR10_PMPADDR10_WIDTH 64u +#define MINION_CSR_PMPADDR10_PMPADDR10_READ_ACCESS 1u +#define MINION_CSR_PMPADDR10_PMPADDR10_WRITE_ACCESS 1u +#define MINION_CSR_PMPADDR10_PMPADDR10_RESET 0x0000000000000000ull +#define MINION_CSR_PMPADDR10_PMPADDR10_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PMPADDR10_PMPADDR10_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_PMPADDR10_PMPADDR10_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_PMPADDR10_PMPADDR10_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.pmpaddr11 */ +#define MINION_CSR_PMPADDR11_ADDRESS 0x00001DD8ul +#define MINION_CSR_PMPADDR11_BYTE_ADDRESS 0x00001DD8ul +#define MINION_CSR_PMPADDR11_OFFSET 0x00001DD8ul +#define MINION_CSR_PMPADDR11_BYTE_OFFSET 0x00001DD8ul +#define MINION_CSR_PMPADDR11_SIZE 0x00000008ul +#define MINION_CSR_PMPADDR11_BYTE_SIZE 0x00000008ul +#define MINION_CSR_PMPADDR11_READ_ACCESS 1u +#define MINION_CSR_PMPADDR11_WRITE_ACCESS 1u +#define MINION_CSR_PMPADDR11_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_PMPADDR11_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PMPADDR11_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PMPADDR11_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_PMPADDR11.pmpaddr11 */ +#define MINION_CSR_PMPADDR11_PMPADDR11_MSB 63u +#define MINION_CSR_PMPADDR11_PMPADDR11_LSB 0u +#define MINION_CSR_PMPADDR11_PMPADDR11_WIDTH 64u +#define MINION_CSR_PMPADDR11_PMPADDR11_READ_ACCESS 1u +#define MINION_CSR_PMPADDR11_PMPADDR11_WRITE_ACCESS 1u +#define MINION_CSR_PMPADDR11_PMPADDR11_RESET 0x0000000000000000ull +#define MINION_CSR_PMPADDR11_PMPADDR11_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PMPADDR11_PMPADDR11_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_PMPADDR11_PMPADDR11_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_PMPADDR11_PMPADDR11_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.pmpaddr12 */ +#define MINION_CSR_PMPADDR12_ADDRESS 0x00001DE0ul +#define MINION_CSR_PMPADDR12_BYTE_ADDRESS 0x00001DE0ul +#define MINION_CSR_PMPADDR12_OFFSET 0x00001DE0ul +#define MINION_CSR_PMPADDR12_BYTE_OFFSET 0x00001DE0ul +#define MINION_CSR_PMPADDR12_SIZE 0x00000008ul +#define MINION_CSR_PMPADDR12_BYTE_SIZE 0x00000008ul +#define MINION_CSR_PMPADDR12_READ_ACCESS 1u +#define MINION_CSR_PMPADDR12_WRITE_ACCESS 1u +#define MINION_CSR_PMPADDR12_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_PMPADDR12_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PMPADDR12_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PMPADDR12_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_PMPADDR12.pmpaddr12 */ +#define MINION_CSR_PMPADDR12_PMPADDR12_MSB 63u +#define MINION_CSR_PMPADDR12_PMPADDR12_LSB 0u +#define MINION_CSR_PMPADDR12_PMPADDR12_WIDTH 64u +#define MINION_CSR_PMPADDR12_PMPADDR12_READ_ACCESS 1u +#define MINION_CSR_PMPADDR12_PMPADDR12_WRITE_ACCESS 1u +#define MINION_CSR_PMPADDR12_PMPADDR12_RESET 0x0000000000000000ull +#define MINION_CSR_PMPADDR12_PMPADDR12_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PMPADDR12_PMPADDR12_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_PMPADDR12_PMPADDR12_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_PMPADDR12_PMPADDR12_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.pmpaddr13 */ +#define MINION_CSR_PMPADDR13_ADDRESS 0x00001DE8ul +#define MINION_CSR_PMPADDR13_BYTE_ADDRESS 0x00001DE8ul +#define MINION_CSR_PMPADDR13_OFFSET 0x00001DE8ul +#define MINION_CSR_PMPADDR13_BYTE_OFFSET 0x00001DE8ul +#define MINION_CSR_PMPADDR13_SIZE 0x00000008ul +#define MINION_CSR_PMPADDR13_BYTE_SIZE 0x00000008ul +#define MINION_CSR_PMPADDR13_READ_ACCESS 1u +#define MINION_CSR_PMPADDR13_WRITE_ACCESS 1u +#define MINION_CSR_PMPADDR13_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_PMPADDR13_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PMPADDR13_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PMPADDR13_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_PMPADDR13.pmpaddr13 */ +#define MINION_CSR_PMPADDR13_PMPADDR13_MSB 63u +#define MINION_CSR_PMPADDR13_PMPADDR13_LSB 0u +#define MINION_CSR_PMPADDR13_PMPADDR13_WIDTH 64u +#define MINION_CSR_PMPADDR13_PMPADDR13_READ_ACCESS 1u +#define MINION_CSR_PMPADDR13_PMPADDR13_WRITE_ACCESS 1u +#define MINION_CSR_PMPADDR13_PMPADDR13_RESET 0x0000000000000000ull +#define MINION_CSR_PMPADDR13_PMPADDR13_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PMPADDR13_PMPADDR13_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_PMPADDR13_PMPADDR13_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_PMPADDR13_PMPADDR13_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.pmpaddr14 */ +#define MINION_CSR_PMPADDR14_ADDRESS 0x00001DF0ul +#define MINION_CSR_PMPADDR14_BYTE_ADDRESS 0x00001DF0ul +#define MINION_CSR_PMPADDR14_OFFSET 0x00001DF0ul +#define MINION_CSR_PMPADDR14_BYTE_OFFSET 0x00001DF0ul +#define MINION_CSR_PMPADDR14_SIZE 0x00000008ul +#define MINION_CSR_PMPADDR14_BYTE_SIZE 0x00000008ul +#define MINION_CSR_PMPADDR14_READ_ACCESS 1u +#define MINION_CSR_PMPADDR14_WRITE_ACCESS 1u +#define MINION_CSR_PMPADDR14_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_PMPADDR14_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PMPADDR14_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PMPADDR14_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_PMPADDR14.pmpaddr14 */ +#define MINION_CSR_PMPADDR14_PMPADDR14_MSB 63u +#define MINION_CSR_PMPADDR14_PMPADDR14_LSB 0u +#define MINION_CSR_PMPADDR14_PMPADDR14_WIDTH 64u +#define MINION_CSR_PMPADDR14_PMPADDR14_READ_ACCESS 1u +#define MINION_CSR_PMPADDR14_PMPADDR14_WRITE_ACCESS 1u +#define MINION_CSR_PMPADDR14_PMPADDR14_RESET 0x0000000000000000ull +#define MINION_CSR_PMPADDR14_PMPADDR14_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PMPADDR14_PMPADDR14_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_PMPADDR14_PMPADDR14_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_PMPADDR14_PMPADDR14_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.pmpaddr15 */ +#define MINION_CSR_PMPADDR15_ADDRESS 0x00001DF8ul +#define MINION_CSR_PMPADDR15_BYTE_ADDRESS 0x00001DF8ul +#define MINION_CSR_PMPADDR15_OFFSET 0x00001DF8ul +#define MINION_CSR_PMPADDR15_BYTE_OFFSET 0x00001DF8ul +#define MINION_CSR_PMPADDR15_SIZE 0x00000008ul +#define MINION_CSR_PMPADDR15_BYTE_SIZE 0x00000008ul +#define MINION_CSR_PMPADDR15_READ_ACCESS 1u +#define MINION_CSR_PMPADDR15_WRITE_ACCESS 1u +#define MINION_CSR_PMPADDR15_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_PMPADDR15_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PMPADDR15_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PMPADDR15_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_PMPADDR15.pmpaddr15 */ +#define MINION_CSR_PMPADDR15_PMPADDR15_MSB 63u +#define MINION_CSR_PMPADDR15_PMPADDR15_LSB 0u +#define MINION_CSR_PMPADDR15_PMPADDR15_WIDTH 64u +#define MINION_CSR_PMPADDR15_PMPADDR15_READ_ACCESS 1u +#define MINION_CSR_PMPADDR15_PMPADDR15_WRITE_ACCESS 1u +#define MINION_CSR_PMPADDR15_PMPADDR15_RESET 0x0000000000000000ull +#define MINION_CSR_PMPADDR15_PMPADDR15_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PMPADDR15_PMPADDR15_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_PMPADDR15_PMPADDR15_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_PMPADDR15_PMPADDR15_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.tselect */ +#define MINION_CSR_TSELECT_ADDRESS 0x00003D00ul +#define MINION_CSR_TSELECT_BYTE_ADDRESS 0x00003D00ul +#define MINION_CSR_TSELECT_OFFSET 0x00003D00ul +#define MINION_CSR_TSELECT_BYTE_OFFSET 0x00003D00ul +#define MINION_CSR_TSELECT_SIZE 0x00000008ul +#define MINION_CSR_TSELECT_BYTE_SIZE 0x00000008ul +#define MINION_CSR_TSELECT_READ_ACCESS 1u +#define MINION_CSR_TSELECT_WRITE_ACCESS 1u +#define MINION_CSR_TSELECT_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_TSELECT_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_TSELECT_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_TSELECT_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_TSELECT.tselect */ +#define MINION_CSR_TSELECT_TSELECT_MSB 63u +#define MINION_CSR_TSELECT_TSELECT_LSB 0u +#define MINION_CSR_TSELECT_TSELECT_WIDTH 64u +#define MINION_CSR_TSELECT_TSELECT_READ_ACCESS 1u +#define MINION_CSR_TSELECT_TSELECT_WRITE_ACCESS 1u +#define MINION_CSR_TSELECT_TSELECT_RESET 0x0000000000000000ull +#define MINION_CSR_TSELECT_TSELECT_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_TSELECT_TSELECT_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_TSELECT_TSELECT_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_TSELECT_TSELECT_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.tdata1 */ +#define MINION_CSR_TDATA1_ADDRESS 0x00003D08ul +#define MINION_CSR_TDATA1_BYTE_ADDRESS 0x00003D08ul +#define MINION_CSR_TDATA1_OFFSET 0x00003D08ul +#define MINION_CSR_TDATA1_BYTE_OFFSET 0x00003D08ul +#define MINION_CSR_TDATA1_SIZE 0x00000008ul +#define MINION_CSR_TDATA1_BYTE_SIZE 0x00000008ul +#define MINION_CSR_TDATA1_READ_ACCESS 1u +#define MINION_CSR_TDATA1_WRITE_ACCESS 1u +#define MINION_CSR_TDATA1_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_TDATA1_RESET_MASK 0x00000000FFFFFFFFull +#define MINION_CSR_TDATA1_READ_MASK 0x00000000FFFFFFFFull +#define MINION_CSR_TDATA1_WRITE_MASK 0x00000000FFFFFFFFull + +/* Field: MINION_CSR_TDATA1.data */ +#define MINION_CSR_TDATA1_DATA_MSB 26u +#define MINION_CSR_TDATA1_DATA_LSB 0u +#define MINION_CSR_TDATA1_DATA_WIDTH 27u +#define MINION_CSR_TDATA1_DATA_READ_ACCESS 1u +#define MINION_CSR_TDATA1_DATA_WRITE_ACCESS 1u +#define MINION_CSR_TDATA1_DATA_RESET 0x0000000000000000ull +#define MINION_CSR_TDATA1_DATA_FIELD_MASK 0x0000000007FFFFFFull +#define MINION_CSR_TDATA1_DATA_GET(x) ((x) & 0x0000000007FFFFFFull) +#define MINION_CSR_TDATA1_DATA_SET(x) ((x) & 0x0000000007FFFFFFull) +#define MINION_CSR_TDATA1_DATA_MODIFY(r, x) ((((x) << 0) & 0x0000000007FFFFFFull) | ((r) & 0xFFFFFFFFF8000000ull)) + +/* Field: MINION_CSR_TDATA1.dmode */ +#define MINION_CSR_TDATA1_DMODE_MSB 27u +#define MINION_CSR_TDATA1_DMODE_LSB 27u +#define MINION_CSR_TDATA1_DMODE_WIDTH 1u +#define MINION_CSR_TDATA1_DMODE_READ_ACCESS 1u +#define MINION_CSR_TDATA1_DMODE_WRITE_ACCESS 1u +#define MINION_CSR_TDATA1_DMODE_RESET 0x0000000000000000ull +#define MINION_CSR_TDATA1_DMODE_FIELD_MASK 0x0000000008000000ull +#define MINION_CSR_TDATA1_DMODE_GET(x) (((x) & 0x0000000008000000ull) >> 27) +#define MINION_CSR_TDATA1_DMODE_SET(x) (((x) << 27) & 0x0000000008000000ull) +#define MINION_CSR_TDATA1_DMODE_MODIFY(r, x) ((((x) << 27) & 0x0000000008000000ull) | ((r) & 0xFFFFFFFFF7FFFFFFull)) + +/* Field: MINION_CSR_TDATA1.trigger */ +#define MINION_CSR_TDATA1_TRIGGER_MSB 31u +#define MINION_CSR_TDATA1_TRIGGER_LSB 28u +#define MINION_CSR_TDATA1_TRIGGER_WIDTH 4u +#define MINION_CSR_TDATA1_TRIGGER_READ_ACCESS 1u +#define MINION_CSR_TDATA1_TRIGGER_WRITE_ACCESS 1u +#define MINION_CSR_TDATA1_TRIGGER_RESET 0x0000000000000000ull +#define MINION_CSR_TDATA1_TRIGGER_FIELD_MASK 0x00000000F0000000ull +#define MINION_CSR_TDATA1_TRIGGER_GET(x) (((x) & 0x00000000F0000000ull) >> 28) +#define MINION_CSR_TDATA1_TRIGGER_SET(x) (((x) << 28) & 0x00000000F0000000ull) +#define MINION_CSR_TDATA1_TRIGGER_MODIFY(r, x) ((((x) << 28) & 0x00000000F0000000ull) | ((r) & 0xFFFFFFFF0FFFFFFFull)) + +/* Register: MINION_CSR.tdata2 */ +#define MINION_CSR_TDATA2_ADDRESS 0x00003D10ul +#define MINION_CSR_TDATA2_BYTE_ADDRESS 0x00003D10ul +#define MINION_CSR_TDATA2_OFFSET 0x00003D10ul +#define MINION_CSR_TDATA2_BYTE_OFFSET 0x00003D10ul +#define MINION_CSR_TDATA2_SIZE 0x00000008ul +#define MINION_CSR_TDATA2_BYTE_SIZE 0x00000008ul +#define MINION_CSR_TDATA2_READ_ACCESS 1u +#define MINION_CSR_TDATA2_WRITE_ACCESS 1u +#define MINION_CSR_TDATA2_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_TDATA2_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_TDATA2_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_TDATA2_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_TDATA2.tdata2 */ +#define MINION_CSR_TDATA2_TDATA2_MSB 63u +#define MINION_CSR_TDATA2_TDATA2_LSB 0u +#define MINION_CSR_TDATA2_TDATA2_WIDTH 64u +#define MINION_CSR_TDATA2_TDATA2_READ_ACCESS 1u +#define MINION_CSR_TDATA2_TDATA2_WRITE_ACCESS 1u +#define MINION_CSR_TDATA2_TDATA2_RESET 0x0000000000000000ull +#define MINION_CSR_TDATA2_TDATA2_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_TDATA2_TDATA2_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_TDATA2_TDATA2_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_TDATA2_TDATA2_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.tdata3 */ +#define MINION_CSR_TDATA3_ADDRESS 0x00003D18ul +#define MINION_CSR_TDATA3_BYTE_ADDRESS 0x00003D18ul +#define MINION_CSR_TDATA3_OFFSET 0x00003D18ul +#define MINION_CSR_TDATA3_BYTE_OFFSET 0x00003D18ul +#define MINION_CSR_TDATA3_SIZE 0x00000008ul +#define MINION_CSR_TDATA3_BYTE_SIZE 0x00000008ul +#define MINION_CSR_TDATA3_READ_ACCESS 1u +#define MINION_CSR_TDATA3_WRITE_ACCESS 1u +#define MINION_CSR_TDATA3_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_TDATA3_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_TDATA3_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_TDATA3_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_TDATA3.tdata3 */ +#define MINION_CSR_TDATA3_TDATA3_MSB 63u +#define MINION_CSR_TDATA3_TDATA3_LSB 0u +#define MINION_CSR_TDATA3_TDATA3_WIDTH 64u +#define MINION_CSR_TDATA3_TDATA3_READ_ACCESS 1u +#define MINION_CSR_TDATA3_TDATA3_WRITE_ACCESS 1u +#define MINION_CSR_TDATA3_TDATA3_RESET 0x0000000000000000ull +#define MINION_CSR_TDATA3_TDATA3_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_TDATA3_TDATA3_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_TDATA3_TDATA3_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_TDATA3_TDATA3_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.tinfo */ +#define MINION_CSR_TINFO_ADDRESS 0x00003D20ul +#define MINION_CSR_TINFO_BYTE_ADDRESS 0x00003D20ul +#define MINION_CSR_TINFO_OFFSET 0x00003D20ul +#define MINION_CSR_TINFO_BYTE_OFFSET 0x00003D20ul +#define MINION_CSR_TINFO_SIZE 0x00000008ul +#define MINION_CSR_TINFO_BYTE_SIZE 0x00000008ul +#define MINION_CSR_TINFO_READ_ACCESS 1u +#define MINION_CSR_TINFO_WRITE_ACCESS 1u +#define MINION_CSR_TINFO_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_TINFO_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_TINFO_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_TINFO_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_TINFO.tinfo */ +#define MINION_CSR_TINFO_TINFO_MSB 63u +#define MINION_CSR_TINFO_TINFO_LSB 0u +#define MINION_CSR_TINFO_TINFO_WIDTH 64u +#define MINION_CSR_TINFO_TINFO_READ_ACCESS 1u +#define MINION_CSR_TINFO_TINFO_WRITE_ACCESS 1u +#define MINION_CSR_TINFO_TINFO_RESET 0x0000000000000000ull +#define MINION_CSR_TINFO_TINFO_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_TINFO_TINFO_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_TINFO_TINFO_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_TINFO_TINFO_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.dcsr */ +#define MINION_CSR_DCSR_ADDRESS 0x00003D80ul +#define MINION_CSR_DCSR_BYTE_ADDRESS 0x00003D80ul +#define MINION_CSR_DCSR_OFFSET 0x00003D80ul +#define MINION_CSR_DCSR_BYTE_OFFSET 0x00003D80ul +#define MINION_CSR_DCSR_SIZE 0x00000008ul +#define MINION_CSR_DCSR_BYTE_SIZE 0x00000008ul +#define MINION_CSR_DCSR_READ_ACCESS 1u +#define MINION_CSR_DCSR_WRITE_ACCESS 1u +#define MINION_CSR_DCSR_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_DCSR_RESET_MASK 0x00000000F000BFDFull +#define MINION_CSR_DCSR_READ_MASK 0x00000000F000BFDFull +#define MINION_CSR_DCSR_WRITE_MASK 0x000000000000BE17ull + +/* Field: MINION_CSR_DCSR.prv */ +#define MINION_CSR_DCSR_PRV_MSB 1u +#define MINION_CSR_DCSR_PRV_LSB 0u +#define MINION_CSR_DCSR_PRV_WIDTH 2u +#define MINION_CSR_DCSR_PRV_READ_ACCESS 1u +#define MINION_CSR_DCSR_PRV_WRITE_ACCESS 1u +#define MINION_CSR_DCSR_PRV_RESET 0x0000000000000000ull +#define MINION_CSR_DCSR_PRV_FIELD_MASK 0x0000000000000003ull +#define MINION_CSR_DCSR_PRV_GET(x) ((x) & 0x0000000000000003ull) +#define MINION_CSR_DCSR_PRV_SET(x) ((x) & 0x0000000000000003ull) +#define MINION_CSR_DCSR_PRV_MODIFY(r, x) ((((x) << 0) & 0x0000000000000003ull) | ((r) & 0xFFFFFFFFFFFFFFFCull)) + +/* Field: MINION_CSR_DCSR.step */ +#define MINION_CSR_DCSR_STEP_MSB 2u +#define MINION_CSR_DCSR_STEP_LSB 2u +#define MINION_CSR_DCSR_STEP_WIDTH 1u +#define MINION_CSR_DCSR_STEP_READ_ACCESS 1u +#define MINION_CSR_DCSR_STEP_WRITE_ACCESS 1u +#define MINION_CSR_DCSR_STEP_RESET 0x0000000000000000ull +#define MINION_CSR_DCSR_STEP_FIELD_MASK 0x0000000000000004ull +#define MINION_CSR_DCSR_STEP_GET(x) (((x) & 0x0000000000000004ull) >> 2) +#define MINION_CSR_DCSR_STEP_SET(x) (((x) << 2) & 0x0000000000000004ull) +#define MINION_CSR_DCSR_STEP_MODIFY(r, x) ((((x) << 2) & 0x0000000000000004ull) | ((r) & 0xFFFFFFFFFFFFFFFBull)) + +/* Field: MINION_CSR_DCSR.nmip */ +#define MINION_CSR_DCSR_NMIP_MSB 3u +#define MINION_CSR_DCSR_NMIP_LSB 3u +#define MINION_CSR_DCSR_NMIP_WIDTH 1u +#define MINION_CSR_DCSR_NMIP_READ_ACCESS 1u +#define MINION_CSR_DCSR_NMIP_WRITE_ACCESS 0u +#define MINION_CSR_DCSR_NMIP_RESET 0x0000000000000000ull +#define MINION_CSR_DCSR_NMIP_FIELD_MASK 0x0000000000000008ull +#define MINION_CSR_DCSR_NMIP_GET(x) (((x) & 0x0000000000000008ull) >> 3) +#define MINION_CSR_DCSR_NMIP_SET(x) (((x) << 3) & 0x0000000000000008ull) +#define MINION_CSR_DCSR_NMIP_MODIFY(r, x) ((((x) << 3) & 0x0000000000000008ull) | ((r) & 0xFFFFFFFFFFFFFFF7ull)) + +/* Field: MINION_CSR_DCSR.mpvren */ +#define MINION_CSR_DCSR_MPVREN_MSB 4u +#define MINION_CSR_DCSR_MPVREN_LSB 4u +#define MINION_CSR_DCSR_MPVREN_WIDTH 1u +#define MINION_CSR_DCSR_MPVREN_READ_ACCESS 1u +#define MINION_CSR_DCSR_MPVREN_WRITE_ACCESS 1u +#define MINION_CSR_DCSR_MPVREN_RESET 0x0000000000000000ull +#define MINION_CSR_DCSR_MPVREN_FIELD_MASK 0x0000000000000010ull +#define MINION_CSR_DCSR_MPVREN_GET(x) (((x) & 0x0000000000000010ull) >> 4) +#define MINION_CSR_DCSR_MPVREN_SET(x) (((x) << 4) & 0x0000000000000010ull) +#define MINION_CSR_DCSR_MPVREN_MODIFY(r, x) ((((x) << 4) & 0x0000000000000010ull) | ((r) & 0xFFFFFFFFFFFFFFEFull)) + +/* Field: MINION_CSR_DCSR.cause */ +#define MINION_CSR_DCSR_CAUSE_MSB 8u +#define MINION_CSR_DCSR_CAUSE_LSB 6u +#define MINION_CSR_DCSR_CAUSE_WIDTH 3u +#define MINION_CSR_DCSR_CAUSE_READ_ACCESS 1u +#define MINION_CSR_DCSR_CAUSE_WRITE_ACCESS 0u +#define MINION_CSR_DCSR_CAUSE_RESET 0x0000000000000000ull +#define MINION_CSR_DCSR_CAUSE_FIELD_MASK 0x00000000000001C0ull +#define MINION_CSR_DCSR_CAUSE_GET(x) (((x) & 0x00000000000001C0ull) >> 6) +#define MINION_CSR_DCSR_CAUSE_SET(x) (((x) << 6) & 0x00000000000001C0ull) +#define MINION_CSR_DCSR_CAUSE_MODIFY(r, x) ((((x) << 6) & 0x00000000000001C0ull) | ((r) & 0xFFFFFFFFFFFFFE3Full)) + +/* Field: MINION_CSR_DCSR.stoptime */ +#define MINION_CSR_DCSR_STOPTIME_MSB 9u +#define MINION_CSR_DCSR_STOPTIME_LSB 9u +#define MINION_CSR_DCSR_STOPTIME_WIDTH 1u +#define MINION_CSR_DCSR_STOPTIME_READ_ACCESS 1u +#define MINION_CSR_DCSR_STOPTIME_WRITE_ACCESS 1u +#define MINION_CSR_DCSR_STOPTIME_RESET 0x0000000000000000ull +#define MINION_CSR_DCSR_STOPTIME_FIELD_MASK 0x0000000000000200ull +#define MINION_CSR_DCSR_STOPTIME_GET(x) (((x) & 0x0000000000000200ull) >> 9) +#define MINION_CSR_DCSR_STOPTIME_SET(x) (((x) << 9) & 0x0000000000000200ull) +#define MINION_CSR_DCSR_STOPTIME_MODIFY(r, x) ((((x) << 9) & 0x0000000000000200ull) | ((r) & 0xFFFFFFFFFFFFFDFFull)) + +/* Field: MINION_CSR_DCSR.stopcount */ +#define MINION_CSR_DCSR_STOPCOUNT_MSB 10u +#define MINION_CSR_DCSR_STOPCOUNT_LSB 10u +#define MINION_CSR_DCSR_STOPCOUNT_WIDTH 1u +#define MINION_CSR_DCSR_STOPCOUNT_READ_ACCESS 1u +#define MINION_CSR_DCSR_STOPCOUNT_WRITE_ACCESS 1u +#define MINION_CSR_DCSR_STOPCOUNT_RESET 0x0000000000000000ull +#define MINION_CSR_DCSR_STOPCOUNT_FIELD_MASK 0x0000000000000400ull +#define MINION_CSR_DCSR_STOPCOUNT_GET(x) (((x) & 0x0000000000000400ull) >> 10) +#define MINION_CSR_DCSR_STOPCOUNT_SET(x) (((x) << 10) & 0x0000000000000400ull) +#define MINION_CSR_DCSR_STOPCOUNT_MODIFY(r, x) ((((x) << 10) & 0x0000000000000400ull) | ((r) & 0xFFFFFFFFFFFFFBFFull)) + +/* Field: MINION_CSR_DCSR.stepie */ +#define MINION_CSR_DCSR_STEPIE_MSB 11u +#define MINION_CSR_DCSR_STEPIE_LSB 11u +#define MINION_CSR_DCSR_STEPIE_WIDTH 1u +#define MINION_CSR_DCSR_STEPIE_READ_ACCESS 1u +#define MINION_CSR_DCSR_STEPIE_WRITE_ACCESS 1u +#define MINION_CSR_DCSR_STEPIE_RESET 0x0000000000000000ull +#define MINION_CSR_DCSR_STEPIE_FIELD_MASK 0x0000000000000800ull +#define MINION_CSR_DCSR_STEPIE_GET(x) (((x) & 0x0000000000000800ull) >> 11) +#define MINION_CSR_DCSR_STEPIE_SET(x) (((x) << 11) & 0x0000000000000800ull) +#define MINION_CSR_DCSR_STEPIE_MODIFY(r, x) ((((x) << 11) & 0x0000000000000800ull) | ((r) & 0xFFFFFFFFFFFFF7FFull)) + +/* Field: MINION_CSR_DCSR.ebreaku */ +#define MINION_CSR_DCSR_EBREAKU_MSB 12u +#define MINION_CSR_DCSR_EBREAKU_LSB 12u +#define MINION_CSR_DCSR_EBREAKU_WIDTH 1u +#define MINION_CSR_DCSR_EBREAKU_READ_ACCESS 1u +#define MINION_CSR_DCSR_EBREAKU_WRITE_ACCESS 1u +#define MINION_CSR_DCSR_EBREAKU_RESET 0x0000000000000000ull +#define MINION_CSR_DCSR_EBREAKU_FIELD_MASK 0x0000000000001000ull +#define MINION_CSR_DCSR_EBREAKU_GET(x) (((x) & 0x0000000000001000ull) >> 12) +#define MINION_CSR_DCSR_EBREAKU_SET(x) (((x) << 12) & 0x0000000000001000ull) +#define MINION_CSR_DCSR_EBREAKU_MODIFY(r, x) ((((x) << 12) & 0x0000000000001000ull) | ((r) & 0xFFFFFFFFFFFFEFFFull)) + +/* Field: MINION_CSR_DCSR.ebreaks */ +#define MINION_CSR_DCSR_EBREAKS_MSB 13u +#define MINION_CSR_DCSR_EBREAKS_LSB 13u +#define MINION_CSR_DCSR_EBREAKS_WIDTH 1u +#define MINION_CSR_DCSR_EBREAKS_READ_ACCESS 1u +#define MINION_CSR_DCSR_EBREAKS_WRITE_ACCESS 1u +#define MINION_CSR_DCSR_EBREAKS_RESET 0x0000000000000000ull +#define MINION_CSR_DCSR_EBREAKS_FIELD_MASK 0x0000000000002000ull +#define MINION_CSR_DCSR_EBREAKS_GET(x) (((x) & 0x0000000000002000ull) >> 13) +#define MINION_CSR_DCSR_EBREAKS_SET(x) (((x) << 13) & 0x0000000000002000ull) +#define MINION_CSR_DCSR_EBREAKS_MODIFY(r, x) ((((x) << 13) & 0x0000000000002000ull) | ((r) & 0xFFFFFFFFFFFFDFFFull)) + +/* Field: MINION_CSR_DCSR.ebreakm */ +#define MINION_CSR_DCSR_EBREAKM_MSB 15u +#define MINION_CSR_DCSR_EBREAKM_LSB 15u +#define MINION_CSR_DCSR_EBREAKM_WIDTH 1u +#define MINION_CSR_DCSR_EBREAKM_READ_ACCESS 1u +#define MINION_CSR_DCSR_EBREAKM_WRITE_ACCESS 1u +#define MINION_CSR_DCSR_EBREAKM_RESET 0x0000000000000000ull +#define MINION_CSR_DCSR_EBREAKM_FIELD_MASK 0x0000000000008000ull +#define MINION_CSR_DCSR_EBREAKM_GET(x) (((x) & 0x0000000000008000ull) >> 15) +#define MINION_CSR_DCSR_EBREAKM_SET(x) (((x) << 15) & 0x0000000000008000ull) +#define MINION_CSR_DCSR_EBREAKM_MODIFY(r, x) ((((x) << 15) & 0x0000000000008000ull) | ((r) & 0xFFFFFFFFFFFF7FFFull)) + +/* Field: MINION_CSR_DCSR.xdebugver */ +#define MINION_CSR_DCSR_XDEBUGVER_MSB 31u +#define MINION_CSR_DCSR_XDEBUGVER_LSB 28u +#define MINION_CSR_DCSR_XDEBUGVER_WIDTH 4u +#define MINION_CSR_DCSR_XDEBUGVER_READ_ACCESS 1u +#define MINION_CSR_DCSR_XDEBUGVER_WRITE_ACCESS 0u +#define MINION_CSR_DCSR_XDEBUGVER_RESET 0x0000000000000000ull +#define MINION_CSR_DCSR_XDEBUGVER_FIELD_MASK 0x00000000F0000000ull +#define MINION_CSR_DCSR_XDEBUGVER_GET(x) (((x) & 0x00000000F0000000ull) >> 28) +#define MINION_CSR_DCSR_XDEBUGVER_SET(x) (((x) << 28) & 0x00000000F0000000ull) +#define MINION_CSR_DCSR_XDEBUGVER_MODIFY(r, x) ((((x) << 28) & 0x00000000F0000000ull) | ((r) & 0xFFFFFFFF0FFFFFFFull)) + +/* Register: MINION_CSR.dpc */ +#define MINION_CSR_DPC_ADDRESS 0x00003D88ul +#define MINION_CSR_DPC_BYTE_ADDRESS 0x00003D88ul +#define MINION_CSR_DPC_OFFSET 0x00003D88ul +#define MINION_CSR_DPC_BYTE_OFFSET 0x00003D88ul +#define MINION_CSR_DPC_SIZE 0x00000008ul +#define MINION_CSR_DPC_BYTE_SIZE 0x00000008ul +#define MINION_CSR_DPC_READ_ACCESS 1u +#define MINION_CSR_DPC_WRITE_ACCESS 1u +#define MINION_CSR_DPC_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_DPC_RESET_MASK 0x0001FFFFFFFFFFFEull +#define MINION_CSR_DPC_READ_MASK 0x0001FFFFFFFFFFFEull +#define MINION_CSR_DPC_WRITE_MASK 0x0001FFFFFFFFFFFEull + +/* Field: MINION_CSR_DPC.base */ +#define MINION_CSR_DPC_BASE_MSB 47u +#define MINION_CSR_DPC_BASE_LSB 1u +#define MINION_CSR_DPC_BASE_WIDTH 47u +#define MINION_CSR_DPC_BASE_READ_ACCESS 1u +#define MINION_CSR_DPC_BASE_WRITE_ACCESS 1u +#define MINION_CSR_DPC_BASE_RESET 0x0000000000000000ull +#define MINION_CSR_DPC_BASE_FIELD_MASK 0x0000FFFFFFFFFFFEull +#define MINION_CSR_DPC_BASE_GET(x) (((x) & 0x0000FFFFFFFFFFFEull) >> 1) +#define MINION_CSR_DPC_BASE_SET(x) (((x) << 1) & 0x0000FFFFFFFFFFFEull) +#define MINION_CSR_DPC_BASE_MODIFY(r, x) ((((x) << 1) & 0x0000FFFFFFFFFFFEull) | ((r) & 0xFFFF000000000001ull)) + +/* Field: MINION_CSR_DPC.sign_ext */ +#define MINION_CSR_DPC_SIGN_EXT_MSB 48u +#define MINION_CSR_DPC_SIGN_EXT_LSB 48u +#define MINION_CSR_DPC_SIGN_EXT_WIDTH 1u +#define MINION_CSR_DPC_SIGN_EXT_READ_ACCESS 1u +#define MINION_CSR_DPC_SIGN_EXT_WRITE_ACCESS 1u +#define MINION_CSR_DPC_SIGN_EXT_RESET 0x0000000000000000ull +#define MINION_CSR_DPC_SIGN_EXT_FIELD_MASK 0x0001000000000000ull +#define MINION_CSR_DPC_SIGN_EXT_GET(x) (((x) & 0x0001000000000000ull) >> 48) +#define MINION_CSR_DPC_SIGN_EXT_SET(x) (((x) << 48) & 0x0001000000000000ull) +#define MINION_CSR_DPC_SIGN_EXT_MODIFY(r, x) ((((x) << 48) & 0x0001000000000000ull) | ((r) & 0xFFFEFFFFFFFFFFFFull)) + +/* Register: MINION_CSR.dscratch0 */ +#define MINION_CSR_DSCRATCH0_ADDRESS 0x00003D90ul +#define MINION_CSR_DSCRATCH0_BYTE_ADDRESS 0x00003D90ul +#define MINION_CSR_DSCRATCH0_OFFSET 0x00003D90ul +#define MINION_CSR_DSCRATCH0_BYTE_OFFSET 0x00003D90ul +#define MINION_CSR_DSCRATCH0_SIZE 0x00000008ul +#define MINION_CSR_DSCRATCH0_BYTE_SIZE 0x00000008ul +#define MINION_CSR_DSCRATCH0_READ_ACCESS 1u +#define MINION_CSR_DSCRATCH0_WRITE_ACCESS 1u +#define MINION_CSR_DSCRATCH0_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_DSCRATCH0_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_DSCRATCH0_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_DSCRATCH0_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_DSCRATCH0.dscratch0 */ +#define MINION_CSR_DSCRATCH0_DSCRATCH0_MSB 63u +#define MINION_CSR_DSCRATCH0_DSCRATCH0_LSB 0u +#define MINION_CSR_DSCRATCH0_DSCRATCH0_WIDTH 64u +#define MINION_CSR_DSCRATCH0_DSCRATCH0_READ_ACCESS 1u +#define MINION_CSR_DSCRATCH0_DSCRATCH0_WRITE_ACCESS 1u +#define MINION_CSR_DSCRATCH0_DSCRATCH0_RESET 0x0000000000000000ull +#define MINION_CSR_DSCRATCH0_DSCRATCH0_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_DSCRATCH0_DSCRATCH0_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_DSCRATCH0_DSCRATCH0_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_DSCRATCH0_DSCRATCH0_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.ddata0 */ +#define MINION_CSR_DDATA0_ADDRESS 0x00003DC0ul +#define MINION_CSR_DDATA0_BYTE_ADDRESS 0x00003DC0ul +#define MINION_CSR_DDATA0_OFFSET 0x00003DC0ul +#define MINION_CSR_DDATA0_BYTE_OFFSET 0x00003DC0ul +#define MINION_CSR_DDATA0_SIZE 0x00000008ul +#define MINION_CSR_DDATA0_BYTE_SIZE 0x00000008ul +#define MINION_CSR_DDATA0_READ_ACCESS 1u +#define MINION_CSR_DDATA0_WRITE_ACCESS 1u +#define MINION_CSR_DDATA0_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_DDATA0_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_DDATA0_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_DDATA0_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_DDATA0.ddata0 */ +#define MINION_CSR_DDATA0_DDATA0_MSB 63u +#define MINION_CSR_DDATA0_DDATA0_LSB 0u +#define MINION_CSR_DDATA0_DDATA0_WIDTH 64u +#define MINION_CSR_DDATA0_DDATA0_READ_ACCESS 1u +#define MINION_CSR_DDATA0_DDATA0_WRITE_ACCESS 1u +#define MINION_CSR_DDATA0_DDATA0_RESET 0x0000000000000000ull +#define MINION_CSR_DDATA0_DDATA0_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_DDATA0_DDATA0_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_DDATA0_DDATA0_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_DDATA0_DDATA0_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.matp */ +#define MINION_CSR_MATP_ADDRESS 0x00003E00ul +#define MINION_CSR_MATP_BYTE_ADDRESS 0x00003E00ul +#define MINION_CSR_MATP_OFFSET 0x00003E00ul +#define MINION_CSR_MATP_BYTE_OFFSET 0x00003E00ul +#define MINION_CSR_MATP_SIZE 0x00000008ul +#define MINION_CSR_MATP_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MATP_READ_ACCESS 1u +#define MINION_CSR_MATP_WRITE_ACCESS 0u +#define MINION_CSR_MATP_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MATP_RESET_MASK 0xF80000000FFFFFFFull +#define MINION_CSR_MATP_READ_MASK 0xF80000000FFFFFFFull +#define MINION_CSR_MATP_WRITE_MASK 0x0000000000000000ull + +/* Field: MINION_CSR_MATP.ppn */ +#define MINION_CSR_MATP_PPN_MSB 27u +#define MINION_CSR_MATP_PPN_LSB 0u +#define MINION_CSR_MATP_PPN_WIDTH 28u +#define MINION_CSR_MATP_PPN_READ_ACCESS 1u +#define MINION_CSR_MATP_PPN_WRITE_ACCESS 0u +#define MINION_CSR_MATP_PPN_RESET 0x0000000000000000ull +#define MINION_CSR_MATP_PPN_FIELD_MASK 0x000000000FFFFFFFull +#define MINION_CSR_MATP_PPN_GET(x) ((x) & 0x000000000FFFFFFFull) +#define MINION_CSR_MATP_PPN_SET(x) ((x) & 0x000000000FFFFFFFull) +#define MINION_CSR_MATP_PPN_MODIFY(r, x) ((((x) << 0) & 0x000000000FFFFFFFull) | ((r) & 0xFFFFFFFFF0000000ull)) + +/* Field: MINION_CSR_MATP.lock */ +#define MINION_CSR_MATP_LOCK_MSB 59u +#define MINION_CSR_MATP_LOCK_LSB 59u +#define MINION_CSR_MATP_LOCK_WIDTH 1u +#define MINION_CSR_MATP_LOCK_READ_ACCESS 1u +#define MINION_CSR_MATP_LOCK_WRITE_ACCESS 0u +#define MINION_CSR_MATP_LOCK_RESET 0x0000000000000000ull +#define MINION_CSR_MATP_LOCK_FIELD_MASK 0x0800000000000000ull +#define MINION_CSR_MATP_LOCK_GET(x) (((x) & 0x0800000000000000ull) >> 59) +#define MINION_CSR_MATP_LOCK_SET(x) (((x) << 59) & 0x0800000000000000ull) +#define MINION_CSR_MATP_LOCK_MODIFY(r, x) ((((x) << 59) & 0x0800000000000000ull) | ((r) & 0xF7FFFFFFFFFFFFFFull)) + +/* Field: MINION_CSR_MATP.mode */ +#define MINION_CSR_MATP_MODE_MSB 63u +#define MINION_CSR_MATP_MODE_LSB 60u +#define MINION_CSR_MATP_MODE_WIDTH 4u +#define MINION_CSR_MATP_MODE_READ_ACCESS 1u +#define MINION_CSR_MATP_MODE_WRITE_ACCESS 0u +#define MINION_CSR_MATP_MODE_RESET 0x0000000000000000ull +#define MINION_CSR_MATP_MODE_FIELD_MASK 0xF000000000000000ull +#define MINION_CSR_MATP_MODE_GET(x) (((x) & 0xF000000000000000ull) >> 60) +#define MINION_CSR_MATP_MODE_SET(x) (((x) << 60) & 0xF000000000000000ull) +#define MINION_CSR_MATP_MODE_MODIFY(r, x) ((((x) << 60) & 0xF000000000000000ull) | ((r) & 0x0FFFFFFFFFFFFFFFull)) + +/* Register: MINION_CSR.minstmask */ +#define MINION_CSR_MINSTMASK_ADDRESS 0x00003E68ul +#define MINION_CSR_MINSTMASK_BYTE_ADDRESS 0x00003E68ul +#define MINION_CSR_MINSTMASK_OFFSET 0x00003E68ul +#define MINION_CSR_MINSTMASK_BYTE_OFFSET 0x00003E68ul +#define MINION_CSR_MINSTMASK_SIZE 0x00000008ul +#define MINION_CSR_MINSTMASK_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MINSTMASK_READ_ACCESS 1u +#define MINION_CSR_MINSTMASK_WRITE_ACCESS 1u +#define MINION_CSR_MINSTMASK_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MINSTMASK_RESET_MASK 0x00000001FFFFFFFFull +#define MINION_CSR_MINSTMASK_READ_MASK 0x00000001FFFFFFFFull +#define MINION_CSR_MINSTMASK_WRITE_MASK 0x00000001FFFFFFFFull + +/* Field: MINION_CSR_MINSTMASK.minstmask */ +#define MINION_CSR_MINSTMASK_MINSTMASK_MSB 32u +#define MINION_CSR_MINSTMASK_MINSTMASK_LSB 0u +#define MINION_CSR_MINSTMASK_MINSTMASK_WIDTH 33u +#define MINION_CSR_MINSTMASK_MINSTMASK_READ_ACCESS 1u +#define MINION_CSR_MINSTMASK_MINSTMASK_WRITE_ACCESS 1u +#define MINION_CSR_MINSTMASK_MINSTMASK_RESET 0x0000000000000000ull +#define MINION_CSR_MINSTMASK_MINSTMASK_FIELD_MASK 0x00000001FFFFFFFFull +#define MINION_CSR_MINSTMASK_MINSTMASK_GET(x) ((x) & 0x00000001FFFFFFFFull) +#define MINION_CSR_MINSTMASK_MINSTMASK_SET(x) ((x) & 0x00000001FFFFFFFFull) +#define MINION_CSR_MINSTMASK_MINSTMASK_MODIFY(r, x) ((((x) << 0) & 0x00000001FFFFFFFFull) | ((r) & 0xFFFFFFFE00000000ull)) + +/* Register: MINION_CSR.minstmatch */ +#define MINION_CSR_MINSTMATCH_ADDRESS 0x00003E70ul +#define MINION_CSR_MINSTMATCH_BYTE_ADDRESS 0x00003E70ul +#define MINION_CSR_MINSTMATCH_OFFSET 0x00003E70ul +#define MINION_CSR_MINSTMATCH_BYTE_OFFSET 0x00003E70ul +#define MINION_CSR_MINSTMATCH_SIZE 0x00000008ul +#define MINION_CSR_MINSTMATCH_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MINSTMATCH_READ_ACCESS 1u +#define MINION_CSR_MINSTMATCH_WRITE_ACCESS 1u +#define MINION_CSR_MINSTMATCH_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MINSTMATCH_RESET_MASK 0x00000000FFFFFFFFull +#define MINION_CSR_MINSTMATCH_READ_MASK 0x00000000FFFFFFFFull +#define MINION_CSR_MINSTMATCH_WRITE_MASK 0x00000000FFFFFFFFull + +/* Field: MINION_CSR_MINSTMATCH.minstmatch */ +#define MINION_CSR_MINSTMATCH_MINSTMATCH_MSB 31u +#define MINION_CSR_MINSTMATCH_MINSTMATCH_LSB 0u +#define MINION_CSR_MINSTMATCH_MINSTMATCH_WIDTH 32u +#define MINION_CSR_MINSTMATCH_MINSTMATCH_READ_ACCESS 1u +#define MINION_CSR_MINSTMATCH_MINSTMATCH_WRITE_ACCESS 1u +#define MINION_CSR_MINSTMATCH_MINSTMATCH_RESET 0x0000000000000000ull +#define MINION_CSR_MINSTMATCH_MINSTMATCH_FIELD_MASK 0x00000000FFFFFFFFull +#define MINION_CSR_MINSTMATCH_MINSTMATCH_GET(x) ((x) & 0x00000000FFFFFFFFull) +#define MINION_CSR_MINSTMATCH_MINSTMATCH_SET(x) ((x) & 0x00000000FFFFFFFFull) +#define MINION_CSR_MINSTMATCH_MINSTMATCH_MODIFY(r, x) ((((x) << 0) & 0x00000000FFFFFFFFull) | ((r) & 0xFFFFFFFF00000000ull)) + +/* Register: MINION_CSR.amofence_ctrl */ +#define MINION_CSR_AMOFENCE_CTRL_ADDRESS 0x00003E78ul +#define MINION_CSR_AMOFENCE_CTRL_BYTE_ADDRESS 0x00003E78ul +#define MINION_CSR_AMOFENCE_CTRL_OFFSET 0x00003E78ul +#define MINION_CSR_AMOFENCE_CTRL_BYTE_OFFSET 0x00003E78ul +#define MINION_CSR_AMOFENCE_CTRL_SIZE 0x00000008ul +#define MINION_CSR_AMOFENCE_CTRL_BYTE_SIZE 0x00000008ul +#define MINION_CSR_AMOFENCE_CTRL_READ_ACCESS 1u +#define MINION_CSR_AMOFENCE_CTRL_WRITE_ACCESS 1u +#define MINION_CSR_AMOFENCE_CTRL_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_AMOFENCE_CTRL_RESET_MASK 0x000000000000000Full +#define MINION_CSR_AMOFENCE_CTRL_READ_MASK 0x000000000000000Full +#define MINION_CSR_AMOFENCE_CTRL_WRITE_MASK 0x000000000000000Full + +/* Field: MINION_CSR_AMOFENCE_CTRL.af_aq */ +#define MINION_CSR_AMOFENCE_CTRL_AF_AQ_MSB 0u +#define MINION_CSR_AMOFENCE_CTRL_AF_AQ_LSB 0u +#define MINION_CSR_AMOFENCE_CTRL_AF_AQ_WIDTH 1u +#define MINION_CSR_AMOFENCE_CTRL_AF_AQ_READ_ACCESS 1u +#define MINION_CSR_AMOFENCE_CTRL_AF_AQ_WRITE_ACCESS 1u +#define MINION_CSR_AMOFENCE_CTRL_AF_AQ_RESET 0x0000000000000000ull +#define MINION_CSR_AMOFENCE_CTRL_AF_AQ_FIELD_MASK 0x0000000000000001ull +#define MINION_CSR_AMOFENCE_CTRL_AF_AQ_GET(x) ((x) & 0x0000000000000001ull) +#define MINION_CSR_AMOFENCE_CTRL_AF_AQ_SET(x) ((x) & 0x0000000000000001ull) +#define MINION_CSR_AMOFENCE_CTRL_AF_AQ_MODIFY(r, x) ((((x) << 0) & 0x0000000000000001ull) | ((r) & 0xFFFFFFFFFFFFFFFEull)) + +/* Field: MINION_CSR_AMOFENCE_CTRL.fa_rl */ +#define MINION_CSR_AMOFENCE_CTRL_FA_RL_MSB 1u +#define MINION_CSR_AMOFENCE_CTRL_FA_RL_LSB 1u +#define MINION_CSR_AMOFENCE_CTRL_FA_RL_WIDTH 1u +#define MINION_CSR_AMOFENCE_CTRL_FA_RL_READ_ACCESS 1u +#define MINION_CSR_AMOFENCE_CTRL_FA_RL_WRITE_ACCESS 1u +#define MINION_CSR_AMOFENCE_CTRL_FA_RL_RESET 0x0000000000000000ull +#define MINION_CSR_AMOFENCE_CTRL_FA_RL_FIELD_MASK 0x0000000000000002ull +#define MINION_CSR_AMOFENCE_CTRL_FA_RL_GET(x) (((x) & 0x0000000000000002ull) >> 1) +#define MINION_CSR_AMOFENCE_CTRL_FA_RL_SET(x) (((x) << 1) & 0x0000000000000002ull) +#define MINION_CSR_AMOFENCE_CTRL_FA_RL_MODIFY(r, x) ((((x) << 1) & 0x0000000000000002ull) | ((r) & 0xFFFFFFFFFFFFFFFDull)) + +/* Field: MINION_CSR_AMOFENCE_CTRL.fa_aq */ +#define MINION_CSR_AMOFENCE_CTRL_FA_AQ_MSB 2u +#define MINION_CSR_AMOFENCE_CTRL_FA_AQ_LSB 2u +#define MINION_CSR_AMOFENCE_CTRL_FA_AQ_WIDTH 1u +#define MINION_CSR_AMOFENCE_CTRL_FA_AQ_READ_ACCESS 1u +#define MINION_CSR_AMOFENCE_CTRL_FA_AQ_WRITE_ACCESS 1u +#define MINION_CSR_AMOFENCE_CTRL_FA_AQ_RESET 0x0000000000000000ull +#define MINION_CSR_AMOFENCE_CTRL_FA_AQ_FIELD_MASK 0x0000000000000004ull +#define MINION_CSR_AMOFENCE_CTRL_FA_AQ_GET(x) (((x) & 0x0000000000000004ull) >> 2) +#define MINION_CSR_AMOFENCE_CTRL_FA_AQ_SET(x) (((x) << 2) & 0x0000000000000004ull) +#define MINION_CSR_AMOFENCE_CTRL_FA_AQ_MODIFY(r, x) ((((x) << 2) & 0x0000000000000004ull) | ((r) & 0xFFFFFFFFFFFFFFFBull)) + +/* Field: MINION_CSR_AMOFENCE_CTRL.af_rl */ +#define MINION_CSR_AMOFENCE_CTRL_AF_RL_MSB 3u +#define MINION_CSR_AMOFENCE_CTRL_AF_RL_LSB 3u +#define MINION_CSR_AMOFENCE_CTRL_AF_RL_WIDTH 1u +#define MINION_CSR_AMOFENCE_CTRL_AF_RL_READ_ACCESS 1u +#define MINION_CSR_AMOFENCE_CTRL_AF_RL_WRITE_ACCESS 1u +#define MINION_CSR_AMOFENCE_CTRL_AF_RL_RESET 0x0000000000000000ull +#define MINION_CSR_AMOFENCE_CTRL_AF_RL_FIELD_MASK 0x0000000000000008ull +#define MINION_CSR_AMOFENCE_CTRL_AF_RL_GET(x) (((x) & 0x0000000000000008ull) >> 3) +#define MINION_CSR_AMOFENCE_CTRL_AF_RL_SET(x) (((x) << 3) & 0x0000000000000008ull) +#define MINION_CSR_AMOFENCE_CTRL_AF_RL_MODIFY(r, x) ((((x) << 3) & 0x0000000000000008ull) | ((r) & 0xFFFFFFFFFFFFFFF7ull)) + +/* Register: MINION_CSR.cacheinvalidate */ +#define MINION_CSR_CACHEINVALIDATE_ADDRESS 0x00003E80ul +#define MINION_CSR_CACHEINVALIDATE_BYTE_ADDRESS 0x00003E80ul +#define MINION_CSR_CACHEINVALIDATE_OFFSET 0x00003E80ul +#define MINION_CSR_CACHEINVALIDATE_BYTE_OFFSET 0x00003E80ul +#define MINION_CSR_CACHEINVALIDATE_SIZE 0x00000008ul +#define MINION_CSR_CACHEINVALIDATE_BYTE_SIZE 0x00000008ul +#define MINION_CSR_CACHEINVALIDATE_READ_ACCESS 1u +#define MINION_CSR_CACHEINVALIDATE_WRITE_ACCESS 1u +#define MINION_CSR_CACHEINVALIDATE_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_CACHEINVALIDATE_RESET_MASK 0x0000000000000003ull +#define MINION_CSR_CACHEINVALIDATE_READ_MASK 0x0000000000000003ull +#define MINION_CSR_CACHEINVALIDATE_WRITE_MASK 0x0000000000000003ull + +/* Field: MINION_CSR_CACHEINVALIDATE.i_cache_invalidate */ +#define MINION_CSR_CACHEINVALIDATE_I_CACHE_INVALIDATE_MSB 0u +#define MINION_CSR_CACHEINVALIDATE_I_CACHE_INVALIDATE_LSB 0u +#define MINION_CSR_CACHEINVALIDATE_I_CACHE_INVALIDATE_WIDTH 1u +#define MINION_CSR_CACHEINVALIDATE_I_CACHE_INVALIDATE_READ_ACCESS 1u +#define MINION_CSR_CACHEINVALIDATE_I_CACHE_INVALIDATE_WRITE_ACCESS 1u +#define MINION_CSR_CACHEINVALIDATE_I_CACHE_INVALIDATE_RESET 0x0000000000000000ull +#define MINION_CSR_CACHEINVALIDATE_I_CACHE_INVALIDATE_FIELD_MASK 0x0000000000000001ull +#define MINION_CSR_CACHEINVALIDATE_I_CACHE_INVALIDATE_GET(x) ((x) & 0x0000000000000001ull) +#define MINION_CSR_CACHEINVALIDATE_I_CACHE_INVALIDATE_SET(x) ((x) & 0x0000000000000001ull) +#define MINION_CSR_CACHEINVALIDATE_I_CACHE_INVALIDATE_MODIFY(r, x) ((((x) << 0) & 0x0000000000000001ull) | ((r) & 0xFFFFFFFFFFFFFFFEull)) + +/* Field: MINION_CSR_CACHEINVALIDATE.tlb_ptw_invalidate */ +#define MINION_CSR_CACHEINVALIDATE_TLB_PTW_INVALIDATE_MSB 1u +#define MINION_CSR_CACHEINVALIDATE_TLB_PTW_INVALIDATE_LSB 1u +#define MINION_CSR_CACHEINVALIDATE_TLB_PTW_INVALIDATE_WIDTH 1u +#define MINION_CSR_CACHEINVALIDATE_TLB_PTW_INVALIDATE_READ_ACCESS 1u +#define MINION_CSR_CACHEINVALIDATE_TLB_PTW_INVALIDATE_WRITE_ACCESS 1u +#define MINION_CSR_CACHEINVALIDATE_TLB_PTW_INVALIDATE_RESET 0x0000000000000000ull +#define MINION_CSR_CACHEINVALIDATE_TLB_PTW_INVALIDATE_FIELD_MASK 0x0000000000000002ull +#define MINION_CSR_CACHEINVALIDATE_TLB_PTW_INVALIDATE_GET(x) (((x) & 0x0000000000000002ull) >> 1) +#define MINION_CSR_CACHEINVALIDATE_TLB_PTW_INVALIDATE_SET(x) (((x) << 1) & 0x0000000000000002ull) +#define MINION_CSR_CACHEINVALIDATE_TLB_PTW_INVALIDATE_MODIFY(r, x) ((((x) << 1) & 0x0000000000000002ull) | ((r) & 0xFFFFFFFFFFFFFFFDull)) + +/* Register: MINION_CSR.msleep_txfma_27 */ +#define MINION_CSR_MSLEEP_TXFMA_27_ADDRESS 0x00003E88ul +#define MINION_CSR_MSLEEP_TXFMA_27_BYTE_ADDRESS 0x00003E88ul +#define MINION_CSR_MSLEEP_TXFMA_27_OFFSET 0x00003E88ul +#define MINION_CSR_MSLEEP_TXFMA_27_BYTE_OFFSET 0x00003E88ul +#define MINION_CSR_MSLEEP_TXFMA_27_SIZE 0x00000008ul +#define MINION_CSR_MSLEEP_TXFMA_27_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MSLEEP_TXFMA_27_READ_ACCESS 1u +#define MINION_CSR_MSLEEP_TXFMA_27_WRITE_ACCESS 1u +#define MINION_CSR_MSLEEP_TXFMA_27_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MSLEEP_TXFMA_27_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MSLEEP_TXFMA_27_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MSLEEP_TXFMA_27_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MSLEEP_TXFMA_27.msleep_txfma_27 */ +#define MINION_CSR_MSLEEP_TXFMA_27_MSLEEP_TXFMA_27_MSB 63u +#define MINION_CSR_MSLEEP_TXFMA_27_MSLEEP_TXFMA_27_LSB 0u +#define MINION_CSR_MSLEEP_TXFMA_27_MSLEEP_TXFMA_27_WIDTH 64u +#define MINION_CSR_MSLEEP_TXFMA_27_MSLEEP_TXFMA_27_READ_ACCESS 1u +#define MINION_CSR_MSLEEP_TXFMA_27_MSLEEP_TXFMA_27_WRITE_ACCESS 1u +#define MINION_CSR_MSLEEP_TXFMA_27_MSLEEP_TXFMA_27_RESET 0x0000000000000000ull +#define MINION_CSR_MSLEEP_TXFMA_27_MSLEEP_TXFMA_27_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MSLEEP_TXFMA_27_MSLEEP_TXFMA_27_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MSLEEP_TXFMA_27_MSLEEP_TXFMA_27_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MSLEEP_TXFMA_27_MSLEEP_TXFMA_27_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.menable_shadows */ +#define MINION_CSR_MENABLE_SHADOWS_ADDRESS 0x00003E90ul +#define MINION_CSR_MENABLE_SHADOWS_BYTE_ADDRESS 0x00003E90ul +#define MINION_CSR_MENABLE_SHADOWS_OFFSET 0x00003E90ul +#define MINION_CSR_MENABLE_SHADOWS_BYTE_OFFSET 0x00003E90ul +#define MINION_CSR_MENABLE_SHADOWS_SIZE 0x00000008ul +#define MINION_CSR_MENABLE_SHADOWS_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MENABLE_SHADOWS_READ_ACCESS 1u +#define MINION_CSR_MENABLE_SHADOWS_WRITE_ACCESS 1u +#define MINION_CSR_MENABLE_SHADOWS_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MENABLE_SHADOWS_RESET_MASK 0x0000000000000001ull +#define MINION_CSR_MENABLE_SHADOWS_READ_MASK 0x0000000000000001ull +#define MINION_CSR_MENABLE_SHADOWS_WRITE_MASK 0x0000000000000001ull + +/* Field: MINION_CSR_MENABLE_SHADOWS.menable_shadows */ +#define MINION_CSR_MENABLE_SHADOWS_MENABLE_SHADOWS_MSB 0u +#define MINION_CSR_MENABLE_SHADOWS_MENABLE_SHADOWS_LSB 0u +#define MINION_CSR_MENABLE_SHADOWS_MENABLE_SHADOWS_WIDTH 1u +#define MINION_CSR_MENABLE_SHADOWS_MENABLE_SHADOWS_READ_ACCESS 1u +#define MINION_CSR_MENABLE_SHADOWS_MENABLE_SHADOWS_WRITE_ACCESS 1u +#define MINION_CSR_MENABLE_SHADOWS_MENABLE_SHADOWS_RESET 0x0000000000000000ull +#define MINION_CSR_MENABLE_SHADOWS_MENABLE_SHADOWS_FIELD_MASK 0x0000000000000001ull +#define MINION_CSR_MENABLE_SHADOWS_MENABLE_SHADOWS_GET(x) ((x) & 0x0000000000000001ull) +#define MINION_CSR_MENABLE_SHADOWS_MENABLE_SHADOWS_SET(x) ((x) & 0x0000000000000001ull) +#define MINION_CSR_MENABLE_SHADOWS_MENABLE_SHADOWS_MODIFY(r, x) ((((x) << 0) & 0x0000000000000001ull) | ((r) & 0xFFFFFFFFFFFFFFFEull)) + +/* Register: MINION_CSR.excl_mode */ +#define MINION_CSR_EXCL_MODE_ADDRESS 0x00003E98ul +#define MINION_CSR_EXCL_MODE_BYTE_ADDRESS 0x00003E98ul +#define MINION_CSR_EXCL_MODE_OFFSET 0x00003E98ul +#define MINION_CSR_EXCL_MODE_BYTE_OFFSET 0x00003E98ul +#define MINION_CSR_EXCL_MODE_SIZE 0x00000008ul +#define MINION_CSR_EXCL_MODE_BYTE_SIZE 0x00000008ul +#define MINION_CSR_EXCL_MODE_READ_ACCESS 1u +#define MINION_CSR_EXCL_MODE_WRITE_ACCESS 1u +#define MINION_CSR_EXCL_MODE_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_EXCL_MODE_RESET_MASK 0x0000000000000001ull +#define MINION_CSR_EXCL_MODE_READ_MASK 0x0000000000000001ull +#define MINION_CSR_EXCL_MODE_WRITE_MASK 0x0000000000000001ull + +/* Field: MINION_CSR_EXCL_MODE.excl_mode */ +#define MINION_CSR_EXCL_MODE_EXCL_MODE_MSB 0u +#define MINION_CSR_EXCL_MODE_EXCL_MODE_LSB 0u +#define MINION_CSR_EXCL_MODE_EXCL_MODE_WIDTH 1u +#define MINION_CSR_EXCL_MODE_EXCL_MODE_READ_ACCESS 1u +#define MINION_CSR_EXCL_MODE_EXCL_MODE_WRITE_ACCESS 1u +#define MINION_CSR_EXCL_MODE_EXCL_MODE_RESET 0x0000000000000000ull +#define MINION_CSR_EXCL_MODE_EXCL_MODE_FIELD_MASK 0x0000000000000001ull +#define MINION_CSR_EXCL_MODE_EXCL_MODE_GET(x) ((x) & 0x0000000000000001ull) +#define MINION_CSR_EXCL_MODE_EXCL_MODE_SET(x) ((x) & 0x0000000000000001ull) +#define MINION_CSR_EXCL_MODE_EXCL_MODE_MODIFY(r, x) ((((x) << 0) & 0x0000000000000001ull) | ((r) & 0xFFFFFFFFFFFFFFFEull)) + +/* Register: MINION_CSR.mtxfma_sleep_traps */ +#define MINION_CSR_MTXFMA_SLEEP_TRAPS_ADDRESS 0x00003EA0ul +#define MINION_CSR_MTXFMA_SLEEP_TRAPS_BYTE_ADDRESS 0x00003EA0ul +#define MINION_CSR_MTXFMA_SLEEP_TRAPS_OFFSET 0x00003EA0ul +#define MINION_CSR_MTXFMA_SLEEP_TRAPS_BYTE_OFFSET 0x00003EA0ul +#define MINION_CSR_MTXFMA_SLEEP_TRAPS_SIZE 0x00000008ul +#define MINION_CSR_MTXFMA_SLEEP_TRAPS_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MTXFMA_SLEEP_TRAPS_READ_ACCESS 1u +#define MINION_CSR_MTXFMA_SLEEP_TRAPS_WRITE_ACCESS 1u +#define MINION_CSR_MTXFMA_SLEEP_TRAPS_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MTXFMA_SLEEP_TRAPS_RESET_MASK 0x000000000000001Full +#define MINION_CSR_MTXFMA_SLEEP_TRAPS_READ_MASK 0x000000000000001Full +#define MINION_CSR_MTXFMA_SLEEP_TRAPS_WRITE_MASK 0x000000000000001Full + +/* Field: MINION_CSR_MTXFMA_SLEEP_TRAPS.other */ +#define MINION_CSR_MTXFMA_SLEEP_TRAPS_OTHER_MSB 0u +#define MINION_CSR_MTXFMA_SLEEP_TRAPS_OTHER_LSB 0u +#define MINION_CSR_MTXFMA_SLEEP_TRAPS_OTHER_WIDTH 1u +#define MINION_CSR_MTXFMA_SLEEP_TRAPS_OTHER_READ_ACCESS 1u +#define MINION_CSR_MTXFMA_SLEEP_TRAPS_OTHER_WRITE_ACCESS 1u +#define MINION_CSR_MTXFMA_SLEEP_TRAPS_OTHER_RESET 0x0000000000000000ull +#define MINION_CSR_MTXFMA_SLEEP_TRAPS_OTHER_FIELD_MASK 0x0000000000000001ull +#define MINION_CSR_MTXFMA_SLEEP_TRAPS_OTHER_GET(x) ((x) & 0x0000000000000001ull) +#define MINION_CSR_MTXFMA_SLEEP_TRAPS_OTHER_SET(x) ((x) & 0x0000000000000001ull) +#define MINION_CSR_MTXFMA_SLEEP_TRAPS_OTHER_MODIFY(r, x) ((((x) << 0) & 0x0000000000000001ull) | ((r) & 0xFFFFFFFFFFFFFFFEull)) + +/* Field: MINION_CSR_MTXFMA_SLEEP_TRAPS.trans */ +#define MINION_CSR_MTXFMA_SLEEP_TRAPS_TRANS_MSB 1u +#define MINION_CSR_MTXFMA_SLEEP_TRAPS_TRANS_LSB 1u +#define MINION_CSR_MTXFMA_SLEEP_TRAPS_TRANS_WIDTH 1u +#define MINION_CSR_MTXFMA_SLEEP_TRAPS_TRANS_READ_ACCESS 1u +#define MINION_CSR_MTXFMA_SLEEP_TRAPS_TRANS_WRITE_ACCESS 1u +#define MINION_CSR_MTXFMA_SLEEP_TRAPS_TRANS_RESET 0x0000000000000000ull +#define MINION_CSR_MTXFMA_SLEEP_TRAPS_TRANS_FIELD_MASK 0x0000000000000002ull +#define MINION_CSR_MTXFMA_SLEEP_TRAPS_TRANS_GET(x) (((x) & 0x0000000000000002ull) >> 1) +#define MINION_CSR_MTXFMA_SLEEP_TRAPS_TRANS_SET(x) (((x) << 1) & 0x0000000000000002ull) +#define MINION_CSR_MTXFMA_SLEEP_TRAPS_TRANS_MODIFY(r, x) ((((x) << 1) & 0x0000000000000002ull) | ((r) & 0xFFFFFFFFFFFFFFFDull)) + +/* Field: MINION_CSR_MTXFMA_SLEEP_TRAPS.tensor_reduce_fp32 */ +#define MINION_CSR_MTXFMA_SLEEP_TRAPS_TENSOR_REDUCE_FP32_MSB 2u +#define MINION_CSR_MTXFMA_SLEEP_TRAPS_TENSOR_REDUCE_FP32_LSB 2u +#define MINION_CSR_MTXFMA_SLEEP_TRAPS_TENSOR_REDUCE_FP32_WIDTH 1u +#define MINION_CSR_MTXFMA_SLEEP_TRAPS_TENSOR_REDUCE_FP32_READ_ACCESS 1u +#define MINION_CSR_MTXFMA_SLEEP_TRAPS_TENSOR_REDUCE_FP32_WRITE_ACCESS 1u +#define MINION_CSR_MTXFMA_SLEEP_TRAPS_TENSOR_REDUCE_FP32_RESET 0x0000000000000000ull +#define MINION_CSR_MTXFMA_SLEEP_TRAPS_TENSOR_REDUCE_FP32_FIELD_MASK 0x0000000000000004ull +#define MINION_CSR_MTXFMA_SLEEP_TRAPS_TENSOR_REDUCE_FP32_GET(x) (((x) & 0x0000000000000004ull) >> 2) +#define MINION_CSR_MTXFMA_SLEEP_TRAPS_TENSOR_REDUCE_FP32_SET(x) (((x) << 2) & 0x0000000000000004ull) +#define MINION_CSR_MTXFMA_SLEEP_TRAPS_TENSOR_REDUCE_FP32_MODIFY(r, x) ((((x) << 2) & 0x0000000000000004ull) | ((r) & 0xFFFFFFFFFFFFFFFBull)) + +/* Field: MINION_CSR_MTXFMA_SLEEP_TRAPS.tensor_quant */ +#define MINION_CSR_MTXFMA_SLEEP_TRAPS_TENSOR_QUANT_MSB 3u +#define MINION_CSR_MTXFMA_SLEEP_TRAPS_TENSOR_QUANT_LSB 3u +#define MINION_CSR_MTXFMA_SLEEP_TRAPS_TENSOR_QUANT_WIDTH 1u +#define MINION_CSR_MTXFMA_SLEEP_TRAPS_TENSOR_QUANT_READ_ACCESS 1u +#define MINION_CSR_MTXFMA_SLEEP_TRAPS_TENSOR_QUANT_WRITE_ACCESS 1u +#define MINION_CSR_MTXFMA_SLEEP_TRAPS_TENSOR_QUANT_RESET 0x0000000000000000ull +#define MINION_CSR_MTXFMA_SLEEP_TRAPS_TENSOR_QUANT_FIELD_MASK 0x0000000000000008ull +#define MINION_CSR_MTXFMA_SLEEP_TRAPS_TENSOR_QUANT_GET(x) (((x) & 0x0000000000000008ull) >> 3) +#define MINION_CSR_MTXFMA_SLEEP_TRAPS_TENSOR_QUANT_SET(x) (((x) << 3) & 0x0000000000000008ull) +#define MINION_CSR_MTXFMA_SLEEP_TRAPS_TENSOR_QUANT_MODIFY(r, x) ((((x) << 3) & 0x0000000000000008ull) | ((r) & 0xFFFFFFFFFFFFFFF7ull)) + +/* Field: MINION_CSR_MTXFMA_SLEEP_TRAPS.tensorfma_fp16_fp32 */ +#define MINION_CSR_MTXFMA_SLEEP_TRAPS_TENSORFMA_FP16_FP32_MSB 4u +#define MINION_CSR_MTXFMA_SLEEP_TRAPS_TENSORFMA_FP16_FP32_LSB 4u +#define MINION_CSR_MTXFMA_SLEEP_TRAPS_TENSORFMA_FP16_FP32_WIDTH 1u +#define MINION_CSR_MTXFMA_SLEEP_TRAPS_TENSORFMA_FP16_FP32_READ_ACCESS 1u +#define MINION_CSR_MTXFMA_SLEEP_TRAPS_TENSORFMA_FP16_FP32_WRITE_ACCESS 1u +#define MINION_CSR_MTXFMA_SLEEP_TRAPS_TENSORFMA_FP16_FP32_RESET 0x0000000000000000ull +#define MINION_CSR_MTXFMA_SLEEP_TRAPS_TENSORFMA_FP16_FP32_FIELD_MASK 0x0000000000000010ull +#define MINION_CSR_MTXFMA_SLEEP_TRAPS_TENSORFMA_FP16_FP32_GET(x) (((x) & 0x0000000000000010ull) >> 4) +#define MINION_CSR_MTXFMA_SLEEP_TRAPS_TENSORFMA_FP16_FP32_SET(x) (((x) << 4) & 0x0000000000000010ull) +#define MINION_CSR_MTXFMA_SLEEP_TRAPS_TENSORFMA_FP16_FP32_MODIFY(r, x) ((((x) << 4) & 0x0000000000000010ull) | ((r) & 0xFFFFFFFFFFFFFFEFull)) + +/* Register: MINION_CSR.mbusaddr */ +#define MINION_CSR_MBUSADDR_ADDRESS 0x00003EA8ul +#define MINION_CSR_MBUSADDR_BYTE_ADDRESS 0x00003EA8ul +#define MINION_CSR_MBUSADDR_OFFSET 0x00003EA8ul +#define MINION_CSR_MBUSADDR_BYTE_OFFSET 0x00003EA8ul +#define MINION_CSR_MBUSADDR_SIZE 0x00000008ul +#define MINION_CSR_MBUSADDR_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MBUSADDR_READ_ACCESS 1u +#define MINION_CSR_MBUSADDR_WRITE_ACCESS 1u +#define MINION_CSR_MBUSADDR_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MBUSADDR_RESET_MASK 0x000000FFFFFFFFFFull +#define MINION_CSR_MBUSADDR_READ_MASK 0x000000FFFFFFFFFFull +#define MINION_CSR_MBUSADDR_WRITE_MASK 0x000000FFFFFFFFFFull + +/* Field: MINION_CSR_MBUSADDR.mbusaddr */ +#define MINION_CSR_MBUSADDR_MBUSADDR_MSB 39u +#define MINION_CSR_MBUSADDR_MBUSADDR_LSB 0u +#define MINION_CSR_MBUSADDR_MBUSADDR_WIDTH 40u +#define MINION_CSR_MBUSADDR_MBUSADDR_READ_ACCESS 1u +#define MINION_CSR_MBUSADDR_MBUSADDR_WRITE_ACCESS 1u +#define MINION_CSR_MBUSADDR_MBUSADDR_RESET 0x0000000000000000ull +#define MINION_CSR_MBUSADDR_MBUSADDR_FIELD_MASK 0x000000FFFFFFFFFFull +#define MINION_CSR_MBUSADDR_MBUSADDR_GET(x) ((x) & 0x000000FFFFFFFFFFull) +#define MINION_CSR_MBUSADDR_MBUSADDR_SET(x) ((x) & 0x000000FFFFFFFFFFull) +#define MINION_CSR_MBUSADDR_MBUSADDR_MODIFY(r, x) ((((x) << 0) & 0x000000FFFFFFFFFFull) | ((r) & 0xFFFFFF0000000000ull)) + +/* Register: MINION_CSR.mbuspc */ +#define MINION_CSR_MBUSPC_ADDRESS 0x00003EB0ul +#define MINION_CSR_MBUSPC_BYTE_ADDRESS 0x00003EB0ul +#define MINION_CSR_MBUSPC_OFFSET 0x00003EB0ul +#define MINION_CSR_MBUSPC_BYTE_OFFSET 0x00003EB0ul +#define MINION_CSR_MBUSPC_SIZE 0x00000008ul +#define MINION_CSR_MBUSPC_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MBUSPC_READ_ACCESS 1u +#define MINION_CSR_MBUSPC_WRITE_ACCESS 1u +#define MINION_CSR_MBUSPC_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MBUSPC_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MBUSPC_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MBUSPC_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MBUSPC.mbuspc */ +#define MINION_CSR_MBUSPC_MBUSPC_MSB 63u +#define MINION_CSR_MBUSPC_MBUSPC_LSB 0u +#define MINION_CSR_MBUSPC_MBUSPC_WIDTH 64u +#define MINION_CSR_MBUSPC_MBUSPC_READ_ACCESS 1u +#define MINION_CSR_MBUSPC_MBUSPC_WRITE_ACCESS 1u +#define MINION_CSR_MBUSPC_MBUSPC_RESET 0x0000000000000000ull +#define MINION_CSR_MBUSPC_MBUSPC_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MBUSPC_MBUSPC_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MBUSPC_MBUSPC_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MBUSPC_MBUSPC_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mcache_control */ +#define MINION_CSR_MCACHE_CONTROL_ADDRESS 0x00003F00ul +#define MINION_CSR_MCACHE_CONTROL_BYTE_ADDRESS 0x00003F00ul +#define MINION_CSR_MCACHE_CONTROL_OFFSET 0x00003F00ul +#define MINION_CSR_MCACHE_CONTROL_BYTE_OFFSET 0x00003F00ul +#define MINION_CSR_MCACHE_CONTROL_SIZE 0x00000008ul +#define MINION_CSR_MCACHE_CONTROL_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MCACHE_CONTROL_READ_ACCESS 1u +#define MINION_CSR_MCACHE_CONTROL_WRITE_ACCESS 1u +#define MINION_CSR_MCACHE_CONTROL_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MCACHE_CONTROL_RESET_MASK 0x0000000000000003ull +#define MINION_CSR_MCACHE_CONTROL_READ_MASK 0x0000000000000003ull +#define MINION_CSR_MCACHE_CONTROL_WRITE_MASK 0x0000000000000003ull + +/* Field: MINION_CSR_MCACHE_CONTROL.d1split */ +#define MINION_CSR_MCACHE_CONTROL_D1SPLIT_MSB 0u +#define MINION_CSR_MCACHE_CONTROL_D1SPLIT_LSB 0u +#define MINION_CSR_MCACHE_CONTROL_D1SPLIT_WIDTH 1u +#define MINION_CSR_MCACHE_CONTROL_D1SPLIT_READ_ACCESS 1u +#define MINION_CSR_MCACHE_CONTROL_D1SPLIT_WRITE_ACCESS 1u +#define MINION_CSR_MCACHE_CONTROL_D1SPLIT_RESET 0x0000000000000000ull +#define MINION_CSR_MCACHE_CONTROL_D1SPLIT_FIELD_MASK 0x0000000000000001ull +#define MINION_CSR_MCACHE_CONTROL_D1SPLIT_GET(x) ((x) & 0x0000000000000001ull) +#define MINION_CSR_MCACHE_CONTROL_D1SPLIT_SET(x) ((x) & 0x0000000000000001ull) +#define MINION_CSR_MCACHE_CONTROL_D1SPLIT_MODIFY(r, x) ((((x) << 0) & 0x0000000000000001ull) | ((r) & 0xFFFFFFFFFFFFFFFEull)) + +/* Field: MINION_CSR_MCACHE_CONTROL.scpenable */ +#define MINION_CSR_MCACHE_CONTROL_SCPENABLE_MSB 1u +#define MINION_CSR_MCACHE_CONTROL_SCPENABLE_LSB 1u +#define MINION_CSR_MCACHE_CONTROL_SCPENABLE_WIDTH 1u +#define MINION_CSR_MCACHE_CONTROL_SCPENABLE_READ_ACCESS 1u +#define MINION_CSR_MCACHE_CONTROL_SCPENABLE_WRITE_ACCESS 1u +#define MINION_CSR_MCACHE_CONTROL_SCPENABLE_RESET 0x0000000000000000ull +#define MINION_CSR_MCACHE_CONTROL_SCPENABLE_FIELD_MASK 0x0000000000000002ull +#define MINION_CSR_MCACHE_CONTROL_SCPENABLE_GET(x) (((x) & 0x0000000000000002ull) >> 1) +#define MINION_CSR_MCACHE_CONTROL_SCPENABLE_SET(x) (((x) << 1) & 0x0000000000000002ull) +#define MINION_CSR_MCACHE_CONTROL_SCPENABLE_MODIFY(r, x) ((((x) << 1) & 0x0000000000000002ull) | ((r) & 0xFFFFFFFFFFFFFFFDull)) + +/* Register: MINION_CSR.co_evict_sw */ +#define MINION_CSR_CO_EVICT_SW_ADDRESS 0x00003FC8ul +#define MINION_CSR_CO_EVICT_SW_BYTE_ADDRESS 0x00003FC8ul +#define MINION_CSR_CO_EVICT_SW_OFFSET 0x00003FC8ul +#define MINION_CSR_CO_EVICT_SW_BYTE_OFFSET 0x00003FC8ul +#define MINION_CSR_CO_EVICT_SW_SIZE 0x00000008ul +#define MINION_CSR_CO_EVICT_SW_BYTE_SIZE 0x00000008ul +#define MINION_CSR_CO_EVICT_SW_READ_ACCESS 1u +#define MINION_CSR_CO_EVICT_SW_WRITE_ACCESS 1u +#define MINION_CSR_CO_EVICT_SW_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_CO_EVICT_SW_RESET_MASK 0x8C0000000003C0CFull +#define MINION_CSR_CO_EVICT_SW_READ_MASK 0x8C0000000003C0CFull +#define MINION_CSR_CO_EVICT_SW_WRITE_MASK 0x8C0000000003C0CFull + +/* Field: MINION_CSR_CO_EVICT_SW.num_lines */ +#define MINION_CSR_CO_EVICT_SW_NUM_LINES_MSB 3u +#define MINION_CSR_CO_EVICT_SW_NUM_LINES_LSB 0u +#define MINION_CSR_CO_EVICT_SW_NUM_LINES_WIDTH 4u +#define MINION_CSR_CO_EVICT_SW_NUM_LINES_READ_ACCESS 1u +#define MINION_CSR_CO_EVICT_SW_NUM_LINES_WRITE_ACCESS 1u +#define MINION_CSR_CO_EVICT_SW_NUM_LINES_RESET 0x0000000000000000ull +#define MINION_CSR_CO_EVICT_SW_NUM_LINES_FIELD_MASK 0x000000000000000Full +#define MINION_CSR_CO_EVICT_SW_NUM_LINES_GET(x) ((x) & 0x000000000000000Full) +#define MINION_CSR_CO_EVICT_SW_NUM_LINES_SET(x) ((x) & 0x000000000000000Full) +#define MINION_CSR_CO_EVICT_SW_NUM_LINES_MODIFY(r, x) ((((x) << 0) & 0x000000000000000Full) | ((r) & 0xFFFFFFFFFFFFFFF0ull)) + +/* Field: MINION_CSR_CO_EVICT_SW.way */ +#define MINION_CSR_CO_EVICT_SW_WAY_MSB 7u +#define MINION_CSR_CO_EVICT_SW_WAY_LSB 6u +#define MINION_CSR_CO_EVICT_SW_WAY_WIDTH 2u +#define MINION_CSR_CO_EVICT_SW_WAY_READ_ACCESS 1u +#define MINION_CSR_CO_EVICT_SW_WAY_WRITE_ACCESS 1u +#define MINION_CSR_CO_EVICT_SW_WAY_RESET 0x0000000000000000ull +#define MINION_CSR_CO_EVICT_SW_WAY_FIELD_MASK 0x00000000000000C0ull +#define MINION_CSR_CO_EVICT_SW_WAY_GET(x) (((x) & 0x00000000000000C0ull) >> 6) +#define MINION_CSR_CO_EVICT_SW_WAY_SET(x) (((x) << 6) & 0x00000000000000C0ull) +#define MINION_CSR_CO_EVICT_SW_WAY_MODIFY(r, x) ((((x) << 6) & 0x00000000000000C0ull) | ((r) & 0xFFFFFFFFFFFFFF3Full)) + +/* Field: MINION_CSR_CO_EVICT_SW.set */ +#define MINION_CSR_CO_EVICT_SW_SET_MSB 17u +#define MINION_CSR_CO_EVICT_SW_SET_LSB 14u +#define MINION_CSR_CO_EVICT_SW_SET_WIDTH 4u +#define MINION_CSR_CO_EVICT_SW_SET_READ_ACCESS 1u +#define MINION_CSR_CO_EVICT_SW_SET_WRITE_ACCESS 1u +#define MINION_CSR_CO_EVICT_SW_SET_RESET 0x0000000000000000ull +#define MINION_CSR_CO_EVICT_SW_SET_FIELD_MASK 0x000000000003C000ull +#define MINION_CSR_CO_EVICT_SW_SET_GET(x) (((x) & 0x000000000003C000ull) >> 14) +#define MINION_CSR_CO_EVICT_SW_SET_SET(x) (((x) << 14) & 0x000000000003C000ull) +#define MINION_CSR_CO_EVICT_SW_SET_MODIFY(r, x) ((((x) << 14) & 0x000000000003C000ull) | ((r) & 0xFFFFFFFFFFFC3FFFull)) + +/* Field: MINION_CSR_CO_EVICT_SW.dest_level */ +#define MINION_CSR_CO_EVICT_SW_DEST_LEVEL_MSB 59u +#define MINION_CSR_CO_EVICT_SW_DEST_LEVEL_LSB 58u +#define MINION_CSR_CO_EVICT_SW_DEST_LEVEL_WIDTH 2u +#define MINION_CSR_CO_EVICT_SW_DEST_LEVEL_READ_ACCESS 1u +#define MINION_CSR_CO_EVICT_SW_DEST_LEVEL_WRITE_ACCESS 1u +#define MINION_CSR_CO_EVICT_SW_DEST_LEVEL_RESET 0x0000000000000000ull +#define MINION_CSR_CO_EVICT_SW_DEST_LEVEL_FIELD_MASK 0x0C00000000000000ull +#define MINION_CSR_CO_EVICT_SW_DEST_LEVEL_GET(x) (((x) & 0x0C00000000000000ull) >> 58) +#define MINION_CSR_CO_EVICT_SW_DEST_LEVEL_SET(x) (((x) << 58) & 0x0C00000000000000ull) +#define MINION_CSR_CO_EVICT_SW_DEST_LEVEL_MODIFY(r, x) ((((x) << 58) & 0x0C00000000000000ull) | ((r) & 0xF3FFFFFFFFFFFFFFull)) + +/* Field: MINION_CSR_CO_EVICT_SW.use_tensor_mask */ +#define MINION_CSR_CO_EVICT_SW_USE_TENSOR_MASK_MSB 63u +#define MINION_CSR_CO_EVICT_SW_USE_TENSOR_MASK_LSB 63u +#define MINION_CSR_CO_EVICT_SW_USE_TENSOR_MASK_WIDTH 1u +#define MINION_CSR_CO_EVICT_SW_USE_TENSOR_MASK_READ_ACCESS 1u +#define MINION_CSR_CO_EVICT_SW_USE_TENSOR_MASK_WRITE_ACCESS 1u +#define MINION_CSR_CO_EVICT_SW_USE_TENSOR_MASK_RESET 0x0000000000000000ull +#define MINION_CSR_CO_EVICT_SW_USE_TENSOR_MASK_FIELD_MASK 0x8000000000000000ull +#define MINION_CSR_CO_EVICT_SW_USE_TENSOR_MASK_GET(x) (((x) & 0x8000000000000000ull) >> 63) +#define MINION_CSR_CO_EVICT_SW_USE_TENSOR_MASK_SET(x) (((x) << 63) & 0x8000000000000000ull) +#define MINION_CSR_CO_EVICT_SW_USE_TENSOR_MASK_MODIFY(r, x) ((((x) << 63) & 0x8000000000000000ull) | ((r) & 0x7FFFFFFFFFFFFFFFull)) + +/* Register: MINION_CSR.co_flush_sw */ +#define MINION_CSR_CO_FLUSH_SW_ADDRESS 0x00003FD8ul +#define MINION_CSR_CO_FLUSH_SW_BYTE_ADDRESS 0x00003FD8ul +#define MINION_CSR_CO_FLUSH_SW_OFFSET 0x00003FD8ul +#define MINION_CSR_CO_FLUSH_SW_BYTE_OFFSET 0x00003FD8ul +#define MINION_CSR_CO_FLUSH_SW_SIZE 0x00000008ul +#define MINION_CSR_CO_FLUSH_SW_BYTE_SIZE 0x00000008ul +#define MINION_CSR_CO_FLUSH_SW_READ_ACCESS 1u +#define MINION_CSR_CO_FLUSH_SW_WRITE_ACCESS 1u +#define MINION_CSR_CO_FLUSH_SW_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_CO_FLUSH_SW_RESET_MASK 0x8C0000000003C0CFull +#define MINION_CSR_CO_FLUSH_SW_READ_MASK 0x8C0000000003C0CFull +#define MINION_CSR_CO_FLUSH_SW_WRITE_MASK 0x8C0000000003C0CFull + +/* Field: MINION_CSR_CO_FLUSH_SW.num_lines */ +#define MINION_CSR_CO_FLUSH_SW_NUM_LINES_MSB 3u +#define MINION_CSR_CO_FLUSH_SW_NUM_LINES_LSB 0u +#define MINION_CSR_CO_FLUSH_SW_NUM_LINES_WIDTH 4u +#define MINION_CSR_CO_FLUSH_SW_NUM_LINES_READ_ACCESS 1u +#define MINION_CSR_CO_FLUSH_SW_NUM_LINES_WRITE_ACCESS 1u +#define MINION_CSR_CO_FLUSH_SW_NUM_LINES_RESET 0x0000000000000000ull +#define MINION_CSR_CO_FLUSH_SW_NUM_LINES_FIELD_MASK 0x000000000000000Full +#define MINION_CSR_CO_FLUSH_SW_NUM_LINES_GET(x) ((x) & 0x000000000000000Full) +#define MINION_CSR_CO_FLUSH_SW_NUM_LINES_SET(x) ((x) & 0x000000000000000Full) +#define MINION_CSR_CO_FLUSH_SW_NUM_LINES_MODIFY(r, x) ((((x) << 0) & 0x000000000000000Full) | ((r) & 0xFFFFFFFFFFFFFFF0ull)) + +/* Field: MINION_CSR_CO_FLUSH_SW.way */ +#define MINION_CSR_CO_FLUSH_SW_WAY_MSB 7u +#define MINION_CSR_CO_FLUSH_SW_WAY_LSB 6u +#define MINION_CSR_CO_FLUSH_SW_WAY_WIDTH 2u +#define MINION_CSR_CO_FLUSH_SW_WAY_READ_ACCESS 1u +#define MINION_CSR_CO_FLUSH_SW_WAY_WRITE_ACCESS 1u +#define MINION_CSR_CO_FLUSH_SW_WAY_RESET 0x0000000000000000ull +#define MINION_CSR_CO_FLUSH_SW_WAY_FIELD_MASK 0x00000000000000C0ull +#define MINION_CSR_CO_FLUSH_SW_WAY_GET(x) (((x) & 0x00000000000000C0ull) >> 6) +#define MINION_CSR_CO_FLUSH_SW_WAY_SET(x) (((x) << 6) & 0x00000000000000C0ull) +#define MINION_CSR_CO_FLUSH_SW_WAY_MODIFY(r, x) ((((x) << 6) & 0x00000000000000C0ull) | ((r) & 0xFFFFFFFFFFFFFF3Full)) + +/* Field: MINION_CSR_CO_FLUSH_SW.set */ +#define MINION_CSR_CO_FLUSH_SW_SET_MSB 17u +#define MINION_CSR_CO_FLUSH_SW_SET_LSB 14u +#define MINION_CSR_CO_FLUSH_SW_SET_WIDTH 4u +#define MINION_CSR_CO_FLUSH_SW_SET_READ_ACCESS 1u +#define MINION_CSR_CO_FLUSH_SW_SET_WRITE_ACCESS 1u +#define MINION_CSR_CO_FLUSH_SW_SET_RESET 0x0000000000000000ull +#define MINION_CSR_CO_FLUSH_SW_SET_FIELD_MASK 0x000000000003C000ull +#define MINION_CSR_CO_FLUSH_SW_SET_GET(x) (((x) & 0x000000000003C000ull) >> 14) +#define MINION_CSR_CO_FLUSH_SW_SET_SET(x) (((x) << 14) & 0x000000000003C000ull) +#define MINION_CSR_CO_FLUSH_SW_SET_MODIFY(r, x) ((((x) << 14) & 0x000000000003C000ull) | ((r) & 0xFFFFFFFFFFFC3FFFull)) + +/* Field: MINION_CSR_CO_FLUSH_SW.dest_level */ +#define MINION_CSR_CO_FLUSH_SW_DEST_LEVEL_MSB 59u +#define MINION_CSR_CO_FLUSH_SW_DEST_LEVEL_LSB 58u +#define MINION_CSR_CO_FLUSH_SW_DEST_LEVEL_WIDTH 2u +#define MINION_CSR_CO_FLUSH_SW_DEST_LEVEL_READ_ACCESS 1u +#define MINION_CSR_CO_FLUSH_SW_DEST_LEVEL_WRITE_ACCESS 1u +#define MINION_CSR_CO_FLUSH_SW_DEST_LEVEL_RESET 0x0000000000000000ull +#define MINION_CSR_CO_FLUSH_SW_DEST_LEVEL_FIELD_MASK 0x0C00000000000000ull +#define MINION_CSR_CO_FLUSH_SW_DEST_LEVEL_GET(x) (((x) & 0x0C00000000000000ull) >> 58) +#define MINION_CSR_CO_FLUSH_SW_DEST_LEVEL_SET(x) (((x) << 58) & 0x0C00000000000000ull) +#define MINION_CSR_CO_FLUSH_SW_DEST_LEVEL_MODIFY(r, x) ((((x) << 58) & 0x0C00000000000000ull) | ((r) & 0xF3FFFFFFFFFFFFFFull)) + +/* Field: MINION_CSR_CO_FLUSH_SW.use_tensor_mask */ +#define MINION_CSR_CO_FLUSH_SW_USE_TENSOR_MASK_MSB 63u +#define MINION_CSR_CO_FLUSH_SW_USE_TENSOR_MASK_LSB 63u +#define MINION_CSR_CO_FLUSH_SW_USE_TENSOR_MASK_WIDTH 1u +#define MINION_CSR_CO_FLUSH_SW_USE_TENSOR_MASK_READ_ACCESS 1u +#define MINION_CSR_CO_FLUSH_SW_USE_TENSOR_MASK_WRITE_ACCESS 1u +#define MINION_CSR_CO_FLUSH_SW_USE_TENSOR_MASK_RESET 0x0000000000000000ull +#define MINION_CSR_CO_FLUSH_SW_USE_TENSOR_MASK_FIELD_MASK 0x8000000000000000ull +#define MINION_CSR_CO_FLUSH_SW_USE_TENSOR_MASK_GET(x) (((x) & 0x8000000000000000ull) >> 63) +#define MINION_CSR_CO_FLUSH_SW_USE_TENSOR_MASK_SET(x) (((x) << 63) & 0x8000000000000000ull) +#define MINION_CSR_CO_FLUSH_SW_USE_TENSOR_MASK_MODIFY(r, x) ((((x) << 63) & 0x8000000000000000ull) | ((r) & 0x7FFFFFFFFFFFFFFFull)) + +/* Register: MINION_CSR.co_lock_sw */ +#define MINION_CSR_CO_LOCK_SW_ADDRESS 0x00003FE8ul +#define MINION_CSR_CO_LOCK_SW_BYTE_ADDRESS 0x00003FE8ul +#define MINION_CSR_CO_LOCK_SW_OFFSET 0x00003FE8ul +#define MINION_CSR_CO_LOCK_SW_BYTE_OFFSET 0x00003FE8ul +#define MINION_CSR_CO_LOCK_SW_SIZE 0x00000008ul +#define MINION_CSR_CO_LOCK_SW_BYTE_SIZE 0x00000008ul +#define MINION_CSR_CO_LOCK_SW_READ_ACCESS 1u +#define MINION_CSR_CO_LOCK_SW_WRITE_ACCESS 1u +#define MINION_CSR_CO_LOCK_SW_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_CO_LOCK_SW_RESET_MASK 0x018000FFFFFFFFC0ull +#define MINION_CSR_CO_LOCK_SW_READ_MASK 0x018000FFFFFFFFC0ull +#define MINION_CSR_CO_LOCK_SW_WRITE_MASK 0x018000FFFFFFFFC0ull + +/* Field: MINION_CSR_CO_LOCK_SW.pa */ +#define MINION_CSR_CO_LOCK_SW_PA_MSB 39u +#define MINION_CSR_CO_LOCK_SW_PA_LSB 6u +#define MINION_CSR_CO_LOCK_SW_PA_WIDTH 34u +#define MINION_CSR_CO_LOCK_SW_PA_READ_ACCESS 1u +#define MINION_CSR_CO_LOCK_SW_PA_WRITE_ACCESS 1u +#define MINION_CSR_CO_LOCK_SW_PA_RESET 0x0000000000000000ull +#define MINION_CSR_CO_LOCK_SW_PA_FIELD_MASK 0x000000FFFFFFFFC0ull +#define MINION_CSR_CO_LOCK_SW_PA_GET(x) (((x) & 0x000000FFFFFFFFC0ull) >> 6) +#define MINION_CSR_CO_LOCK_SW_PA_SET(x) (((x) << 6) & 0x000000FFFFFFFFC0ull) +#define MINION_CSR_CO_LOCK_SW_PA_MODIFY(r, x) ((((x) << 6) & 0x000000FFFFFFFFC0ull) | ((r) & 0xFFFFFF000000003Full)) + +/* Field: MINION_CSR_CO_LOCK_SW.way */ +#define MINION_CSR_CO_LOCK_SW_WAY_MSB 56u +#define MINION_CSR_CO_LOCK_SW_WAY_LSB 55u +#define MINION_CSR_CO_LOCK_SW_WAY_WIDTH 2u +#define MINION_CSR_CO_LOCK_SW_WAY_READ_ACCESS 1u +#define MINION_CSR_CO_LOCK_SW_WAY_WRITE_ACCESS 1u +#define MINION_CSR_CO_LOCK_SW_WAY_RESET 0x0000000000000000ull +#define MINION_CSR_CO_LOCK_SW_WAY_FIELD_MASK 0x0180000000000000ull +#define MINION_CSR_CO_LOCK_SW_WAY_GET(x) (((x) & 0x0180000000000000ull) >> 55) +#define MINION_CSR_CO_LOCK_SW_WAY_SET(x) (((x) << 55) & 0x0180000000000000ull) +#define MINION_CSR_CO_LOCK_SW_WAY_MODIFY(r, x) ((((x) << 55) & 0x0180000000000000ull) | ((r) & 0xFE7FFFFFFFFFFFFFull)) + +/* Register: MINION_CSR.co_unlock_sw */ +#define MINION_CSR_CO_UNLOCK_SW_ADDRESS 0x00003FF8ul +#define MINION_CSR_CO_UNLOCK_SW_BYTE_ADDRESS 0x00003FF8ul +#define MINION_CSR_CO_UNLOCK_SW_OFFSET 0x00003FF8ul +#define MINION_CSR_CO_UNLOCK_SW_BYTE_OFFSET 0x00003FF8ul +#define MINION_CSR_CO_UNLOCK_SW_SIZE 0x00000008ul +#define MINION_CSR_CO_UNLOCK_SW_BYTE_SIZE 0x00000008ul +#define MINION_CSR_CO_UNLOCK_SW_READ_ACCESS 1u +#define MINION_CSR_CO_UNLOCK_SW_WRITE_ACCESS 1u +#define MINION_CSR_CO_UNLOCK_SW_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_CO_UNLOCK_SW_RESET_MASK 0x01800000000003C0ull +#define MINION_CSR_CO_UNLOCK_SW_READ_MASK 0x01800000000003C0ull +#define MINION_CSR_CO_UNLOCK_SW_WRITE_MASK 0x01800000000003C0ull + +/* Field: MINION_CSR_CO_UNLOCK_SW.set */ +#define MINION_CSR_CO_UNLOCK_SW_SET_MSB 9u +#define MINION_CSR_CO_UNLOCK_SW_SET_LSB 6u +#define MINION_CSR_CO_UNLOCK_SW_SET_WIDTH 4u +#define MINION_CSR_CO_UNLOCK_SW_SET_READ_ACCESS 1u +#define MINION_CSR_CO_UNLOCK_SW_SET_WRITE_ACCESS 1u +#define MINION_CSR_CO_UNLOCK_SW_SET_RESET 0x0000000000000000ull +#define MINION_CSR_CO_UNLOCK_SW_SET_FIELD_MASK 0x00000000000003C0ull +#define MINION_CSR_CO_UNLOCK_SW_SET_GET(x) (((x) & 0x00000000000003C0ull) >> 6) +#define MINION_CSR_CO_UNLOCK_SW_SET_SET(x) (((x) << 6) & 0x00000000000003C0ull) +#define MINION_CSR_CO_UNLOCK_SW_SET_MODIFY(r, x) ((((x) << 6) & 0x00000000000003C0ull) | ((r) & 0xFFFFFFFFFFFFFC3Full)) + +/* Field: MINION_CSR_CO_UNLOCK_SW.way */ +#define MINION_CSR_CO_UNLOCK_SW_WAY_MSB 56u +#define MINION_CSR_CO_UNLOCK_SW_WAY_LSB 55u +#define MINION_CSR_CO_UNLOCK_SW_WAY_WIDTH 2u +#define MINION_CSR_CO_UNLOCK_SW_WAY_READ_ACCESS 1u +#define MINION_CSR_CO_UNLOCK_SW_WAY_WRITE_ACCESS 1u +#define MINION_CSR_CO_UNLOCK_SW_WAY_RESET 0x0000000000000000ull +#define MINION_CSR_CO_UNLOCK_SW_WAY_FIELD_MASK 0x0180000000000000ull +#define MINION_CSR_CO_UNLOCK_SW_WAY_GET(x) (((x) & 0x0180000000000000ull) >> 55) +#define MINION_CSR_CO_UNLOCK_SW_WAY_SET(x) (((x) << 55) & 0x0180000000000000ull) +#define MINION_CSR_CO_UNLOCK_SW_WAY_MODIFY(r, x) ((((x) << 55) & 0x0180000000000000ull) | ((r) & 0xFE7FFFFFFFFFFFFFull)) + +/* Register: MINION_CSR.tensor_reduce */ +#define MINION_CSR_TENSOR_REDUCE_ADDRESS 0x00004000ul +#define MINION_CSR_TENSOR_REDUCE_BYTE_ADDRESS 0x00004000ul +#define MINION_CSR_TENSOR_REDUCE_OFFSET 0x00004000ul +#define MINION_CSR_TENSOR_REDUCE_BYTE_OFFSET 0x00004000ul +#define MINION_CSR_TENSOR_REDUCE_SIZE 0x00000008ul +#define MINION_CSR_TENSOR_REDUCE_BYTE_SIZE 0x00000008ul +#define MINION_CSR_TENSOR_REDUCE_READ_ACCESS 1u +#define MINION_CSR_TENSOR_REDUCE_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_REDUCE_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_TENSOR_REDUCE_RESET_MASK 0x3E0000000F7FFFFBull +#define MINION_CSR_TENSOR_REDUCE_READ_MASK 0x3E0000000F7FFFFBull +#define MINION_CSR_TENSOR_REDUCE_WRITE_MASK 0x3E0000000F7FFFFBull + +/* Field: MINION_CSR_TENSOR_REDUCE.tensor_op_encoding */ +#define MINION_CSR_TENSOR_REDUCE_TENSOR_OP_ENCODING_MSB 1u +#define MINION_CSR_TENSOR_REDUCE_TENSOR_OP_ENCODING_LSB 0u +#define MINION_CSR_TENSOR_REDUCE_TENSOR_OP_ENCODING_WIDTH 2u +#define MINION_CSR_TENSOR_REDUCE_TENSOR_OP_ENCODING_READ_ACCESS 1u +#define MINION_CSR_TENSOR_REDUCE_TENSOR_OP_ENCODING_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_REDUCE_TENSOR_OP_ENCODING_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_REDUCE_TENSOR_OP_ENCODING_FIELD_MASK 0x0000000000000003ull +#define MINION_CSR_TENSOR_REDUCE_TENSOR_OP_ENCODING_GET(x) ((x) & 0x0000000000000003ull) +#define MINION_CSR_TENSOR_REDUCE_TENSOR_OP_ENCODING_SET(x) ((x) & 0x0000000000000003ull) +#define MINION_CSR_TENSOR_REDUCE_TENSOR_OP_ENCODING_MODIFY(r, x) ((((x) << 0) & 0x0000000000000003ull) | ((r) & 0xFFFFFFFFFFFFFFFCull)) + +/* Field: MINION_CSR_TENSOR_REDUCE.tree_depth */ +#define MINION_CSR_TENSOR_REDUCE_TREE_DEPTH_MSB 6u +#define MINION_CSR_TENSOR_REDUCE_TREE_DEPTH_LSB 3u +#define MINION_CSR_TENSOR_REDUCE_TREE_DEPTH_WIDTH 4u +#define MINION_CSR_TENSOR_REDUCE_TREE_DEPTH_READ_ACCESS 1u +#define MINION_CSR_TENSOR_REDUCE_TREE_DEPTH_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_REDUCE_TREE_DEPTH_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_REDUCE_TREE_DEPTH_FIELD_MASK 0x0000000000000078ull +#define MINION_CSR_TENSOR_REDUCE_TREE_DEPTH_GET(x) (((x) & 0x0000000000000078ull) >> 3) +#define MINION_CSR_TENSOR_REDUCE_TREE_DEPTH_SET(x) (((x) << 3) & 0x0000000000000078ull) +#define MINION_CSR_TENSOR_REDUCE_TREE_DEPTH_MODIFY(r, x) ((((x) << 3) & 0x0000000000000078ull) | ((r) & 0xFFFFFFFFFFFFFF87ull)) + +/* Field: MINION_CSR_TENSOR_REDUCE.minion_id */ +#define MINION_CSR_TENSOR_REDUCE_MINION_ID_MSB 15u +#define MINION_CSR_TENSOR_REDUCE_MINION_ID_LSB 7u +#define MINION_CSR_TENSOR_REDUCE_MINION_ID_WIDTH 9u +#define MINION_CSR_TENSOR_REDUCE_MINION_ID_READ_ACCESS 1u +#define MINION_CSR_TENSOR_REDUCE_MINION_ID_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_REDUCE_MINION_ID_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_REDUCE_MINION_ID_FIELD_MASK 0x000000000000FF80ull +#define MINION_CSR_TENSOR_REDUCE_MINION_ID_GET(x) (((x) & 0x000000000000FF80ull) >> 7) +#define MINION_CSR_TENSOR_REDUCE_MINION_ID_SET(x) (((x) << 7) & 0x000000000000FF80ull) +#define MINION_CSR_TENSOR_REDUCE_MINION_ID_MODIFY(r, x) ((((x) << 7) & 0x000000000000FF80ull) | ((r) & 0xFFFFFFFFFFFF007Full)) + +/* Field: MINION_CSR_TENSOR_REDUCE.num_regs */ +#define MINION_CSR_TENSOR_REDUCE_NUM_REGS_MSB 22u +#define MINION_CSR_TENSOR_REDUCE_NUM_REGS_LSB 16u +#define MINION_CSR_TENSOR_REDUCE_NUM_REGS_WIDTH 7u +#define MINION_CSR_TENSOR_REDUCE_NUM_REGS_READ_ACCESS 1u +#define MINION_CSR_TENSOR_REDUCE_NUM_REGS_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_REDUCE_NUM_REGS_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_REDUCE_NUM_REGS_FIELD_MASK 0x00000000007F0000ull +#define MINION_CSR_TENSOR_REDUCE_NUM_REGS_GET(x) (((x) & 0x00000000007F0000ull) >> 16) +#define MINION_CSR_TENSOR_REDUCE_NUM_REGS_SET(x) (((x) << 16) & 0x00000000007F0000ull) +#define MINION_CSR_TENSOR_REDUCE_NUM_REGS_MODIFY(r, x) ((((x) << 16) & 0x00000000007F0000ull) | ((r) & 0xFFFFFFFFFF80FFFFull)) + +/* Field: MINION_CSR_TENSOR_REDUCE.sub_op */ +#define MINION_CSR_TENSOR_REDUCE_SUB_OP_MSB 27u +#define MINION_CSR_TENSOR_REDUCE_SUB_OP_LSB 24u +#define MINION_CSR_TENSOR_REDUCE_SUB_OP_WIDTH 4u +#define MINION_CSR_TENSOR_REDUCE_SUB_OP_READ_ACCESS 1u +#define MINION_CSR_TENSOR_REDUCE_SUB_OP_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_REDUCE_SUB_OP_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_REDUCE_SUB_OP_FIELD_MASK 0x000000000F000000ull +#define MINION_CSR_TENSOR_REDUCE_SUB_OP_GET(x) (((x) & 0x000000000F000000ull) >> 24) +#define MINION_CSR_TENSOR_REDUCE_SUB_OP_SET(x) (((x) << 24) & 0x000000000F000000ull) +#define MINION_CSR_TENSOR_REDUCE_SUB_OP_MODIFY(r, x) ((((x) << 24) & 0x000000000F000000ull) | ((r) & 0xFFFFFFFFF0FFFFFFull)) + +/* Field: MINION_CSR_TENSOR_REDUCE.start_reg */ +#define MINION_CSR_TENSOR_REDUCE_START_REG_MSB 61u +#define MINION_CSR_TENSOR_REDUCE_START_REG_LSB 57u +#define MINION_CSR_TENSOR_REDUCE_START_REG_WIDTH 5u +#define MINION_CSR_TENSOR_REDUCE_START_REG_READ_ACCESS 1u +#define MINION_CSR_TENSOR_REDUCE_START_REG_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_REDUCE_START_REG_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_REDUCE_START_REG_FIELD_MASK 0x3E00000000000000ull +#define MINION_CSR_TENSOR_REDUCE_START_REG_GET(x) (((x) & 0x3E00000000000000ull) >> 57) +#define MINION_CSR_TENSOR_REDUCE_START_REG_SET(x) (((x) << 57) & 0x3E00000000000000ull) +#define MINION_CSR_TENSOR_REDUCE_START_REG_MODIFY(r, x) ((((x) << 57) & 0x3E00000000000000ull) | ((r) & 0xC1FFFFFFFFFFFFFFull)) + +/* Register: MINION_CSR.tensor_fma */ +#define MINION_CSR_TENSOR_FMA_ADDRESS 0x00004008ul +#define MINION_CSR_TENSOR_FMA_BYTE_ADDRESS 0x00004008ul +#define MINION_CSR_TENSOR_FMA_OFFSET 0x00004008ul +#define MINION_CSR_TENSOR_FMA_BYTE_OFFSET 0x00004008ul +#define MINION_CSR_TENSOR_FMA_SIZE 0x00000008ul +#define MINION_CSR_TENSOR_FMA_BYTE_SIZE 0x00000008ul +#define MINION_CSR_TENSOR_FMA_READ_ACCESS 1u +#define MINION_CSR_TENSOR_FMA_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_FMA_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_TENSOR_FMA_RESET_MASK 0x81FFF8000013F3FFull +#define MINION_CSR_TENSOR_FMA_READ_MASK 0x81FFF8000013F3FFull +#define MINION_CSR_TENSOR_FMA_WRITE_MASK 0x81FFF8000013F3FFull + +/* Field: MINION_CSR_TENSOR_FMA.set_clear */ +#define MINION_CSR_TENSOR_FMA_SET_CLEAR_MSB 0u +#define MINION_CSR_TENSOR_FMA_SET_CLEAR_LSB 0u +#define MINION_CSR_TENSOR_FMA_SET_CLEAR_WIDTH 1u +#define MINION_CSR_TENSOR_FMA_SET_CLEAR_READ_ACCESS 1u +#define MINION_CSR_TENSOR_FMA_SET_CLEAR_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_FMA_SET_CLEAR_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_FMA_SET_CLEAR_FIELD_MASK 0x0000000000000001ull +#define MINION_CSR_TENSOR_FMA_SET_CLEAR_GET(x) ((x) & 0x0000000000000001ull) +#define MINION_CSR_TENSOR_FMA_SET_CLEAR_SET(x) ((x) & 0x0000000000000001ull) +#define MINION_CSR_TENSOR_FMA_SET_CLEAR_MODIFY(r, x) ((((x) << 0) & 0x0000000000000001ull) | ((r) & 0xFFFFFFFFFFFFFFFEull)) + +/* Field: MINION_CSR_TENSOR_FMA.tensor_type */ +#define MINION_CSR_TENSOR_FMA_TENSOR_TYPE_MSB 3u +#define MINION_CSR_TENSOR_FMA_TENSOR_TYPE_LSB 1u +#define MINION_CSR_TENSOR_FMA_TENSOR_TYPE_WIDTH 3u +#define MINION_CSR_TENSOR_FMA_TENSOR_TYPE_READ_ACCESS 1u +#define MINION_CSR_TENSOR_FMA_TENSOR_TYPE_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_FMA_TENSOR_TYPE_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_FMA_TENSOR_TYPE_FIELD_MASK 0x000000000000000Eull +#define MINION_CSR_TENSOR_FMA_TENSOR_TYPE_GET(x) (((x) & 0x000000000000000Eull) >> 1) +#define MINION_CSR_TENSOR_FMA_TENSOR_TYPE_SET(x) (((x) << 1) & 0x000000000000000Eull) +#define MINION_CSR_TENSOR_FMA_TENSOR_TYPE_MODIFY(r, x) ((((x) << 1) & 0x000000000000000Eull) | ((r) & 0xFFFFFFFFFFFFFFF1ull)) + +/* Field: MINION_CSR_TENSOR_FMA.l1scp_start_line_a */ +#define MINION_CSR_TENSOR_FMA_L1SCP_START_LINE_A_MSB 9u +#define MINION_CSR_TENSOR_FMA_L1SCP_START_LINE_A_LSB 4u +#define MINION_CSR_TENSOR_FMA_L1SCP_START_LINE_A_WIDTH 6u +#define MINION_CSR_TENSOR_FMA_L1SCP_START_LINE_A_READ_ACCESS 1u +#define MINION_CSR_TENSOR_FMA_L1SCP_START_LINE_A_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_FMA_L1SCP_START_LINE_A_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_FMA_L1SCP_START_LINE_A_FIELD_MASK 0x00000000000003F0ull +#define MINION_CSR_TENSOR_FMA_L1SCP_START_LINE_A_GET(x) (((x) & 0x00000000000003F0ull) >> 4) +#define MINION_CSR_TENSOR_FMA_L1SCP_START_LINE_A_SET(x) (((x) << 4) & 0x00000000000003F0ull) +#define MINION_CSR_TENSOR_FMA_L1SCP_START_LINE_A_MODIFY(r, x) ((((x) << 4) & 0x00000000000003F0ull) | ((r) & 0xFFFFFFFFFFFFFC0Full)) + +/* Field: MINION_CSR_TENSOR_FMA.l1scp_start_line_b */ +#define MINION_CSR_TENSOR_FMA_L1SCP_START_LINE_B_MSB 17u +#define MINION_CSR_TENSOR_FMA_L1SCP_START_LINE_B_LSB 12u +#define MINION_CSR_TENSOR_FMA_L1SCP_START_LINE_B_WIDTH 6u +#define MINION_CSR_TENSOR_FMA_L1SCP_START_LINE_B_READ_ACCESS 1u +#define MINION_CSR_TENSOR_FMA_L1SCP_START_LINE_B_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_FMA_L1SCP_START_LINE_B_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_FMA_L1SCP_START_LINE_B_FIELD_MASK 0x000000000003F000ull +#define MINION_CSR_TENSOR_FMA_L1SCP_START_LINE_B_GET(x) (((x) & 0x000000000003F000ull) >> 12) +#define MINION_CSR_TENSOR_FMA_L1SCP_START_LINE_B_SET(x) (((x) << 12) & 0x000000000003F000ull) +#define MINION_CSR_TENSOR_FMA_L1SCP_START_LINE_B_MODIFY(r, x) ((((x) << 12) & 0x000000000003F000ull) | ((r) & 0xFFFFFFFFFFFC0FFFull)) + +/* Field: MINION_CSR_TENSOR_FMA.loc_b */ +#define MINION_CSR_TENSOR_FMA_LOC_B_MSB 20u +#define MINION_CSR_TENSOR_FMA_LOC_B_LSB 20u +#define MINION_CSR_TENSOR_FMA_LOC_B_WIDTH 1u +#define MINION_CSR_TENSOR_FMA_LOC_B_READ_ACCESS 1u +#define MINION_CSR_TENSOR_FMA_LOC_B_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_FMA_LOC_B_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_FMA_LOC_B_FIELD_MASK 0x0000000000100000ull +#define MINION_CSR_TENSOR_FMA_LOC_B_GET(x) (((x) & 0x0000000000100000ull) >> 20) +#define MINION_CSR_TENSOR_FMA_LOC_B_SET(x) (((x) << 20) & 0x0000000000100000ull) +#define MINION_CSR_TENSOR_FMA_LOC_B_MODIFY(r, x) ((((x) << 20) & 0x0000000000100000ull) | ((r) & 0xFFFFFFFFFFEFFFFFull)) + +/* Field: MINION_CSR_TENSOR_FMA.a_start_col */ +#define MINION_CSR_TENSOR_FMA_A_START_COL_MSB 46u +#define MINION_CSR_TENSOR_FMA_A_START_COL_LSB 43u +#define MINION_CSR_TENSOR_FMA_A_START_COL_WIDTH 4u +#define MINION_CSR_TENSOR_FMA_A_START_COL_READ_ACCESS 1u +#define MINION_CSR_TENSOR_FMA_A_START_COL_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_FMA_A_START_COL_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_FMA_A_START_COL_FIELD_MASK 0x0000780000000000ull +#define MINION_CSR_TENSOR_FMA_A_START_COL_GET(x) (((x) & 0x0000780000000000ull) >> 43) +#define MINION_CSR_TENSOR_FMA_A_START_COL_SET(x) (((x) << 43) & 0x0000780000000000ull) +#define MINION_CSR_TENSOR_FMA_A_START_COL_MODIFY(r, x) ((((x) << 43) & 0x0000780000000000ull) | ((r) & 0xFFFF87FFFFFFFFFFull)) + +/* Field: MINION_CSR_TENSOR_FMA.a_num_cols */ +#define MINION_CSR_TENSOR_FMA_A_NUM_COLS_MSB 50u +#define MINION_CSR_TENSOR_FMA_A_NUM_COLS_LSB 47u +#define MINION_CSR_TENSOR_FMA_A_NUM_COLS_WIDTH 4u +#define MINION_CSR_TENSOR_FMA_A_NUM_COLS_READ_ACCESS 1u +#define MINION_CSR_TENSOR_FMA_A_NUM_COLS_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_FMA_A_NUM_COLS_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_FMA_A_NUM_COLS_FIELD_MASK 0x0007800000000000ull +#define MINION_CSR_TENSOR_FMA_A_NUM_COLS_GET(x) (((x) & 0x0007800000000000ull) >> 47) +#define MINION_CSR_TENSOR_FMA_A_NUM_COLS_SET(x) (((x) << 47) & 0x0007800000000000ull) +#define MINION_CSR_TENSOR_FMA_A_NUM_COLS_MODIFY(r, x) ((((x) << 47) & 0x0007800000000000ull) | ((r) & 0xFFF87FFFFFFFFFFFull)) + +/* Field: MINION_CSR_TENSOR_FMA.a_num_rows */ +#define MINION_CSR_TENSOR_FMA_A_NUM_ROWS_MSB 54u +#define MINION_CSR_TENSOR_FMA_A_NUM_ROWS_LSB 51u +#define MINION_CSR_TENSOR_FMA_A_NUM_ROWS_WIDTH 4u +#define MINION_CSR_TENSOR_FMA_A_NUM_ROWS_READ_ACCESS 1u +#define MINION_CSR_TENSOR_FMA_A_NUM_ROWS_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_FMA_A_NUM_ROWS_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_FMA_A_NUM_ROWS_FIELD_MASK 0x0078000000000000ull +#define MINION_CSR_TENSOR_FMA_A_NUM_ROWS_GET(x) (((x) & 0x0078000000000000ull) >> 51) +#define MINION_CSR_TENSOR_FMA_A_NUM_ROWS_SET(x) (((x) << 51) & 0x0078000000000000ull) +#define MINION_CSR_TENSOR_FMA_A_NUM_ROWS_MODIFY(r, x) ((((x) << 51) & 0x0078000000000000ull) | ((r) & 0xFF87FFFFFFFFFFFFull)) + +/* Field: MINION_CSR_TENSOR_FMA.b_num_cols */ +#define MINION_CSR_TENSOR_FMA_B_NUM_COLS_MSB 56u +#define MINION_CSR_TENSOR_FMA_B_NUM_COLS_LSB 55u +#define MINION_CSR_TENSOR_FMA_B_NUM_COLS_WIDTH 2u +#define MINION_CSR_TENSOR_FMA_B_NUM_COLS_READ_ACCESS 1u +#define MINION_CSR_TENSOR_FMA_B_NUM_COLS_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_FMA_B_NUM_COLS_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_FMA_B_NUM_COLS_FIELD_MASK 0x0180000000000000ull +#define MINION_CSR_TENSOR_FMA_B_NUM_COLS_GET(x) (((x) & 0x0180000000000000ull) >> 55) +#define MINION_CSR_TENSOR_FMA_B_NUM_COLS_SET(x) (((x) << 55) & 0x0180000000000000ull) +#define MINION_CSR_TENSOR_FMA_B_NUM_COLS_MODIFY(r, x) ((((x) << 55) & 0x0180000000000000ull) | ((r) & 0xFE7FFFFFFFFFFFFFull)) + +/* Field: MINION_CSR_TENSOR_FMA.use_tensor_mask */ +#define MINION_CSR_TENSOR_FMA_USE_TENSOR_MASK_MSB 63u +#define MINION_CSR_TENSOR_FMA_USE_TENSOR_MASK_LSB 63u +#define MINION_CSR_TENSOR_FMA_USE_TENSOR_MASK_WIDTH 1u +#define MINION_CSR_TENSOR_FMA_USE_TENSOR_MASK_READ_ACCESS 1u +#define MINION_CSR_TENSOR_FMA_USE_TENSOR_MASK_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_FMA_USE_TENSOR_MASK_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_FMA_USE_TENSOR_MASK_FIELD_MASK 0x8000000000000000ull +#define MINION_CSR_TENSOR_FMA_USE_TENSOR_MASK_GET(x) (((x) & 0x8000000000000000ull) >> 63) +#define MINION_CSR_TENSOR_FMA_USE_TENSOR_MASK_SET(x) (((x) << 63) & 0x8000000000000000ull) +#define MINION_CSR_TENSOR_FMA_USE_TENSOR_MASK_MODIFY(r, x) ((((x) << 63) & 0x8000000000000000ull) | ((r) & 0x7FFFFFFFFFFFFFFFull)) + +/* Register: MINION_CSR.tensor_conv_size */ +#define MINION_CSR_TENSOR_CONV_SIZE_ADDRESS 0x00004010ul +#define MINION_CSR_TENSOR_CONV_SIZE_BYTE_ADDRESS 0x00004010ul +#define MINION_CSR_TENSOR_CONV_SIZE_OFFSET 0x00004010ul +#define MINION_CSR_TENSOR_CONV_SIZE_BYTE_OFFSET 0x00004010ul +#define MINION_CSR_TENSOR_CONV_SIZE_SIZE 0x00000008ul +#define MINION_CSR_TENSOR_CONV_SIZE_BYTE_SIZE 0x00000008ul +#define MINION_CSR_TENSOR_CONV_SIZE_READ_ACCESS 1u +#define MINION_CSR_TENSOR_CONV_SIZE_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_CONV_SIZE_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_TENSOR_CONV_SIZE_RESET_MASK 0xFF00FFFFFF00FFFFull +#define MINION_CSR_TENSOR_CONV_SIZE_READ_MASK 0xFF00FFFFFF00FFFFull +#define MINION_CSR_TENSOR_CONV_SIZE_WRITE_MASK 0xFF00FFFFFF00FFFFull + +/* Field: MINION_CSR_TENSOR_CONV_SIZE.ncol */ +#define MINION_CSR_TENSOR_CONV_SIZE_NCOL_MSB 15u +#define MINION_CSR_TENSOR_CONV_SIZE_NCOL_LSB 0u +#define MINION_CSR_TENSOR_CONV_SIZE_NCOL_WIDTH 16u +#define MINION_CSR_TENSOR_CONV_SIZE_NCOL_READ_ACCESS 1u +#define MINION_CSR_TENSOR_CONV_SIZE_NCOL_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_CONV_SIZE_NCOL_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_CONV_SIZE_NCOL_FIELD_MASK 0x000000000000FFFFull +#define MINION_CSR_TENSOR_CONV_SIZE_NCOL_GET(x) ((x) & 0x000000000000FFFFull) +#define MINION_CSR_TENSOR_CONV_SIZE_NCOL_SET(x) ((x) & 0x000000000000FFFFull) +#define MINION_CSR_TENSOR_CONV_SIZE_NCOL_MODIFY(r, x) ((((x) << 0) & 0x000000000000FFFFull) | ((r) & 0xFFFFFFFFFFFF0000ull)) + +/* Field: MINION_CSR_TENSOR_CONV_SIZE.scol */ +#define MINION_CSR_TENSOR_CONV_SIZE_SCOL_MSB 31u +#define MINION_CSR_TENSOR_CONV_SIZE_SCOL_LSB 24u +#define MINION_CSR_TENSOR_CONV_SIZE_SCOL_WIDTH 8u +#define MINION_CSR_TENSOR_CONV_SIZE_SCOL_READ_ACCESS 1u +#define MINION_CSR_TENSOR_CONV_SIZE_SCOL_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_CONV_SIZE_SCOL_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_CONV_SIZE_SCOL_FIELD_MASK 0x00000000FF000000ull +#define MINION_CSR_TENSOR_CONV_SIZE_SCOL_GET(x) (((x) & 0x00000000FF000000ull) >> 24) +#define MINION_CSR_TENSOR_CONV_SIZE_SCOL_SET(x) (((x) << 24) & 0x00000000FF000000ull) +#define MINION_CSR_TENSOR_CONV_SIZE_SCOL_MODIFY(r, x) ((((x) << 24) & 0x00000000FF000000ull) | ((r) & 0xFFFFFFFF00FFFFFFull)) + +/* Field: MINION_CSR_TENSOR_CONV_SIZE.nrow */ +#define MINION_CSR_TENSOR_CONV_SIZE_NROW_MSB 47u +#define MINION_CSR_TENSOR_CONV_SIZE_NROW_LSB 32u +#define MINION_CSR_TENSOR_CONV_SIZE_NROW_WIDTH 16u +#define MINION_CSR_TENSOR_CONV_SIZE_NROW_READ_ACCESS 1u +#define MINION_CSR_TENSOR_CONV_SIZE_NROW_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_CONV_SIZE_NROW_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_CONV_SIZE_NROW_FIELD_MASK 0x0000FFFF00000000ull +#define MINION_CSR_TENSOR_CONV_SIZE_NROW_GET(x) (((x) & 0x0000FFFF00000000ull) >> 32) +#define MINION_CSR_TENSOR_CONV_SIZE_NROW_SET(x) (((x) << 32) & 0x0000FFFF00000000ull) +#define MINION_CSR_TENSOR_CONV_SIZE_NROW_MODIFY(r, x) ((((x) << 32) & 0x0000FFFF00000000ull) | ((r) & 0xFFFF0000FFFFFFFFull)) + +/* Field: MINION_CSR_TENSOR_CONV_SIZE.srow */ +#define MINION_CSR_TENSOR_CONV_SIZE_SROW_MSB 63u +#define MINION_CSR_TENSOR_CONV_SIZE_SROW_LSB 56u +#define MINION_CSR_TENSOR_CONV_SIZE_SROW_WIDTH 8u +#define MINION_CSR_TENSOR_CONV_SIZE_SROW_READ_ACCESS 1u +#define MINION_CSR_TENSOR_CONV_SIZE_SROW_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_CONV_SIZE_SROW_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_CONV_SIZE_SROW_FIELD_MASK 0xFF00000000000000ull +#define MINION_CSR_TENSOR_CONV_SIZE_SROW_GET(x) (((x) & 0xFF00000000000000ull) >> 56) +#define MINION_CSR_TENSOR_CONV_SIZE_SROW_SET(x) (((x) << 56) & 0xFF00000000000000ull) +#define MINION_CSR_TENSOR_CONV_SIZE_SROW_MODIFY(r, x) ((((x) << 56) & 0xFF00000000000000ull) | ((r) & 0x00FFFFFFFFFFFFFFull)) + +/* Register: MINION_CSR.tensor_conv_ctrl */ +#define MINION_CSR_TENSOR_CONV_CTRL_ADDRESS 0x00004018ul +#define MINION_CSR_TENSOR_CONV_CTRL_BYTE_ADDRESS 0x00004018ul +#define MINION_CSR_TENSOR_CONV_CTRL_OFFSET 0x00004018ul +#define MINION_CSR_TENSOR_CONV_CTRL_BYTE_OFFSET 0x00004018ul +#define MINION_CSR_TENSOR_CONV_CTRL_SIZE 0x00000008ul +#define MINION_CSR_TENSOR_CONV_CTRL_BYTE_SIZE 0x00000008ul +#define MINION_CSR_TENSOR_CONV_CTRL_READ_ACCESS 1u +#define MINION_CSR_TENSOR_CONV_CTRL_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_CONV_CTRL_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_TENSOR_CONV_CTRL_RESET_MASK 0x0000FFFF0000FFFFull +#define MINION_CSR_TENSOR_CONV_CTRL_READ_MASK 0x0000FFFF0000FFFFull +#define MINION_CSR_TENSOR_CONV_CTRL_WRITE_MASK 0x0000FFFF0000FFFFull + +/* Field: MINION_CSR_TENSOR_CONV_CTRL.colstart */ +#define MINION_CSR_TENSOR_CONV_CTRL_COLSTART_MSB 15u +#define MINION_CSR_TENSOR_CONV_CTRL_COLSTART_LSB 0u +#define MINION_CSR_TENSOR_CONV_CTRL_COLSTART_WIDTH 16u +#define MINION_CSR_TENSOR_CONV_CTRL_COLSTART_READ_ACCESS 1u +#define MINION_CSR_TENSOR_CONV_CTRL_COLSTART_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_CONV_CTRL_COLSTART_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_CONV_CTRL_COLSTART_FIELD_MASK 0x000000000000FFFFull +#define MINION_CSR_TENSOR_CONV_CTRL_COLSTART_GET(x) ((x) & 0x000000000000FFFFull) +#define MINION_CSR_TENSOR_CONV_CTRL_COLSTART_SET(x) ((x) & 0x000000000000FFFFull) +#define MINION_CSR_TENSOR_CONV_CTRL_COLSTART_MODIFY(r, x) ((((x) << 0) & 0x000000000000FFFFull) | ((r) & 0xFFFFFFFFFFFF0000ull)) + +/* Field: MINION_CSR_TENSOR_CONV_CTRL.rowstart */ +#define MINION_CSR_TENSOR_CONV_CTRL_ROWSTART_MSB 47u +#define MINION_CSR_TENSOR_CONV_CTRL_ROWSTART_LSB 32u +#define MINION_CSR_TENSOR_CONV_CTRL_ROWSTART_WIDTH 16u +#define MINION_CSR_TENSOR_CONV_CTRL_ROWSTART_READ_ACCESS 1u +#define MINION_CSR_TENSOR_CONV_CTRL_ROWSTART_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_CONV_CTRL_ROWSTART_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_CONV_CTRL_ROWSTART_FIELD_MASK 0x0000FFFF00000000ull +#define MINION_CSR_TENSOR_CONV_CTRL_ROWSTART_GET(x) (((x) & 0x0000FFFF00000000ull) >> 32) +#define MINION_CSR_TENSOR_CONV_CTRL_ROWSTART_SET(x) (((x) << 32) & 0x0000FFFF00000000ull) +#define MINION_CSR_TENSOR_CONV_CTRL_ROWSTART_MODIFY(r, x) ((((x) << 32) & 0x0000FFFF00000000ull) | ((r) & 0xFFFF0000FFFFFFFFull)) + +/* Register: MINION_CSR.tensor_cooperation */ +#define MINION_CSR_TENSOR_COOPERATION_ADDRESS 0x00004020ul +#define MINION_CSR_TENSOR_COOPERATION_BYTE_ADDRESS 0x00004020ul +#define MINION_CSR_TENSOR_COOPERATION_OFFSET 0x00004020ul +#define MINION_CSR_TENSOR_COOPERATION_BYTE_OFFSET 0x00004020ul +#define MINION_CSR_TENSOR_COOPERATION_SIZE 0x00000008ul +#define MINION_CSR_TENSOR_COOPERATION_BYTE_SIZE 0x00000008ul +#define MINION_CSR_TENSOR_COOPERATION_READ_ACCESS 1u +#define MINION_CSR_TENSOR_COOPERATION_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_COOPERATION_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_TENSOR_COOPERATION_RESET_MASK 0x0000000000000007ull +#define MINION_CSR_TENSOR_COOPERATION_READ_MASK 0x0000000000000007ull +#define MINION_CSR_TENSOR_COOPERATION_WRITE_MASK 0x0000000000000007ull + +/* Field: MINION_CSR_TENSOR_COOPERATION.coopneighmask */ +#define MINION_CSR_TENSOR_COOPERATION_COOPNEIGHMASK_MSB 0u +#define MINION_CSR_TENSOR_COOPERATION_COOPNEIGHMASK_LSB 0u +#define MINION_CSR_TENSOR_COOPERATION_COOPNEIGHMASK_WIDTH 1u +#define MINION_CSR_TENSOR_COOPERATION_COOPNEIGHMASK_READ_ACCESS 1u +#define MINION_CSR_TENSOR_COOPERATION_COOPNEIGHMASK_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_COOPERATION_COOPNEIGHMASK_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_COOPERATION_COOPNEIGHMASK_FIELD_MASK 0x0000000000000001ull +#define MINION_CSR_TENSOR_COOPERATION_COOPNEIGHMASK_GET(x) ((x) & 0x0000000000000001ull) +#define MINION_CSR_TENSOR_COOPERATION_COOPNEIGHMASK_SET(x) ((x) & 0x0000000000000001ull) +#define MINION_CSR_TENSOR_COOPERATION_COOPNEIGHMASK_MODIFY(r, x) ((((x) << 0) & 0x0000000000000001ull) | ((r) & 0xFFFFFFFFFFFFFFFEull)) + +/* Field: MINION_CSR_TENSOR_COOPERATION.coopminmask */ +#define MINION_CSR_TENSOR_COOPERATION_COOPMINMASK_MSB 1u +#define MINION_CSR_TENSOR_COOPERATION_COOPMINMASK_LSB 1u +#define MINION_CSR_TENSOR_COOPERATION_COOPMINMASK_WIDTH 1u +#define MINION_CSR_TENSOR_COOPERATION_COOPMINMASK_READ_ACCESS 1u +#define MINION_CSR_TENSOR_COOPERATION_COOPMINMASK_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_COOPERATION_COOPMINMASK_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_COOPERATION_COOPMINMASK_FIELD_MASK 0x0000000000000002ull +#define MINION_CSR_TENSOR_COOPERATION_COOPMINMASK_GET(x) (((x) & 0x0000000000000002ull) >> 1) +#define MINION_CSR_TENSOR_COOPERATION_COOPMINMASK_SET(x) (((x) << 1) & 0x0000000000000002ull) +#define MINION_CSR_TENSOR_COOPERATION_COOPMINMASK_MODIFY(r, x) ((((x) << 1) & 0x0000000000000002ull) | ((r) & 0xFFFFFFFFFFFFFFFDull)) + +/* Field: MINION_CSR_TENSOR_COOPERATION.coopid */ +#define MINION_CSR_TENSOR_COOPERATION_COOPID_MSB 2u +#define MINION_CSR_TENSOR_COOPERATION_COOPID_LSB 2u +#define MINION_CSR_TENSOR_COOPERATION_COOPID_WIDTH 1u +#define MINION_CSR_TENSOR_COOPERATION_COOPID_READ_ACCESS 1u +#define MINION_CSR_TENSOR_COOPERATION_COOPID_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_COOPERATION_COOPID_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_COOPERATION_COOPID_FIELD_MASK 0x0000000000000004ull +#define MINION_CSR_TENSOR_COOPERATION_COOPID_GET(x) (((x) & 0x0000000000000004ull) >> 2) +#define MINION_CSR_TENSOR_COOPERATION_COOPID_SET(x) (((x) << 2) & 0x0000000000000004ull) +#define MINION_CSR_TENSOR_COOPERATION_COOPID_MODIFY(r, x) ((((x) << 2) & 0x0000000000000004ull) | ((r) & 0xFFFFFFFFFFFFFFFBull)) + +/* Register: MINION_CSR.tensor_mask */ +#define MINION_CSR_TENSOR_MASK_ADDRESS 0x00004028ul +#define MINION_CSR_TENSOR_MASK_BYTE_ADDRESS 0x00004028ul +#define MINION_CSR_TENSOR_MASK_OFFSET 0x00004028ul +#define MINION_CSR_TENSOR_MASK_BYTE_OFFSET 0x00004028ul +#define MINION_CSR_TENSOR_MASK_SIZE 0x00000008ul +#define MINION_CSR_TENSOR_MASK_BYTE_SIZE 0x00000008ul +#define MINION_CSR_TENSOR_MASK_READ_ACCESS 1u +#define MINION_CSR_TENSOR_MASK_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_MASK_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_TENSOR_MASK_RESET_MASK 0x000000000000FFFFull +#define MINION_CSR_TENSOR_MASK_READ_MASK 0x000000000000FFFFull +#define MINION_CSR_TENSOR_MASK_WRITE_MASK 0x000000000000FFFFull + +/* Field: MINION_CSR_TENSOR_MASK.tensormask */ +#define MINION_CSR_TENSOR_MASK_TENSORMASK_MSB 15u +#define MINION_CSR_TENSOR_MASK_TENSORMASK_LSB 0u +#define MINION_CSR_TENSOR_MASK_TENSORMASK_WIDTH 16u +#define MINION_CSR_TENSOR_MASK_TENSORMASK_READ_ACCESS 1u +#define MINION_CSR_TENSOR_MASK_TENSORMASK_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_MASK_TENSORMASK_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_MASK_TENSORMASK_FIELD_MASK 0x000000000000FFFFull +#define MINION_CSR_TENSOR_MASK_TENSORMASK_GET(x) ((x) & 0x000000000000FFFFull) +#define MINION_CSR_TENSOR_MASK_TENSORMASK_SET(x) ((x) & 0x000000000000FFFFull) +#define MINION_CSR_TENSOR_MASK_TENSORMASK_MODIFY(r, x) ((((x) << 0) & 0x000000000000FFFFull) | ((r) & 0xFFFFFFFFFFFF0000ull)) + +/* Register: MINION_CSR.tensor_quant */ +#define MINION_CSR_TENSOR_QUANT_ADDRESS 0x00004030ul +#define MINION_CSR_TENSOR_QUANT_BYTE_ADDRESS 0x00004030ul +#define MINION_CSR_TENSOR_QUANT_OFFSET 0x00004030ul +#define MINION_CSR_TENSOR_QUANT_BYTE_OFFSET 0x00004030ul +#define MINION_CSR_TENSOR_QUANT_SIZE 0x00000008ul +#define MINION_CSR_TENSOR_QUANT_BYTE_SIZE 0x00000008ul +#define MINION_CSR_TENSOR_QUANT_READ_ACCESS 1u +#define MINION_CSR_TENSOR_QUANT_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_QUANT_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_TENSOR_QUANT_RESET_MASK 0x3FFFE0FFFFFFFFFFull +#define MINION_CSR_TENSOR_QUANT_READ_MASK 0x3FFFE0FFFFFFFFFFull +#define MINION_CSR_TENSOR_QUANT_WRITE_MASK 0x3FFFE0FFFFFFFFFFull + +/* Field: MINION_CSR_TENSOR_QUANT.transform_0 */ +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_0_MSB 3u +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_0_LSB 0u +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_0_WIDTH 4u +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_0_READ_ACCESS 1u +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_0_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_0_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_0_FIELD_MASK 0x000000000000000Full +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_0_GET(x) ((x) & 0x000000000000000Full) +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_0_SET(x) ((x) & 0x000000000000000Full) +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_0_MODIFY(r, x) ((((x) << 0) & 0x000000000000000Full) | ((r) & 0xFFFFFFFFFFFFFFF0ull)) + +/* Field: MINION_CSR_TENSOR_QUANT.transform_1 */ +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_1_MSB 7u +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_1_LSB 4u +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_1_WIDTH 4u +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_1_READ_ACCESS 1u +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_1_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_1_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_1_FIELD_MASK 0x00000000000000F0ull +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_1_GET(x) (((x) & 0x00000000000000F0ull) >> 4) +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_1_SET(x) (((x) << 4) & 0x00000000000000F0ull) +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_1_MODIFY(r, x) ((((x) << 4) & 0x00000000000000F0ull) | ((r) & 0xFFFFFFFFFFFFFF0Full)) + +/* Field: MINION_CSR_TENSOR_QUANT.transform_2 */ +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_2_MSB 11u +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_2_LSB 8u +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_2_WIDTH 4u +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_2_READ_ACCESS 1u +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_2_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_2_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_2_FIELD_MASK 0x0000000000000F00ull +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_2_GET(x) (((x) & 0x0000000000000F00ull) >> 8) +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_2_SET(x) (((x) << 8) & 0x0000000000000F00ull) +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_2_MODIFY(r, x) ((((x) << 8) & 0x0000000000000F00ull) | ((r) & 0xFFFFFFFFFFFFF0FFull)) + +/* Field: MINION_CSR_TENSOR_QUANT.transform_3 */ +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_3_MSB 15u +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_3_LSB 12u +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_3_WIDTH 4u +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_3_READ_ACCESS 1u +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_3_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_3_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_3_FIELD_MASK 0x000000000000F000ull +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_3_GET(x) (((x) & 0x000000000000F000ull) >> 12) +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_3_SET(x) (((x) << 12) & 0x000000000000F000ull) +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_3_MODIFY(r, x) ((((x) << 12) & 0x000000000000F000ull) | ((r) & 0xFFFFFFFFFFFF0FFFull)) + +/* Field: MINION_CSR_TENSOR_QUANT.transform_4 */ +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_4_MSB 19u +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_4_LSB 16u +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_4_WIDTH 4u +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_4_READ_ACCESS 1u +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_4_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_4_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_4_FIELD_MASK 0x00000000000F0000ull +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_4_GET(x) (((x) & 0x00000000000F0000ull) >> 16) +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_4_SET(x) (((x) << 16) & 0x00000000000F0000ull) +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_4_MODIFY(r, x) ((((x) << 16) & 0x00000000000F0000ull) | ((r) & 0xFFFFFFFFFFF0FFFFull)) + +/* Field: MINION_CSR_TENSOR_QUANT.transform_5 */ +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_5_MSB 23u +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_5_LSB 20u +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_5_WIDTH 4u +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_5_READ_ACCESS 1u +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_5_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_5_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_5_FIELD_MASK 0x0000000000F00000ull +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_5_GET(x) (((x) & 0x0000000000F00000ull) >> 20) +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_5_SET(x) (((x) << 20) & 0x0000000000F00000ull) +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_5_MODIFY(r, x) ((((x) << 20) & 0x0000000000F00000ull) | ((r) & 0xFFFFFFFFFF0FFFFFull)) + +/* Field: MINION_CSR_TENSOR_QUANT.transform_6 */ +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_6_MSB 27u +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_6_LSB 24u +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_6_WIDTH 4u +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_6_READ_ACCESS 1u +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_6_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_6_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_6_FIELD_MASK 0x000000000F000000ull +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_6_GET(x) (((x) & 0x000000000F000000ull) >> 24) +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_6_SET(x) (((x) << 24) & 0x000000000F000000ull) +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_6_MODIFY(r, x) ((((x) << 24) & 0x000000000F000000ull) | ((r) & 0xFFFFFFFFF0FFFFFFull)) + +/* Field: MINION_CSR_TENSOR_QUANT.transform_7 */ +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_7_MSB 31u +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_7_LSB 28u +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_7_WIDTH 4u +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_7_READ_ACCESS 1u +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_7_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_7_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_7_FIELD_MASK 0x00000000F0000000ull +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_7_GET(x) (((x) & 0x00000000F0000000ull) >> 28) +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_7_SET(x) (((x) << 28) & 0x00000000F0000000ull) +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_7_MODIFY(r, x) ((((x) << 28) & 0x00000000F0000000ull) | ((r) & 0xFFFFFFFF0FFFFFFFull)) + +/* Field: MINION_CSR_TENSOR_QUANT.transform_8 */ +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_8_MSB 35u +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_8_LSB 32u +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_8_WIDTH 4u +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_8_READ_ACCESS 1u +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_8_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_8_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_8_FIELD_MASK 0x0000000F00000000ull +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_8_GET(x) (((x) & 0x0000000F00000000ull) >> 32) +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_8_SET(x) (((x) << 32) & 0x0000000F00000000ull) +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_8_MODIFY(r, x) ((((x) << 32) & 0x0000000F00000000ull) | ((r) & 0xFFFFFFF0FFFFFFFFull)) + +/* Field: MINION_CSR_TENSOR_QUANT.transform_9 */ +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_9_MSB 39u +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_9_LSB 36u +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_9_WIDTH 4u +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_9_READ_ACCESS 1u +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_9_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_9_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_9_FIELD_MASK 0x000000F000000000ull +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_9_GET(x) (((x) & 0x000000F000000000ull) >> 36) +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_9_SET(x) (((x) << 36) & 0x000000F000000000ull) +#define MINION_CSR_TENSOR_QUANT_TRANSFORM_9_MODIFY(r, x) ((((x) << 36) & 0x000000F000000000ull) | ((r) & 0xFFFFFF0FFFFFFFFFull)) + +/* Field: MINION_CSR_TENSOR_QUANT.l1scp_start_line */ +#define MINION_CSR_TENSOR_QUANT_L1SCP_START_LINE_MSB 50u +#define MINION_CSR_TENSOR_QUANT_L1SCP_START_LINE_LSB 45u +#define MINION_CSR_TENSOR_QUANT_L1SCP_START_LINE_WIDTH 6u +#define MINION_CSR_TENSOR_QUANT_L1SCP_START_LINE_READ_ACCESS 1u +#define MINION_CSR_TENSOR_QUANT_L1SCP_START_LINE_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_QUANT_L1SCP_START_LINE_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_QUANT_L1SCP_START_LINE_FIELD_MASK 0x0007E00000000000ull +#define MINION_CSR_TENSOR_QUANT_L1SCP_START_LINE_GET(x) (((x) & 0x0007E00000000000ull) >> 45) +#define MINION_CSR_TENSOR_QUANT_L1SCP_START_LINE_SET(x) (((x) << 45) & 0x0007E00000000000ull) +#define MINION_CSR_TENSOR_QUANT_L1SCP_START_LINE_MODIFY(r, x) ((((x) << 45) & 0x0007E00000000000ull) | ((r) & 0xFFF81FFFFFFFFFFFull)) + +/* Field: MINION_CSR_TENSOR_QUANT.a_matrix_num_rows */ +#define MINION_CSR_TENSOR_QUANT_A_MATRIX_NUM_ROWS_MSB 54u +#define MINION_CSR_TENSOR_QUANT_A_MATRIX_NUM_ROWS_LSB 51u +#define MINION_CSR_TENSOR_QUANT_A_MATRIX_NUM_ROWS_WIDTH 4u +#define MINION_CSR_TENSOR_QUANT_A_MATRIX_NUM_ROWS_READ_ACCESS 1u +#define MINION_CSR_TENSOR_QUANT_A_MATRIX_NUM_ROWS_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_QUANT_A_MATRIX_NUM_ROWS_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_QUANT_A_MATRIX_NUM_ROWS_FIELD_MASK 0x0078000000000000ull +#define MINION_CSR_TENSOR_QUANT_A_MATRIX_NUM_ROWS_GET(x) (((x) & 0x0078000000000000ull) >> 51) +#define MINION_CSR_TENSOR_QUANT_A_MATRIX_NUM_ROWS_SET(x) (((x) << 51) & 0x0078000000000000ull) +#define MINION_CSR_TENSOR_QUANT_A_MATRIX_NUM_ROWS_MODIFY(r, x) ((((x) << 51) & 0x0078000000000000ull) | ((r) & 0xFF87FFFFFFFFFFFFull)) + +/* Field: MINION_CSR_TENSOR_QUANT.a_matrix_num_cols */ +#define MINION_CSR_TENSOR_QUANT_A_MATRIX_NUM_COLS_MSB 56u +#define MINION_CSR_TENSOR_QUANT_A_MATRIX_NUM_COLS_LSB 55u +#define MINION_CSR_TENSOR_QUANT_A_MATRIX_NUM_COLS_WIDTH 2u +#define MINION_CSR_TENSOR_QUANT_A_MATRIX_NUM_COLS_READ_ACCESS 1u +#define MINION_CSR_TENSOR_QUANT_A_MATRIX_NUM_COLS_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_QUANT_A_MATRIX_NUM_COLS_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_QUANT_A_MATRIX_NUM_COLS_FIELD_MASK 0x0180000000000000ull +#define MINION_CSR_TENSOR_QUANT_A_MATRIX_NUM_COLS_GET(x) (((x) & 0x0180000000000000ull) >> 55) +#define MINION_CSR_TENSOR_QUANT_A_MATRIX_NUM_COLS_SET(x) (((x) << 55) & 0x0180000000000000ull) +#define MINION_CSR_TENSOR_QUANT_A_MATRIX_NUM_COLS_MODIFY(r, x) ((((x) << 55) & 0x0180000000000000ull) | ((r) & 0xFE7FFFFFFFFFFFFFull)) + +/* Field: MINION_CSR_TENSOR_QUANT.start_reg */ +#define MINION_CSR_TENSOR_QUANT_START_REG_MSB 61u +#define MINION_CSR_TENSOR_QUANT_START_REG_LSB 57u +#define MINION_CSR_TENSOR_QUANT_START_REG_WIDTH 5u +#define MINION_CSR_TENSOR_QUANT_START_REG_READ_ACCESS 1u +#define MINION_CSR_TENSOR_QUANT_START_REG_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_QUANT_START_REG_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_QUANT_START_REG_FIELD_MASK 0x3E00000000000000ull +#define MINION_CSR_TENSOR_QUANT_START_REG_GET(x) (((x) & 0x3E00000000000000ull) >> 57) +#define MINION_CSR_TENSOR_QUANT_START_REG_SET(x) (((x) << 57) & 0x3E00000000000000ull) +#define MINION_CSR_TENSOR_QUANT_START_REG_MODIFY(r, x) ((((x) << 57) & 0x3E00000000000000ull) | ((r) & 0xC1FFFFFFFFFFFFFFull)) + +/* Register: MINION_CSR.tex_send */ +#define MINION_CSR_TEX_SEND_ADDRESS 0x00004038ul +#define MINION_CSR_TEX_SEND_BYTE_ADDRESS 0x00004038ul +#define MINION_CSR_TEX_SEND_OFFSET 0x00004038ul +#define MINION_CSR_TEX_SEND_BYTE_OFFSET 0x00004038ul +#define MINION_CSR_TEX_SEND_SIZE 0x00000008ul +#define MINION_CSR_TEX_SEND_BYTE_SIZE 0x00000008ul +#define MINION_CSR_TEX_SEND_READ_ACCESS 1u +#define MINION_CSR_TEX_SEND_WRITE_ACCESS 1u +#define MINION_CSR_TEX_SEND_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_TEX_SEND_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_TEX_SEND_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_TEX_SEND_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_TEX_SEND.tex_send */ +#define MINION_CSR_TEX_SEND_TEX_SEND_MSB 63u +#define MINION_CSR_TEX_SEND_TEX_SEND_LSB 0u +#define MINION_CSR_TEX_SEND_TEX_SEND_WIDTH 64u +#define MINION_CSR_TEX_SEND_TEX_SEND_READ_ACCESS 1u +#define MINION_CSR_TEX_SEND_TEX_SEND_WRITE_ACCESS 1u +#define MINION_CSR_TEX_SEND_TEX_SEND_RESET 0x0000000000000000ull +#define MINION_CSR_TEX_SEND_TEX_SEND_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_TEX_SEND_TEX_SEND_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_TEX_SEND_TEX_SEND_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_TEX_SEND_TEX_SEND_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.tensor_error */ +#define MINION_CSR_TENSOR_ERROR_ADDRESS 0x00004040ul +#define MINION_CSR_TENSOR_ERROR_BYTE_ADDRESS 0x00004040ul +#define MINION_CSR_TENSOR_ERROR_OFFSET 0x00004040ul +#define MINION_CSR_TENSOR_ERROR_BYTE_OFFSET 0x00004040ul +#define MINION_CSR_TENSOR_ERROR_SIZE 0x00000008ul +#define MINION_CSR_TENSOR_ERROR_BYTE_SIZE 0x00000008ul +#define MINION_CSR_TENSOR_ERROR_READ_ACCESS 1u +#define MINION_CSR_TENSOR_ERROR_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_ERROR_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_TENSOR_ERROR_RESET_MASK 0x00000000000003FAull +#define MINION_CSR_TENSOR_ERROR_READ_MASK 0x00000000000003FAull +#define MINION_CSR_TENSOR_ERROR_WRITE_MASK 0x00000000000003FAull + +/* Field: MINION_CSR_TENSOR_ERROR.wrong_tload_txform */ +#define MINION_CSR_TENSOR_ERROR_WRONG_TLOAD_TXFORM_MSB 1u +#define MINION_CSR_TENSOR_ERROR_WRONG_TLOAD_TXFORM_LSB 1u +#define MINION_CSR_TENSOR_ERROR_WRONG_TLOAD_TXFORM_WIDTH 1u +#define MINION_CSR_TENSOR_ERROR_WRONG_TLOAD_TXFORM_READ_ACCESS 1u +#define MINION_CSR_TENSOR_ERROR_WRONG_TLOAD_TXFORM_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_ERROR_WRONG_TLOAD_TXFORM_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_ERROR_WRONG_TLOAD_TXFORM_FIELD_MASK 0x0000000000000002ull +#define MINION_CSR_TENSOR_ERROR_WRONG_TLOAD_TXFORM_GET(x) (((x) & 0x0000000000000002ull) >> 1) +#define MINION_CSR_TENSOR_ERROR_WRONG_TLOAD_TXFORM_SET(x) (((x) << 1) & 0x0000000000000002ull) +#define MINION_CSR_TENSOR_ERROR_WRONG_TLOAD_TXFORM_MODIFY(r, x) ((((x) << 1) & 0x0000000000000002ull) | ((r) & 0xFFFFFFFFFFFFFFFDull)) + +/* Field: MINION_CSR_TENSOR_ERROR.fcc_overflow */ +#define MINION_CSR_TENSOR_ERROR_FCC_OVERFLOW_MSB 3u +#define MINION_CSR_TENSOR_ERROR_FCC_OVERFLOW_LSB 3u +#define MINION_CSR_TENSOR_ERROR_FCC_OVERFLOW_WIDTH 1u +#define MINION_CSR_TENSOR_ERROR_FCC_OVERFLOW_READ_ACCESS 1u +#define MINION_CSR_TENSOR_ERROR_FCC_OVERFLOW_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_ERROR_FCC_OVERFLOW_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_ERROR_FCC_OVERFLOW_FIELD_MASK 0x0000000000000008ull +#define MINION_CSR_TENSOR_ERROR_FCC_OVERFLOW_GET(x) (((x) & 0x0000000000000008ull) >> 3) +#define MINION_CSR_TENSOR_ERROR_FCC_OVERFLOW_SET(x) (((x) << 3) & 0x0000000000000008ull) +#define MINION_CSR_TENSOR_ERROR_FCC_OVERFLOW_MODIFY(r, x) ((((x) << 3) & 0x0000000000000008ull) | ((r) & 0xFFFFFFFFFFFFFFF7ull)) + +/* Field: MINION_CSR_TENSOR_ERROR.l1_scp_disabled */ +#define MINION_CSR_TENSOR_ERROR_L1_SCP_DISABLED_MSB 4u +#define MINION_CSR_TENSOR_ERROR_L1_SCP_DISABLED_LSB 4u +#define MINION_CSR_TENSOR_ERROR_L1_SCP_DISABLED_WIDTH 1u +#define MINION_CSR_TENSOR_ERROR_L1_SCP_DISABLED_READ_ACCESS 1u +#define MINION_CSR_TENSOR_ERROR_L1_SCP_DISABLED_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_ERROR_L1_SCP_DISABLED_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_ERROR_L1_SCP_DISABLED_FIELD_MASK 0x0000000000000010ull +#define MINION_CSR_TENSOR_ERROR_L1_SCP_DISABLED_GET(x) (((x) & 0x0000000000000010ull) >> 4) +#define MINION_CSR_TENSOR_ERROR_L1_SCP_DISABLED_SET(x) (((x) << 4) & 0x0000000000000010ull) +#define MINION_CSR_TENSOR_ERROR_L1_SCP_DISABLED_MODIFY(r, x) ((((x) << 4) & 0x0000000000000010ull) | ((r) & 0xFFFFFFFFFFFFFFEFull)) + +/* Field: MINION_CSR_TENSOR_ERROR.lock_sw_failed */ +#define MINION_CSR_TENSOR_ERROR_LOCK_SW_FAILED_MSB 5u +#define MINION_CSR_TENSOR_ERROR_LOCK_SW_FAILED_LSB 5u +#define MINION_CSR_TENSOR_ERROR_LOCK_SW_FAILED_WIDTH 1u +#define MINION_CSR_TENSOR_ERROR_LOCK_SW_FAILED_READ_ACCESS 1u +#define MINION_CSR_TENSOR_ERROR_LOCK_SW_FAILED_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_ERROR_LOCK_SW_FAILED_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_ERROR_LOCK_SW_FAILED_FIELD_MASK 0x0000000000000020ull +#define MINION_CSR_TENSOR_ERROR_LOCK_SW_FAILED_GET(x) (((x) & 0x0000000000000020ull) >> 5) +#define MINION_CSR_TENSOR_ERROR_LOCK_SW_FAILED_SET(x) (((x) << 5) & 0x0000000000000020ull) +#define MINION_CSR_TENSOR_ERROR_LOCK_SW_FAILED_MODIFY(r, x) ((((x) << 5) & 0x0000000000000020ull) | ((r) & 0xFFFFFFFFFFFFFFDFull)) + +/* Field: MINION_CSR_TENSOR_ERROR.ill_tb_tfma_pair */ +#define MINION_CSR_TENSOR_ERROR_ILL_TB_TFMA_PAIR_MSB 6u +#define MINION_CSR_TENSOR_ERROR_ILL_TB_TFMA_PAIR_LSB 6u +#define MINION_CSR_TENSOR_ERROR_ILL_TB_TFMA_PAIR_WIDTH 1u +#define MINION_CSR_TENSOR_ERROR_ILL_TB_TFMA_PAIR_READ_ACCESS 1u +#define MINION_CSR_TENSOR_ERROR_ILL_TB_TFMA_PAIR_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_ERROR_ILL_TB_TFMA_PAIR_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_ERROR_ILL_TB_TFMA_PAIR_FIELD_MASK 0x0000000000000040ull +#define MINION_CSR_TENSOR_ERROR_ILL_TB_TFMA_PAIR_GET(x) (((x) & 0x0000000000000040ull) >> 6) +#define MINION_CSR_TENSOR_ERROR_ILL_TB_TFMA_PAIR_SET(x) (((x) << 6) & 0x0000000000000040ull) +#define MINION_CSR_TENSOR_ERROR_ILL_TB_TFMA_PAIR_MODIFY(r, x) ((((x) << 6) & 0x0000000000000040ull) | ((r) & 0xFFFFFFFFFFFFFFBFull)) + +/* Field: MINION_CSR_TENSOR_ERROR.mem_fault */ +#define MINION_CSR_TENSOR_ERROR_MEM_FAULT_MSB 7u +#define MINION_CSR_TENSOR_ERROR_MEM_FAULT_LSB 7u +#define MINION_CSR_TENSOR_ERROR_MEM_FAULT_WIDTH 1u +#define MINION_CSR_TENSOR_ERROR_MEM_FAULT_READ_ACCESS 1u +#define MINION_CSR_TENSOR_ERROR_MEM_FAULT_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_ERROR_MEM_FAULT_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_ERROR_MEM_FAULT_FIELD_MASK 0x0000000000000080ull +#define MINION_CSR_TENSOR_ERROR_MEM_FAULT_GET(x) (((x) & 0x0000000000000080ull) >> 7) +#define MINION_CSR_TENSOR_ERROR_MEM_FAULT_SET(x) (((x) << 7) & 0x0000000000000080ull) +#define MINION_CSR_TENSOR_ERROR_MEM_FAULT_MODIFY(r, x) ((((x) << 7) & 0x0000000000000080ull) | ((r) & 0xFFFFFFFFFFFFFF7Full)) + +/* Field: MINION_CSR_TENSOR_ERROR.inv_comb_store_size */ +#define MINION_CSR_TENSOR_ERROR_INV_COMB_STORE_SIZE_MSB 8u +#define MINION_CSR_TENSOR_ERROR_INV_COMB_STORE_SIZE_LSB 8u +#define MINION_CSR_TENSOR_ERROR_INV_COMB_STORE_SIZE_WIDTH 1u +#define MINION_CSR_TENSOR_ERROR_INV_COMB_STORE_SIZE_READ_ACCESS 1u +#define MINION_CSR_TENSOR_ERROR_INV_COMB_STORE_SIZE_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_ERROR_INV_COMB_STORE_SIZE_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_ERROR_INV_COMB_STORE_SIZE_FIELD_MASK 0x0000000000000100ull +#define MINION_CSR_TENSOR_ERROR_INV_COMB_STORE_SIZE_GET(x) (((x) & 0x0000000000000100ull) >> 8) +#define MINION_CSR_TENSOR_ERROR_INV_COMB_STORE_SIZE_SET(x) (((x) << 8) & 0x0000000000000100ull) +#define MINION_CSR_TENSOR_ERROR_INV_COMB_STORE_SIZE_MODIFY(r, x) ((((x) << 8) & 0x0000000000000100ull) | ((r) & 0xFFFFFFFFFFFFFEFFull)) + +/* Field: MINION_CSR_TENSOR_ERROR.illegal_tensor_send_rcv */ +#define MINION_CSR_TENSOR_ERROR_ILLEGAL_TENSOR_SEND_RCV_MSB 9u +#define MINION_CSR_TENSOR_ERROR_ILLEGAL_TENSOR_SEND_RCV_LSB 9u +#define MINION_CSR_TENSOR_ERROR_ILLEGAL_TENSOR_SEND_RCV_WIDTH 1u +#define MINION_CSR_TENSOR_ERROR_ILLEGAL_TENSOR_SEND_RCV_READ_ACCESS 1u +#define MINION_CSR_TENSOR_ERROR_ILLEGAL_TENSOR_SEND_RCV_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_ERROR_ILLEGAL_TENSOR_SEND_RCV_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_ERROR_ILLEGAL_TENSOR_SEND_RCV_FIELD_MASK 0x0000000000000200ull +#define MINION_CSR_TENSOR_ERROR_ILLEGAL_TENSOR_SEND_RCV_GET(x) (((x) & 0x0000000000000200ull) >> 9) +#define MINION_CSR_TENSOR_ERROR_ILLEGAL_TENSOR_SEND_RCV_SET(x) (((x) << 9) & 0x0000000000000200ull) +#define MINION_CSR_TENSOR_ERROR_ILLEGAL_TENSOR_SEND_RCV_MODIFY(r, x) ((((x) << 9) & 0x0000000000000200ull) | ((r) & 0xFFFFFFFFFFFFFDFFull)) + +/* Register: MINION_CSR.ucache_control */ +#define MINION_CSR_UCACHE_CONTROL_ADDRESS 0x00004080ul +#define MINION_CSR_UCACHE_CONTROL_BYTE_ADDRESS 0x00004080ul +#define MINION_CSR_UCACHE_CONTROL_OFFSET 0x00004080ul +#define MINION_CSR_UCACHE_CONTROL_BYTE_OFFSET 0x00004080ul +#define MINION_CSR_UCACHE_CONTROL_SIZE 0x00000008ul +#define MINION_CSR_UCACHE_CONTROL_BYTE_SIZE 0x00000008ul +#define MINION_CSR_UCACHE_CONTROL_READ_ACCESS 1u +#define MINION_CSR_UCACHE_CONTROL_WRITE_ACCESS 1u +#define MINION_CSR_UCACHE_CONTROL_RESET_VALUE 0x0000000000000200ull +#define MINION_CSR_UCACHE_CONTROL_RESET_MASK 0x00000000000007DFull +#define MINION_CSR_UCACHE_CONTROL_READ_MASK 0x00000000000007DFull +#define MINION_CSR_UCACHE_CONTROL_WRITE_MASK 0x00000000000007DEull + +/* Field: MINION_CSR_UCACHE_CONTROL.d1split */ +#define MINION_CSR_UCACHE_CONTROL_D1SPLIT_MSB 0u +#define MINION_CSR_UCACHE_CONTROL_D1SPLIT_LSB 0u +#define MINION_CSR_UCACHE_CONTROL_D1SPLIT_WIDTH 1u +#define MINION_CSR_UCACHE_CONTROL_D1SPLIT_READ_ACCESS 1u +#define MINION_CSR_UCACHE_CONTROL_D1SPLIT_WRITE_ACCESS 0u +#define MINION_CSR_UCACHE_CONTROL_D1SPLIT_RESET 0x0000000000000000ull +#define MINION_CSR_UCACHE_CONTROL_D1SPLIT_FIELD_MASK 0x0000000000000001ull +#define MINION_CSR_UCACHE_CONTROL_D1SPLIT_GET(x) ((x) & 0x0000000000000001ull) +#define MINION_CSR_UCACHE_CONTROL_D1SPLIT_SET(x) ((x) & 0x0000000000000001ull) +#define MINION_CSR_UCACHE_CONTROL_D1SPLIT_MODIFY(r, x) ((((x) << 0) & 0x0000000000000001ull) | ((r) & 0xFFFFFFFFFFFFFFFEull)) + +/* Field: MINION_CSR_UCACHE_CONTROL.scpenable */ +#define MINION_CSR_UCACHE_CONTROL_SCPENABLE_MSB 1u +#define MINION_CSR_UCACHE_CONTROL_SCPENABLE_LSB 1u +#define MINION_CSR_UCACHE_CONTROL_SCPENABLE_WIDTH 1u +#define MINION_CSR_UCACHE_CONTROL_SCPENABLE_READ_ACCESS 1u +#define MINION_CSR_UCACHE_CONTROL_SCPENABLE_WRITE_ACCESS 1u +#define MINION_CSR_UCACHE_CONTROL_SCPENABLE_RESET 0x0000000000000000ull +#define MINION_CSR_UCACHE_CONTROL_SCPENABLE_FIELD_MASK 0x0000000000000002ull +#define MINION_CSR_UCACHE_CONTROL_SCPENABLE_GET(x) (((x) & 0x0000000000000002ull) >> 1) +#define MINION_CSR_UCACHE_CONTROL_SCPENABLE_SET(x) (((x) << 1) & 0x0000000000000002ull) +#define MINION_CSR_UCACHE_CONTROL_SCPENABLE_MODIFY(r, x) ((((x) << 1) & 0x0000000000000002ull) | ((r) & 0xFFFFFFFFFFFFFFFDull)) + +/* Field: MINION_CSR_UCACHE_CONTROL.cacheop_reprate */ +#define MINION_CSR_UCACHE_CONTROL_CACHEOP_REPRATE_MSB 4u +#define MINION_CSR_UCACHE_CONTROL_CACHEOP_REPRATE_LSB 2u +#define MINION_CSR_UCACHE_CONTROL_CACHEOP_REPRATE_WIDTH 3u +#define MINION_CSR_UCACHE_CONTROL_CACHEOP_REPRATE_READ_ACCESS 1u +#define MINION_CSR_UCACHE_CONTROL_CACHEOP_REPRATE_WRITE_ACCESS 1u +#define MINION_CSR_UCACHE_CONTROL_CACHEOP_REPRATE_RESET 0x0000000000000000ull +#define MINION_CSR_UCACHE_CONTROL_CACHEOP_REPRATE_FIELD_MASK 0x000000000000001Cull +#define MINION_CSR_UCACHE_CONTROL_CACHEOP_REPRATE_GET(x) (((x) & 0x000000000000001Cull) >> 2) +#define MINION_CSR_UCACHE_CONTROL_CACHEOP_REPRATE_SET(x) (((x) << 2) & 0x000000000000001Cull) +#define MINION_CSR_UCACHE_CONTROL_CACHEOP_REPRATE_MODIFY(r, x) ((((x) << 2) & 0x000000000000001Cull) | ((r) & 0xFFFFFFFFFFFFFFE3ull)) + +/* Field: MINION_CSR_UCACHE_CONTROL.cacheop_max */ +#define MINION_CSR_UCACHE_CONTROL_CACHEOP_MAX_MSB 10u +#define MINION_CSR_UCACHE_CONTROL_CACHEOP_MAX_LSB 6u +#define MINION_CSR_UCACHE_CONTROL_CACHEOP_MAX_WIDTH 5u +#define MINION_CSR_UCACHE_CONTROL_CACHEOP_MAX_READ_ACCESS 1u +#define MINION_CSR_UCACHE_CONTROL_CACHEOP_MAX_WRITE_ACCESS 1u +#define MINION_CSR_UCACHE_CONTROL_CACHEOP_MAX_RESET 0x0000000000000008ull +#define MINION_CSR_UCACHE_CONTROL_CACHEOP_MAX_FIELD_MASK 0x00000000000007C0ull +#define MINION_CSR_UCACHE_CONTROL_CACHEOP_MAX_GET(x) (((x) & 0x00000000000007C0ull) >> 6) +#define MINION_CSR_UCACHE_CONTROL_CACHEOP_MAX_SET(x) (((x) << 6) & 0x00000000000007C0ull) +#define MINION_CSR_UCACHE_CONTROL_CACHEOP_MAX_MODIFY(r, x) ((((x) << 6) & 0x00000000000007C0ull) | ((r) & 0xFFFFFFFFFFFFF83Full)) + +/* Register: MINION_CSR.co_prefetch_va */ +#define MINION_CSR_CO_PREFETCH_VA_ADDRESS 0x000040F8ul +#define MINION_CSR_CO_PREFETCH_VA_BYTE_ADDRESS 0x000040F8ul +#define MINION_CSR_CO_PREFETCH_VA_OFFSET 0x000040F8ul +#define MINION_CSR_CO_PREFETCH_VA_BYTE_OFFSET 0x000040F8ul +#define MINION_CSR_CO_PREFETCH_VA_SIZE 0x00000008ul +#define MINION_CSR_CO_PREFETCH_VA_BYTE_SIZE 0x00000008ul +#define MINION_CSR_CO_PREFETCH_VA_READ_ACCESS 1u +#define MINION_CSR_CO_PREFETCH_VA_WRITE_ACCESS 1u +#define MINION_CSR_CO_PREFETCH_VA_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_CO_PREFETCH_VA_RESET_MASK 0x8C00FFFFFFFFFFCFull +#define MINION_CSR_CO_PREFETCH_VA_READ_MASK 0x8C00FFFFFFFFFFCFull +#define MINION_CSR_CO_PREFETCH_VA_WRITE_MASK 0x8C00FFFFFFFFFFCFull + +/* Field: MINION_CSR_CO_PREFETCH_VA.num_lines */ +#define MINION_CSR_CO_PREFETCH_VA_NUM_LINES_MSB 3u +#define MINION_CSR_CO_PREFETCH_VA_NUM_LINES_LSB 0u +#define MINION_CSR_CO_PREFETCH_VA_NUM_LINES_WIDTH 4u +#define MINION_CSR_CO_PREFETCH_VA_NUM_LINES_READ_ACCESS 1u +#define MINION_CSR_CO_PREFETCH_VA_NUM_LINES_WRITE_ACCESS 1u +#define MINION_CSR_CO_PREFETCH_VA_NUM_LINES_RESET 0x0000000000000000ull +#define MINION_CSR_CO_PREFETCH_VA_NUM_LINES_FIELD_MASK 0x000000000000000Full +#define MINION_CSR_CO_PREFETCH_VA_NUM_LINES_GET(x) ((x) & 0x000000000000000Full) +#define MINION_CSR_CO_PREFETCH_VA_NUM_LINES_SET(x) ((x) & 0x000000000000000Full) +#define MINION_CSR_CO_PREFETCH_VA_NUM_LINES_MODIFY(r, x) ((((x) << 0) & 0x000000000000000Full) | ((r) & 0xFFFFFFFFFFFFFFF0ull)) + +/* Field: MINION_CSR_CO_PREFETCH_VA.va */ +#define MINION_CSR_CO_PREFETCH_VA_VA_MSB 47u +#define MINION_CSR_CO_PREFETCH_VA_VA_LSB 6u +#define MINION_CSR_CO_PREFETCH_VA_VA_WIDTH 42u +#define MINION_CSR_CO_PREFETCH_VA_VA_READ_ACCESS 1u +#define MINION_CSR_CO_PREFETCH_VA_VA_WRITE_ACCESS 1u +#define MINION_CSR_CO_PREFETCH_VA_VA_RESET 0x0000000000000000ull +#define MINION_CSR_CO_PREFETCH_VA_VA_FIELD_MASK 0x0000FFFFFFFFFFC0ull +#define MINION_CSR_CO_PREFETCH_VA_VA_GET(x) (((x) & 0x0000FFFFFFFFFFC0ull) >> 6) +#define MINION_CSR_CO_PREFETCH_VA_VA_SET(x) (((x) << 6) & 0x0000FFFFFFFFFFC0ull) +#define MINION_CSR_CO_PREFETCH_VA_VA_MODIFY(r, x) ((((x) << 6) & 0x0000FFFFFFFFFFC0ull) | ((r) & 0xFFFF00000000003Full)) + +/* Field: MINION_CSR_CO_PREFETCH_VA.dest_level */ +#define MINION_CSR_CO_PREFETCH_VA_DEST_LEVEL_MSB 59u +#define MINION_CSR_CO_PREFETCH_VA_DEST_LEVEL_LSB 58u +#define MINION_CSR_CO_PREFETCH_VA_DEST_LEVEL_WIDTH 2u +#define MINION_CSR_CO_PREFETCH_VA_DEST_LEVEL_READ_ACCESS 1u +#define MINION_CSR_CO_PREFETCH_VA_DEST_LEVEL_WRITE_ACCESS 1u +#define MINION_CSR_CO_PREFETCH_VA_DEST_LEVEL_RESET 0x0000000000000000ull +#define MINION_CSR_CO_PREFETCH_VA_DEST_LEVEL_FIELD_MASK 0x0C00000000000000ull +#define MINION_CSR_CO_PREFETCH_VA_DEST_LEVEL_GET(x) (((x) & 0x0C00000000000000ull) >> 58) +#define MINION_CSR_CO_PREFETCH_VA_DEST_LEVEL_SET(x) (((x) << 58) & 0x0C00000000000000ull) +#define MINION_CSR_CO_PREFETCH_VA_DEST_LEVEL_MODIFY(r, x) ((((x) << 58) & 0x0C00000000000000ull) | ((r) & 0xF3FFFFFFFFFFFFFFull)) + +/* Field: MINION_CSR_CO_PREFETCH_VA.use_tensor_mask */ +#define MINION_CSR_CO_PREFETCH_VA_USE_TENSOR_MASK_MSB 63u +#define MINION_CSR_CO_PREFETCH_VA_USE_TENSOR_MASK_LSB 63u +#define MINION_CSR_CO_PREFETCH_VA_USE_TENSOR_MASK_WIDTH 1u +#define MINION_CSR_CO_PREFETCH_VA_USE_TENSOR_MASK_READ_ACCESS 1u +#define MINION_CSR_CO_PREFETCH_VA_USE_TENSOR_MASK_WRITE_ACCESS 1u +#define MINION_CSR_CO_PREFETCH_VA_USE_TENSOR_MASK_RESET 0x0000000000000000ull +#define MINION_CSR_CO_PREFETCH_VA_USE_TENSOR_MASK_FIELD_MASK 0x8000000000000000ull +#define MINION_CSR_CO_PREFETCH_VA_USE_TENSOR_MASK_GET(x) (((x) & 0x8000000000000000ull) >> 63) +#define MINION_CSR_CO_PREFETCH_VA_USE_TENSOR_MASK_SET(x) (((x) << 63) & 0x8000000000000000ull) +#define MINION_CSR_CO_PREFETCH_VA_USE_TENSOR_MASK_MODIFY(r, x) ((((x) << 63) & 0x8000000000000000ull) | ((r) & 0x7FFFFFFFFFFFFFFFull)) + +/* Register: MINION_CSR.flb */ +#define MINION_CSR_FLB_ADDRESS 0x00004100ul +#define MINION_CSR_FLB_BYTE_ADDRESS 0x00004100ul +#define MINION_CSR_FLB_OFFSET 0x00004100ul +#define MINION_CSR_FLB_BYTE_OFFSET 0x00004100ul +#define MINION_CSR_FLB_SIZE 0x00000008ul +#define MINION_CSR_FLB_BYTE_SIZE 0x00000008ul +#define MINION_CSR_FLB_READ_ACCESS 1u +#define MINION_CSR_FLB_WRITE_ACCESS 1u +#define MINION_CSR_FLB_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_FLB_RESET_MASK 0x0000000000001FFFull +#define MINION_CSR_FLB_READ_MASK 0x0000000000001FFFull +#define MINION_CSR_FLB_WRITE_MASK 0x0000000000001FFFull + +/* Field: MINION_CSR_FLB.barrier_number */ +#define MINION_CSR_FLB_BARRIER_NUMBER_MSB 4u +#define MINION_CSR_FLB_BARRIER_NUMBER_LSB 0u +#define MINION_CSR_FLB_BARRIER_NUMBER_WIDTH 5u +#define MINION_CSR_FLB_BARRIER_NUMBER_READ_ACCESS 1u +#define MINION_CSR_FLB_BARRIER_NUMBER_WRITE_ACCESS 1u +#define MINION_CSR_FLB_BARRIER_NUMBER_RESET 0x0000000000000000ull +#define MINION_CSR_FLB_BARRIER_NUMBER_FIELD_MASK 0x000000000000001Full +#define MINION_CSR_FLB_BARRIER_NUMBER_GET(x) ((x) & 0x000000000000001Full) +#define MINION_CSR_FLB_BARRIER_NUMBER_SET(x) ((x) & 0x000000000000001Full) +#define MINION_CSR_FLB_BARRIER_NUMBER_MODIFY(r, x) ((((x) << 0) & 0x000000000000001Full) | ((r) & 0xFFFFFFFFFFFFFFE0ull)) + +/* Field: MINION_CSR_FLB.match_value */ +#define MINION_CSR_FLB_MATCH_VALUE_MSB 12u +#define MINION_CSR_FLB_MATCH_VALUE_LSB 5u +#define MINION_CSR_FLB_MATCH_VALUE_WIDTH 8u +#define MINION_CSR_FLB_MATCH_VALUE_READ_ACCESS 1u +#define MINION_CSR_FLB_MATCH_VALUE_WRITE_ACCESS 1u +#define MINION_CSR_FLB_MATCH_VALUE_RESET 0x0000000000000000ull +#define MINION_CSR_FLB_MATCH_VALUE_FIELD_MASK 0x0000000000001FE0ull +#define MINION_CSR_FLB_MATCH_VALUE_GET(x) (((x) & 0x0000000000001FE0ull) >> 5) +#define MINION_CSR_FLB_MATCH_VALUE_SET(x) (((x) << 5) & 0x0000000000001FE0ull) +#define MINION_CSR_FLB_MATCH_VALUE_MODIFY(r, x) ((((x) << 5) & 0x0000000000001FE0ull) | ((r) & 0xFFFFFFFFFFFFE01Full)) + +/* Register: MINION_CSR.fcc */ +#define MINION_CSR_FCC_ADDRESS 0x00004108ul +#define MINION_CSR_FCC_BYTE_ADDRESS 0x00004108ul +#define MINION_CSR_FCC_OFFSET 0x00004108ul +#define MINION_CSR_FCC_BYTE_OFFSET 0x00004108ul +#define MINION_CSR_FCC_SIZE 0x00000008ul +#define MINION_CSR_FCC_BYTE_SIZE 0x00000008ul +#define MINION_CSR_FCC_READ_ACCESS 1u +#define MINION_CSR_FCC_WRITE_ACCESS 1u +#define MINION_CSR_FCC_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_FCC_RESET_MASK 0x0000000000000001ull +#define MINION_CSR_FCC_READ_MASK 0x0000000000000001ull +#define MINION_CSR_FCC_WRITE_MASK 0x0000000000000001ull + +/* Field: MINION_CSR_FCC.counter_index */ +#define MINION_CSR_FCC_COUNTER_INDEX_MSB 0u +#define MINION_CSR_FCC_COUNTER_INDEX_LSB 0u +#define MINION_CSR_FCC_COUNTER_INDEX_WIDTH 1u +#define MINION_CSR_FCC_COUNTER_INDEX_READ_ACCESS 1u +#define MINION_CSR_FCC_COUNTER_INDEX_WRITE_ACCESS 1u +#define MINION_CSR_FCC_COUNTER_INDEX_RESET 0x0000000000000000ull +#define MINION_CSR_FCC_COUNTER_INDEX_FIELD_MASK 0x0000000000000001ull +#define MINION_CSR_FCC_COUNTER_INDEX_GET(x) ((x) & 0x0000000000000001ull) +#define MINION_CSR_FCC_COUNTER_INDEX_SET(x) ((x) & 0x0000000000000001ull) +#define MINION_CSR_FCC_COUNTER_INDEX_MODIFY(r, x) ((((x) << 0) & 0x0000000000000001ull) | ((r) & 0xFFFFFFFFFFFFFFFEull)) + +/* Register: MINION_CSR.stall */ +#define MINION_CSR_STALL_ADDRESS 0x00004110ul +#define MINION_CSR_STALL_BYTE_ADDRESS 0x00004110ul +#define MINION_CSR_STALL_OFFSET 0x00004110ul +#define MINION_CSR_STALL_BYTE_OFFSET 0x00004110ul +#define MINION_CSR_STALL_SIZE 0x00000008ul +#define MINION_CSR_STALL_BYTE_SIZE 0x00000008ul +#define MINION_CSR_STALL_READ_ACCESS 1u +#define MINION_CSR_STALL_WRITE_ACCESS 1u +#define MINION_CSR_STALL_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_STALL_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_STALL_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_STALL_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_STALL.stall */ +#define MINION_CSR_STALL_STALL_MSB 63u +#define MINION_CSR_STALL_STALL_LSB 0u +#define MINION_CSR_STALL_STALL_WIDTH 64u +#define MINION_CSR_STALL_STALL_READ_ACCESS 1u +#define MINION_CSR_STALL_STALL_WRITE_ACCESS 1u +#define MINION_CSR_STALL_STALL_RESET 0x0000000000000000ull +#define MINION_CSR_STALL_STALL_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_STALL_STALL_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_STALL_STALL_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_STALL_STALL_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.tensor_wait */ +#define MINION_CSR_TENSOR_WAIT_ADDRESS 0x00004180ul +#define MINION_CSR_TENSOR_WAIT_BYTE_ADDRESS 0x00004180ul +#define MINION_CSR_TENSOR_WAIT_OFFSET 0x00004180ul +#define MINION_CSR_TENSOR_WAIT_BYTE_OFFSET 0x00004180ul +#define MINION_CSR_TENSOR_WAIT_SIZE 0x00000008ul +#define MINION_CSR_TENSOR_WAIT_BYTE_SIZE 0x00000008ul +#define MINION_CSR_TENSOR_WAIT_READ_ACCESS 1u +#define MINION_CSR_TENSOR_WAIT_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_WAIT_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_TENSOR_WAIT_RESET_MASK 0x000000000000000Full +#define MINION_CSR_TENSOR_WAIT_READ_MASK 0x000000000000000Full +#define MINION_CSR_TENSOR_WAIT_WRITE_MASK 0x000000000000000Full + +/* Field: MINION_CSR_TENSOR_WAIT.event_id */ +#define MINION_CSR_TENSOR_WAIT_EVENT_ID_MSB 3u +#define MINION_CSR_TENSOR_WAIT_EVENT_ID_LSB 0u +#define MINION_CSR_TENSOR_WAIT_EVENT_ID_WIDTH 4u +#define MINION_CSR_TENSOR_WAIT_EVENT_ID_READ_ACCESS 1u +#define MINION_CSR_TENSOR_WAIT_EVENT_ID_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_WAIT_EVENT_ID_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_WAIT_EVENT_ID_FIELD_MASK 0x000000000000000Full +#define MINION_CSR_TENSOR_WAIT_EVENT_ID_GET(x) ((x) & 0x000000000000000Full) +#define MINION_CSR_TENSOR_WAIT_EVENT_ID_SET(x) ((x) & 0x000000000000000Full) +#define MINION_CSR_TENSOR_WAIT_EVENT_ID_MODIFY(r, x) ((((x) << 0) & 0x000000000000000Full) | ((r) & 0xFFFFFFFFFFFFFFF0ull)) + +/* Register: MINION_CSR.tensor_load */ +#define MINION_CSR_TENSOR_LOAD_ADDRESS 0x000041F8ul +#define MINION_CSR_TENSOR_LOAD_BYTE_ADDRESS 0x000041F8ul +#define MINION_CSR_TENSOR_LOAD_OFFSET 0x000041F8ul +#define MINION_CSR_TENSOR_LOAD_BYTE_OFFSET 0x000041F8ul +#define MINION_CSR_TENSOR_LOAD_SIZE 0x00000008ul +#define MINION_CSR_TENSOR_LOAD_BYTE_SIZE 0x00000008ul +#define MINION_CSR_TENSOR_LOAD_READ_ACCESS 1u +#define MINION_CSR_TENSOR_LOAD_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_LOAD_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_TENSOR_LOAD_RESET_MASK 0xFFF0FFFFFFFFFFCFull +#define MINION_CSR_TENSOR_LOAD_READ_MASK 0xFFF0FFFFFFFFFFCFull +#define MINION_CSR_TENSOR_LOAD_WRITE_MASK 0xFFF0FFFFFFFFFFCFull + +/* Field: MINION_CSR_TENSOR_LOAD.num_lines */ +#define MINION_CSR_TENSOR_LOAD_NUM_LINES_MSB 3u +#define MINION_CSR_TENSOR_LOAD_NUM_LINES_LSB 0u +#define MINION_CSR_TENSOR_LOAD_NUM_LINES_WIDTH 4u +#define MINION_CSR_TENSOR_LOAD_NUM_LINES_READ_ACCESS 1u +#define MINION_CSR_TENSOR_LOAD_NUM_LINES_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_LOAD_NUM_LINES_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_LOAD_NUM_LINES_FIELD_MASK 0x000000000000000Full +#define MINION_CSR_TENSOR_LOAD_NUM_LINES_GET(x) ((x) & 0x000000000000000Full) +#define MINION_CSR_TENSOR_LOAD_NUM_LINES_SET(x) ((x) & 0x000000000000000Full) +#define MINION_CSR_TENSOR_LOAD_NUM_LINES_MODIFY(r, x) ((((x) << 0) & 0x000000000000000Full) | ((r) & 0xFFFFFFFFFFFFFFF0ull)) + +/* Field: MINION_CSR_TENSOR_LOAD.va */ +#define MINION_CSR_TENSOR_LOAD_VA_MSB 47u +#define MINION_CSR_TENSOR_LOAD_VA_LSB 6u +#define MINION_CSR_TENSOR_LOAD_VA_WIDTH 42u +#define MINION_CSR_TENSOR_LOAD_VA_READ_ACCESS 1u +#define MINION_CSR_TENSOR_LOAD_VA_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_LOAD_VA_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_LOAD_VA_FIELD_MASK 0x0000FFFFFFFFFFC0ull +#define MINION_CSR_TENSOR_LOAD_VA_GET(x) (((x) & 0x0000FFFFFFFFFFC0ull) >> 6) +#define MINION_CSR_TENSOR_LOAD_VA_SET(x) (((x) << 6) & 0x0000FFFFFFFFFFC0ull) +#define MINION_CSR_TENSOR_LOAD_VA_MODIFY(r, x) ((((x) << 6) & 0x0000FFFFFFFFFFC0ull) | ((r) & 0xFFFF00000000003Full)) + +/* Field: MINION_CSR_TENSOR_LOAD.is_tensor_b */ +#define MINION_CSR_TENSOR_LOAD_IS_TENSOR_B_MSB 52u +#define MINION_CSR_TENSOR_LOAD_IS_TENSOR_B_LSB 52u +#define MINION_CSR_TENSOR_LOAD_IS_TENSOR_B_WIDTH 1u +#define MINION_CSR_TENSOR_LOAD_IS_TENSOR_B_READ_ACCESS 1u +#define MINION_CSR_TENSOR_LOAD_IS_TENSOR_B_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_LOAD_IS_TENSOR_B_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_LOAD_IS_TENSOR_B_FIELD_MASK 0x0010000000000000ull +#define MINION_CSR_TENSOR_LOAD_IS_TENSOR_B_GET(x) (((x) & 0x0010000000000000ull) >> 52) +#define MINION_CSR_TENSOR_LOAD_IS_TENSOR_B_SET(x) (((x) << 52) & 0x0010000000000000ull) +#define MINION_CSR_TENSOR_LOAD_IS_TENSOR_B_MODIFY(r, x) ((((x) << 52) & 0x0010000000000000ull) | ((r) & 0xFFEFFFFFFFFFFFFFull)) + +/* Field: MINION_CSR_TENSOR_LOAD.l1_scp_start_cl */ +#define MINION_CSR_TENSOR_LOAD_L1_SCP_START_CL_MSB 58u +#define MINION_CSR_TENSOR_LOAD_L1_SCP_START_CL_LSB 53u +#define MINION_CSR_TENSOR_LOAD_L1_SCP_START_CL_WIDTH 6u +#define MINION_CSR_TENSOR_LOAD_L1_SCP_START_CL_READ_ACCESS 1u +#define MINION_CSR_TENSOR_LOAD_L1_SCP_START_CL_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_LOAD_L1_SCP_START_CL_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_LOAD_L1_SCP_START_CL_FIELD_MASK 0x07E0000000000000ull +#define MINION_CSR_TENSOR_LOAD_L1_SCP_START_CL_GET(x) (((x) & 0x07E0000000000000ull) >> 53) +#define MINION_CSR_TENSOR_LOAD_L1_SCP_START_CL_SET(x) (((x) << 53) & 0x07E0000000000000ull) +#define MINION_CSR_TENSOR_LOAD_L1_SCP_START_CL_MODIFY(r, x) ((((x) << 53) & 0x07E0000000000000ull) | ((r) & 0xF81FFFFFFFFFFFFFull)) + +/* Field: MINION_CSR_TENSOR_LOAD.tensor_load_variant */ +#define MINION_CSR_TENSOR_LOAD_TENSOR_LOAD_VARIANT_MSB 61u +#define MINION_CSR_TENSOR_LOAD_TENSOR_LOAD_VARIANT_LSB 59u +#define MINION_CSR_TENSOR_LOAD_TENSOR_LOAD_VARIANT_WIDTH 3u +#define MINION_CSR_TENSOR_LOAD_TENSOR_LOAD_VARIANT_READ_ACCESS 1u +#define MINION_CSR_TENSOR_LOAD_TENSOR_LOAD_VARIANT_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_LOAD_TENSOR_LOAD_VARIANT_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_LOAD_TENSOR_LOAD_VARIANT_FIELD_MASK 0x3800000000000000ull +#define MINION_CSR_TENSOR_LOAD_TENSOR_LOAD_VARIANT_GET(x) (((x) & 0x3800000000000000ull) >> 59) +#define MINION_CSR_TENSOR_LOAD_TENSOR_LOAD_VARIANT_SET(x) (((x) << 59) & 0x3800000000000000ull) +#define MINION_CSR_TENSOR_LOAD_TENSOR_LOAD_VARIANT_MODIFY(r, x) ((((x) << 59) & 0x3800000000000000ull) | ((r) & 0xC7FFFFFFFFFFFFFFull)) + +/* Field: MINION_CSR_TENSOR_LOAD.coop_tload */ +#define MINION_CSR_TENSOR_LOAD_COOP_TLOAD_MSB 62u +#define MINION_CSR_TENSOR_LOAD_COOP_TLOAD_LSB 62u +#define MINION_CSR_TENSOR_LOAD_COOP_TLOAD_WIDTH 1u +#define MINION_CSR_TENSOR_LOAD_COOP_TLOAD_READ_ACCESS 1u +#define MINION_CSR_TENSOR_LOAD_COOP_TLOAD_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_LOAD_COOP_TLOAD_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_LOAD_COOP_TLOAD_FIELD_MASK 0x4000000000000000ull +#define MINION_CSR_TENSOR_LOAD_COOP_TLOAD_GET(x) (((x) & 0x4000000000000000ull) >> 62) +#define MINION_CSR_TENSOR_LOAD_COOP_TLOAD_SET(x) (((x) << 62) & 0x4000000000000000ull) +#define MINION_CSR_TENSOR_LOAD_COOP_TLOAD_MODIFY(r, x) ((((x) << 62) & 0x4000000000000000ull) | ((r) & 0xBFFFFFFFFFFFFFFFull)) + +/* Field: MINION_CSR_TENSOR_LOAD.use_tensor_mask */ +#define MINION_CSR_TENSOR_LOAD_USE_TENSOR_MASK_MSB 63u +#define MINION_CSR_TENSOR_LOAD_USE_TENSOR_MASK_LSB 63u +#define MINION_CSR_TENSOR_LOAD_USE_TENSOR_MASK_WIDTH 1u +#define MINION_CSR_TENSOR_LOAD_USE_TENSOR_MASK_READ_ACCESS 1u +#define MINION_CSR_TENSOR_LOAD_USE_TENSOR_MASK_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_LOAD_USE_TENSOR_MASK_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_LOAD_USE_TENSOR_MASK_FIELD_MASK 0x8000000000000000ull +#define MINION_CSR_TENSOR_LOAD_USE_TENSOR_MASK_GET(x) (((x) & 0x8000000000000000ull) >> 63) +#define MINION_CSR_TENSOR_LOAD_USE_TENSOR_MASK_SET(x) (((x) << 63) & 0x8000000000000000ull) +#define MINION_CSR_TENSOR_LOAD_USE_TENSOR_MASK_MODIFY(r, x) ((((x) << 63) & 0x8000000000000000ull) | ((r) & 0x7FFFFFFFFFFFFFFFull)) + +/* Register: MINION_CSR.gsc_progress */ +#define MINION_CSR_GSC_PROGRESS_ADDRESS 0x00004200ul +#define MINION_CSR_GSC_PROGRESS_BYTE_ADDRESS 0x00004200ul +#define MINION_CSR_GSC_PROGRESS_OFFSET 0x00004200ul +#define MINION_CSR_GSC_PROGRESS_BYTE_OFFSET 0x00004200ul +#define MINION_CSR_GSC_PROGRESS_SIZE 0x00000008ul +#define MINION_CSR_GSC_PROGRESS_BYTE_SIZE 0x00000008ul +#define MINION_CSR_GSC_PROGRESS_READ_ACCESS 1u +#define MINION_CSR_GSC_PROGRESS_WRITE_ACCESS 1u +#define MINION_CSR_GSC_PROGRESS_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_GSC_PROGRESS_RESET_MASK 0x0000000000000007ull +#define MINION_CSR_GSC_PROGRESS_READ_MASK 0x0000000000000007ull +#define MINION_CSR_GSC_PROGRESS_WRITE_MASK 0x0000000000000007ull + +/* Field: MINION_CSR_GSC_PROGRESS.gsc_progress */ +#define MINION_CSR_GSC_PROGRESS_GSC_PROGRESS_MSB 2u +#define MINION_CSR_GSC_PROGRESS_GSC_PROGRESS_LSB 0u +#define MINION_CSR_GSC_PROGRESS_GSC_PROGRESS_WIDTH 3u +#define MINION_CSR_GSC_PROGRESS_GSC_PROGRESS_READ_ACCESS 1u +#define MINION_CSR_GSC_PROGRESS_GSC_PROGRESS_WRITE_ACCESS 1u +#define MINION_CSR_GSC_PROGRESS_GSC_PROGRESS_RESET 0x0000000000000000ull +#define MINION_CSR_GSC_PROGRESS_GSC_PROGRESS_FIELD_MASK 0x0000000000000007ull +#define MINION_CSR_GSC_PROGRESS_GSC_PROGRESS_GET(x) ((x) & 0x0000000000000007ull) +#define MINION_CSR_GSC_PROGRESS_GSC_PROGRESS_SET(x) ((x) & 0x0000000000000007ull) +#define MINION_CSR_GSC_PROGRESS_GSC_PROGRESS_MODIFY(r, x) ((((x) << 0) & 0x0000000000000007ull) | ((r) & 0xFFFFFFFFFFFFFFF8ull)) + +/* Register: MINION_CSR.tensor_load_l2scp */ +#define MINION_CSR_TENSOR_LOAD_L2SCP_ADDRESS 0x000042F8ul +#define MINION_CSR_TENSOR_LOAD_L2SCP_BYTE_ADDRESS 0x000042F8ul +#define MINION_CSR_TENSOR_LOAD_L2SCP_OFFSET 0x000042F8ul +#define MINION_CSR_TENSOR_LOAD_L2SCP_BYTE_OFFSET 0x000042F8ul +#define MINION_CSR_TENSOR_LOAD_L2SCP_SIZE 0x00000008ul +#define MINION_CSR_TENSOR_LOAD_L2SCP_BYTE_SIZE 0x00000008ul +#define MINION_CSR_TENSOR_LOAD_L2SCP_READ_ACCESS 1u +#define MINION_CSR_TENSOR_LOAD_L2SCP_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_LOAD_L2SCP_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_TENSOR_LOAD_L2SCP_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_TENSOR_LOAD_L2SCP_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_TENSOR_LOAD_L2SCP_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_TENSOR_LOAD_L2SCP.num_lines */ +#define MINION_CSR_TENSOR_LOAD_L2SCP_NUM_LINES_MSB 3u +#define MINION_CSR_TENSOR_LOAD_L2SCP_NUM_LINES_LSB 0u +#define MINION_CSR_TENSOR_LOAD_L2SCP_NUM_LINES_WIDTH 4u +#define MINION_CSR_TENSOR_LOAD_L2SCP_NUM_LINES_READ_ACCESS 1u +#define MINION_CSR_TENSOR_LOAD_L2SCP_NUM_LINES_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_LOAD_L2SCP_NUM_LINES_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_LOAD_L2SCP_NUM_LINES_FIELD_MASK 0x000000000000000Full +#define MINION_CSR_TENSOR_LOAD_L2SCP_NUM_LINES_GET(x) ((x) & 0x000000000000000Full) +#define MINION_CSR_TENSOR_LOAD_L2SCP_NUM_LINES_SET(x) ((x) & 0x000000000000000Full) +#define MINION_CSR_TENSOR_LOAD_L2SCP_NUM_LINES_MODIFY(r, x) ((((x) << 0) & 0x000000000000000Full) | ((r) & 0xFFFFFFFFFFFFFFF0ull)) + +/* Field: MINION_CSR_TENSOR_LOAD_L2SCP.l2scp_start_line_7_6 */ +#define MINION_CSR_TENSOR_LOAD_L2SCP_L2SCP_START_LINE_7_6_MSB 5u +#define MINION_CSR_TENSOR_LOAD_L2SCP_L2SCP_START_LINE_7_6_LSB 4u +#define MINION_CSR_TENSOR_LOAD_L2SCP_L2SCP_START_LINE_7_6_WIDTH 2u +#define MINION_CSR_TENSOR_LOAD_L2SCP_L2SCP_START_LINE_7_6_READ_ACCESS 1u +#define MINION_CSR_TENSOR_LOAD_L2SCP_L2SCP_START_LINE_7_6_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_LOAD_L2SCP_L2SCP_START_LINE_7_6_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_LOAD_L2SCP_L2SCP_START_LINE_7_6_FIELD_MASK 0x0000000000000030ull +#define MINION_CSR_TENSOR_LOAD_L2SCP_L2SCP_START_LINE_7_6_GET(x) (((x) & 0x0000000000000030ull) >> 4) +#define MINION_CSR_TENSOR_LOAD_L2SCP_L2SCP_START_LINE_7_6_SET(x) (((x) << 4) & 0x0000000000000030ull) +#define MINION_CSR_TENSOR_LOAD_L2SCP_L2SCP_START_LINE_7_6_MODIFY(r, x) ((((x) << 4) & 0x0000000000000030ull) | ((r) & 0xFFFFFFFFFFFFFFCFull)) + +/* Field: MINION_CSR_TENSOR_LOAD_L2SCP.va */ +#define MINION_CSR_TENSOR_LOAD_L2SCP_VA_MSB 47u +#define MINION_CSR_TENSOR_LOAD_L2SCP_VA_LSB 6u +#define MINION_CSR_TENSOR_LOAD_L2SCP_VA_WIDTH 42u +#define MINION_CSR_TENSOR_LOAD_L2SCP_VA_READ_ACCESS 1u +#define MINION_CSR_TENSOR_LOAD_L2SCP_VA_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_LOAD_L2SCP_VA_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_LOAD_L2SCP_VA_FIELD_MASK 0x0000FFFFFFFFFFC0ull +#define MINION_CSR_TENSOR_LOAD_L2SCP_VA_GET(x) (((x) & 0x0000FFFFFFFFFFC0ull) >> 6) +#define MINION_CSR_TENSOR_LOAD_L2SCP_VA_SET(x) (((x) << 6) & 0x0000FFFFFFFFFFC0ull) +#define MINION_CSR_TENSOR_LOAD_L2SCP_VA_MODIFY(r, x) ((((x) << 6) & 0x0000FFFFFFFFFFC0ull) | ((r) & 0xFFFF00000000003Full)) + +/* Field: MINION_CSR_TENSOR_LOAD_L2SCP.l2scp_start_line_22_8 */ +#define MINION_CSR_TENSOR_LOAD_L2SCP_L2SCP_START_LINE_22_8_MSB 62u +#define MINION_CSR_TENSOR_LOAD_L2SCP_L2SCP_START_LINE_22_8_LSB 48u +#define MINION_CSR_TENSOR_LOAD_L2SCP_L2SCP_START_LINE_22_8_WIDTH 15u +#define MINION_CSR_TENSOR_LOAD_L2SCP_L2SCP_START_LINE_22_8_READ_ACCESS 1u +#define MINION_CSR_TENSOR_LOAD_L2SCP_L2SCP_START_LINE_22_8_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_LOAD_L2SCP_L2SCP_START_LINE_22_8_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_LOAD_L2SCP_L2SCP_START_LINE_22_8_FIELD_MASK 0x7FFF000000000000ull +#define MINION_CSR_TENSOR_LOAD_L2SCP_L2SCP_START_LINE_22_8_GET(x) (((x) & 0x7FFF000000000000ull) >> 48) +#define MINION_CSR_TENSOR_LOAD_L2SCP_L2SCP_START_LINE_22_8_SET(x) (((x) << 48) & 0x7FFF000000000000ull) +#define MINION_CSR_TENSOR_LOAD_L2SCP_L2SCP_START_LINE_22_8_MODIFY(r, x) ((((x) << 48) & 0x7FFF000000000000ull) | ((r) & 0x8000FFFFFFFFFFFFull)) + +/* Field: MINION_CSR_TENSOR_LOAD_L2SCP.use_tensor_mask */ +#define MINION_CSR_TENSOR_LOAD_L2SCP_USE_TENSOR_MASK_MSB 63u +#define MINION_CSR_TENSOR_LOAD_L2SCP_USE_TENSOR_MASK_LSB 63u +#define MINION_CSR_TENSOR_LOAD_L2SCP_USE_TENSOR_MASK_WIDTH 1u +#define MINION_CSR_TENSOR_LOAD_L2SCP_USE_TENSOR_MASK_READ_ACCESS 1u +#define MINION_CSR_TENSOR_LOAD_L2SCP_USE_TENSOR_MASK_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_LOAD_L2SCP_USE_TENSOR_MASK_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_LOAD_L2SCP_USE_TENSOR_MASK_FIELD_MASK 0x8000000000000000ull +#define MINION_CSR_TENSOR_LOAD_L2SCP_USE_TENSOR_MASK_GET(x) (((x) & 0x8000000000000000ull) >> 63) +#define MINION_CSR_TENSOR_LOAD_L2SCP_USE_TENSOR_MASK_SET(x) (((x) << 63) & 0x8000000000000000ull) +#define MINION_CSR_TENSOR_LOAD_L2SCP_USE_TENSOR_MASK_MODIFY(r, x) ((((x) << 63) & 0x8000000000000000ull) | ((r) & 0x7FFFFFFFFFFFFFFFull)) + +/* Register: MINION_CSR.tensor_store */ +#define MINION_CSR_TENSOR_STORE_ADDRESS 0x000043F8ul +#define MINION_CSR_TENSOR_STORE_BYTE_ADDRESS 0x000043F8ul +#define MINION_CSR_TENSOR_STORE_OFFSET 0x000043F8ul +#define MINION_CSR_TENSOR_STORE_BYTE_OFFSET 0x000043F8ul +#define MINION_CSR_TENSOR_STORE_SIZE 0x00000008ul +#define MINION_CSR_TENSOR_STORE_BYTE_SIZE 0x00000008ul +#define MINION_CSR_TENSOR_STORE_READ_ACCESS 1u +#define MINION_CSR_TENSOR_STORE_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_STORE_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_TENSOR_STORE_RESET_MASK 0xFFFFFFFFFFFFFFF0ull +#define MINION_CSR_TENSOR_STORE_READ_MASK 0xFFFFFFFFFFFFFFF0ull +#define MINION_CSR_TENSOR_STORE_WRITE_MASK 0xFFFFFFFFFFFFFFF0ull + +/* Field: MINION_CSR_TENSOR_STORE.va */ +#define MINION_CSR_TENSOR_STORE_VA_MSB 47u +#define MINION_CSR_TENSOR_STORE_VA_LSB 4u +#define MINION_CSR_TENSOR_STORE_VA_WIDTH 44u +#define MINION_CSR_TENSOR_STORE_VA_READ_ACCESS 1u +#define MINION_CSR_TENSOR_STORE_VA_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_STORE_VA_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_STORE_VA_FIELD_MASK 0x0000FFFFFFFFFFF0ull +#define MINION_CSR_TENSOR_STORE_VA_GET(x) (((x) & 0x0000FFFFFFFFFFF0ull) >> 4) +#define MINION_CSR_TENSOR_STORE_VA_SET(x) (((x) << 4) & 0x0000FFFFFFFFFFF0ull) +#define MINION_CSR_TENSOR_STORE_VA_MODIFY(r, x) ((((x) << 4) & 0x0000FFFFFFFFFFF0ull) | ((r) & 0xFFFF00000000000Full)) + +/* Field: MINION_CSR_TENSOR_STORE.tensor_op_encoding */ +#define MINION_CSR_TENSOR_STORE_TENSOR_OP_ENCODING_MSB 48u +#define MINION_CSR_TENSOR_STORE_TENSOR_OP_ENCODING_LSB 48u +#define MINION_CSR_TENSOR_STORE_TENSOR_OP_ENCODING_WIDTH 1u +#define MINION_CSR_TENSOR_STORE_TENSOR_OP_ENCODING_READ_ACCESS 1u +#define MINION_CSR_TENSOR_STORE_TENSOR_OP_ENCODING_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_STORE_TENSOR_OP_ENCODING_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_STORE_TENSOR_OP_ENCODING_FIELD_MASK 0x0001000000000000ull +#define MINION_CSR_TENSOR_STORE_TENSOR_OP_ENCODING_GET(x) (((x) & 0x0001000000000000ull) >> 48) +#define MINION_CSR_TENSOR_STORE_TENSOR_OP_ENCODING_SET(x) (((x) << 48) & 0x0001000000000000ull) +#define MINION_CSR_TENSOR_STORE_TENSOR_OP_ENCODING_MODIFY(r, x) ((((x) << 48) & 0x0001000000000000ull) | ((r) & 0xFFFEFFFFFFFFFFFFull)) + +/* Field: MINION_CSR_TENSOR_STORE.num_coop_minions */ +#define MINION_CSR_TENSOR_STORE_NUM_COOP_MINIONS_MSB 50u +#define MINION_CSR_TENSOR_STORE_NUM_COOP_MINIONS_LSB 49u +#define MINION_CSR_TENSOR_STORE_NUM_COOP_MINIONS_WIDTH 2u +#define MINION_CSR_TENSOR_STORE_NUM_COOP_MINIONS_READ_ACCESS 1u +#define MINION_CSR_TENSOR_STORE_NUM_COOP_MINIONS_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_STORE_NUM_COOP_MINIONS_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_STORE_NUM_COOP_MINIONS_FIELD_MASK 0x0006000000000000ull +#define MINION_CSR_TENSOR_STORE_NUM_COOP_MINIONS_GET(x) (((x) & 0x0006000000000000ull) >> 49) +#define MINION_CSR_TENSOR_STORE_NUM_COOP_MINIONS_SET(x) (((x) << 49) & 0x0006000000000000ull) +#define MINION_CSR_TENSOR_STORE_NUM_COOP_MINIONS_MODIFY(r, x) ((((x) << 49) & 0x0006000000000000ull) | ((r) & 0xFFF9FFFFFFFFFFFFull)) + +/* Field: MINION_CSR_TENSOR_STORE.num_rows */ +#define MINION_CSR_TENSOR_STORE_NUM_ROWS_MSB 54u +#define MINION_CSR_TENSOR_STORE_NUM_ROWS_LSB 51u +#define MINION_CSR_TENSOR_STORE_NUM_ROWS_WIDTH 4u +#define MINION_CSR_TENSOR_STORE_NUM_ROWS_READ_ACCESS 1u +#define MINION_CSR_TENSOR_STORE_NUM_ROWS_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_STORE_NUM_ROWS_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_STORE_NUM_ROWS_FIELD_MASK 0x0078000000000000ull +#define MINION_CSR_TENSOR_STORE_NUM_ROWS_GET(x) (((x) & 0x0078000000000000ull) >> 51) +#define MINION_CSR_TENSOR_STORE_NUM_ROWS_SET(x) (((x) << 51) & 0x0078000000000000ull) +#define MINION_CSR_TENSOR_STORE_NUM_ROWS_MODIFY(r, x) ((((x) << 51) & 0x0078000000000000ull) | ((r) & 0xFF87FFFFFFFFFFFFull)) + +/* Field: MINION_CSR_TENSOR_STORE.start_size */ +#define MINION_CSR_TENSOR_STORE_START_SIZE_MSB 61u +#define MINION_CSR_TENSOR_STORE_START_SIZE_LSB 55u +#define MINION_CSR_TENSOR_STORE_START_SIZE_WIDTH 7u +#define MINION_CSR_TENSOR_STORE_START_SIZE_READ_ACCESS 1u +#define MINION_CSR_TENSOR_STORE_START_SIZE_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_STORE_START_SIZE_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_STORE_START_SIZE_FIELD_MASK 0x3F80000000000000ull +#define MINION_CSR_TENSOR_STORE_START_SIZE_GET(x) (((x) & 0x3F80000000000000ull) >> 55) +#define MINION_CSR_TENSOR_STORE_START_SIZE_SET(x) (((x) << 55) & 0x3F80000000000000ull) +#define MINION_CSR_TENSOR_STORE_START_SIZE_MODIFY(r, x) ((((x) << 55) & 0x3F80000000000000ull) | ((r) & 0xC07FFFFFFFFFFFFFull)) + +/* Field: MINION_CSR_TENSOR_STORE.stride */ +#define MINION_CSR_TENSOR_STORE_STRIDE_MSB 63u +#define MINION_CSR_TENSOR_STORE_STRIDE_LSB 62u +#define MINION_CSR_TENSOR_STORE_STRIDE_WIDTH 2u +#define MINION_CSR_TENSOR_STORE_STRIDE_READ_ACCESS 1u +#define MINION_CSR_TENSOR_STORE_STRIDE_WRITE_ACCESS 1u +#define MINION_CSR_TENSOR_STORE_STRIDE_RESET 0x0000000000000000ull +#define MINION_CSR_TENSOR_STORE_STRIDE_FIELD_MASK 0xC000000000000000ull +#define MINION_CSR_TENSOR_STORE_STRIDE_GET(x) (((x) & 0xC000000000000000ull) >> 62) +#define MINION_CSR_TENSOR_STORE_STRIDE_SET(x) (((x) << 62) & 0xC000000000000000ull) +#define MINION_CSR_TENSOR_STORE_STRIDE_MODIFY(r, x) ((((x) << 62) & 0xC000000000000000ull) | ((r) & 0x3FFFFFFFFFFFFFFFull)) + +/* Register: MINION_CSR.co_evict_va */ +#define MINION_CSR_CO_EVICT_VA_ADDRESS 0x000044F8ul +#define MINION_CSR_CO_EVICT_VA_BYTE_ADDRESS 0x000044F8ul +#define MINION_CSR_CO_EVICT_VA_OFFSET 0x000044F8ul +#define MINION_CSR_CO_EVICT_VA_BYTE_OFFSET 0x000044F8ul +#define MINION_CSR_CO_EVICT_VA_SIZE 0x00000008ul +#define MINION_CSR_CO_EVICT_VA_BYTE_SIZE 0x00000008ul +#define MINION_CSR_CO_EVICT_VA_READ_ACCESS 1u +#define MINION_CSR_CO_EVICT_VA_WRITE_ACCESS 1u +#define MINION_CSR_CO_EVICT_VA_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_CO_EVICT_VA_RESET_MASK 0x8C00FFFFFFFFFFCFull +#define MINION_CSR_CO_EVICT_VA_READ_MASK 0x8C00FFFFFFFFFFCFull +#define MINION_CSR_CO_EVICT_VA_WRITE_MASK 0x8C00FFFFFFFFFFCFull + +/* Field: MINION_CSR_CO_EVICT_VA.num_lines */ +#define MINION_CSR_CO_EVICT_VA_NUM_LINES_MSB 3u +#define MINION_CSR_CO_EVICT_VA_NUM_LINES_LSB 0u +#define MINION_CSR_CO_EVICT_VA_NUM_LINES_WIDTH 4u +#define MINION_CSR_CO_EVICT_VA_NUM_LINES_READ_ACCESS 1u +#define MINION_CSR_CO_EVICT_VA_NUM_LINES_WRITE_ACCESS 1u +#define MINION_CSR_CO_EVICT_VA_NUM_LINES_RESET 0x0000000000000000ull +#define MINION_CSR_CO_EVICT_VA_NUM_LINES_FIELD_MASK 0x000000000000000Full +#define MINION_CSR_CO_EVICT_VA_NUM_LINES_GET(x) ((x) & 0x000000000000000Full) +#define MINION_CSR_CO_EVICT_VA_NUM_LINES_SET(x) ((x) & 0x000000000000000Full) +#define MINION_CSR_CO_EVICT_VA_NUM_LINES_MODIFY(r, x) ((((x) << 0) & 0x000000000000000Full) | ((r) & 0xFFFFFFFFFFFFFFF0ull)) + +/* Field: MINION_CSR_CO_EVICT_VA.va */ +#define MINION_CSR_CO_EVICT_VA_VA_MSB 47u +#define MINION_CSR_CO_EVICT_VA_VA_LSB 6u +#define MINION_CSR_CO_EVICT_VA_VA_WIDTH 42u +#define MINION_CSR_CO_EVICT_VA_VA_READ_ACCESS 1u +#define MINION_CSR_CO_EVICT_VA_VA_WRITE_ACCESS 1u +#define MINION_CSR_CO_EVICT_VA_VA_RESET 0x0000000000000000ull +#define MINION_CSR_CO_EVICT_VA_VA_FIELD_MASK 0x0000FFFFFFFFFFC0ull +#define MINION_CSR_CO_EVICT_VA_VA_GET(x) (((x) & 0x0000FFFFFFFFFFC0ull) >> 6) +#define MINION_CSR_CO_EVICT_VA_VA_SET(x) (((x) << 6) & 0x0000FFFFFFFFFFC0ull) +#define MINION_CSR_CO_EVICT_VA_VA_MODIFY(r, x) ((((x) << 6) & 0x0000FFFFFFFFFFC0ull) | ((r) & 0xFFFF00000000003Full)) + +/* Field: MINION_CSR_CO_EVICT_VA.dest_level */ +#define MINION_CSR_CO_EVICT_VA_DEST_LEVEL_MSB 59u +#define MINION_CSR_CO_EVICT_VA_DEST_LEVEL_LSB 58u +#define MINION_CSR_CO_EVICT_VA_DEST_LEVEL_WIDTH 2u +#define MINION_CSR_CO_EVICT_VA_DEST_LEVEL_READ_ACCESS 1u +#define MINION_CSR_CO_EVICT_VA_DEST_LEVEL_WRITE_ACCESS 1u +#define MINION_CSR_CO_EVICT_VA_DEST_LEVEL_RESET 0x0000000000000000ull +#define MINION_CSR_CO_EVICT_VA_DEST_LEVEL_FIELD_MASK 0x0C00000000000000ull +#define MINION_CSR_CO_EVICT_VA_DEST_LEVEL_GET(x) (((x) & 0x0C00000000000000ull) >> 58) +#define MINION_CSR_CO_EVICT_VA_DEST_LEVEL_SET(x) (((x) << 58) & 0x0C00000000000000ull) +#define MINION_CSR_CO_EVICT_VA_DEST_LEVEL_MODIFY(r, x) ((((x) << 58) & 0x0C00000000000000ull) | ((r) & 0xF3FFFFFFFFFFFFFFull)) + +/* Field: MINION_CSR_CO_EVICT_VA.use_tensor_mask */ +#define MINION_CSR_CO_EVICT_VA_USE_TENSOR_MASK_MSB 63u +#define MINION_CSR_CO_EVICT_VA_USE_TENSOR_MASK_LSB 63u +#define MINION_CSR_CO_EVICT_VA_USE_TENSOR_MASK_WIDTH 1u +#define MINION_CSR_CO_EVICT_VA_USE_TENSOR_MASK_READ_ACCESS 1u +#define MINION_CSR_CO_EVICT_VA_USE_TENSOR_MASK_WRITE_ACCESS 1u +#define MINION_CSR_CO_EVICT_VA_USE_TENSOR_MASK_RESET 0x0000000000000000ull +#define MINION_CSR_CO_EVICT_VA_USE_TENSOR_MASK_FIELD_MASK 0x8000000000000000ull +#define MINION_CSR_CO_EVICT_VA_USE_TENSOR_MASK_GET(x) (((x) & 0x8000000000000000ull) >> 63) +#define MINION_CSR_CO_EVICT_VA_USE_TENSOR_MASK_SET(x) (((x) << 63) & 0x8000000000000000ull) +#define MINION_CSR_CO_EVICT_VA_USE_TENSOR_MASK_MODIFY(r, x) ((((x) << 63) & 0x8000000000000000ull) | ((r) & 0x7FFFFFFFFFFFFFFFull)) + +/* Register: MINION_CSR.co_flush_va */ +#define MINION_CSR_CO_FLUSH_VA_ADDRESS 0x000045F8ul +#define MINION_CSR_CO_FLUSH_VA_BYTE_ADDRESS 0x000045F8ul +#define MINION_CSR_CO_FLUSH_VA_OFFSET 0x000045F8ul +#define MINION_CSR_CO_FLUSH_VA_BYTE_OFFSET 0x000045F8ul +#define MINION_CSR_CO_FLUSH_VA_SIZE 0x00000008ul +#define MINION_CSR_CO_FLUSH_VA_BYTE_SIZE 0x00000008ul +#define MINION_CSR_CO_FLUSH_VA_READ_ACCESS 1u +#define MINION_CSR_CO_FLUSH_VA_WRITE_ACCESS 1u +#define MINION_CSR_CO_FLUSH_VA_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_CO_FLUSH_VA_RESET_MASK 0x8C00FFFFFFFFFFCFull +#define MINION_CSR_CO_FLUSH_VA_READ_MASK 0x8C00FFFFFFFFFFCFull +#define MINION_CSR_CO_FLUSH_VA_WRITE_MASK 0x8C00FFFFFFFFFFCFull + +/* Field: MINION_CSR_CO_FLUSH_VA.num_lines */ +#define MINION_CSR_CO_FLUSH_VA_NUM_LINES_MSB 3u +#define MINION_CSR_CO_FLUSH_VA_NUM_LINES_LSB 0u +#define MINION_CSR_CO_FLUSH_VA_NUM_LINES_WIDTH 4u +#define MINION_CSR_CO_FLUSH_VA_NUM_LINES_READ_ACCESS 1u +#define MINION_CSR_CO_FLUSH_VA_NUM_LINES_WRITE_ACCESS 1u +#define MINION_CSR_CO_FLUSH_VA_NUM_LINES_RESET 0x0000000000000000ull +#define MINION_CSR_CO_FLUSH_VA_NUM_LINES_FIELD_MASK 0x000000000000000Full +#define MINION_CSR_CO_FLUSH_VA_NUM_LINES_GET(x) ((x) & 0x000000000000000Full) +#define MINION_CSR_CO_FLUSH_VA_NUM_LINES_SET(x) ((x) & 0x000000000000000Full) +#define MINION_CSR_CO_FLUSH_VA_NUM_LINES_MODIFY(r, x) ((((x) << 0) & 0x000000000000000Full) | ((r) & 0xFFFFFFFFFFFFFFF0ull)) + +/* Field: MINION_CSR_CO_FLUSH_VA.va */ +#define MINION_CSR_CO_FLUSH_VA_VA_MSB 47u +#define MINION_CSR_CO_FLUSH_VA_VA_LSB 6u +#define MINION_CSR_CO_FLUSH_VA_VA_WIDTH 42u +#define MINION_CSR_CO_FLUSH_VA_VA_READ_ACCESS 1u +#define MINION_CSR_CO_FLUSH_VA_VA_WRITE_ACCESS 1u +#define MINION_CSR_CO_FLUSH_VA_VA_RESET 0x0000000000000000ull +#define MINION_CSR_CO_FLUSH_VA_VA_FIELD_MASK 0x0000FFFFFFFFFFC0ull +#define MINION_CSR_CO_FLUSH_VA_VA_GET(x) (((x) & 0x0000FFFFFFFFFFC0ull) >> 6) +#define MINION_CSR_CO_FLUSH_VA_VA_SET(x) (((x) << 6) & 0x0000FFFFFFFFFFC0ull) +#define MINION_CSR_CO_FLUSH_VA_VA_MODIFY(r, x) ((((x) << 6) & 0x0000FFFFFFFFFFC0ull) | ((r) & 0xFFFF00000000003Full)) + +/* Field: MINION_CSR_CO_FLUSH_VA.dest_level */ +#define MINION_CSR_CO_FLUSH_VA_DEST_LEVEL_MSB 59u +#define MINION_CSR_CO_FLUSH_VA_DEST_LEVEL_LSB 58u +#define MINION_CSR_CO_FLUSH_VA_DEST_LEVEL_WIDTH 2u +#define MINION_CSR_CO_FLUSH_VA_DEST_LEVEL_READ_ACCESS 1u +#define MINION_CSR_CO_FLUSH_VA_DEST_LEVEL_WRITE_ACCESS 1u +#define MINION_CSR_CO_FLUSH_VA_DEST_LEVEL_RESET 0x0000000000000000ull +#define MINION_CSR_CO_FLUSH_VA_DEST_LEVEL_FIELD_MASK 0x0C00000000000000ull +#define MINION_CSR_CO_FLUSH_VA_DEST_LEVEL_GET(x) (((x) & 0x0C00000000000000ull) >> 58) +#define MINION_CSR_CO_FLUSH_VA_DEST_LEVEL_SET(x) (((x) << 58) & 0x0C00000000000000ull) +#define MINION_CSR_CO_FLUSH_VA_DEST_LEVEL_MODIFY(r, x) ((((x) << 58) & 0x0C00000000000000ull) | ((r) & 0xF3FFFFFFFFFFFFFFull)) + +/* Field: MINION_CSR_CO_FLUSH_VA.use_tensor_mask */ +#define MINION_CSR_CO_FLUSH_VA_USE_TENSOR_MASK_MSB 63u +#define MINION_CSR_CO_FLUSH_VA_USE_TENSOR_MASK_LSB 63u +#define MINION_CSR_CO_FLUSH_VA_USE_TENSOR_MASK_WIDTH 1u +#define MINION_CSR_CO_FLUSH_VA_USE_TENSOR_MASK_READ_ACCESS 1u +#define MINION_CSR_CO_FLUSH_VA_USE_TENSOR_MASK_WRITE_ACCESS 1u +#define MINION_CSR_CO_FLUSH_VA_USE_TENSOR_MASK_RESET 0x0000000000000000ull +#define MINION_CSR_CO_FLUSH_VA_USE_TENSOR_MASK_FIELD_MASK 0x8000000000000000ull +#define MINION_CSR_CO_FLUSH_VA_USE_TENSOR_MASK_GET(x) (((x) & 0x8000000000000000ull) >> 63) +#define MINION_CSR_CO_FLUSH_VA_USE_TENSOR_MASK_SET(x) (((x) << 63) & 0x8000000000000000ull) +#define MINION_CSR_CO_FLUSH_VA_USE_TENSOR_MASK_MODIFY(r, x) ((((x) << 63) & 0x8000000000000000ull) | ((r) & 0x7FFFFFFFFFFFFFFFull)) + +/* Register: MINION_CSR.umsg_port0 */ +#define MINION_CSR_UMSG_PORT0_ADDRESS 0x00004660ul +#define MINION_CSR_UMSG_PORT0_BYTE_ADDRESS 0x00004660ul +#define MINION_CSR_UMSG_PORT0_OFFSET 0x00004660ul +#define MINION_CSR_UMSG_PORT0_BYTE_OFFSET 0x00004660ul +#define MINION_CSR_UMSG_PORT0_SIZE 0x00000008ul +#define MINION_CSR_UMSG_PORT0_BYTE_SIZE 0x00000008ul +#define MINION_CSR_UMSG_PORT0_READ_ACCESS 1u +#define MINION_CSR_UMSG_PORT0_WRITE_ACCESS 1u +#define MINION_CSR_UMSG_PORT0_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_UMSG_PORT0_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_UMSG_PORT0_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_UMSG_PORT0_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_UMSG_PORT0.umsg_port0 */ +#define MINION_CSR_UMSG_PORT0_UMSG_PORT0_MSB 63u +#define MINION_CSR_UMSG_PORT0_UMSG_PORT0_LSB 0u +#define MINION_CSR_UMSG_PORT0_UMSG_PORT0_WIDTH 64u +#define MINION_CSR_UMSG_PORT0_UMSG_PORT0_READ_ACCESS 1u +#define MINION_CSR_UMSG_PORT0_UMSG_PORT0_WRITE_ACCESS 1u +#define MINION_CSR_UMSG_PORT0_UMSG_PORT0_RESET 0x0000000000000000ull +#define MINION_CSR_UMSG_PORT0_UMSG_PORT0_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_UMSG_PORT0_UMSG_PORT0_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_UMSG_PORT0_UMSG_PORT0_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_UMSG_PORT0_UMSG_PORT0_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.umsg_port1 */ +#define MINION_CSR_UMSG_PORT1_ADDRESS 0x00004668ul +#define MINION_CSR_UMSG_PORT1_BYTE_ADDRESS 0x00004668ul +#define MINION_CSR_UMSG_PORT1_OFFSET 0x00004668ul +#define MINION_CSR_UMSG_PORT1_BYTE_OFFSET 0x00004668ul +#define MINION_CSR_UMSG_PORT1_SIZE 0x00000008ul +#define MINION_CSR_UMSG_PORT1_BYTE_SIZE 0x00000008ul +#define MINION_CSR_UMSG_PORT1_READ_ACCESS 1u +#define MINION_CSR_UMSG_PORT1_WRITE_ACCESS 1u +#define MINION_CSR_UMSG_PORT1_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_UMSG_PORT1_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_UMSG_PORT1_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_UMSG_PORT1_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_UMSG_PORT1.umsg_port1 */ +#define MINION_CSR_UMSG_PORT1_UMSG_PORT1_MSB 63u +#define MINION_CSR_UMSG_PORT1_UMSG_PORT1_LSB 0u +#define MINION_CSR_UMSG_PORT1_UMSG_PORT1_WIDTH 64u +#define MINION_CSR_UMSG_PORT1_UMSG_PORT1_READ_ACCESS 1u +#define MINION_CSR_UMSG_PORT1_UMSG_PORT1_WRITE_ACCESS 1u +#define MINION_CSR_UMSG_PORT1_UMSG_PORT1_RESET 0x0000000000000000ull +#define MINION_CSR_UMSG_PORT1_UMSG_PORT1_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_UMSG_PORT1_UMSG_PORT1_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_UMSG_PORT1_UMSG_PORT1_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_UMSG_PORT1_UMSG_PORT1_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.umsg_port2 */ +#define MINION_CSR_UMSG_PORT2_ADDRESS 0x00004670ul +#define MINION_CSR_UMSG_PORT2_BYTE_ADDRESS 0x00004670ul +#define MINION_CSR_UMSG_PORT2_OFFSET 0x00004670ul +#define MINION_CSR_UMSG_PORT2_BYTE_OFFSET 0x00004670ul +#define MINION_CSR_UMSG_PORT2_SIZE 0x00000008ul +#define MINION_CSR_UMSG_PORT2_BYTE_SIZE 0x00000008ul +#define MINION_CSR_UMSG_PORT2_READ_ACCESS 1u +#define MINION_CSR_UMSG_PORT2_WRITE_ACCESS 1u +#define MINION_CSR_UMSG_PORT2_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_UMSG_PORT2_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_UMSG_PORT2_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_UMSG_PORT2_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_UMSG_PORT2.umsg_port2 */ +#define MINION_CSR_UMSG_PORT2_UMSG_PORT2_MSB 63u +#define MINION_CSR_UMSG_PORT2_UMSG_PORT2_LSB 0u +#define MINION_CSR_UMSG_PORT2_UMSG_PORT2_WIDTH 64u +#define MINION_CSR_UMSG_PORT2_UMSG_PORT2_READ_ACCESS 1u +#define MINION_CSR_UMSG_PORT2_UMSG_PORT2_WRITE_ACCESS 1u +#define MINION_CSR_UMSG_PORT2_UMSG_PORT2_RESET 0x0000000000000000ull +#define MINION_CSR_UMSG_PORT2_UMSG_PORT2_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_UMSG_PORT2_UMSG_PORT2_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_UMSG_PORT2_UMSG_PORT2_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_UMSG_PORT2_UMSG_PORT2_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.umsg_port3 */ +#define MINION_CSR_UMSG_PORT3_ADDRESS 0x00004678ul +#define MINION_CSR_UMSG_PORT3_BYTE_ADDRESS 0x00004678ul +#define MINION_CSR_UMSG_PORT3_OFFSET 0x00004678ul +#define MINION_CSR_UMSG_PORT3_BYTE_OFFSET 0x00004678ul +#define MINION_CSR_UMSG_PORT3_SIZE 0x00000008ul +#define MINION_CSR_UMSG_PORT3_BYTE_SIZE 0x00000008ul +#define MINION_CSR_UMSG_PORT3_READ_ACCESS 1u +#define MINION_CSR_UMSG_PORT3_WRITE_ACCESS 1u +#define MINION_CSR_UMSG_PORT3_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_UMSG_PORT3_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_UMSG_PORT3_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_UMSG_PORT3_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_UMSG_PORT3.umsg_port3 */ +#define MINION_CSR_UMSG_PORT3_UMSG_PORT3_MSB 63u +#define MINION_CSR_UMSG_PORT3_UMSG_PORT3_LSB 0u +#define MINION_CSR_UMSG_PORT3_UMSG_PORT3_WIDTH 64u +#define MINION_CSR_UMSG_PORT3_UMSG_PORT3_READ_ACCESS 1u +#define MINION_CSR_UMSG_PORT3_UMSG_PORT3_WRITE_ACCESS 1u +#define MINION_CSR_UMSG_PORT3_UMSG_PORT3_RESET 0x0000000000000000ull +#define MINION_CSR_UMSG_PORT3_UMSG_PORT3_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_UMSG_PORT3_UMSG_PORT3_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_UMSG_PORT3_UMSG_PORT3_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_UMSG_PORT3_UMSG_PORT3_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.validation0 */ +#define MINION_CSR_VALIDATION0_ADDRESS 0x00004680ul +#define MINION_CSR_VALIDATION0_BYTE_ADDRESS 0x00004680ul +#define MINION_CSR_VALIDATION0_OFFSET 0x00004680ul +#define MINION_CSR_VALIDATION0_BYTE_OFFSET 0x00004680ul +#define MINION_CSR_VALIDATION0_SIZE 0x00000008ul +#define MINION_CSR_VALIDATION0_BYTE_SIZE 0x00000008ul +#define MINION_CSR_VALIDATION0_READ_ACCESS 1u +#define MINION_CSR_VALIDATION0_WRITE_ACCESS 1u +#define MINION_CSR_VALIDATION0_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_VALIDATION0_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_VALIDATION0_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_VALIDATION0_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_VALIDATION0.validation0 */ +#define MINION_CSR_VALIDATION0_VALIDATION0_MSB 63u +#define MINION_CSR_VALIDATION0_VALIDATION0_LSB 0u +#define MINION_CSR_VALIDATION0_VALIDATION0_WIDTH 64u +#define MINION_CSR_VALIDATION0_VALIDATION0_READ_ACCESS 1u +#define MINION_CSR_VALIDATION0_VALIDATION0_WRITE_ACCESS 1u +#define MINION_CSR_VALIDATION0_VALIDATION0_RESET 0x0000000000000000ull +#define MINION_CSR_VALIDATION0_VALIDATION0_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_VALIDATION0_VALIDATION0_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_VALIDATION0_VALIDATION0_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_VALIDATION0_VALIDATION0_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.validation1 */ +#define MINION_CSR_VALIDATION1_ADDRESS 0x00004688ul +#define MINION_CSR_VALIDATION1_BYTE_ADDRESS 0x00004688ul +#define MINION_CSR_VALIDATION1_OFFSET 0x00004688ul +#define MINION_CSR_VALIDATION1_BYTE_OFFSET 0x00004688ul +#define MINION_CSR_VALIDATION1_SIZE 0x00000008ul +#define MINION_CSR_VALIDATION1_BYTE_SIZE 0x00000008ul +#define MINION_CSR_VALIDATION1_READ_ACCESS 1u +#define MINION_CSR_VALIDATION1_WRITE_ACCESS 1u +#define MINION_CSR_VALIDATION1_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_VALIDATION1_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_VALIDATION1_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_VALIDATION1_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_VALIDATION1.validation1 */ +#define MINION_CSR_VALIDATION1_VALIDATION1_MSB 63u +#define MINION_CSR_VALIDATION1_VALIDATION1_LSB 0u +#define MINION_CSR_VALIDATION1_VALIDATION1_WIDTH 64u +#define MINION_CSR_VALIDATION1_VALIDATION1_READ_ACCESS 1u +#define MINION_CSR_VALIDATION1_VALIDATION1_WRITE_ACCESS 1u +#define MINION_CSR_VALIDATION1_VALIDATION1_RESET 0x0000000000000000ull +#define MINION_CSR_VALIDATION1_VALIDATION1_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_VALIDATION1_VALIDATION1_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_VALIDATION1_VALIDATION1_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_VALIDATION1_VALIDATION1_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.validation2 */ +#define MINION_CSR_VALIDATION2_ADDRESS 0x00004690ul +#define MINION_CSR_VALIDATION2_BYTE_ADDRESS 0x00004690ul +#define MINION_CSR_VALIDATION2_OFFSET 0x00004690ul +#define MINION_CSR_VALIDATION2_BYTE_OFFSET 0x00004690ul +#define MINION_CSR_VALIDATION2_SIZE 0x00000008ul +#define MINION_CSR_VALIDATION2_BYTE_SIZE 0x00000008ul +#define MINION_CSR_VALIDATION2_READ_ACCESS 1u +#define MINION_CSR_VALIDATION2_WRITE_ACCESS 1u +#define MINION_CSR_VALIDATION2_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_VALIDATION2_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_VALIDATION2_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_VALIDATION2_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_VALIDATION2.validation2 */ +#define MINION_CSR_VALIDATION2_VALIDATION2_MSB 63u +#define MINION_CSR_VALIDATION2_VALIDATION2_LSB 0u +#define MINION_CSR_VALIDATION2_VALIDATION2_WIDTH 64u +#define MINION_CSR_VALIDATION2_VALIDATION2_READ_ACCESS 1u +#define MINION_CSR_VALIDATION2_VALIDATION2_WRITE_ACCESS 1u +#define MINION_CSR_VALIDATION2_VALIDATION2_RESET 0x0000000000000000ull +#define MINION_CSR_VALIDATION2_VALIDATION2_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_VALIDATION2_VALIDATION2_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_VALIDATION2_VALIDATION2_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_VALIDATION2_VALIDATION2_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.validation3 */ +#define MINION_CSR_VALIDATION3_ADDRESS 0x00004698ul +#define MINION_CSR_VALIDATION3_BYTE_ADDRESS 0x00004698ul +#define MINION_CSR_VALIDATION3_OFFSET 0x00004698ul +#define MINION_CSR_VALIDATION3_BYTE_OFFSET 0x00004698ul +#define MINION_CSR_VALIDATION3_SIZE 0x00000008ul +#define MINION_CSR_VALIDATION3_BYTE_SIZE 0x00000008ul +#define MINION_CSR_VALIDATION3_READ_ACCESS 1u +#define MINION_CSR_VALIDATION3_WRITE_ACCESS 1u +#define MINION_CSR_VALIDATION3_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_VALIDATION3_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_VALIDATION3_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_VALIDATION3_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_VALIDATION3.validation3 */ +#define MINION_CSR_VALIDATION3_VALIDATION3_MSB 63u +#define MINION_CSR_VALIDATION3_VALIDATION3_LSB 0u +#define MINION_CSR_VALIDATION3_VALIDATION3_WIDTH 64u +#define MINION_CSR_VALIDATION3_VALIDATION3_READ_ACCESS 1u +#define MINION_CSR_VALIDATION3_VALIDATION3_WRITE_ACCESS 1u +#define MINION_CSR_VALIDATION3_VALIDATION3_RESET 0x0000000000000000ull +#define MINION_CSR_VALIDATION3_VALIDATION3_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_VALIDATION3_VALIDATION3_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_VALIDATION3_VALIDATION3_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_VALIDATION3_VALIDATION3_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.sleep_txfma_27 */ +#define MINION_CSR_SLEEP_TXFMA_27_ADDRESS 0x000046A8ul +#define MINION_CSR_SLEEP_TXFMA_27_BYTE_ADDRESS 0x000046A8ul +#define MINION_CSR_SLEEP_TXFMA_27_OFFSET 0x000046A8ul +#define MINION_CSR_SLEEP_TXFMA_27_BYTE_OFFSET 0x000046A8ul +#define MINION_CSR_SLEEP_TXFMA_27_SIZE 0x00000008ul +#define MINION_CSR_SLEEP_TXFMA_27_BYTE_SIZE 0x00000008ul +#define MINION_CSR_SLEEP_TXFMA_27_READ_ACCESS 1u +#define MINION_CSR_SLEEP_TXFMA_27_WRITE_ACCESS 1u +#define MINION_CSR_SLEEP_TXFMA_27_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_SLEEP_TXFMA_27_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_SLEEP_TXFMA_27_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_SLEEP_TXFMA_27_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_SLEEP_TXFMA_27.sleep_txfma_27 */ +#define MINION_CSR_SLEEP_TXFMA_27_SLEEP_TXFMA_27_MSB 63u +#define MINION_CSR_SLEEP_TXFMA_27_SLEEP_TXFMA_27_LSB 0u +#define MINION_CSR_SLEEP_TXFMA_27_SLEEP_TXFMA_27_WIDTH 64u +#define MINION_CSR_SLEEP_TXFMA_27_SLEEP_TXFMA_27_READ_ACCESS 1u +#define MINION_CSR_SLEEP_TXFMA_27_SLEEP_TXFMA_27_WRITE_ACCESS 1u +#define MINION_CSR_SLEEP_TXFMA_27_SLEEP_TXFMA_27_RESET 0x0000000000000000ull +#define MINION_CSR_SLEEP_TXFMA_27_SLEEP_TXFMA_27_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_SLEEP_TXFMA_27_SLEEP_TXFMA_27_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_SLEEP_TXFMA_27_SLEEP_TXFMA_27_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_SLEEP_TXFMA_27_SLEEP_TXFMA_27_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.co_lock_va */ +#define MINION_CSR_CO_LOCK_VA_ADDRESS 0x000046F8ul +#define MINION_CSR_CO_LOCK_VA_BYTE_ADDRESS 0x000046F8ul +#define MINION_CSR_CO_LOCK_VA_OFFSET 0x000046F8ul +#define MINION_CSR_CO_LOCK_VA_BYTE_OFFSET 0x000046F8ul +#define MINION_CSR_CO_LOCK_VA_SIZE 0x00000008ul +#define MINION_CSR_CO_LOCK_VA_BYTE_SIZE 0x00000008ul +#define MINION_CSR_CO_LOCK_VA_READ_ACCESS 1u +#define MINION_CSR_CO_LOCK_VA_WRITE_ACCESS 1u +#define MINION_CSR_CO_LOCK_VA_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_CO_LOCK_VA_RESET_MASK 0x8000FFFFFFFFFFCFull +#define MINION_CSR_CO_LOCK_VA_READ_MASK 0x8000FFFFFFFFFFCFull +#define MINION_CSR_CO_LOCK_VA_WRITE_MASK 0x8000FFFFFFFFFFCFull + +/* Field: MINION_CSR_CO_LOCK_VA.num_lines */ +#define MINION_CSR_CO_LOCK_VA_NUM_LINES_MSB 3u +#define MINION_CSR_CO_LOCK_VA_NUM_LINES_LSB 0u +#define MINION_CSR_CO_LOCK_VA_NUM_LINES_WIDTH 4u +#define MINION_CSR_CO_LOCK_VA_NUM_LINES_READ_ACCESS 1u +#define MINION_CSR_CO_LOCK_VA_NUM_LINES_WRITE_ACCESS 1u +#define MINION_CSR_CO_LOCK_VA_NUM_LINES_RESET 0x0000000000000000ull +#define MINION_CSR_CO_LOCK_VA_NUM_LINES_FIELD_MASK 0x000000000000000Full +#define MINION_CSR_CO_LOCK_VA_NUM_LINES_GET(x) ((x) & 0x000000000000000Full) +#define MINION_CSR_CO_LOCK_VA_NUM_LINES_SET(x) ((x) & 0x000000000000000Full) +#define MINION_CSR_CO_LOCK_VA_NUM_LINES_MODIFY(r, x) ((((x) << 0) & 0x000000000000000Full) | ((r) & 0xFFFFFFFFFFFFFFF0ull)) + +/* Field: MINION_CSR_CO_LOCK_VA.va */ +#define MINION_CSR_CO_LOCK_VA_VA_MSB 47u +#define MINION_CSR_CO_LOCK_VA_VA_LSB 6u +#define MINION_CSR_CO_LOCK_VA_VA_WIDTH 42u +#define MINION_CSR_CO_LOCK_VA_VA_READ_ACCESS 1u +#define MINION_CSR_CO_LOCK_VA_VA_WRITE_ACCESS 1u +#define MINION_CSR_CO_LOCK_VA_VA_RESET 0x0000000000000000ull +#define MINION_CSR_CO_LOCK_VA_VA_FIELD_MASK 0x0000FFFFFFFFFFC0ull +#define MINION_CSR_CO_LOCK_VA_VA_GET(x) (((x) & 0x0000FFFFFFFFFFC0ull) >> 6) +#define MINION_CSR_CO_LOCK_VA_VA_SET(x) (((x) << 6) & 0x0000FFFFFFFFFFC0ull) +#define MINION_CSR_CO_LOCK_VA_VA_MODIFY(r, x) ((((x) << 6) & 0x0000FFFFFFFFFFC0ull) | ((r) & 0xFFFF00000000003Full)) + +/* Field: MINION_CSR_CO_LOCK_VA.use_tensor_mask */ +#define MINION_CSR_CO_LOCK_VA_USE_TENSOR_MASK_MSB 63u +#define MINION_CSR_CO_LOCK_VA_USE_TENSOR_MASK_LSB 63u +#define MINION_CSR_CO_LOCK_VA_USE_TENSOR_MASK_WIDTH 1u +#define MINION_CSR_CO_LOCK_VA_USE_TENSOR_MASK_READ_ACCESS 1u +#define MINION_CSR_CO_LOCK_VA_USE_TENSOR_MASK_WRITE_ACCESS 1u +#define MINION_CSR_CO_LOCK_VA_USE_TENSOR_MASK_RESET 0x0000000000000000ull +#define MINION_CSR_CO_LOCK_VA_USE_TENSOR_MASK_FIELD_MASK 0x8000000000000000ull +#define MINION_CSR_CO_LOCK_VA_USE_TENSOR_MASK_GET(x) (((x) & 0x8000000000000000ull) >> 63) +#define MINION_CSR_CO_LOCK_VA_USE_TENSOR_MASK_SET(x) (((x) << 63) & 0x8000000000000000ull) +#define MINION_CSR_CO_LOCK_VA_USE_TENSOR_MASK_MODIFY(r, x) ((((x) << 63) & 0x8000000000000000ull) | ((r) & 0x7FFFFFFFFFFFFFFFull)) + +/* Register: MINION_CSR.co_unlock_va */ +#define MINION_CSR_CO_UNLOCK_VA_ADDRESS 0x000047F8ul +#define MINION_CSR_CO_UNLOCK_VA_BYTE_ADDRESS 0x000047F8ul +#define MINION_CSR_CO_UNLOCK_VA_OFFSET 0x000047F8ul +#define MINION_CSR_CO_UNLOCK_VA_BYTE_OFFSET 0x000047F8ul +#define MINION_CSR_CO_UNLOCK_VA_SIZE 0x00000008ul +#define MINION_CSR_CO_UNLOCK_VA_BYTE_SIZE 0x00000008ul +#define MINION_CSR_CO_UNLOCK_VA_READ_ACCESS 1u +#define MINION_CSR_CO_UNLOCK_VA_WRITE_ACCESS 1u +#define MINION_CSR_CO_UNLOCK_VA_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_CO_UNLOCK_VA_RESET_MASK 0x8000FFFFFFFFFFCFull +#define MINION_CSR_CO_UNLOCK_VA_READ_MASK 0x8000FFFFFFFFFFCFull +#define MINION_CSR_CO_UNLOCK_VA_WRITE_MASK 0x8000FFFFFFFFFFCFull + +/* Field: MINION_CSR_CO_UNLOCK_VA.num_lines */ +#define MINION_CSR_CO_UNLOCK_VA_NUM_LINES_MSB 3u +#define MINION_CSR_CO_UNLOCK_VA_NUM_LINES_LSB 0u +#define MINION_CSR_CO_UNLOCK_VA_NUM_LINES_WIDTH 4u +#define MINION_CSR_CO_UNLOCK_VA_NUM_LINES_READ_ACCESS 1u +#define MINION_CSR_CO_UNLOCK_VA_NUM_LINES_WRITE_ACCESS 1u +#define MINION_CSR_CO_UNLOCK_VA_NUM_LINES_RESET 0x0000000000000000ull +#define MINION_CSR_CO_UNLOCK_VA_NUM_LINES_FIELD_MASK 0x000000000000000Full +#define MINION_CSR_CO_UNLOCK_VA_NUM_LINES_GET(x) ((x) & 0x000000000000000Full) +#define MINION_CSR_CO_UNLOCK_VA_NUM_LINES_SET(x) ((x) & 0x000000000000000Full) +#define MINION_CSR_CO_UNLOCK_VA_NUM_LINES_MODIFY(r, x) ((((x) << 0) & 0x000000000000000Full) | ((r) & 0xFFFFFFFFFFFFFFF0ull)) + +/* Field: MINION_CSR_CO_UNLOCK_VA.va */ +#define MINION_CSR_CO_UNLOCK_VA_VA_MSB 47u +#define MINION_CSR_CO_UNLOCK_VA_VA_LSB 6u +#define MINION_CSR_CO_UNLOCK_VA_VA_WIDTH 42u +#define MINION_CSR_CO_UNLOCK_VA_VA_READ_ACCESS 1u +#define MINION_CSR_CO_UNLOCK_VA_VA_WRITE_ACCESS 1u +#define MINION_CSR_CO_UNLOCK_VA_VA_RESET 0x0000000000000000ull +#define MINION_CSR_CO_UNLOCK_VA_VA_FIELD_MASK 0x0000FFFFFFFFFFC0ull +#define MINION_CSR_CO_UNLOCK_VA_VA_GET(x) (((x) & 0x0000FFFFFFFFFFC0ull) >> 6) +#define MINION_CSR_CO_UNLOCK_VA_VA_SET(x) (((x) << 6) & 0x0000FFFFFFFFFFC0ull) +#define MINION_CSR_CO_UNLOCK_VA_VA_MODIFY(r, x) ((((x) << 6) & 0x0000FFFFFFFFFFC0ull) | ((r) & 0xFFFF00000000003Full)) + +/* Field: MINION_CSR_CO_UNLOCK_VA.use_tensor_mask */ +#define MINION_CSR_CO_UNLOCK_VA_USE_TENSOR_MASK_MSB 63u +#define MINION_CSR_CO_UNLOCK_VA_USE_TENSOR_MASK_LSB 63u +#define MINION_CSR_CO_UNLOCK_VA_USE_TENSOR_MASK_WIDTH 1u +#define MINION_CSR_CO_UNLOCK_VA_USE_TENSOR_MASK_READ_ACCESS 1u +#define MINION_CSR_CO_UNLOCK_VA_USE_TENSOR_MASK_WRITE_ACCESS 1u +#define MINION_CSR_CO_UNLOCK_VA_USE_TENSOR_MASK_RESET 0x0000000000000000ull +#define MINION_CSR_CO_UNLOCK_VA_USE_TENSOR_MASK_FIELD_MASK 0x8000000000000000ull +#define MINION_CSR_CO_UNLOCK_VA_USE_TENSOR_MASK_GET(x) (((x) & 0x8000000000000000ull) >> 63) +#define MINION_CSR_CO_UNLOCK_VA_USE_TENSOR_MASK_SET(x) (((x) << 63) & 0x8000000000000000ull) +#define MINION_CSR_CO_UNLOCK_VA_USE_TENSOR_MASK_MODIFY(r, x) ((((x) << 63) & 0x8000000000000000ull) | ((r) & 0x7FFFFFFFFFFFFFFFull)) + +/* Register: MINION_CSR.smsg_port0 */ +#define MINION_CSR_SMSG_PORT0_ADDRESS 0x00004E60ul +#define MINION_CSR_SMSG_PORT0_BYTE_ADDRESS 0x00004E60ul +#define MINION_CSR_SMSG_PORT0_OFFSET 0x00004E60ul +#define MINION_CSR_SMSG_PORT0_BYTE_OFFSET 0x00004E60ul +#define MINION_CSR_SMSG_PORT0_SIZE 0x00000008ul +#define MINION_CSR_SMSG_PORT0_BYTE_SIZE 0x00000008ul +#define MINION_CSR_SMSG_PORT0_READ_ACCESS 1u +#define MINION_CSR_SMSG_PORT0_WRITE_ACCESS 1u +#define MINION_CSR_SMSG_PORT0_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_SMSG_PORT0_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_SMSG_PORT0_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_SMSG_PORT0_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_SMSG_PORT0.smsg_port0 */ +#define MINION_CSR_SMSG_PORT0_SMSG_PORT0_MSB 63u +#define MINION_CSR_SMSG_PORT0_SMSG_PORT0_LSB 0u +#define MINION_CSR_SMSG_PORT0_SMSG_PORT0_WIDTH 64u +#define MINION_CSR_SMSG_PORT0_SMSG_PORT0_READ_ACCESS 1u +#define MINION_CSR_SMSG_PORT0_SMSG_PORT0_WRITE_ACCESS 1u +#define MINION_CSR_SMSG_PORT0_SMSG_PORT0_RESET 0x0000000000000000ull +#define MINION_CSR_SMSG_PORT0_SMSG_PORT0_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_SMSG_PORT0_SMSG_PORT0_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_SMSG_PORT0_SMSG_PORT0_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_SMSG_PORT0_SMSG_PORT0_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.smsg_port1 */ +#define MINION_CSR_SMSG_PORT1_ADDRESS 0x00004E68ul +#define MINION_CSR_SMSG_PORT1_BYTE_ADDRESS 0x00004E68ul +#define MINION_CSR_SMSG_PORT1_OFFSET 0x00004E68ul +#define MINION_CSR_SMSG_PORT1_BYTE_OFFSET 0x00004E68ul +#define MINION_CSR_SMSG_PORT1_SIZE 0x00000008ul +#define MINION_CSR_SMSG_PORT1_BYTE_SIZE 0x00000008ul +#define MINION_CSR_SMSG_PORT1_READ_ACCESS 1u +#define MINION_CSR_SMSG_PORT1_WRITE_ACCESS 1u +#define MINION_CSR_SMSG_PORT1_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_SMSG_PORT1_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_SMSG_PORT1_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_SMSG_PORT1_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_SMSG_PORT1.smsg_port1 */ +#define MINION_CSR_SMSG_PORT1_SMSG_PORT1_MSB 63u +#define MINION_CSR_SMSG_PORT1_SMSG_PORT1_LSB 0u +#define MINION_CSR_SMSG_PORT1_SMSG_PORT1_WIDTH 64u +#define MINION_CSR_SMSG_PORT1_SMSG_PORT1_READ_ACCESS 1u +#define MINION_CSR_SMSG_PORT1_SMSG_PORT1_WRITE_ACCESS 1u +#define MINION_CSR_SMSG_PORT1_SMSG_PORT1_RESET 0x0000000000000000ull +#define MINION_CSR_SMSG_PORT1_SMSG_PORT1_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_SMSG_PORT1_SMSG_PORT1_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_SMSG_PORT1_SMSG_PORT1_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_SMSG_PORT1_SMSG_PORT1_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.smsg_port2 */ +#define MINION_CSR_SMSG_PORT2_ADDRESS 0x00004E70ul +#define MINION_CSR_SMSG_PORT2_BYTE_ADDRESS 0x00004E70ul +#define MINION_CSR_SMSG_PORT2_OFFSET 0x00004E70ul +#define MINION_CSR_SMSG_PORT2_BYTE_OFFSET 0x00004E70ul +#define MINION_CSR_SMSG_PORT2_SIZE 0x00000008ul +#define MINION_CSR_SMSG_PORT2_BYTE_SIZE 0x00000008ul +#define MINION_CSR_SMSG_PORT2_READ_ACCESS 1u +#define MINION_CSR_SMSG_PORT2_WRITE_ACCESS 1u +#define MINION_CSR_SMSG_PORT2_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_SMSG_PORT2_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_SMSG_PORT2_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_SMSG_PORT2_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_SMSG_PORT2.smsg_port2 */ +#define MINION_CSR_SMSG_PORT2_SMSG_PORT2_MSB 63u +#define MINION_CSR_SMSG_PORT2_SMSG_PORT2_LSB 0u +#define MINION_CSR_SMSG_PORT2_SMSG_PORT2_WIDTH 64u +#define MINION_CSR_SMSG_PORT2_SMSG_PORT2_READ_ACCESS 1u +#define MINION_CSR_SMSG_PORT2_SMSG_PORT2_WRITE_ACCESS 1u +#define MINION_CSR_SMSG_PORT2_SMSG_PORT2_RESET 0x0000000000000000ull +#define MINION_CSR_SMSG_PORT2_SMSG_PORT2_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_SMSG_PORT2_SMSG_PORT2_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_SMSG_PORT2_SMSG_PORT2_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_SMSG_PORT2_SMSG_PORT2_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.smsg_port3 */ +#define MINION_CSR_SMSG_PORT3_ADDRESS 0x00004E78ul +#define MINION_CSR_SMSG_PORT3_BYTE_ADDRESS 0x00004E78ul +#define MINION_CSR_SMSG_PORT3_OFFSET 0x00004E78ul +#define MINION_CSR_SMSG_PORT3_BYTE_OFFSET 0x00004E78ul +#define MINION_CSR_SMSG_PORT3_SIZE 0x00000008ul +#define MINION_CSR_SMSG_PORT3_BYTE_SIZE 0x00000008ul +#define MINION_CSR_SMSG_PORT3_READ_ACCESS 1u +#define MINION_CSR_SMSG_PORT3_WRITE_ACCESS 1u +#define MINION_CSR_SMSG_PORT3_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_SMSG_PORT3_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_SMSG_PORT3_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_SMSG_PORT3_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_SMSG_PORT3.smsg_port3 */ +#define MINION_CSR_SMSG_PORT3_SMSG_PORT3_MSB 63u +#define MINION_CSR_SMSG_PORT3_SMSG_PORT3_LSB 0u +#define MINION_CSR_SMSG_PORT3_SMSG_PORT3_WIDTH 64u +#define MINION_CSR_SMSG_PORT3_SMSG_PORT3_READ_ACCESS 1u +#define MINION_CSR_SMSG_PORT3_SMSG_PORT3_WRITE_ACCESS 1u +#define MINION_CSR_SMSG_PORT3_SMSG_PORT3_RESET 0x0000000000000000ull +#define MINION_CSR_SMSG_PORT3_SMSG_PORT3_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_SMSG_PORT3_SMSG_PORT3_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_SMSG_PORT3_SMSG_PORT3_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_SMSG_PORT3_SMSG_PORT3_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mcycle */ +#define MINION_CSR_MCYCLE_ADDRESS 0x00005800ul +#define MINION_CSR_MCYCLE_BYTE_ADDRESS 0x00005800ul +#define MINION_CSR_MCYCLE_OFFSET 0x00005800ul +#define MINION_CSR_MCYCLE_BYTE_OFFSET 0x00005800ul +#define MINION_CSR_MCYCLE_SIZE 0x00000008ul +#define MINION_CSR_MCYCLE_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MCYCLE_READ_ACCESS 1u +#define MINION_CSR_MCYCLE_WRITE_ACCESS 1u +#define MINION_CSR_MCYCLE_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MCYCLE_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MCYCLE_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MCYCLE_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MCYCLE.mcycle */ +#define MINION_CSR_MCYCLE_MCYCLE_MSB 63u +#define MINION_CSR_MCYCLE_MCYCLE_LSB 0u +#define MINION_CSR_MCYCLE_MCYCLE_WIDTH 64u +#define MINION_CSR_MCYCLE_MCYCLE_READ_ACCESS 1u +#define MINION_CSR_MCYCLE_MCYCLE_WRITE_ACCESS 1u +#define MINION_CSR_MCYCLE_MCYCLE_RESET 0x0000000000000000ull +#define MINION_CSR_MCYCLE_MCYCLE_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MCYCLE_MCYCLE_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MCYCLE_MCYCLE_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MCYCLE_MCYCLE_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.minstret */ +#define MINION_CSR_MINSTRET_ADDRESS 0x00005810ul +#define MINION_CSR_MINSTRET_BYTE_ADDRESS 0x00005810ul +#define MINION_CSR_MINSTRET_OFFSET 0x00005810ul +#define MINION_CSR_MINSTRET_BYTE_OFFSET 0x00005810ul +#define MINION_CSR_MINSTRET_SIZE 0x00000008ul +#define MINION_CSR_MINSTRET_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MINSTRET_READ_ACCESS 1u +#define MINION_CSR_MINSTRET_WRITE_ACCESS 1u +#define MINION_CSR_MINSTRET_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MINSTRET_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MINSTRET_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MINSTRET_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MINSTRET.minstret */ +#define MINION_CSR_MINSTRET_MINSTRET_MSB 63u +#define MINION_CSR_MINSTRET_MINSTRET_LSB 0u +#define MINION_CSR_MINSTRET_MINSTRET_WIDTH 64u +#define MINION_CSR_MINSTRET_MINSTRET_READ_ACCESS 1u +#define MINION_CSR_MINSTRET_MINSTRET_WRITE_ACCESS 1u +#define MINION_CSR_MINSTRET_MINSTRET_RESET 0x0000000000000000ull +#define MINION_CSR_MINSTRET_MINSTRET_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MINSTRET_MINSTRET_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MINSTRET_MINSTRET_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MINSTRET_MINSTRET_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mhpmcounter3 */ +#define MINION_CSR_MHPMCOUNTER3_ADDRESS 0x00005818ul +#define MINION_CSR_MHPMCOUNTER3_BYTE_ADDRESS 0x00005818ul +#define MINION_CSR_MHPMCOUNTER3_OFFSET 0x00005818ul +#define MINION_CSR_MHPMCOUNTER3_BYTE_OFFSET 0x00005818ul +#define MINION_CSR_MHPMCOUNTER3_SIZE 0x00000008ul +#define MINION_CSR_MHPMCOUNTER3_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MHPMCOUNTER3_READ_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER3_WRITE_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER3_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MHPMCOUNTER3_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER3_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER3_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MHPMCOUNTER3.mhpmcounter3 */ +#define MINION_CSR_MHPMCOUNTER3_MHPMCOUNTER3_MSB 63u +#define MINION_CSR_MHPMCOUNTER3_MHPMCOUNTER3_LSB 0u +#define MINION_CSR_MHPMCOUNTER3_MHPMCOUNTER3_WIDTH 64u +#define MINION_CSR_MHPMCOUNTER3_MHPMCOUNTER3_READ_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER3_MHPMCOUNTER3_WRITE_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER3_MHPMCOUNTER3_RESET 0x0000000000000000ull +#define MINION_CSR_MHPMCOUNTER3_MHPMCOUNTER3_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER3_MHPMCOUNTER3_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMCOUNTER3_MHPMCOUNTER3_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMCOUNTER3_MHPMCOUNTER3_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mhpmcounter4 */ +#define MINION_CSR_MHPMCOUNTER4_ADDRESS 0x00005820ul +#define MINION_CSR_MHPMCOUNTER4_BYTE_ADDRESS 0x00005820ul +#define MINION_CSR_MHPMCOUNTER4_OFFSET 0x00005820ul +#define MINION_CSR_MHPMCOUNTER4_BYTE_OFFSET 0x00005820ul +#define MINION_CSR_MHPMCOUNTER4_SIZE 0x00000008ul +#define MINION_CSR_MHPMCOUNTER4_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MHPMCOUNTER4_READ_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER4_WRITE_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER4_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MHPMCOUNTER4_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER4_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER4_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MHPMCOUNTER4.mhpmcounter4 */ +#define MINION_CSR_MHPMCOUNTER4_MHPMCOUNTER4_MSB 63u +#define MINION_CSR_MHPMCOUNTER4_MHPMCOUNTER4_LSB 0u +#define MINION_CSR_MHPMCOUNTER4_MHPMCOUNTER4_WIDTH 64u +#define MINION_CSR_MHPMCOUNTER4_MHPMCOUNTER4_READ_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER4_MHPMCOUNTER4_WRITE_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER4_MHPMCOUNTER4_RESET 0x0000000000000000ull +#define MINION_CSR_MHPMCOUNTER4_MHPMCOUNTER4_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER4_MHPMCOUNTER4_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMCOUNTER4_MHPMCOUNTER4_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMCOUNTER4_MHPMCOUNTER4_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mhpmcounter5 */ +#define MINION_CSR_MHPMCOUNTER5_ADDRESS 0x00005828ul +#define MINION_CSR_MHPMCOUNTER5_BYTE_ADDRESS 0x00005828ul +#define MINION_CSR_MHPMCOUNTER5_OFFSET 0x00005828ul +#define MINION_CSR_MHPMCOUNTER5_BYTE_OFFSET 0x00005828ul +#define MINION_CSR_MHPMCOUNTER5_SIZE 0x00000008ul +#define MINION_CSR_MHPMCOUNTER5_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MHPMCOUNTER5_READ_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER5_WRITE_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER5_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MHPMCOUNTER5_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER5_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER5_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MHPMCOUNTER5.mhpmcounter5 */ +#define MINION_CSR_MHPMCOUNTER5_MHPMCOUNTER5_MSB 63u +#define MINION_CSR_MHPMCOUNTER5_MHPMCOUNTER5_LSB 0u +#define MINION_CSR_MHPMCOUNTER5_MHPMCOUNTER5_WIDTH 64u +#define MINION_CSR_MHPMCOUNTER5_MHPMCOUNTER5_READ_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER5_MHPMCOUNTER5_WRITE_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER5_MHPMCOUNTER5_RESET 0x0000000000000000ull +#define MINION_CSR_MHPMCOUNTER5_MHPMCOUNTER5_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER5_MHPMCOUNTER5_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMCOUNTER5_MHPMCOUNTER5_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMCOUNTER5_MHPMCOUNTER5_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mhpmcounter6 */ +#define MINION_CSR_MHPMCOUNTER6_ADDRESS 0x00005830ul +#define MINION_CSR_MHPMCOUNTER6_BYTE_ADDRESS 0x00005830ul +#define MINION_CSR_MHPMCOUNTER6_OFFSET 0x00005830ul +#define MINION_CSR_MHPMCOUNTER6_BYTE_OFFSET 0x00005830ul +#define MINION_CSR_MHPMCOUNTER6_SIZE 0x00000008ul +#define MINION_CSR_MHPMCOUNTER6_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MHPMCOUNTER6_READ_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER6_WRITE_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER6_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MHPMCOUNTER6_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER6_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER6_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MHPMCOUNTER6.mhpmcounter6 */ +#define MINION_CSR_MHPMCOUNTER6_MHPMCOUNTER6_MSB 63u +#define MINION_CSR_MHPMCOUNTER6_MHPMCOUNTER6_LSB 0u +#define MINION_CSR_MHPMCOUNTER6_MHPMCOUNTER6_WIDTH 64u +#define MINION_CSR_MHPMCOUNTER6_MHPMCOUNTER6_READ_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER6_MHPMCOUNTER6_WRITE_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER6_MHPMCOUNTER6_RESET 0x0000000000000000ull +#define MINION_CSR_MHPMCOUNTER6_MHPMCOUNTER6_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER6_MHPMCOUNTER6_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMCOUNTER6_MHPMCOUNTER6_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMCOUNTER6_MHPMCOUNTER6_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mhpmcounter7 */ +#define MINION_CSR_MHPMCOUNTER7_ADDRESS 0x00005838ul +#define MINION_CSR_MHPMCOUNTER7_BYTE_ADDRESS 0x00005838ul +#define MINION_CSR_MHPMCOUNTER7_OFFSET 0x00005838ul +#define MINION_CSR_MHPMCOUNTER7_BYTE_OFFSET 0x00005838ul +#define MINION_CSR_MHPMCOUNTER7_SIZE 0x00000008ul +#define MINION_CSR_MHPMCOUNTER7_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MHPMCOUNTER7_READ_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER7_WRITE_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER7_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MHPMCOUNTER7_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER7_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER7_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MHPMCOUNTER7.mhpmcounter7 */ +#define MINION_CSR_MHPMCOUNTER7_MHPMCOUNTER7_MSB 63u +#define MINION_CSR_MHPMCOUNTER7_MHPMCOUNTER7_LSB 0u +#define MINION_CSR_MHPMCOUNTER7_MHPMCOUNTER7_WIDTH 64u +#define MINION_CSR_MHPMCOUNTER7_MHPMCOUNTER7_READ_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER7_MHPMCOUNTER7_WRITE_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER7_MHPMCOUNTER7_RESET 0x0000000000000000ull +#define MINION_CSR_MHPMCOUNTER7_MHPMCOUNTER7_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER7_MHPMCOUNTER7_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMCOUNTER7_MHPMCOUNTER7_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMCOUNTER7_MHPMCOUNTER7_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mhpmcounter8 */ +#define MINION_CSR_MHPMCOUNTER8_ADDRESS 0x00005840ul +#define MINION_CSR_MHPMCOUNTER8_BYTE_ADDRESS 0x00005840ul +#define MINION_CSR_MHPMCOUNTER8_OFFSET 0x00005840ul +#define MINION_CSR_MHPMCOUNTER8_BYTE_OFFSET 0x00005840ul +#define MINION_CSR_MHPMCOUNTER8_SIZE 0x00000008ul +#define MINION_CSR_MHPMCOUNTER8_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MHPMCOUNTER8_READ_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER8_WRITE_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER8_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MHPMCOUNTER8_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER8_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER8_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MHPMCOUNTER8.mhpmcounter8 */ +#define MINION_CSR_MHPMCOUNTER8_MHPMCOUNTER8_MSB 63u +#define MINION_CSR_MHPMCOUNTER8_MHPMCOUNTER8_LSB 0u +#define MINION_CSR_MHPMCOUNTER8_MHPMCOUNTER8_WIDTH 64u +#define MINION_CSR_MHPMCOUNTER8_MHPMCOUNTER8_READ_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER8_MHPMCOUNTER8_WRITE_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER8_MHPMCOUNTER8_RESET 0x0000000000000000ull +#define MINION_CSR_MHPMCOUNTER8_MHPMCOUNTER8_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER8_MHPMCOUNTER8_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMCOUNTER8_MHPMCOUNTER8_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMCOUNTER8_MHPMCOUNTER8_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mhpmcounter9 */ +#define MINION_CSR_MHPMCOUNTER9_ADDRESS 0x00005848ul +#define MINION_CSR_MHPMCOUNTER9_BYTE_ADDRESS 0x00005848ul +#define MINION_CSR_MHPMCOUNTER9_OFFSET 0x00005848ul +#define MINION_CSR_MHPMCOUNTER9_BYTE_OFFSET 0x00005848ul +#define MINION_CSR_MHPMCOUNTER9_SIZE 0x00000008ul +#define MINION_CSR_MHPMCOUNTER9_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MHPMCOUNTER9_READ_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER9_WRITE_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER9_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MHPMCOUNTER9_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER9_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER9_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MHPMCOUNTER9.mhpmcounter9 */ +#define MINION_CSR_MHPMCOUNTER9_MHPMCOUNTER9_MSB 63u +#define MINION_CSR_MHPMCOUNTER9_MHPMCOUNTER9_LSB 0u +#define MINION_CSR_MHPMCOUNTER9_MHPMCOUNTER9_WIDTH 64u +#define MINION_CSR_MHPMCOUNTER9_MHPMCOUNTER9_READ_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER9_MHPMCOUNTER9_WRITE_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER9_MHPMCOUNTER9_RESET 0x0000000000000000ull +#define MINION_CSR_MHPMCOUNTER9_MHPMCOUNTER9_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER9_MHPMCOUNTER9_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMCOUNTER9_MHPMCOUNTER9_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMCOUNTER9_MHPMCOUNTER9_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mhpmcounter10 */ +#define MINION_CSR_MHPMCOUNTER10_ADDRESS 0x00005850ul +#define MINION_CSR_MHPMCOUNTER10_BYTE_ADDRESS 0x00005850ul +#define MINION_CSR_MHPMCOUNTER10_OFFSET 0x00005850ul +#define MINION_CSR_MHPMCOUNTER10_BYTE_OFFSET 0x00005850ul +#define MINION_CSR_MHPMCOUNTER10_SIZE 0x00000008ul +#define MINION_CSR_MHPMCOUNTER10_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MHPMCOUNTER10_READ_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER10_WRITE_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER10_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MHPMCOUNTER10_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER10_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER10_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MHPMCOUNTER10.mhpmcounter10 */ +#define MINION_CSR_MHPMCOUNTER10_MHPMCOUNTER10_MSB 63u +#define MINION_CSR_MHPMCOUNTER10_MHPMCOUNTER10_LSB 0u +#define MINION_CSR_MHPMCOUNTER10_MHPMCOUNTER10_WIDTH 64u +#define MINION_CSR_MHPMCOUNTER10_MHPMCOUNTER10_READ_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER10_MHPMCOUNTER10_WRITE_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER10_MHPMCOUNTER10_RESET 0x0000000000000000ull +#define MINION_CSR_MHPMCOUNTER10_MHPMCOUNTER10_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER10_MHPMCOUNTER10_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMCOUNTER10_MHPMCOUNTER10_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMCOUNTER10_MHPMCOUNTER10_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mhpmcounter11 */ +#define MINION_CSR_MHPMCOUNTER11_ADDRESS 0x00005858ul +#define MINION_CSR_MHPMCOUNTER11_BYTE_ADDRESS 0x00005858ul +#define MINION_CSR_MHPMCOUNTER11_OFFSET 0x00005858ul +#define MINION_CSR_MHPMCOUNTER11_BYTE_OFFSET 0x00005858ul +#define MINION_CSR_MHPMCOUNTER11_SIZE 0x00000008ul +#define MINION_CSR_MHPMCOUNTER11_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MHPMCOUNTER11_READ_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER11_WRITE_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER11_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MHPMCOUNTER11_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER11_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER11_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MHPMCOUNTER11.mhpmcounter11 */ +#define MINION_CSR_MHPMCOUNTER11_MHPMCOUNTER11_MSB 63u +#define MINION_CSR_MHPMCOUNTER11_MHPMCOUNTER11_LSB 0u +#define MINION_CSR_MHPMCOUNTER11_MHPMCOUNTER11_WIDTH 64u +#define MINION_CSR_MHPMCOUNTER11_MHPMCOUNTER11_READ_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER11_MHPMCOUNTER11_WRITE_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER11_MHPMCOUNTER11_RESET 0x0000000000000000ull +#define MINION_CSR_MHPMCOUNTER11_MHPMCOUNTER11_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER11_MHPMCOUNTER11_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMCOUNTER11_MHPMCOUNTER11_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMCOUNTER11_MHPMCOUNTER11_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mhpmcounter12 */ +#define MINION_CSR_MHPMCOUNTER12_ADDRESS 0x00005860ul +#define MINION_CSR_MHPMCOUNTER12_BYTE_ADDRESS 0x00005860ul +#define MINION_CSR_MHPMCOUNTER12_OFFSET 0x00005860ul +#define MINION_CSR_MHPMCOUNTER12_BYTE_OFFSET 0x00005860ul +#define MINION_CSR_MHPMCOUNTER12_SIZE 0x00000008ul +#define MINION_CSR_MHPMCOUNTER12_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MHPMCOUNTER12_READ_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER12_WRITE_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER12_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MHPMCOUNTER12_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER12_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER12_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MHPMCOUNTER12.mhpmcounter12 */ +#define MINION_CSR_MHPMCOUNTER12_MHPMCOUNTER12_MSB 63u +#define MINION_CSR_MHPMCOUNTER12_MHPMCOUNTER12_LSB 0u +#define MINION_CSR_MHPMCOUNTER12_MHPMCOUNTER12_WIDTH 64u +#define MINION_CSR_MHPMCOUNTER12_MHPMCOUNTER12_READ_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER12_MHPMCOUNTER12_WRITE_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER12_MHPMCOUNTER12_RESET 0x0000000000000000ull +#define MINION_CSR_MHPMCOUNTER12_MHPMCOUNTER12_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER12_MHPMCOUNTER12_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMCOUNTER12_MHPMCOUNTER12_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMCOUNTER12_MHPMCOUNTER12_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mhpmcounter13 */ +#define MINION_CSR_MHPMCOUNTER13_ADDRESS 0x00005868ul +#define MINION_CSR_MHPMCOUNTER13_BYTE_ADDRESS 0x00005868ul +#define MINION_CSR_MHPMCOUNTER13_OFFSET 0x00005868ul +#define MINION_CSR_MHPMCOUNTER13_BYTE_OFFSET 0x00005868ul +#define MINION_CSR_MHPMCOUNTER13_SIZE 0x00000008ul +#define MINION_CSR_MHPMCOUNTER13_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MHPMCOUNTER13_READ_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER13_WRITE_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER13_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MHPMCOUNTER13_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER13_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER13_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MHPMCOUNTER13.mhpmcounter13 */ +#define MINION_CSR_MHPMCOUNTER13_MHPMCOUNTER13_MSB 63u +#define MINION_CSR_MHPMCOUNTER13_MHPMCOUNTER13_LSB 0u +#define MINION_CSR_MHPMCOUNTER13_MHPMCOUNTER13_WIDTH 64u +#define MINION_CSR_MHPMCOUNTER13_MHPMCOUNTER13_READ_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER13_MHPMCOUNTER13_WRITE_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER13_MHPMCOUNTER13_RESET 0x0000000000000000ull +#define MINION_CSR_MHPMCOUNTER13_MHPMCOUNTER13_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER13_MHPMCOUNTER13_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMCOUNTER13_MHPMCOUNTER13_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMCOUNTER13_MHPMCOUNTER13_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mhpmcounter14 */ +#define MINION_CSR_MHPMCOUNTER14_ADDRESS 0x00005870ul +#define MINION_CSR_MHPMCOUNTER14_BYTE_ADDRESS 0x00005870ul +#define MINION_CSR_MHPMCOUNTER14_OFFSET 0x00005870ul +#define MINION_CSR_MHPMCOUNTER14_BYTE_OFFSET 0x00005870ul +#define MINION_CSR_MHPMCOUNTER14_SIZE 0x00000008ul +#define MINION_CSR_MHPMCOUNTER14_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MHPMCOUNTER14_READ_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER14_WRITE_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER14_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MHPMCOUNTER14_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER14_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER14_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MHPMCOUNTER14.mhpmcounter14 */ +#define MINION_CSR_MHPMCOUNTER14_MHPMCOUNTER14_MSB 63u +#define MINION_CSR_MHPMCOUNTER14_MHPMCOUNTER14_LSB 0u +#define MINION_CSR_MHPMCOUNTER14_MHPMCOUNTER14_WIDTH 64u +#define MINION_CSR_MHPMCOUNTER14_MHPMCOUNTER14_READ_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER14_MHPMCOUNTER14_WRITE_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER14_MHPMCOUNTER14_RESET 0x0000000000000000ull +#define MINION_CSR_MHPMCOUNTER14_MHPMCOUNTER14_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER14_MHPMCOUNTER14_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMCOUNTER14_MHPMCOUNTER14_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMCOUNTER14_MHPMCOUNTER14_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mhpmcounter15 */ +#define MINION_CSR_MHPMCOUNTER15_ADDRESS 0x00005878ul +#define MINION_CSR_MHPMCOUNTER15_BYTE_ADDRESS 0x00005878ul +#define MINION_CSR_MHPMCOUNTER15_OFFSET 0x00005878ul +#define MINION_CSR_MHPMCOUNTER15_BYTE_OFFSET 0x00005878ul +#define MINION_CSR_MHPMCOUNTER15_SIZE 0x00000008ul +#define MINION_CSR_MHPMCOUNTER15_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MHPMCOUNTER15_READ_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER15_WRITE_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER15_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MHPMCOUNTER15_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER15_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER15_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MHPMCOUNTER15.mhpmcounter15 */ +#define MINION_CSR_MHPMCOUNTER15_MHPMCOUNTER15_MSB 63u +#define MINION_CSR_MHPMCOUNTER15_MHPMCOUNTER15_LSB 0u +#define MINION_CSR_MHPMCOUNTER15_MHPMCOUNTER15_WIDTH 64u +#define MINION_CSR_MHPMCOUNTER15_MHPMCOUNTER15_READ_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER15_MHPMCOUNTER15_WRITE_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER15_MHPMCOUNTER15_RESET 0x0000000000000000ull +#define MINION_CSR_MHPMCOUNTER15_MHPMCOUNTER15_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER15_MHPMCOUNTER15_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMCOUNTER15_MHPMCOUNTER15_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMCOUNTER15_MHPMCOUNTER15_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mhpmcounter16 */ +#define MINION_CSR_MHPMCOUNTER16_ADDRESS 0x00005880ul +#define MINION_CSR_MHPMCOUNTER16_BYTE_ADDRESS 0x00005880ul +#define MINION_CSR_MHPMCOUNTER16_OFFSET 0x00005880ul +#define MINION_CSR_MHPMCOUNTER16_BYTE_OFFSET 0x00005880ul +#define MINION_CSR_MHPMCOUNTER16_SIZE 0x00000008ul +#define MINION_CSR_MHPMCOUNTER16_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MHPMCOUNTER16_READ_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER16_WRITE_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER16_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MHPMCOUNTER16_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER16_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER16_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MHPMCOUNTER16.mhpmcounter16 */ +#define MINION_CSR_MHPMCOUNTER16_MHPMCOUNTER16_MSB 63u +#define MINION_CSR_MHPMCOUNTER16_MHPMCOUNTER16_LSB 0u +#define MINION_CSR_MHPMCOUNTER16_MHPMCOUNTER16_WIDTH 64u +#define MINION_CSR_MHPMCOUNTER16_MHPMCOUNTER16_READ_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER16_MHPMCOUNTER16_WRITE_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER16_MHPMCOUNTER16_RESET 0x0000000000000000ull +#define MINION_CSR_MHPMCOUNTER16_MHPMCOUNTER16_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER16_MHPMCOUNTER16_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMCOUNTER16_MHPMCOUNTER16_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMCOUNTER16_MHPMCOUNTER16_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mhpmcounter17 */ +#define MINION_CSR_MHPMCOUNTER17_ADDRESS 0x00005888ul +#define MINION_CSR_MHPMCOUNTER17_BYTE_ADDRESS 0x00005888ul +#define MINION_CSR_MHPMCOUNTER17_OFFSET 0x00005888ul +#define MINION_CSR_MHPMCOUNTER17_BYTE_OFFSET 0x00005888ul +#define MINION_CSR_MHPMCOUNTER17_SIZE 0x00000008ul +#define MINION_CSR_MHPMCOUNTER17_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MHPMCOUNTER17_READ_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER17_WRITE_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER17_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MHPMCOUNTER17_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER17_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER17_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MHPMCOUNTER17.mhpmcounter17 */ +#define MINION_CSR_MHPMCOUNTER17_MHPMCOUNTER17_MSB 63u +#define MINION_CSR_MHPMCOUNTER17_MHPMCOUNTER17_LSB 0u +#define MINION_CSR_MHPMCOUNTER17_MHPMCOUNTER17_WIDTH 64u +#define MINION_CSR_MHPMCOUNTER17_MHPMCOUNTER17_READ_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER17_MHPMCOUNTER17_WRITE_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER17_MHPMCOUNTER17_RESET 0x0000000000000000ull +#define MINION_CSR_MHPMCOUNTER17_MHPMCOUNTER17_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER17_MHPMCOUNTER17_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMCOUNTER17_MHPMCOUNTER17_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMCOUNTER17_MHPMCOUNTER17_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mhpmcounter18 */ +#define MINION_CSR_MHPMCOUNTER18_ADDRESS 0x00005890ul +#define MINION_CSR_MHPMCOUNTER18_BYTE_ADDRESS 0x00005890ul +#define MINION_CSR_MHPMCOUNTER18_OFFSET 0x00005890ul +#define MINION_CSR_MHPMCOUNTER18_BYTE_OFFSET 0x00005890ul +#define MINION_CSR_MHPMCOUNTER18_SIZE 0x00000008ul +#define MINION_CSR_MHPMCOUNTER18_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MHPMCOUNTER18_READ_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER18_WRITE_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER18_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MHPMCOUNTER18_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER18_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER18_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MHPMCOUNTER18.mhpmcounter18 */ +#define MINION_CSR_MHPMCOUNTER18_MHPMCOUNTER18_MSB 63u +#define MINION_CSR_MHPMCOUNTER18_MHPMCOUNTER18_LSB 0u +#define MINION_CSR_MHPMCOUNTER18_MHPMCOUNTER18_WIDTH 64u +#define MINION_CSR_MHPMCOUNTER18_MHPMCOUNTER18_READ_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER18_MHPMCOUNTER18_WRITE_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER18_MHPMCOUNTER18_RESET 0x0000000000000000ull +#define MINION_CSR_MHPMCOUNTER18_MHPMCOUNTER18_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER18_MHPMCOUNTER18_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMCOUNTER18_MHPMCOUNTER18_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMCOUNTER18_MHPMCOUNTER18_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mhpmcounter19 */ +#define MINION_CSR_MHPMCOUNTER19_ADDRESS 0x00005898ul +#define MINION_CSR_MHPMCOUNTER19_BYTE_ADDRESS 0x00005898ul +#define MINION_CSR_MHPMCOUNTER19_OFFSET 0x00005898ul +#define MINION_CSR_MHPMCOUNTER19_BYTE_OFFSET 0x00005898ul +#define MINION_CSR_MHPMCOUNTER19_SIZE 0x00000008ul +#define MINION_CSR_MHPMCOUNTER19_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MHPMCOUNTER19_READ_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER19_WRITE_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER19_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MHPMCOUNTER19_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER19_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER19_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MHPMCOUNTER19.mhpmcounter19 */ +#define MINION_CSR_MHPMCOUNTER19_MHPMCOUNTER19_MSB 63u +#define MINION_CSR_MHPMCOUNTER19_MHPMCOUNTER19_LSB 0u +#define MINION_CSR_MHPMCOUNTER19_MHPMCOUNTER19_WIDTH 64u +#define MINION_CSR_MHPMCOUNTER19_MHPMCOUNTER19_READ_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER19_MHPMCOUNTER19_WRITE_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER19_MHPMCOUNTER19_RESET 0x0000000000000000ull +#define MINION_CSR_MHPMCOUNTER19_MHPMCOUNTER19_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER19_MHPMCOUNTER19_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMCOUNTER19_MHPMCOUNTER19_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMCOUNTER19_MHPMCOUNTER19_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mhpmcounter20 */ +#define MINION_CSR_MHPMCOUNTER20_ADDRESS 0x000058A0ul +#define MINION_CSR_MHPMCOUNTER20_BYTE_ADDRESS 0x000058A0ul +#define MINION_CSR_MHPMCOUNTER20_OFFSET 0x000058A0ul +#define MINION_CSR_MHPMCOUNTER20_BYTE_OFFSET 0x000058A0ul +#define MINION_CSR_MHPMCOUNTER20_SIZE 0x00000008ul +#define MINION_CSR_MHPMCOUNTER20_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MHPMCOUNTER20_READ_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER20_WRITE_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER20_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MHPMCOUNTER20_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER20_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER20_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MHPMCOUNTER20.mhpmcounter20 */ +#define MINION_CSR_MHPMCOUNTER20_MHPMCOUNTER20_MSB 63u +#define MINION_CSR_MHPMCOUNTER20_MHPMCOUNTER20_LSB 0u +#define MINION_CSR_MHPMCOUNTER20_MHPMCOUNTER20_WIDTH 64u +#define MINION_CSR_MHPMCOUNTER20_MHPMCOUNTER20_READ_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER20_MHPMCOUNTER20_WRITE_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER20_MHPMCOUNTER20_RESET 0x0000000000000000ull +#define MINION_CSR_MHPMCOUNTER20_MHPMCOUNTER20_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER20_MHPMCOUNTER20_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMCOUNTER20_MHPMCOUNTER20_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMCOUNTER20_MHPMCOUNTER20_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mhpmcounter21 */ +#define MINION_CSR_MHPMCOUNTER21_ADDRESS 0x000058A8ul +#define MINION_CSR_MHPMCOUNTER21_BYTE_ADDRESS 0x000058A8ul +#define MINION_CSR_MHPMCOUNTER21_OFFSET 0x000058A8ul +#define MINION_CSR_MHPMCOUNTER21_BYTE_OFFSET 0x000058A8ul +#define MINION_CSR_MHPMCOUNTER21_SIZE 0x00000008ul +#define MINION_CSR_MHPMCOUNTER21_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MHPMCOUNTER21_READ_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER21_WRITE_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER21_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MHPMCOUNTER21_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER21_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER21_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MHPMCOUNTER21.mhpmcounter21 */ +#define MINION_CSR_MHPMCOUNTER21_MHPMCOUNTER21_MSB 63u +#define MINION_CSR_MHPMCOUNTER21_MHPMCOUNTER21_LSB 0u +#define MINION_CSR_MHPMCOUNTER21_MHPMCOUNTER21_WIDTH 64u +#define MINION_CSR_MHPMCOUNTER21_MHPMCOUNTER21_READ_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER21_MHPMCOUNTER21_WRITE_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER21_MHPMCOUNTER21_RESET 0x0000000000000000ull +#define MINION_CSR_MHPMCOUNTER21_MHPMCOUNTER21_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER21_MHPMCOUNTER21_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMCOUNTER21_MHPMCOUNTER21_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMCOUNTER21_MHPMCOUNTER21_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mhpmcounter22 */ +#define MINION_CSR_MHPMCOUNTER22_ADDRESS 0x000058B0ul +#define MINION_CSR_MHPMCOUNTER22_BYTE_ADDRESS 0x000058B0ul +#define MINION_CSR_MHPMCOUNTER22_OFFSET 0x000058B0ul +#define MINION_CSR_MHPMCOUNTER22_BYTE_OFFSET 0x000058B0ul +#define MINION_CSR_MHPMCOUNTER22_SIZE 0x00000008ul +#define MINION_CSR_MHPMCOUNTER22_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MHPMCOUNTER22_READ_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER22_WRITE_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER22_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MHPMCOUNTER22_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER22_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER22_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MHPMCOUNTER22.mhpmcounter22 */ +#define MINION_CSR_MHPMCOUNTER22_MHPMCOUNTER22_MSB 63u +#define MINION_CSR_MHPMCOUNTER22_MHPMCOUNTER22_LSB 0u +#define MINION_CSR_MHPMCOUNTER22_MHPMCOUNTER22_WIDTH 64u +#define MINION_CSR_MHPMCOUNTER22_MHPMCOUNTER22_READ_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER22_MHPMCOUNTER22_WRITE_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER22_MHPMCOUNTER22_RESET 0x0000000000000000ull +#define MINION_CSR_MHPMCOUNTER22_MHPMCOUNTER22_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER22_MHPMCOUNTER22_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMCOUNTER22_MHPMCOUNTER22_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMCOUNTER22_MHPMCOUNTER22_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mhpmcounter23 */ +#define MINION_CSR_MHPMCOUNTER23_ADDRESS 0x000058B8ul +#define MINION_CSR_MHPMCOUNTER23_BYTE_ADDRESS 0x000058B8ul +#define MINION_CSR_MHPMCOUNTER23_OFFSET 0x000058B8ul +#define MINION_CSR_MHPMCOUNTER23_BYTE_OFFSET 0x000058B8ul +#define MINION_CSR_MHPMCOUNTER23_SIZE 0x00000008ul +#define MINION_CSR_MHPMCOUNTER23_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MHPMCOUNTER23_READ_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER23_WRITE_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER23_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MHPMCOUNTER23_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER23_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER23_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MHPMCOUNTER23.mhpmcounter23 */ +#define MINION_CSR_MHPMCOUNTER23_MHPMCOUNTER23_MSB 63u +#define MINION_CSR_MHPMCOUNTER23_MHPMCOUNTER23_LSB 0u +#define MINION_CSR_MHPMCOUNTER23_MHPMCOUNTER23_WIDTH 64u +#define MINION_CSR_MHPMCOUNTER23_MHPMCOUNTER23_READ_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER23_MHPMCOUNTER23_WRITE_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER23_MHPMCOUNTER23_RESET 0x0000000000000000ull +#define MINION_CSR_MHPMCOUNTER23_MHPMCOUNTER23_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER23_MHPMCOUNTER23_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMCOUNTER23_MHPMCOUNTER23_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMCOUNTER23_MHPMCOUNTER23_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mhpmcounter24 */ +#define MINION_CSR_MHPMCOUNTER24_ADDRESS 0x000058C0ul +#define MINION_CSR_MHPMCOUNTER24_BYTE_ADDRESS 0x000058C0ul +#define MINION_CSR_MHPMCOUNTER24_OFFSET 0x000058C0ul +#define MINION_CSR_MHPMCOUNTER24_BYTE_OFFSET 0x000058C0ul +#define MINION_CSR_MHPMCOUNTER24_SIZE 0x00000008ul +#define MINION_CSR_MHPMCOUNTER24_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MHPMCOUNTER24_READ_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER24_WRITE_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER24_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MHPMCOUNTER24_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER24_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER24_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MHPMCOUNTER24.mhpmcounter24 */ +#define MINION_CSR_MHPMCOUNTER24_MHPMCOUNTER24_MSB 63u +#define MINION_CSR_MHPMCOUNTER24_MHPMCOUNTER24_LSB 0u +#define MINION_CSR_MHPMCOUNTER24_MHPMCOUNTER24_WIDTH 64u +#define MINION_CSR_MHPMCOUNTER24_MHPMCOUNTER24_READ_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER24_MHPMCOUNTER24_WRITE_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER24_MHPMCOUNTER24_RESET 0x0000000000000000ull +#define MINION_CSR_MHPMCOUNTER24_MHPMCOUNTER24_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER24_MHPMCOUNTER24_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMCOUNTER24_MHPMCOUNTER24_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMCOUNTER24_MHPMCOUNTER24_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mhpmcounter25 */ +#define MINION_CSR_MHPMCOUNTER25_ADDRESS 0x000058C8ul +#define MINION_CSR_MHPMCOUNTER25_BYTE_ADDRESS 0x000058C8ul +#define MINION_CSR_MHPMCOUNTER25_OFFSET 0x000058C8ul +#define MINION_CSR_MHPMCOUNTER25_BYTE_OFFSET 0x000058C8ul +#define MINION_CSR_MHPMCOUNTER25_SIZE 0x00000008ul +#define MINION_CSR_MHPMCOUNTER25_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MHPMCOUNTER25_READ_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER25_WRITE_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER25_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MHPMCOUNTER25_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER25_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER25_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MHPMCOUNTER25.mhpmcounter25 */ +#define MINION_CSR_MHPMCOUNTER25_MHPMCOUNTER25_MSB 63u +#define MINION_CSR_MHPMCOUNTER25_MHPMCOUNTER25_LSB 0u +#define MINION_CSR_MHPMCOUNTER25_MHPMCOUNTER25_WIDTH 64u +#define MINION_CSR_MHPMCOUNTER25_MHPMCOUNTER25_READ_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER25_MHPMCOUNTER25_WRITE_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER25_MHPMCOUNTER25_RESET 0x0000000000000000ull +#define MINION_CSR_MHPMCOUNTER25_MHPMCOUNTER25_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER25_MHPMCOUNTER25_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMCOUNTER25_MHPMCOUNTER25_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMCOUNTER25_MHPMCOUNTER25_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mhpmcounter26 */ +#define MINION_CSR_MHPMCOUNTER26_ADDRESS 0x000058D0ul +#define MINION_CSR_MHPMCOUNTER26_BYTE_ADDRESS 0x000058D0ul +#define MINION_CSR_MHPMCOUNTER26_OFFSET 0x000058D0ul +#define MINION_CSR_MHPMCOUNTER26_BYTE_OFFSET 0x000058D0ul +#define MINION_CSR_MHPMCOUNTER26_SIZE 0x00000008ul +#define MINION_CSR_MHPMCOUNTER26_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MHPMCOUNTER26_READ_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER26_WRITE_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER26_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MHPMCOUNTER26_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER26_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER26_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MHPMCOUNTER26.mhpmcounter26 */ +#define MINION_CSR_MHPMCOUNTER26_MHPMCOUNTER26_MSB 63u +#define MINION_CSR_MHPMCOUNTER26_MHPMCOUNTER26_LSB 0u +#define MINION_CSR_MHPMCOUNTER26_MHPMCOUNTER26_WIDTH 64u +#define MINION_CSR_MHPMCOUNTER26_MHPMCOUNTER26_READ_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER26_MHPMCOUNTER26_WRITE_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER26_MHPMCOUNTER26_RESET 0x0000000000000000ull +#define MINION_CSR_MHPMCOUNTER26_MHPMCOUNTER26_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER26_MHPMCOUNTER26_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMCOUNTER26_MHPMCOUNTER26_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMCOUNTER26_MHPMCOUNTER26_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mhpmcounter27 */ +#define MINION_CSR_MHPMCOUNTER27_ADDRESS 0x000058D8ul +#define MINION_CSR_MHPMCOUNTER27_BYTE_ADDRESS 0x000058D8ul +#define MINION_CSR_MHPMCOUNTER27_OFFSET 0x000058D8ul +#define MINION_CSR_MHPMCOUNTER27_BYTE_OFFSET 0x000058D8ul +#define MINION_CSR_MHPMCOUNTER27_SIZE 0x00000008ul +#define MINION_CSR_MHPMCOUNTER27_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MHPMCOUNTER27_READ_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER27_WRITE_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER27_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MHPMCOUNTER27_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER27_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER27_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MHPMCOUNTER27.mhpmcounter27 */ +#define MINION_CSR_MHPMCOUNTER27_MHPMCOUNTER27_MSB 63u +#define MINION_CSR_MHPMCOUNTER27_MHPMCOUNTER27_LSB 0u +#define MINION_CSR_MHPMCOUNTER27_MHPMCOUNTER27_WIDTH 64u +#define MINION_CSR_MHPMCOUNTER27_MHPMCOUNTER27_READ_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER27_MHPMCOUNTER27_WRITE_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER27_MHPMCOUNTER27_RESET 0x0000000000000000ull +#define MINION_CSR_MHPMCOUNTER27_MHPMCOUNTER27_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER27_MHPMCOUNTER27_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMCOUNTER27_MHPMCOUNTER27_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMCOUNTER27_MHPMCOUNTER27_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mhpmcounter28 */ +#define MINION_CSR_MHPMCOUNTER28_ADDRESS 0x000058E0ul +#define MINION_CSR_MHPMCOUNTER28_BYTE_ADDRESS 0x000058E0ul +#define MINION_CSR_MHPMCOUNTER28_OFFSET 0x000058E0ul +#define MINION_CSR_MHPMCOUNTER28_BYTE_OFFSET 0x000058E0ul +#define MINION_CSR_MHPMCOUNTER28_SIZE 0x00000008ul +#define MINION_CSR_MHPMCOUNTER28_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MHPMCOUNTER28_READ_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER28_WRITE_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER28_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MHPMCOUNTER28_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER28_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER28_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MHPMCOUNTER28.mhpmcounter28 */ +#define MINION_CSR_MHPMCOUNTER28_MHPMCOUNTER28_MSB 63u +#define MINION_CSR_MHPMCOUNTER28_MHPMCOUNTER28_LSB 0u +#define MINION_CSR_MHPMCOUNTER28_MHPMCOUNTER28_WIDTH 64u +#define MINION_CSR_MHPMCOUNTER28_MHPMCOUNTER28_READ_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER28_MHPMCOUNTER28_WRITE_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER28_MHPMCOUNTER28_RESET 0x0000000000000000ull +#define MINION_CSR_MHPMCOUNTER28_MHPMCOUNTER28_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER28_MHPMCOUNTER28_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMCOUNTER28_MHPMCOUNTER28_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMCOUNTER28_MHPMCOUNTER28_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mhpmcounter29 */ +#define MINION_CSR_MHPMCOUNTER29_ADDRESS 0x000058E8ul +#define MINION_CSR_MHPMCOUNTER29_BYTE_ADDRESS 0x000058E8ul +#define MINION_CSR_MHPMCOUNTER29_OFFSET 0x000058E8ul +#define MINION_CSR_MHPMCOUNTER29_BYTE_OFFSET 0x000058E8ul +#define MINION_CSR_MHPMCOUNTER29_SIZE 0x00000008ul +#define MINION_CSR_MHPMCOUNTER29_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MHPMCOUNTER29_READ_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER29_WRITE_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER29_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MHPMCOUNTER29_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER29_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER29_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MHPMCOUNTER29.mhpmcounter29 */ +#define MINION_CSR_MHPMCOUNTER29_MHPMCOUNTER29_MSB 63u +#define MINION_CSR_MHPMCOUNTER29_MHPMCOUNTER29_LSB 0u +#define MINION_CSR_MHPMCOUNTER29_MHPMCOUNTER29_WIDTH 64u +#define MINION_CSR_MHPMCOUNTER29_MHPMCOUNTER29_READ_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER29_MHPMCOUNTER29_WRITE_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER29_MHPMCOUNTER29_RESET 0x0000000000000000ull +#define MINION_CSR_MHPMCOUNTER29_MHPMCOUNTER29_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER29_MHPMCOUNTER29_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMCOUNTER29_MHPMCOUNTER29_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMCOUNTER29_MHPMCOUNTER29_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mhpmcounter30 */ +#define MINION_CSR_MHPMCOUNTER30_ADDRESS 0x000058F0ul +#define MINION_CSR_MHPMCOUNTER30_BYTE_ADDRESS 0x000058F0ul +#define MINION_CSR_MHPMCOUNTER30_OFFSET 0x000058F0ul +#define MINION_CSR_MHPMCOUNTER30_BYTE_OFFSET 0x000058F0ul +#define MINION_CSR_MHPMCOUNTER30_SIZE 0x00000008ul +#define MINION_CSR_MHPMCOUNTER30_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MHPMCOUNTER30_READ_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER30_WRITE_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER30_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MHPMCOUNTER30_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER30_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER30_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MHPMCOUNTER30.mhpmcounter30 */ +#define MINION_CSR_MHPMCOUNTER30_MHPMCOUNTER30_MSB 63u +#define MINION_CSR_MHPMCOUNTER30_MHPMCOUNTER30_LSB 0u +#define MINION_CSR_MHPMCOUNTER30_MHPMCOUNTER30_WIDTH 64u +#define MINION_CSR_MHPMCOUNTER30_MHPMCOUNTER30_READ_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER30_MHPMCOUNTER30_WRITE_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER30_MHPMCOUNTER30_RESET 0x0000000000000000ull +#define MINION_CSR_MHPMCOUNTER30_MHPMCOUNTER30_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER30_MHPMCOUNTER30_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMCOUNTER30_MHPMCOUNTER30_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMCOUNTER30_MHPMCOUNTER30_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mhpmcounter31 */ +#define MINION_CSR_MHPMCOUNTER31_ADDRESS 0x000058F8ul +#define MINION_CSR_MHPMCOUNTER31_BYTE_ADDRESS 0x000058F8ul +#define MINION_CSR_MHPMCOUNTER31_OFFSET 0x000058F8ul +#define MINION_CSR_MHPMCOUNTER31_BYTE_OFFSET 0x000058F8ul +#define MINION_CSR_MHPMCOUNTER31_SIZE 0x00000008ul +#define MINION_CSR_MHPMCOUNTER31_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MHPMCOUNTER31_READ_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER31_WRITE_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER31_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MHPMCOUNTER31_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER31_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER31_WRITE_MASK 0xFFFFFFFFFFFFFFFFull + +/* Field: MINION_CSR_MHPMCOUNTER31.mhpmcounter31 */ +#define MINION_CSR_MHPMCOUNTER31_MHPMCOUNTER31_MSB 63u +#define MINION_CSR_MHPMCOUNTER31_MHPMCOUNTER31_LSB 0u +#define MINION_CSR_MHPMCOUNTER31_MHPMCOUNTER31_WIDTH 64u +#define MINION_CSR_MHPMCOUNTER31_MHPMCOUNTER31_READ_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER31_MHPMCOUNTER31_WRITE_ACCESS 1u +#define MINION_CSR_MHPMCOUNTER31_MHPMCOUNTER31_RESET 0x0000000000000000ull +#define MINION_CSR_MHPMCOUNTER31_MHPMCOUNTER31_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHPMCOUNTER31_MHPMCOUNTER31_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMCOUNTER31_MHPMCOUNTER31_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHPMCOUNTER31_MHPMCOUNTER31_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.cycle */ +#define MINION_CSR_CYCLE_ADDRESS 0x00006000ul +#define MINION_CSR_CYCLE_BYTE_ADDRESS 0x00006000ul +#define MINION_CSR_CYCLE_OFFSET 0x00006000ul +#define MINION_CSR_CYCLE_BYTE_OFFSET 0x00006000ul +#define MINION_CSR_CYCLE_SIZE 0x00000008ul +#define MINION_CSR_CYCLE_BYTE_SIZE 0x00000008ul +#define MINION_CSR_CYCLE_READ_ACCESS 1u +#define MINION_CSR_CYCLE_WRITE_ACCESS 0u +#define MINION_CSR_CYCLE_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_CYCLE_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_CYCLE_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_CYCLE_WRITE_MASK 0x0000000000000000ull + +/* Field: MINION_CSR_CYCLE.cycle */ +#define MINION_CSR_CYCLE_CYCLE_MSB 63u +#define MINION_CSR_CYCLE_CYCLE_LSB 0u +#define MINION_CSR_CYCLE_CYCLE_WIDTH 64u +#define MINION_CSR_CYCLE_CYCLE_READ_ACCESS 1u +#define MINION_CSR_CYCLE_CYCLE_WRITE_ACCESS 0u +#define MINION_CSR_CYCLE_CYCLE_RESET 0x0000000000000000ull +#define MINION_CSR_CYCLE_CYCLE_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_CYCLE_CYCLE_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_CYCLE_CYCLE_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_CYCLE_CYCLE_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.time */ +#define MINION_CSR_TIME_ADDRESS 0x00006008ul +#define MINION_CSR_TIME_BYTE_ADDRESS 0x00006008ul +#define MINION_CSR_TIME_OFFSET 0x00006008ul +#define MINION_CSR_TIME_BYTE_OFFSET 0x00006008ul +#define MINION_CSR_TIME_SIZE 0x00000008ul +#define MINION_CSR_TIME_BYTE_SIZE 0x00000008ul +#define MINION_CSR_TIME_READ_ACCESS 1u +#define MINION_CSR_TIME_WRITE_ACCESS 0u +#define MINION_CSR_TIME_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_TIME_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_TIME_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_TIME_WRITE_MASK 0x0000000000000000ull + +/* Field: MINION_CSR_TIME.time */ +#define MINION_CSR_TIME_TIME_MSB 63u +#define MINION_CSR_TIME_TIME_LSB 0u +#define MINION_CSR_TIME_TIME_WIDTH 64u +#define MINION_CSR_TIME_TIME_READ_ACCESS 1u +#define MINION_CSR_TIME_TIME_WRITE_ACCESS 0u +#define MINION_CSR_TIME_TIME_RESET 0x0000000000000000ull +#define MINION_CSR_TIME_TIME_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_TIME_TIME_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_TIME_TIME_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_TIME_TIME_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.instret */ +#define MINION_CSR_INSTRET_ADDRESS 0x00006010ul +#define MINION_CSR_INSTRET_BYTE_ADDRESS 0x00006010ul +#define MINION_CSR_INSTRET_OFFSET 0x00006010ul +#define MINION_CSR_INSTRET_BYTE_OFFSET 0x00006010ul +#define MINION_CSR_INSTRET_SIZE 0x00000008ul +#define MINION_CSR_INSTRET_BYTE_SIZE 0x00000008ul +#define MINION_CSR_INSTRET_READ_ACCESS 1u +#define MINION_CSR_INSTRET_WRITE_ACCESS 0u +#define MINION_CSR_INSTRET_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_INSTRET_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_INSTRET_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_INSTRET_WRITE_MASK 0x0000000000000000ull + +/* Field: MINION_CSR_INSTRET.instret */ +#define MINION_CSR_INSTRET_INSTRET_MSB 63u +#define MINION_CSR_INSTRET_INSTRET_LSB 0u +#define MINION_CSR_INSTRET_INSTRET_WIDTH 64u +#define MINION_CSR_INSTRET_INSTRET_READ_ACCESS 1u +#define MINION_CSR_INSTRET_INSTRET_WRITE_ACCESS 0u +#define MINION_CSR_INSTRET_INSTRET_RESET 0x0000000000000000ull +#define MINION_CSR_INSTRET_INSTRET_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_INSTRET_INSTRET_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_INSTRET_INSTRET_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_INSTRET_INSTRET_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.hpmcounter3 */ +#define MINION_CSR_HPMCOUNTER3_ADDRESS 0x00006018ul +#define MINION_CSR_HPMCOUNTER3_BYTE_ADDRESS 0x00006018ul +#define MINION_CSR_HPMCOUNTER3_OFFSET 0x00006018ul +#define MINION_CSR_HPMCOUNTER3_BYTE_OFFSET 0x00006018ul +#define MINION_CSR_HPMCOUNTER3_SIZE 0x00000008ul +#define MINION_CSR_HPMCOUNTER3_BYTE_SIZE 0x00000008ul +#define MINION_CSR_HPMCOUNTER3_READ_ACCESS 1u +#define MINION_CSR_HPMCOUNTER3_WRITE_ACCESS 0u +#define MINION_CSR_HPMCOUNTER3_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_HPMCOUNTER3_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER3_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER3_WRITE_MASK 0x0000000000000000ull + +/* Field: MINION_CSR_HPMCOUNTER3.hpmcounter3 */ +#define MINION_CSR_HPMCOUNTER3_HPMCOUNTER3_MSB 63u +#define MINION_CSR_HPMCOUNTER3_HPMCOUNTER3_LSB 0u +#define MINION_CSR_HPMCOUNTER3_HPMCOUNTER3_WIDTH 64u +#define MINION_CSR_HPMCOUNTER3_HPMCOUNTER3_READ_ACCESS 1u +#define MINION_CSR_HPMCOUNTER3_HPMCOUNTER3_WRITE_ACCESS 0u +#define MINION_CSR_HPMCOUNTER3_HPMCOUNTER3_RESET 0x0000000000000000ull +#define MINION_CSR_HPMCOUNTER3_HPMCOUNTER3_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER3_HPMCOUNTER3_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_HPMCOUNTER3_HPMCOUNTER3_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_HPMCOUNTER3_HPMCOUNTER3_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.hpmcounter4 */ +#define MINION_CSR_HPMCOUNTER4_ADDRESS 0x00006020ul +#define MINION_CSR_HPMCOUNTER4_BYTE_ADDRESS 0x00006020ul +#define MINION_CSR_HPMCOUNTER4_OFFSET 0x00006020ul +#define MINION_CSR_HPMCOUNTER4_BYTE_OFFSET 0x00006020ul +#define MINION_CSR_HPMCOUNTER4_SIZE 0x00000008ul +#define MINION_CSR_HPMCOUNTER4_BYTE_SIZE 0x00000008ul +#define MINION_CSR_HPMCOUNTER4_READ_ACCESS 1u +#define MINION_CSR_HPMCOUNTER4_WRITE_ACCESS 0u +#define MINION_CSR_HPMCOUNTER4_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_HPMCOUNTER4_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER4_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER4_WRITE_MASK 0x0000000000000000ull + +/* Field: MINION_CSR_HPMCOUNTER4.hpmcounter4 */ +#define MINION_CSR_HPMCOUNTER4_HPMCOUNTER4_MSB 63u +#define MINION_CSR_HPMCOUNTER4_HPMCOUNTER4_LSB 0u +#define MINION_CSR_HPMCOUNTER4_HPMCOUNTER4_WIDTH 64u +#define MINION_CSR_HPMCOUNTER4_HPMCOUNTER4_READ_ACCESS 1u +#define MINION_CSR_HPMCOUNTER4_HPMCOUNTER4_WRITE_ACCESS 0u +#define MINION_CSR_HPMCOUNTER4_HPMCOUNTER4_RESET 0x0000000000000000ull +#define MINION_CSR_HPMCOUNTER4_HPMCOUNTER4_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER4_HPMCOUNTER4_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_HPMCOUNTER4_HPMCOUNTER4_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_HPMCOUNTER4_HPMCOUNTER4_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.hpmcounter5 */ +#define MINION_CSR_HPMCOUNTER5_ADDRESS 0x00006028ul +#define MINION_CSR_HPMCOUNTER5_BYTE_ADDRESS 0x00006028ul +#define MINION_CSR_HPMCOUNTER5_OFFSET 0x00006028ul +#define MINION_CSR_HPMCOUNTER5_BYTE_OFFSET 0x00006028ul +#define MINION_CSR_HPMCOUNTER5_SIZE 0x00000008ul +#define MINION_CSR_HPMCOUNTER5_BYTE_SIZE 0x00000008ul +#define MINION_CSR_HPMCOUNTER5_READ_ACCESS 1u +#define MINION_CSR_HPMCOUNTER5_WRITE_ACCESS 0u +#define MINION_CSR_HPMCOUNTER5_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_HPMCOUNTER5_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER5_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER5_WRITE_MASK 0x0000000000000000ull + +/* Field: MINION_CSR_HPMCOUNTER5.hpmcounter5 */ +#define MINION_CSR_HPMCOUNTER5_HPMCOUNTER5_MSB 63u +#define MINION_CSR_HPMCOUNTER5_HPMCOUNTER5_LSB 0u +#define MINION_CSR_HPMCOUNTER5_HPMCOUNTER5_WIDTH 64u +#define MINION_CSR_HPMCOUNTER5_HPMCOUNTER5_READ_ACCESS 1u +#define MINION_CSR_HPMCOUNTER5_HPMCOUNTER5_WRITE_ACCESS 0u +#define MINION_CSR_HPMCOUNTER5_HPMCOUNTER5_RESET 0x0000000000000000ull +#define MINION_CSR_HPMCOUNTER5_HPMCOUNTER5_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER5_HPMCOUNTER5_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_HPMCOUNTER5_HPMCOUNTER5_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_HPMCOUNTER5_HPMCOUNTER5_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.hpmcounter6 */ +#define MINION_CSR_HPMCOUNTER6_ADDRESS 0x00006030ul +#define MINION_CSR_HPMCOUNTER6_BYTE_ADDRESS 0x00006030ul +#define MINION_CSR_HPMCOUNTER6_OFFSET 0x00006030ul +#define MINION_CSR_HPMCOUNTER6_BYTE_OFFSET 0x00006030ul +#define MINION_CSR_HPMCOUNTER6_SIZE 0x00000008ul +#define MINION_CSR_HPMCOUNTER6_BYTE_SIZE 0x00000008ul +#define MINION_CSR_HPMCOUNTER6_READ_ACCESS 1u +#define MINION_CSR_HPMCOUNTER6_WRITE_ACCESS 0u +#define MINION_CSR_HPMCOUNTER6_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_HPMCOUNTER6_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER6_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER6_WRITE_MASK 0x0000000000000000ull + +/* Field: MINION_CSR_HPMCOUNTER6.hpmcounter6 */ +#define MINION_CSR_HPMCOUNTER6_HPMCOUNTER6_MSB 63u +#define MINION_CSR_HPMCOUNTER6_HPMCOUNTER6_LSB 0u +#define MINION_CSR_HPMCOUNTER6_HPMCOUNTER6_WIDTH 64u +#define MINION_CSR_HPMCOUNTER6_HPMCOUNTER6_READ_ACCESS 1u +#define MINION_CSR_HPMCOUNTER6_HPMCOUNTER6_WRITE_ACCESS 0u +#define MINION_CSR_HPMCOUNTER6_HPMCOUNTER6_RESET 0x0000000000000000ull +#define MINION_CSR_HPMCOUNTER6_HPMCOUNTER6_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER6_HPMCOUNTER6_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_HPMCOUNTER6_HPMCOUNTER6_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_HPMCOUNTER6_HPMCOUNTER6_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.hpmcounter7 */ +#define MINION_CSR_HPMCOUNTER7_ADDRESS 0x00006038ul +#define MINION_CSR_HPMCOUNTER7_BYTE_ADDRESS 0x00006038ul +#define MINION_CSR_HPMCOUNTER7_OFFSET 0x00006038ul +#define MINION_CSR_HPMCOUNTER7_BYTE_OFFSET 0x00006038ul +#define MINION_CSR_HPMCOUNTER7_SIZE 0x00000008ul +#define MINION_CSR_HPMCOUNTER7_BYTE_SIZE 0x00000008ul +#define MINION_CSR_HPMCOUNTER7_READ_ACCESS 1u +#define MINION_CSR_HPMCOUNTER7_WRITE_ACCESS 0u +#define MINION_CSR_HPMCOUNTER7_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_HPMCOUNTER7_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER7_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER7_WRITE_MASK 0x0000000000000000ull + +/* Field: MINION_CSR_HPMCOUNTER7.hpmcounter7 */ +#define MINION_CSR_HPMCOUNTER7_HPMCOUNTER7_MSB 63u +#define MINION_CSR_HPMCOUNTER7_HPMCOUNTER7_LSB 0u +#define MINION_CSR_HPMCOUNTER7_HPMCOUNTER7_WIDTH 64u +#define MINION_CSR_HPMCOUNTER7_HPMCOUNTER7_READ_ACCESS 1u +#define MINION_CSR_HPMCOUNTER7_HPMCOUNTER7_WRITE_ACCESS 0u +#define MINION_CSR_HPMCOUNTER7_HPMCOUNTER7_RESET 0x0000000000000000ull +#define MINION_CSR_HPMCOUNTER7_HPMCOUNTER7_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER7_HPMCOUNTER7_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_HPMCOUNTER7_HPMCOUNTER7_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_HPMCOUNTER7_HPMCOUNTER7_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.hpmcounter8 */ +#define MINION_CSR_HPMCOUNTER8_ADDRESS 0x00006040ul +#define MINION_CSR_HPMCOUNTER8_BYTE_ADDRESS 0x00006040ul +#define MINION_CSR_HPMCOUNTER8_OFFSET 0x00006040ul +#define MINION_CSR_HPMCOUNTER8_BYTE_OFFSET 0x00006040ul +#define MINION_CSR_HPMCOUNTER8_SIZE 0x00000008ul +#define MINION_CSR_HPMCOUNTER8_BYTE_SIZE 0x00000008ul +#define MINION_CSR_HPMCOUNTER8_READ_ACCESS 1u +#define MINION_CSR_HPMCOUNTER8_WRITE_ACCESS 0u +#define MINION_CSR_HPMCOUNTER8_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_HPMCOUNTER8_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER8_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER8_WRITE_MASK 0x0000000000000000ull + +/* Field: MINION_CSR_HPMCOUNTER8.hpmcounter8 */ +#define MINION_CSR_HPMCOUNTER8_HPMCOUNTER8_MSB 63u +#define MINION_CSR_HPMCOUNTER8_HPMCOUNTER8_LSB 0u +#define MINION_CSR_HPMCOUNTER8_HPMCOUNTER8_WIDTH 64u +#define MINION_CSR_HPMCOUNTER8_HPMCOUNTER8_READ_ACCESS 1u +#define MINION_CSR_HPMCOUNTER8_HPMCOUNTER8_WRITE_ACCESS 0u +#define MINION_CSR_HPMCOUNTER8_HPMCOUNTER8_RESET 0x0000000000000000ull +#define MINION_CSR_HPMCOUNTER8_HPMCOUNTER8_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER8_HPMCOUNTER8_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_HPMCOUNTER8_HPMCOUNTER8_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_HPMCOUNTER8_HPMCOUNTER8_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.hpmcounter9 */ +#define MINION_CSR_HPMCOUNTER9_ADDRESS 0x00006048ul +#define MINION_CSR_HPMCOUNTER9_BYTE_ADDRESS 0x00006048ul +#define MINION_CSR_HPMCOUNTER9_OFFSET 0x00006048ul +#define MINION_CSR_HPMCOUNTER9_BYTE_OFFSET 0x00006048ul +#define MINION_CSR_HPMCOUNTER9_SIZE 0x00000008ul +#define MINION_CSR_HPMCOUNTER9_BYTE_SIZE 0x00000008ul +#define MINION_CSR_HPMCOUNTER9_READ_ACCESS 1u +#define MINION_CSR_HPMCOUNTER9_WRITE_ACCESS 0u +#define MINION_CSR_HPMCOUNTER9_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_HPMCOUNTER9_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER9_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER9_WRITE_MASK 0x0000000000000000ull + +/* Field: MINION_CSR_HPMCOUNTER9.hpmcounter9 */ +#define MINION_CSR_HPMCOUNTER9_HPMCOUNTER9_MSB 63u +#define MINION_CSR_HPMCOUNTER9_HPMCOUNTER9_LSB 0u +#define MINION_CSR_HPMCOUNTER9_HPMCOUNTER9_WIDTH 64u +#define MINION_CSR_HPMCOUNTER9_HPMCOUNTER9_READ_ACCESS 1u +#define MINION_CSR_HPMCOUNTER9_HPMCOUNTER9_WRITE_ACCESS 0u +#define MINION_CSR_HPMCOUNTER9_HPMCOUNTER9_RESET 0x0000000000000000ull +#define MINION_CSR_HPMCOUNTER9_HPMCOUNTER9_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER9_HPMCOUNTER9_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_HPMCOUNTER9_HPMCOUNTER9_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_HPMCOUNTER9_HPMCOUNTER9_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.hpmcounter10 */ +#define MINION_CSR_HPMCOUNTER10_ADDRESS 0x00006050ul +#define MINION_CSR_HPMCOUNTER10_BYTE_ADDRESS 0x00006050ul +#define MINION_CSR_HPMCOUNTER10_OFFSET 0x00006050ul +#define MINION_CSR_HPMCOUNTER10_BYTE_OFFSET 0x00006050ul +#define MINION_CSR_HPMCOUNTER10_SIZE 0x00000008ul +#define MINION_CSR_HPMCOUNTER10_BYTE_SIZE 0x00000008ul +#define MINION_CSR_HPMCOUNTER10_READ_ACCESS 1u +#define MINION_CSR_HPMCOUNTER10_WRITE_ACCESS 0u +#define MINION_CSR_HPMCOUNTER10_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_HPMCOUNTER10_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER10_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER10_WRITE_MASK 0x0000000000000000ull + +/* Field: MINION_CSR_HPMCOUNTER10.hpmcounter10 */ +#define MINION_CSR_HPMCOUNTER10_HPMCOUNTER10_MSB 63u +#define MINION_CSR_HPMCOUNTER10_HPMCOUNTER10_LSB 0u +#define MINION_CSR_HPMCOUNTER10_HPMCOUNTER10_WIDTH 64u +#define MINION_CSR_HPMCOUNTER10_HPMCOUNTER10_READ_ACCESS 1u +#define MINION_CSR_HPMCOUNTER10_HPMCOUNTER10_WRITE_ACCESS 0u +#define MINION_CSR_HPMCOUNTER10_HPMCOUNTER10_RESET 0x0000000000000000ull +#define MINION_CSR_HPMCOUNTER10_HPMCOUNTER10_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER10_HPMCOUNTER10_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_HPMCOUNTER10_HPMCOUNTER10_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_HPMCOUNTER10_HPMCOUNTER10_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.hpmcounter11 */ +#define MINION_CSR_HPMCOUNTER11_ADDRESS 0x00006058ul +#define MINION_CSR_HPMCOUNTER11_BYTE_ADDRESS 0x00006058ul +#define MINION_CSR_HPMCOUNTER11_OFFSET 0x00006058ul +#define MINION_CSR_HPMCOUNTER11_BYTE_OFFSET 0x00006058ul +#define MINION_CSR_HPMCOUNTER11_SIZE 0x00000008ul +#define MINION_CSR_HPMCOUNTER11_BYTE_SIZE 0x00000008ul +#define MINION_CSR_HPMCOUNTER11_READ_ACCESS 1u +#define MINION_CSR_HPMCOUNTER11_WRITE_ACCESS 0u +#define MINION_CSR_HPMCOUNTER11_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_HPMCOUNTER11_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER11_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER11_WRITE_MASK 0x0000000000000000ull + +/* Field: MINION_CSR_HPMCOUNTER11.hpmcounter11 */ +#define MINION_CSR_HPMCOUNTER11_HPMCOUNTER11_MSB 63u +#define MINION_CSR_HPMCOUNTER11_HPMCOUNTER11_LSB 0u +#define MINION_CSR_HPMCOUNTER11_HPMCOUNTER11_WIDTH 64u +#define MINION_CSR_HPMCOUNTER11_HPMCOUNTER11_READ_ACCESS 1u +#define MINION_CSR_HPMCOUNTER11_HPMCOUNTER11_WRITE_ACCESS 0u +#define MINION_CSR_HPMCOUNTER11_HPMCOUNTER11_RESET 0x0000000000000000ull +#define MINION_CSR_HPMCOUNTER11_HPMCOUNTER11_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER11_HPMCOUNTER11_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_HPMCOUNTER11_HPMCOUNTER11_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_HPMCOUNTER11_HPMCOUNTER11_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.hpmcounter12 */ +#define MINION_CSR_HPMCOUNTER12_ADDRESS 0x00006060ul +#define MINION_CSR_HPMCOUNTER12_BYTE_ADDRESS 0x00006060ul +#define MINION_CSR_HPMCOUNTER12_OFFSET 0x00006060ul +#define MINION_CSR_HPMCOUNTER12_BYTE_OFFSET 0x00006060ul +#define MINION_CSR_HPMCOUNTER12_SIZE 0x00000008ul +#define MINION_CSR_HPMCOUNTER12_BYTE_SIZE 0x00000008ul +#define MINION_CSR_HPMCOUNTER12_READ_ACCESS 1u +#define MINION_CSR_HPMCOUNTER12_WRITE_ACCESS 0u +#define MINION_CSR_HPMCOUNTER12_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_HPMCOUNTER12_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER12_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER12_WRITE_MASK 0x0000000000000000ull + +/* Field: MINION_CSR_HPMCOUNTER12.hpmcounter12 */ +#define MINION_CSR_HPMCOUNTER12_HPMCOUNTER12_MSB 63u +#define MINION_CSR_HPMCOUNTER12_HPMCOUNTER12_LSB 0u +#define MINION_CSR_HPMCOUNTER12_HPMCOUNTER12_WIDTH 64u +#define MINION_CSR_HPMCOUNTER12_HPMCOUNTER12_READ_ACCESS 1u +#define MINION_CSR_HPMCOUNTER12_HPMCOUNTER12_WRITE_ACCESS 0u +#define MINION_CSR_HPMCOUNTER12_HPMCOUNTER12_RESET 0x0000000000000000ull +#define MINION_CSR_HPMCOUNTER12_HPMCOUNTER12_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER12_HPMCOUNTER12_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_HPMCOUNTER12_HPMCOUNTER12_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_HPMCOUNTER12_HPMCOUNTER12_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.hpmcounter13 */ +#define MINION_CSR_HPMCOUNTER13_ADDRESS 0x00006068ul +#define MINION_CSR_HPMCOUNTER13_BYTE_ADDRESS 0x00006068ul +#define MINION_CSR_HPMCOUNTER13_OFFSET 0x00006068ul +#define MINION_CSR_HPMCOUNTER13_BYTE_OFFSET 0x00006068ul +#define MINION_CSR_HPMCOUNTER13_SIZE 0x00000008ul +#define MINION_CSR_HPMCOUNTER13_BYTE_SIZE 0x00000008ul +#define MINION_CSR_HPMCOUNTER13_READ_ACCESS 1u +#define MINION_CSR_HPMCOUNTER13_WRITE_ACCESS 0u +#define MINION_CSR_HPMCOUNTER13_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_HPMCOUNTER13_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER13_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER13_WRITE_MASK 0x0000000000000000ull + +/* Field: MINION_CSR_HPMCOUNTER13.hpmcounter13 */ +#define MINION_CSR_HPMCOUNTER13_HPMCOUNTER13_MSB 63u +#define MINION_CSR_HPMCOUNTER13_HPMCOUNTER13_LSB 0u +#define MINION_CSR_HPMCOUNTER13_HPMCOUNTER13_WIDTH 64u +#define MINION_CSR_HPMCOUNTER13_HPMCOUNTER13_READ_ACCESS 1u +#define MINION_CSR_HPMCOUNTER13_HPMCOUNTER13_WRITE_ACCESS 0u +#define MINION_CSR_HPMCOUNTER13_HPMCOUNTER13_RESET 0x0000000000000000ull +#define MINION_CSR_HPMCOUNTER13_HPMCOUNTER13_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER13_HPMCOUNTER13_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_HPMCOUNTER13_HPMCOUNTER13_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_HPMCOUNTER13_HPMCOUNTER13_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.hpmcounter14 */ +#define MINION_CSR_HPMCOUNTER14_ADDRESS 0x00006070ul +#define MINION_CSR_HPMCOUNTER14_BYTE_ADDRESS 0x00006070ul +#define MINION_CSR_HPMCOUNTER14_OFFSET 0x00006070ul +#define MINION_CSR_HPMCOUNTER14_BYTE_OFFSET 0x00006070ul +#define MINION_CSR_HPMCOUNTER14_SIZE 0x00000008ul +#define MINION_CSR_HPMCOUNTER14_BYTE_SIZE 0x00000008ul +#define MINION_CSR_HPMCOUNTER14_READ_ACCESS 1u +#define MINION_CSR_HPMCOUNTER14_WRITE_ACCESS 0u +#define MINION_CSR_HPMCOUNTER14_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_HPMCOUNTER14_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER14_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER14_WRITE_MASK 0x0000000000000000ull + +/* Field: MINION_CSR_HPMCOUNTER14.hpmcounter14 */ +#define MINION_CSR_HPMCOUNTER14_HPMCOUNTER14_MSB 63u +#define MINION_CSR_HPMCOUNTER14_HPMCOUNTER14_LSB 0u +#define MINION_CSR_HPMCOUNTER14_HPMCOUNTER14_WIDTH 64u +#define MINION_CSR_HPMCOUNTER14_HPMCOUNTER14_READ_ACCESS 1u +#define MINION_CSR_HPMCOUNTER14_HPMCOUNTER14_WRITE_ACCESS 0u +#define MINION_CSR_HPMCOUNTER14_HPMCOUNTER14_RESET 0x0000000000000000ull +#define MINION_CSR_HPMCOUNTER14_HPMCOUNTER14_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER14_HPMCOUNTER14_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_HPMCOUNTER14_HPMCOUNTER14_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_HPMCOUNTER14_HPMCOUNTER14_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.hpmcounter15 */ +#define MINION_CSR_HPMCOUNTER15_ADDRESS 0x00006078ul +#define MINION_CSR_HPMCOUNTER15_BYTE_ADDRESS 0x00006078ul +#define MINION_CSR_HPMCOUNTER15_OFFSET 0x00006078ul +#define MINION_CSR_HPMCOUNTER15_BYTE_OFFSET 0x00006078ul +#define MINION_CSR_HPMCOUNTER15_SIZE 0x00000008ul +#define MINION_CSR_HPMCOUNTER15_BYTE_SIZE 0x00000008ul +#define MINION_CSR_HPMCOUNTER15_READ_ACCESS 1u +#define MINION_CSR_HPMCOUNTER15_WRITE_ACCESS 0u +#define MINION_CSR_HPMCOUNTER15_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_HPMCOUNTER15_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER15_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER15_WRITE_MASK 0x0000000000000000ull + +/* Field: MINION_CSR_HPMCOUNTER15.hpmcounter15 */ +#define MINION_CSR_HPMCOUNTER15_HPMCOUNTER15_MSB 63u +#define MINION_CSR_HPMCOUNTER15_HPMCOUNTER15_LSB 0u +#define MINION_CSR_HPMCOUNTER15_HPMCOUNTER15_WIDTH 64u +#define MINION_CSR_HPMCOUNTER15_HPMCOUNTER15_READ_ACCESS 1u +#define MINION_CSR_HPMCOUNTER15_HPMCOUNTER15_WRITE_ACCESS 0u +#define MINION_CSR_HPMCOUNTER15_HPMCOUNTER15_RESET 0x0000000000000000ull +#define MINION_CSR_HPMCOUNTER15_HPMCOUNTER15_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER15_HPMCOUNTER15_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_HPMCOUNTER15_HPMCOUNTER15_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_HPMCOUNTER15_HPMCOUNTER15_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.hpmcounter16 */ +#define MINION_CSR_HPMCOUNTER16_ADDRESS 0x00006080ul +#define MINION_CSR_HPMCOUNTER16_BYTE_ADDRESS 0x00006080ul +#define MINION_CSR_HPMCOUNTER16_OFFSET 0x00006080ul +#define MINION_CSR_HPMCOUNTER16_BYTE_OFFSET 0x00006080ul +#define MINION_CSR_HPMCOUNTER16_SIZE 0x00000008ul +#define MINION_CSR_HPMCOUNTER16_BYTE_SIZE 0x00000008ul +#define MINION_CSR_HPMCOUNTER16_READ_ACCESS 1u +#define MINION_CSR_HPMCOUNTER16_WRITE_ACCESS 0u +#define MINION_CSR_HPMCOUNTER16_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_HPMCOUNTER16_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER16_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER16_WRITE_MASK 0x0000000000000000ull + +/* Field: MINION_CSR_HPMCOUNTER16.hpmcounter16 */ +#define MINION_CSR_HPMCOUNTER16_HPMCOUNTER16_MSB 63u +#define MINION_CSR_HPMCOUNTER16_HPMCOUNTER16_LSB 0u +#define MINION_CSR_HPMCOUNTER16_HPMCOUNTER16_WIDTH 64u +#define MINION_CSR_HPMCOUNTER16_HPMCOUNTER16_READ_ACCESS 1u +#define MINION_CSR_HPMCOUNTER16_HPMCOUNTER16_WRITE_ACCESS 0u +#define MINION_CSR_HPMCOUNTER16_HPMCOUNTER16_RESET 0x0000000000000000ull +#define MINION_CSR_HPMCOUNTER16_HPMCOUNTER16_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER16_HPMCOUNTER16_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_HPMCOUNTER16_HPMCOUNTER16_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_HPMCOUNTER16_HPMCOUNTER16_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.hpmcounter17 */ +#define MINION_CSR_HPMCOUNTER17_ADDRESS 0x00006088ul +#define MINION_CSR_HPMCOUNTER17_BYTE_ADDRESS 0x00006088ul +#define MINION_CSR_HPMCOUNTER17_OFFSET 0x00006088ul +#define MINION_CSR_HPMCOUNTER17_BYTE_OFFSET 0x00006088ul +#define MINION_CSR_HPMCOUNTER17_SIZE 0x00000008ul +#define MINION_CSR_HPMCOUNTER17_BYTE_SIZE 0x00000008ul +#define MINION_CSR_HPMCOUNTER17_READ_ACCESS 1u +#define MINION_CSR_HPMCOUNTER17_WRITE_ACCESS 0u +#define MINION_CSR_HPMCOUNTER17_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_HPMCOUNTER17_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER17_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER17_WRITE_MASK 0x0000000000000000ull + +/* Field: MINION_CSR_HPMCOUNTER17.hpmcounter17 */ +#define MINION_CSR_HPMCOUNTER17_HPMCOUNTER17_MSB 63u +#define MINION_CSR_HPMCOUNTER17_HPMCOUNTER17_LSB 0u +#define MINION_CSR_HPMCOUNTER17_HPMCOUNTER17_WIDTH 64u +#define MINION_CSR_HPMCOUNTER17_HPMCOUNTER17_READ_ACCESS 1u +#define MINION_CSR_HPMCOUNTER17_HPMCOUNTER17_WRITE_ACCESS 0u +#define MINION_CSR_HPMCOUNTER17_HPMCOUNTER17_RESET 0x0000000000000000ull +#define MINION_CSR_HPMCOUNTER17_HPMCOUNTER17_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER17_HPMCOUNTER17_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_HPMCOUNTER17_HPMCOUNTER17_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_HPMCOUNTER17_HPMCOUNTER17_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.hpmcounter18 */ +#define MINION_CSR_HPMCOUNTER18_ADDRESS 0x00006090ul +#define MINION_CSR_HPMCOUNTER18_BYTE_ADDRESS 0x00006090ul +#define MINION_CSR_HPMCOUNTER18_OFFSET 0x00006090ul +#define MINION_CSR_HPMCOUNTER18_BYTE_OFFSET 0x00006090ul +#define MINION_CSR_HPMCOUNTER18_SIZE 0x00000008ul +#define MINION_CSR_HPMCOUNTER18_BYTE_SIZE 0x00000008ul +#define MINION_CSR_HPMCOUNTER18_READ_ACCESS 1u +#define MINION_CSR_HPMCOUNTER18_WRITE_ACCESS 0u +#define MINION_CSR_HPMCOUNTER18_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_HPMCOUNTER18_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER18_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER18_WRITE_MASK 0x0000000000000000ull + +/* Field: MINION_CSR_HPMCOUNTER18.hpmcounter18 */ +#define MINION_CSR_HPMCOUNTER18_HPMCOUNTER18_MSB 63u +#define MINION_CSR_HPMCOUNTER18_HPMCOUNTER18_LSB 0u +#define MINION_CSR_HPMCOUNTER18_HPMCOUNTER18_WIDTH 64u +#define MINION_CSR_HPMCOUNTER18_HPMCOUNTER18_READ_ACCESS 1u +#define MINION_CSR_HPMCOUNTER18_HPMCOUNTER18_WRITE_ACCESS 0u +#define MINION_CSR_HPMCOUNTER18_HPMCOUNTER18_RESET 0x0000000000000000ull +#define MINION_CSR_HPMCOUNTER18_HPMCOUNTER18_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER18_HPMCOUNTER18_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_HPMCOUNTER18_HPMCOUNTER18_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_HPMCOUNTER18_HPMCOUNTER18_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.hpmcounter19 */ +#define MINION_CSR_HPMCOUNTER19_ADDRESS 0x00006098ul +#define MINION_CSR_HPMCOUNTER19_BYTE_ADDRESS 0x00006098ul +#define MINION_CSR_HPMCOUNTER19_OFFSET 0x00006098ul +#define MINION_CSR_HPMCOUNTER19_BYTE_OFFSET 0x00006098ul +#define MINION_CSR_HPMCOUNTER19_SIZE 0x00000008ul +#define MINION_CSR_HPMCOUNTER19_BYTE_SIZE 0x00000008ul +#define MINION_CSR_HPMCOUNTER19_READ_ACCESS 1u +#define MINION_CSR_HPMCOUNTER19_WRITE_ACCESS 0u +#define MINION_CSR_HPMCOUNTER19_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_HPMCOUNTER19_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER19_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER19_WRITE_MASK 0x0000000000000000ull + +/* Field: MINION_CSR_HPMCOUNTER19.hpmcounter19 */ +#define MINION_CSR_HPMCOUNTER19_HPMCOUNTER19_MSB 63u +#define MINION_CSR_HPMCOUNTER19_HPMCOUNTER19_LSB 0u +#define MINION_CSR_HPMCOUNTER19_HPMCOUNTER19_WIDTH 64u +#define MINION_CSR_HPMCOUNTER19_HPMCOUNTER19_READ_ACCESS 1u +#define MINION_CSR_HPMCOUNTER19_HPMCOUNTER19_WRITE_ACCESS 0u +#define MINION_CSR_HPMCOUNTER19_HPMCOUNTER19_RESET 0x0000000000000000ull +#define MINION_CSR_HPMCOUNTER19_HPMCOUNTER19_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER19_HPMCOUNTER19_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_HPMCOUNTER19_HPMCOUNTER19_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_HPMCOUNTER19_HPMCOUNTER19_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.hpmcounter20 */ +#define MINION_CSR_HPMCOUNTER20_ADDRESS 0x000060A0ul +#define MINION_CSR_HPMCOUNTER20_BYTE_ADDRESS 0x000060A0ul +#define MINION_CSR_HPMCOUNTER20_OFFSET 0x000060A0ul +#define MINION_CSR_HPMCOUNTER20_BYTE_OFFSET 0x000060A0ul +#define MINION_CSR_HPMCOUNTER20_SIZE 0x00000008ul +#define MINION_CSR_HPMCOUNTER20_BYTE_SIZE 0x00000008ul +#define MINION_CSR_HPMCOUNTER20_READ_ACCESS 1u +#define MINION_CSR_HPMCOUNTER20_WRITE_ACCESS 0u +#define MINION_CSR_HPMCOUNTER20_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_HPMCOUNTER20_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER20_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER20_WRITE_MASK 0x0000000000000000ull + +/* Field: MINION_CSR_HPMCOUNTER20.hpmcounter20 */ +#define MINION_CSR_HPMCOUNTER20_HPMCOUNTER20_MSB 63u +#define MINION_CSR_HPMCOUNTER20_HPMCOUNTER20_LSB 0u +#define MINION_CSR_HPMCOUNTER20_HPMCOUNTER20_WIDTH 64u +#define MINION_CSR_HPMCOUNTER20_HPMCOUNTER20_READ_ACCESS 1u +#define MINION_CSR_HPMCOUNTER20_HPMCOUNTER20_WRITE_ACCESS 0u +#define MINION_CSR_HPMCOUNTER20_HPMCOUNTER20_RESET 0x0000000000000000ull +#define MINION_CSR_HPMCOUNTER20_HPMCOUNTER20_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER20_HPMCOUNTER20_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_HPMCOUNTER20_HPMCOUNTER20_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_HPMCOUNTER20_HPMCOUNTER20_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.hpmcounter21 */ +#define MINION_CSR_HPMCOUNTER21_ADDRESS 0x000060A8ul +#define MINION_CSR_HPMCOUNTER21_BYTE_ADDRESS 0x000060A8ul +#define MINION_CSR_HPMCOUNTER21_OFFSET 0x000060A8ul +#define MINION_CSR_HPMCOUNTER21_BYTE_OFFSET 0x000060A8ul +#define MINION_CSR_HPMCOUNTER21_SIZE 0x00000008ul +#define MINION_CSR_HPMCOUNTER21_BYTE_SIZE 0x00000008ul +#define MINION_CSR_HPMCOUNTER21_READ_ACCESS 1u +#define MINION_CSR_HPMCOUNTER21_WRITE_ACCESS 0u +#define MINION_CSR_HPMCOUNTER21_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_HPMCOUNTER21_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER21_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER21_WRITE_MASK 0x0000000000000000ull + +/* Field: MINION_CSR_HPMCOUNTER21.hpmcounter21 */ +#define MINION_CSR_HPMCOUNTER21_HPMCOUNTER21_MSB 63u +#define MINION_CSR_HPMCOUNTER21_HPMCOUNTER21_LSB 0u +#define MINION_CSR_HPMCOUNTER21_HPMCOUNTER21_WIDTH 64u +#define MINION_CSR_HPMCOUNTER21_HPMCOUNTER21_READ_ACCESS 1u +#define MINION_CSR_HPMCOUNTER21_HPMCOUNTER21_WRITE_ACCESS 0u +#define MINION_CSR_HPMCOUNTER21_HPMCOUNTER21_RESET 0x0000000000000000ull +#define MINION_CSR_HPMCOUNTER21_HPMCOUNTER21_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER21_HPMCOUNTER21_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_HPMCOUNTER21_HPMCOUNTER21_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_HPMCOUNTER21_HPMCOUNTER21_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.hpmcounter22 */ +#define MINION_CSR_HPMCOUNTER22_ADDRESS 0x000060B0ul +#define MINION_CSR_HPMCOUNTER22_BYTE_ADDRESS 0x000060B0ul +#define MINION_CSR_HPMCOUNTER22_OFFSET 0x000060B0ul +#define MINION_CSR_HPMCOUNTER22_BYTE_OFFSET 0x000060B0ul +#define MINION_CSR_HPMCOUNTER22_SIZE 0x00000008ul +#define MINION_CSR_HPMCOUNTER22_BYTE_SIZE 0x00000008ul +#define MINION_CSR_HPMCOUNTER22_READ_ACCESS 1u +#define MINION_CSR_HPMCOUNTER22_WRITE_ACCESS 0u +#define MINION_CSR_HPMCOUNTER22_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_HPMCOUNTER22_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER22_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER22_WRITE_MASK 0x0000000000000000ull + +/* Field: MINION_CSR_HPMCOUNTER22.hpmcounter22 */ +#define MINION_CSR_HPMCOUNTER22_HPMCOUNTER22_MSB 63u +#define MINION_CSR_HPMCOUNTER22_HPMCOUNTER22_LSB 0u +#define MINION_CSR_HPMCOUNTER22_HPMCOUNTER22_WIDTH 64u +#define MINION_CSR_HPMCOUNTER22_HPMCOUNTER22_READ_ACCESS 1u +#define MINION_CSR_HPMCOUNTER22_HPMCOUNTER22_WRITE_ACCESS 0u +#define MINION_CSR_HPMCOUNTER22_HPMCOUNTER22_RESET 0x0000000000000000ull +#define MINION_CSR_HPMCOUNTER22_HPMCOUNTER22_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER22_HPMCOUNTER22_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_HPMCOUNTER22_HPMCOUNTER22_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_HPMCOUNTER22_HPMCOUNTER22_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.hpmcounter23 */ +#define MINION_CSR_HPMCOUNTER23_ADDRESS 0x000060B8ul +#define MINION_CSR_HPMCOUNTER23_BYTE_ADDRESS 0x000060B8ul +#define MINION_CSR_HPMCOUNTER23_OFFSET 0x000060B8ul +#define MINION_CSR_HPMCOUNTER23_BYTE_OFFSET 0x000060B8ul +#define MINION_CSR_HPMCOUNTER23_SIZE 0x00000008ul +#define MINION_CSR_HPMCOUNTER23_BYTE_SIZE 0x00000008ul +#define MINION_CSR_HPMCOUNTER23_READ_ACCESS 1u +#define MINION_CSR_HPMCOUNTER23_WRITE_ACCESS 0u +#define MINION_CSR_HPMCOUNTER23_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_HPMCOUNTER23_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER23_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER23_WRITE_MASK 0x0000000000000000ull + +/* Field: MINION_CSR_HPMCOUNTER23.hpmcounter23 */ +#define MINION_CSR_HPMCOUNTER23_HPMCOUNTER23_MSB 63u +#define MINION_CSR_HPMCOUNTER23_HPMCOUNTER23_LSB 0u +#define MINION_CSR_HPMCOUNTER23_HPMCOUNTER23_WIDTH 64u +#define MINION_CSR_HPMCOUNTER23_HPMCOUNTER23_READ_ACCESS 1u +#define MINION_CSR_HPMCOUNTER23_HPMCOUNTER23_WRITE_ACCESS 0u +#define MINION_CSR_HPMCOUNTER23_HPMCOUNTER23_RESET 0x0000000000000000ull +#define MINION_CSR_HPMCOUNTER23_HPMCOUNTER23_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER23_HPMCOUNTER23_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_HPMCOUNTER23_HPMCOUNTER23_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_HPMCOUNTER23_HPMCOUNTER23_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.hpmcounter24 */ +#define MINION_CSR_HPMCOUNTER24_ADDRESS 0x000060C0ul +#define MINION_CSR_HPMCOUNTER24_BYTE_ADDRESS 0x000060C0ul +#define MINION_CSR_HPMCOUNTER24_OFFSET 0x000060C0ul +#define MINION_CSR_HPMCOUNTER24_BYTE_OFFSET 0x000060C0ul +#define MINION_CSR_HPMCOUNTER24_SIZE 0x00000008ul +#define MINION_CSR_HPMCOUNTER24_BYTE_SIZE 0x00000008ul +#define MINION_CSR_HPMCOUNTER24_READ_ACCESS 1u +#define MINION_CSR_HPMCOUNTER24_WRITE_ACCESS 0u +#define MINION_CSR_HPMCOUNTER24_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_HPMCOUNTER24_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER24_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER24_WRITE_MASK 0x0000000000000000ull + +/* Field: MINION_CSR_HPMCOUNTER24.hpmcounter24 */ +#define MINION_CSR_HPMCOUNTER24_HPMCOUNTER24_MSB 63u +#define MINION_CSR_HPMCOUNTER24_HPMCOUNTER24_LSB 0u +#define MINION_CSR_HPMCOUNTER24_HPMCOUNTER24_WIDTH 64u +#define MINION_CSR_HPMCOUNTER24_HPMCOUNTER24_READ_ACCESS 1u +#define MINION_CSR_HPMCOUNTER24_HPMCOUNTER24_WRITE_ACCESS 0u +#define MINION_CSR_HPMCOUNTER24_HPMCOUNTER24_RESET 0x0000000000000000ull +#define MINION_CSR_HPMCOUNTER24_HPMCOUNTER24_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER24_HPMCOUNTER24_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_HPMCOUNTER24_HPMCOUNTER24_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_HPMCOUNTER24_HPMCOUNTER24_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.hpmcounter25 */ +#define MINION_CSR_HPMCOUNTER25_ADDRESS 0x000060C8ul +#define MINION_CSR_HPMCOUNTER25_BYTE_ADDRESS 0x000060C8ul +#define MINION_CSR_HPMCOUNTER25_OFFSET 0x000060C8ul +#define MINION_CSR_HPMCOUNTER25_BYTE_OFFSET 0x000060C8ul +#define MINION_CSR_HPMCOUNTER25_SIZE 0x00000008ul +#define MINION_CSR_HPMCOUNTER25_BYTE_SIZE 0x00000008ul +#define MINION_CSR_HPMCOUNTER25_READ_ACCESS 1u +#define MINION_CSR_HPMCOUNTER25_WRITE_ACCESS 0u +#define MINION_CSR_HPMCOUNTER25_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_HPMCOUNTER25_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER25_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER25_WRITE_MASK 0x0000000000000000ull + +/* Field: MINION_CSR_HPMCOUNTER25.hpmcounter25 */ +#define MINION_CSR_HPMCOUNTER25_HPMCOUNTER25_MSB 63u +#define MINION_CSR_HPMCOUNTER25_HPMCOUNTER25_LSB 0u +#define MINION_CSR_HPMCOUNTER25_HPMCOUNTER25_WIDTH 64u +#define MINION_CSR_HPMCOUNTER25_HPMCOUNTER25_READ_ACCESS 1u +#define MINION_CSR_HPMCOUNTER25_HPMCOUNTER25_WRITE_ACCESS 0u +#define MINION_CSR_HPMCOUNTER25_HPMCOUNTER25_RESET 0x0000000000000000ull +#define MINION_CSR_HPMCOUNTER25_HPMCOUNTER25_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER25_HPMCOUNTER25_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_HPMCOUNTER25_HPMCOUNTER25_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_HPMCOUNTER25_HPMCOUNTER25_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.hpmcounter26 */ +#define MINION_CSR_HPMCOUNTER26_ADDRESS 0x000060D0ul +#define MINION_CSR_HPMCOUNTER26_BYTE_ADDRESS 0x000060D0ul +#define MINION_CSR_HPMCOUNTER26_OFFSET 0x000060D0ul +#define MINION_CSR_HPMCOUNTER26_BYTE_OFFSET 0x000060D0ul +#define MINION_CSR_HPMCOUNTER26_SIZE 0x00000008ul +#define MINION_CSR_HPMCOUNTER26_BYTE_SIZE 0x00000008ul +#define MINION_CSR_HPMCOUNTER26_READ_ACCESS 1u +#define MINION_CSR_HPMCOUNTER26_WRITE_ACCESS 0u +#define MINION_CSR_HPMCOUNTER26_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_HPMCOUNTER26_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER26_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER26_WRITE_MASK 0x0000000000000000ull + +/* Field: MINION_CSR_HPMCOUNTER26.hpmcounter26 */ +#define MINION_CSR_HPMCOUNTER26_HPMCOUNTER26_MSB 63u +#define MINION_CSR_HPMCOUNTER26_HPMCOUNTER26_LSB 0u +#define MINION_CSR_HPMCOUNTER26_HPMCOUNTER26_WIDTH 64u +#define MINION_CSR_HPMCOUNTER26_HPMCOUNTER26_READ_ACCESS 1u +#define MINION_CSR_HPMCOUNTER26_HPMCOUNTER26_WRITE_ACCESS 0u +#define MINION_CSR_HPMCOUNTER26_HPMCOUNTER26_RESET 0x0000000000000000ull +#define MINION_CSR_HPMCOUNTER26_HPMCOUNTER26_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER26_HPMCOUNTER26_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_HPMCOUNTER26_HPMCOUNTER26_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_HPMCOUNTER26_HPMCOUNTER26_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.hpmcounter27 */ +#define MINION_CSR_HPMCOUNTER27_ADDRESS 0x000060D8ul +#define MINION_CSR_HPMCOUNTER27_BYTE_ADDRESS 0x000060D8ul +#define MINION_CSR_HPMCOUNTER27_OFFSET 0x000060D8ul +#define MINION_CSR_HPMCOUNTER27_BYTE_OFFSET 0x000060D8ul +#define MINION_CSR_HPMCOUNTER27_SIZE 0x00000008ul +#define MINION_CSR_HPMCOUNTER27_BYTE_SIZE 0x00000008ul +#define MINION_CSR_HPMCOUNTER27_READ_ACCESS 1u +#define MINION_CSR_HPMCOUNTER27_WRITE_ACCESS 0u +#define MINION_CSR_HPMCOUNTER27_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_HPMCOUNTER27_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER27_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER27_WRITE_MASK 0x0000000000000000ull + +/* Field: MINION_CSR_HPMCOUNTER27.hpmcounter27 */ +#define MINION_CSR_HPMCOUNTER27_HPMCOUNTER27_MSB 63u +#define MINION_CSR_HPMCOUNTER27_HPMCOUNTER27_LSB 0u +#define MINION_CSR_HPMCOUNTER27_HPMCOUNTER27_WIDTH 64u +#define MINION_CSR_HPMCOUNTER27_HPMCOUNTER27_READ_ACCESS 1u +#define MINION_CSR_HPMCOUNTER27_HPMCOUNTER27_WRITE_ACCESS 0u +#define MINION_CSR_HPMCOUNTER27_HPMCOUNTER27_RESET 0x0000000000000000ull +#define MINION_CSR_HPMCOUNTER27_HPMCOUNTER27_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER27_HPMCOUNTER27_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_HPMCOUNTER27_HPMCOUNTER27_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_HPMCOUNTER27_HPMCOUNTER27_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.hpmcounter28 */ +#define MINION_CSR_HPMCOUNTER28_ADDRESS 0x000060E0ul +#define MINION_CSR_HPMCOUNTER28_BYTE_ADDRESS 0x000060E0ul +#define MINION_CSR_HPMCOUNTER28_OFFSET 0x000060E0ul +#define MINION_CSR_HPMCOUNTER28_BYTE_OFFSET 0x000060E0ul +#define MINION_CSR_HPMCOUNTER28_SIZE 0x00000008ul +#define MINION_CSR_HPMCOUNTER28_BYTE_SIZE 0x00000008ul +#define MINION_CSR_HPMCOUNTER28_READ_ACCESS 1u +#define MINION_CSR_HPMCOUNTER28_WRITE_ACCESS 0u +#define MINION_CSR_HPMCOUNTER28_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_HPMCOUNTER28_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER28_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER28_WRITE_MASK 0x0000000000000000ull + +/* Field: MINION_CSR_HPMCOUNTER28.hpmcounter28 */ +#define MINION_CSR_HPMCOUNTER28_HPMCOUNTER28_MSB 63u +#define MINION_CSR_HPMCOUNTER28_HPMCOUNTER28_LSB 0u +#define MINION_CSR_HPMCOUNTER28_HPMCOUNTER28_WIDTH 64u +#define MINION_CSR_HPMCOUNTER28_HPMCOUNTER28_READ_ACCESS 1u +#define MINION_CSR_HPMCOUNTER28_HPMCOUNTER28_WRITE_ACCESS 0u +#define MINION_CSR_HPMCOUNTER28_HPMCOUNTER28_RESET 0x0000000000000000ull +#define MINION_CSR_HPMCOUNTER28_HPMCOUNTER28_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER28_HPMCOUNTER28_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_HPMCOUNTER28_HPMCOUNTER28_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_HPMCOUNTER28_HPMCOUNTER28_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.hpmcounter29 */ +#define MINION_CSR_HPMCOUNTER29_ADDRESS 0x000060E8ul +#define MINION_CSR_HPMCOUNTER29_BYTE_ADDRESS 0x000060E8ul +#define MINION_CSR_HPMCOUNTER29_OFFSET 0x000060E8ul +#define MINION_CSR_HPMCOUNTER29_BYTE_OFFSET 0x000060E8ul +#define MINION_CSR_HPMCOUNTER29_SIZE 0x00000008ul +#define MINION_CSR_HPMCOUNTER29_BYTE_SIZE 0x00000008ul +#define MINION_CSR_HPMCOUNTER29_READ_ACCESS 1u +#define MINION_CSR_HPMCOUNTER29_WRITE_ACCESS 0u +#define MINION_CSR_HPMCOUNTER29_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_HPMCOUNTER29_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER29_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER29_WRITE_MASK 0x0000000000000000ull + +/* Field: MINION_CSR_HPMCOUNTER29.hpmcounter29 */ +#define MINION_CSR_HPMCOUNTER29_HPMCOUNTER29_MSB 63u +#define MINION_CSR_HPMCOUNTER29_HPMCOUNTER29_LSB 0u +#define MINION_CSR_HPMCOUNTER29_HPMCOUNTER29_WIDTH 64u +#define MINION_CSR_HPMCOUNTER29_HPMCOUNTER29_READ_ACCESS 1u +#define MINION_CSR_HPMCOUNTER29_HPMCOUNTER29_WRITE_ACCESS 0u +#define MINION_CSR_HPMCOUNTER29_HPMCOUNTER29_RESET 0x0000000000000000ull +#define MINION_CSR_HPMCOUNTER29_HPMCOUNTER29_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER29_HPMCOUNTER29_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_HPMCOUNTER29_HPMCOUNTER29_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_HPMCOUNTER29_HPMCOUNTER29_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.hpmcounter30 */ +#define MINION_CSR_HPMCOUNTER30_ADDRESS 0x000060F0ul +#define MINION_CSR_HPMCOUNTER30_BYTE_ADDRESS 0x000060F0ul +#define MINION_CSR_HPMCOUNTER30_OFFSET 0x000060F0ul +#define MINION_CSR_HPMCOUNTER30_BYTE_OFFSET 0x000060F0ul +#define MINION_CSR_HPMCOUNTER30_SIZE 0x00000008ul +#define MINION_CSR_HPMCOUNTER30_BYTE_SIZE 0x00000008ul +#define MINION_CSR_HPMCOUNTER30_READ_ACCESS 1u +#define MINION_CSR_HPMCOUNTER30_WRITE_ACCESS 0u +#define MINION_CSR_HPMCOUNTER30_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_HPMCOUNTER30_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER30_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER30_WRITE_MASK 0x0000000000000000ull + +/* Field: MINION_CSR_HPMCOUNTER30.hpmcounter30 */ +#define MINION_CSR_HPMCOUNTER30_HPMCOUNTER30_MSB 63u +#define MINION_CSR_HPMCOUNTER30_HPMCOUNTER30_LSB 0u +#define MINION_CSR_HPMCOUNTER30_HPMCOUNTER30_WIDTH 64u +#define MINION_CSR_HPMCOUNTER30_HPMCOUNTER30_READ_ACCESS 1u +#define MINION_CSR_HPMCOUNTER30_HPMCOUNTER30_WRITE_ACCESS 0u +#define MINION_CSR_HPMCOUNTER30_HPMCOUNTER30_RESET 0x0000000000000000ull +#define MINION_CSR_HPMCOUNTER30_HPMCOUNTER30_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER30_HPMCOUNTER30_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_HPMCOUNTER30_HPMCOUNTER30_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_HPMCOUNTER30_HPMCOUNTER30_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.hpmcounter31 */ +#define MINION_CSR_HPMCOUNTER31_ADDRESS 0x000060F8ul +#define MINION_CSR_HPMCOUNTER31_BYTE_ADDRESS 0x000060F8ul +#define MINION_CSR_HPMCOUNTER31_OFFSET 0x000060F8ul +#define MINION_CSR_HPMCOUNTER31_BYTE_OFFSET 0x000060F8ul +#define MINION_CSR_HPMCOUNTER31_SIZE 0x00000008ul +#define MINION_CSR_HPMCOUNTER31_BYTE_SIZE 0x00000008ul +#define MINION_CSR_HPMCOUNTER31_READ_ACCESS 1u +#define MINION_CSR_HPMCOUNTER31_WRITE_ACCESS 0u +#define MINION_CSR_HPMCOUNTER31_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_HPMCOUNTER31_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER31_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER31_WRITE_MASK 0x0000000000000000ull + +/* Field: MINION_CSR_HPMCOUNTER31.hpmcounter31 */ +#define MINION_CSR_HPMCOUNTER31_HPMCOUNTER31_MSB 63u +#define MINION_CSR_HPMCOUNTER31_HPMCOUNTER31_LSB 0u +#define MINION_CSR_HPMCOUNTER31_HPMCOUNTER31_WIDTH 64u +#define MINION_CSR_HPMCOUNTER31_HPMCOUNTER31_READ_ACCESS 1u +#define MINION_CSR_HPMCOUNTER31_HPMCOUNTER31_WRITE_ACCESS 0u +#define MINION_CSR_HPMCOUNTER31_HPMCOUNTER31_RESET 0x0000000000000000ull +#define MINION_CSR_HPMCOUNTER31_HPMCOUNTER31_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HPMCOUNTER31_HPMCOUNTER31_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_HPMCOUNTER31_HPMCOUNTER31_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_HPMCOUNTER31_HPMCOUNTER31_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.nb_fcc */ +#define MINION_CSR_NB_FCC_ADDRESS 0x00006600ul +#define MINION_CSR_NB_FCC_BYTE_ADDRESS 0x00006600ul +#define MINION_CSR_NB_FCC_OFFSET 0x00006600ul +#define MINION_CSR_NB_FCC_BYTE_OFFSET 0x00006600ul +#define MINION_CSR_NB_FCC_SIZE 0x00000008ul +#define MINION_CSR_NB_FCC_BYTE_SIZE 0x00000008ul +#define MINION_CSR_NB_FCC_READ_ACCESS 1u +#define MINION_CSR_NB_FCC_WRITE_ACCESS 0u +#define MINION_CSR_NB_FCC_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_NB_FCC_RESET_MASK 0x00000000FFFFFFFFull +#define MINION_CSR_NB_FCC_READ_MASK 0x00000000FFFFFFFFull +#define MINION_CSR_NB_FCC_WRITE_MASK 0x0000000000000000ull + +/* Field: MINION_CSR_NB_FCC.credit_0 */ +#define MINION_CSR_NB_FCC_CREDIT_0_MSB 15u +#define MINION_CSR_NB_FCC_CREDIT_0_LSB 0u +#define MINION_CSR_NB_FCC_CREDIT_0_WIDTH 16u +#define MINION_CSR_NB_FCC_CREDIT_0_READ_ACCESS 1u +#define MINION_CSR_NB_FCC_CREDIT_0_WRITE_ACCESS 0u +#define MINION_CSR_NB_FCC_CREDIT_0_RESET 0x0000000000000000ull +#define MINION_CSR_NB_FCC_CREDIT_0_FIELD_MASK 0x000000000000FFFFull +#define MINION_CSR_NB_FCC_CREDIT_0_GET(x) ((x) & 0x000000000000FFFFull) +#define MINION_CSR_NB_FCC_CREDIT_0_SET(x) ((x) & 0x000000000000FFFFull) +#define MINION_CSR_NB_FCC_CREDIT_0_MODIFY(r, x) ((((x) << 0) & 0x000000000000FFFFull) | ((r) & 0xFFFFFFFFFFFF0000ull)) + +/* Field: MINION_CSR_NB_FCC.credit_1 */ +#define MINION_CSR_NB_FCC_CREDIT_1_MSB 31u +#define MINION_CSR_NB_FCC_CREDIT_1_LSB 16u +#define MINION_CSR_NB_FCC_CREDIT_1_WIDTH 16u +#define MINION_CSR_NB_FCC_CREDIT_1_READ_ACCESS 1u +#define MINION_CSR_NB_FCC_CREDIT_1_WRITE_ACCESS 0u +#define MINION_CSR_NB_FCC_CREDIT_1_RESET 0x0000000000000000ull +#define MINION_CSR_NB_FCC_CREDIT_1_FIELD_MASK 0x00000000FFFF0000ull +#define MINION_CSR_NB_FCC_CREDIT_1_GET(x) (((x) & 0x00000000FFFF0000ull) >> 16) +#define MINION_CSR_NB_FCC_CREDIT_1_SET(x) (((x) << 16) & 0x00000000FFFF0000ull) +#define MINION_CSR_NB_FCC_CREDIT_1_MODIFY(r, x) ((((x) << 16) & 0x00000000FFFF0000ull) | ((r) & 0xFFFFFFFF0000FFFFull)) + +/* Register: MINION_CSR.porthead0 */ +#define MINION_CSR_PORTHEAD0_ADDRESS 0x00006640ul +#define MINION_CSR_PORTHEAD0_BYTE_ADDRESS 0x00006640ul +#define MINION_CSR_PORTHEAD0_OFFSET 0x00006640ul +#define MINION_CSR_PORTHEAD0_BYTE_OFFSET 0x00006640ul +#define MINION_CSR_PORTHEAD0_SIZE 0x00000008ul +#define MINION_CSR_PORTHEAD0_BYTE_SIZE 0x00000008ul +#define MINION_CSR_PORTHEAD0_READ_ACCESS 1u +#define MINION_CSR_PORTHEAD0_WRITE_ACCESS 0u +#define MINION_CSR_PORTHEAD0_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_PORTHEAD0_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PORTHEAD0_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PORTHEAD0_WRITE_MASK 0x0000000000000000ull + +/* Field: MINION_CSR_PORTHEAD0.porthead0 */ +#define MINION_CSR_PORTHEAD0_PORTHEAD0_MSB 63u +#define MINION_CSR_PORTHEAD0_PORTHEAD0_LSB 0u +#define MINION_CSR_PORTHEAD0_PORTHEAD0_WIDTH 64u +#define MINION_CSR_PORTHEAD0_PORTHEAD0_READ_ACCESS 1u +#define MINION_CSR_PORTHEAD0_PORTHEAD0_WRITE_ACCESS 0u +#define MINION_CSR_PORTHEAD0_PORTHEAD0_RESET 0x0000000000000000ull +#define MINION_CSR_PORTHEAD0_PORTHEAD0_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PORTHEAD0_PORTHEAD0_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_PORTHEAD0_PORTHEAD0_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_PORTHEAD0_PORTHEAD0_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.porthead1 */ +#define MINION_CSR_PORTHEAD1_ADDRESS 0x00006648ul +#define MINION_CSR_PORTHEAD1_BYTE_ADDRESS 0x00006648ul +#define MINION_CSR_PORTHEAD1_OFFSET 0x00006648ul +#define MINION_CSR_PORTHEAD1_BYTE_OFFSET 0x00006648ul +#define MINION_CSR_PORTHEAD1_SIZE 0x00000008ul +#define MINION_CSR_PORTHEAD1_BYTE_SIZE 0x00000008ul +#define MINION_CSR_PORTHEAD1_READ_ACCESS 1u +#define MINION_CSR_PORTHEAD1_WRITE_ACCESS 0u +#define MINION_CSR_PORTHEAD1_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_PORTHEAD1_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PORTHEAD1_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PORTHEAD1_WRITE_MASK 0x0000000000000000ull + +/* Field: MINION_CSR_PORTHEAD1.porthead1 */ +#define MINION_CSR_PORTHEAD1_PORTHEAD1_MSB 63u +#define MINION_CSR_PORTHEAD1_PORTHEAD1_LSB 0u +#define MINION_CSR_PORTHEAD1_PORTHEAD1_WIDTH 64u +#define MINION_CSR_PORTHEAD1_PORTHEAD1_READ_ACCESS 1u +#define MINION_CSR_PORTHEAD1_PORTHEAD1_WRITE_ACCESS 0u +#define MINION_CSR_PORTHEAD1_PORTHEAD1_RESET 0x0000000000000000ull +#define MINION_CSR_PORTHEAD1_PORTHEAD1_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PORTHEAD1_PORTHEAD1_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_PORTHEAD1_PORTHEAD1_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_PORTHEAD1_PORTHEAD1_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.porthead2 */ +#define MINION_CSR_PORTHEAD2_ADDRESS 0x00006650ul +#define MINION_CSR_PORTHEAD2_BYTE_ADDRESS 0x00006650ul +#define MINION_CSR_PORTHEAD2_OFFSET 0x00006650ul +#define MINION_CSR_PORTHEAD2_BYTE_OFFSET 0x00006650ul +#define MINION_CSR_PORTHEAD2_SIZE 0x00000008ul +#define MINION_CSR_PORTHEAD2_BYTE_SIZE 0x00000008ul +#define MINION_CSR_PORTHEAD2_READ_ACCESS 1u +#define MINION_CSR_PORTHEAD2_WRITE_ACCESS 0u +#define MINION_CSR_PORTHEAD2_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_PORTHEAD2_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PORTHEAD2_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PORTHEAD2_WRITE_MASK 0x0000000000000000ull + +/* Field: MINION_CSR_PORTHEAD2.porthead2 */ +#define MINION_CSR_PORTHEAD2_PORTHEAD2_MSB 63u +#define MINION_CSR_PORTHEAD2_PORTHEAD2_LSB 0u +#define MINION_CSR_PORTHEAD2_PORTHEAD2_WIDTH 64u +#define MINION_CSR_PORTHEAD2_PORTHEAD2_READ_ACCESS 1u +#define MINION_CSR_PORTHEAD2_PORTHEAD2_WRITE_ACCESS 0u +#define MINION_CSR_PORTHEAD2_PORTHEAD2_RESET 0x0000000000000000ull +#define MINION_CSR_PORTHEAD2_PORTHEAD2_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PORTHEAD2_PORTHEAD2_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_PORTHEAD2_PORTHEAD2_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_PORTHEAD2_PORTHEAD2_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.porthead3 */ +#define MINION_CSR_PORTHEAD3_ADDRESS 0x00006658ul +#define MINION_CSR_PORTHEAD3_BYTE_ADDRESS 0x00006658ul +#define MINION_CSR_PORTHEAD3_OFFSET 0x00006658ul +#define MINION_CSR_PORTHEAD3_BYTE_OFFSET 0x00006658ul +#define MINION_CSR_PORTHEAD3_SIZE 0x00000008ul +#define MINION_CSR_PORTHEAD3_BYTE_SIZE 0x00000008ul +#define MINION_CSR_PORTHEAD3_READ_ACCESS 1u +#define MINION_CSR_PORTHEAD3_WRITE_ACCESS 0u +#define MINION_CSR_PORTHEAD3_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_PORTHEAD3_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PORTHEAD3_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PORTHEAD3_WRITE_MASK 0x0000000000000000ull + +/* Field: MINION_CSR_PORTHEAD3.porthead3 */ +#define MINION_CSR_PORTHEAD3_PORTHEAD3_MSB 63u +#define MINION_CSR_PORTHEAD3_PORTHEAD3_LSB 0u +#define MINION_CSR_PORTHEAD3_PORTHEAD3_WIDTH 64u +#define MINION_CSR_PORTHEAD3_PORTHEAD3_READ_ACCESS 1u +#define MINION_CSR_PORTHEAD3_PORTHEAD3_WRITE_ACCESS 0u +#define MINION_CSR_PORTHEAD3_PORTHEAD3_RESET 0x0000000000000000ull +#define MINION_CSR_PORTHEAD3_PORTHEAD3_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PORTHEAD3_PORTHEAD3_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_PORTHEAD3_PORTHEAD3_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_PORTHEAD3_PORTHEAD3_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.portheadnb0 */ +#define MINION_CSR_PORTHEADNB0_ADDRESS 0x00006660ul +#define MINION_CSR_PORTHEADNB0_BYTE_ADDRESS 0x00006660ul +#define MINION_CSR_PORTHEADNB0_OFFSET 0x00006660ul +#define MINION_CSR_PORTHEADNB0_BYTE_OFFSET 0x00006660ul +#define MINION_CSR_PORTHEADNB0_SIZE 0x00000008ul +#define MINION_CSR_PORTHEADNB0_BYTE_SIZE 0x00000008ul +#define MINION_CSR_PORTHEADNB0_READ_ACCESS 1u +#define MINION_CSR_PORTHEADNB0_WRITE_ACCESS 0u +#define MINION_CSR_PORTHEADNB0_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_PORTHEADNB0_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PORTHEADNB0_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PORTHEADNB0_WRITE_MASK 0x0000000000000000ull + +/* Field: MINION_CSR_PORTHEADNB0.portheadnb0 */ +#define MINION_CSR_PORTHEADNB0_PORTHEADNB0_MSB 63u +#define MINION_CSR_PORTHEADNB0_PORTHEADNB0_LSB 0u +#define MINION_CSR_PORTHEADNB0_PORTHEADNB0_WIDTH 64u +#define MINION_CSR_PORTHEADNB0_PORTHEADNB0_READ_ACCESS 1u +#define MINION_CSR_PORTHEADNB0_PORTHEADNB0_WRITE_ACCESS 0u +#define MINION_CSR_PORTHEADNB0_PORTHEADNB0_RESET 0x0000000000000000ull +#define MINION_CSR_PORTHEADNB0_PORTHEADNB0_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PORTHEADNB0_PORTHEADNB0_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_PORTHEADNB0_PORTHEADNB0_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_PORTHEADNB0_PORTHEADNB0_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.portheadnb1 */ +#define MINION_CSR_PORTHEADNB1_ADDRESS 0x00006668ul +#define MINION_CSR_PORTHEADNB1_BYTE_ADDRESS 0x00006668ul +#define MINION_CSR_PORTHEADNB1_OFFSET 0x00006668ul +#define MINION_CSR_PORTHEADNB1_BYTE_OFFSET 0x00006668ul +#define MINION_CSR_PORTHEADNB1_SIZE 0x00000008ul +#define MINION_CSR_PORTHEADNB1_BYTE_SIZE 0x00000008ul +#define MINION_CSR_PORTHEADNB1_READ_ACCESS 1u +#define MINION_CSR_PORTHEADNB1_WRITE_ACCESS 0u +#define MINION_CSR_PORTHEADNB1_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_PORTHEADNB1_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PORTHEADNB1_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PORTHEADNB1_WRITE_MASK 0x0000000000000000ull + +/* Field: MINION_CSR_PORTHEADNB1.portheadnb1 */ +#define MINION_CSR_PORTHEADNB1_PORTHEADNB1_MSB 63u +#define MINION_CSR_PORTHEADNB1_PORTHEADNB1_LSB 0u +#define MINION_CSR_PORTHEADNB1_PORTHEADNB1_WIDTH 64u +#define MINION_CSR_PORTHEADNB1_PORTHEADNB1_READ_ACCESS 1u +#define MINION_CSR_PORTHEADNB1_PORTHEADNB1_WRITE_ACCESS 0u +#define MINION_CSR_PORTHEADNB1_PORTHEADNB1_RESET 0x0000000000000000ull +#define MINION_CSR_PORTHEADNB1_PORTHEADNB1_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PORTHEADNB1_PORTHEADNB1_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_PORTHEADNB1_PORTHEADNB1_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_PORTHEADNB1_PORTHEADNB1_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.portheadnb2 */ +#define MINION_CSR_PORTHEADNB2_ADDRESS 0x00006670ul +#define MINION_CSR_PORTHEADNB2_BYTE_ADDRESS 0x00006670ul +#define MINION_CSR_PORTHEADNB2_OFFSET 0x00006670ul +#define MINION_CSR_PORTHEADNB2_BYTE_OFFSET 0x00006670ul +#define MINION_CSR_PORTHEADNB2_SIZE 0x00000008ul +#define MINION_CSR_PORTHEADNB2_BYTE_SIZE 0x00000008ul +#define MINION_CSR_PORTHEADNB2_READ_ACCESS 1u +#define MINION_CSR_PORTHEADNB2_WRITE_ACCESS 0u +#define MINION_CSR_PORTHEADNB2_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_PORTHEADNB2_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PORTHEADNB2_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PORTHEADNB2_WRITE_MASK 0x0000000000000000ull + +/* Field: MINION_CSR_PORTHEADNB2.portheadnb2 */ +#define MINION_CSR_PORTHEADNB2_PORTHEADNB2_MSB 63u +#define MINION_CSR_PORTHEADNB2_PORTHEADNB2_LSB 0u +#define MINION_CSR_PORTHEADNB2_PORTHEADNB2_WIDTH 64u +#define MINION_CSR_PORTHEADNB2_PORTHEADNB2_READ_ACCESS 1u +#define MINION_CSR_PORTHEADNB2_PORTHEADNB2_WRITE_ACCESS 0u +#define MINION_CSR_PORTHEADNB2_PORTHEADNB2_RESET 0x0000000000000000ull +#define MINION_CSR_PORTHEADNB2_PORTHEADNB2_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PORTHEADNB2_PORTHEADNB2_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_PORTHEADNB2_PORTHEADNB2_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_PORTHEADNB2_PORTHEADNB2_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.portheadnb3 */ +#define MINION_CSR_PORTHEADNB3_ADDRESS 0x00006678ul +#define MINION_CSR_PORTHEADNB3_BYTE_ADDRESS 0x00006678ul +#define MINION_CSR_PORTHEADNB3_OFFSET 0x00006678ul +#define MINION_CSR_PORTHEADNB3_BYTE_OFFSET 0x00006678ul +#define MINION_CSR_PORTHEADNB3_SIZE 0x00000008ul +#define MINION_CSR_PORTHEADNB3_BYTE_SIZE 0x00000008ul +#define MINION_CSR_PORTHEADNB3_READ_ACCESS 1u +#define MINION_CSR_PORTHEADNB3_WRITE_ACCESS 0u +#define MINION_CSR_PORTHEADNB3_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_PORTHEADNB3_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PORTHEADNB3_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PORTHEADNB3_WRITE_MASK 0x0000000000000000ull + +/* Field: MINION_CSR_PORTHEADNB3.portheadnb3 */ +#define MINION_CSR_PORTHEADNB3_PORTHEADNB3_MSB 63u +#define MINION_CSR_PORTHEADNB3_PORTHEADNB3_LSB 0u +#define MINION_CSR_PORTHEADNB3_PORTHEADNB3_WIDTH 64u +#define MINION_CSR_PORTHEADNB3_PORTHEADNB3_READ_ACCESS 1u +#define MINION_CSR_PORTHEADNB3_PORTHEADNB3_WRITE_ACCESS 0u +#define MINION_CSR_PORTHEADNB3_PORTHEADNB3_RESET 0x0000000000000000ull +#define MINION_CSR_PORTHEADNB3_PORTHEADNB3_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_PORTHEADNB3_PORTHEADNB3_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_PORTHEADNB3_PORTHEADNB3_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_PORTHEADNB3_PORTHEADNB3_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.hartid */ +#define MINION_CSR_HARTID_ADDRESS 0x00006680ul +#define MINION_CSR_HARTID_BYTE_ADDRESS 0x00006680ul +#define MINION_CSR_HARTID_OFFSET 0x00006680ul +#define MINION_CSR_HARTID_BYTE_OFFSET 0x00006680ul +#define MINION_CSR_HARTID_SIZE 0x00000008ul +#define MINION_CSR_HARTID_BYTE_SIZE 0x00000008ul +#define MINION_CSR_HARTID_READ_ACCESS 1u +#define MINION_CSR_HARTID_WRITE_ACCESS 0u +#define MINION_CSR_HARTID_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_HARTID_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HARTID_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HARTID_WRITE_MASK 0x0000000000000000ull + +/* Field: MINION_CSR_HARTID.hartid */ +#define MINION_CSR_HARTID_HARTID_MSB 63u +#define MINION_CSR_HARTID_HARTID_LSB 0u +#define MINION_CSR_HARTID_HARTID_WIDTH 64u +#define MINION_CSR_HARTID_HARTID_READ_ACCESS 1u +#define MINION_CSR_HARTID_HARTID_WRITE_ACCESS 0u +#define MINION_CSR_HARTID_HARTID_RESET 0x0000000000000000ull +#define MINION_CSR_HARTID_HARTID_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_HARTID_HARTID_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_HARTID_HARTID_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_HARTID_HARTID_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mvendorid */ +#define MINION_CSR_MVENDORID_ADDRESS 0x00007888ul +#define MINION_CSR_MVENDORID_BYTE_ADDRESS 0x00007888ul +#define MINION_CSR_MVENDORID_OFFSET 0x00007888ul +#define MINION_CSR_MVENDORID_BYTE_OFFSET 0x00007888ul +#define MINION_CSR_MVENDORID_SIZE 0x00000008ul +#define MINION_CSR_MVENDORID_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MVENDORID_READ_ACCESS 1u +#define MINION_CSR_MVENDORID_WRITE_ACCESS 0u +#define MINION_CSR_MVENDORID_RESET_VALUE 0x00000000000005E5ull +#define MINION_CSR_MVENDORID_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MVENDORID_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MVENDORID_WRITE_MASK 0x0000000000000000ull + +/* Field: MINION_CSR_MVENDORID.mvendorid */ +#define MINION_CSR_MVENDORID_MVENDORID_MSB 63u +#define MINION_CSR_MVENDORID_MVENDORID_LSB 0u +#define MINION_CSR_MVENDORID_MVENDORID_WIDTH 64u +#define MINION_CSR_MVENDORID_MVENDORID_READ_ACCESS 1u +#define MINION_CSR_MVENDORID_MVENDORID_WRITE_ACCESS 0u +#define MINION_CSR_MVENDORID_MVENDORID_RESET 0x00000000000005E5ull +#define MINION_CSR_MVENDORID_MVENDORID_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MVENDORID_MVENDORID_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MVENDORID_MVENDORID_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MVENDORID_MVENDORID_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.marchid */ +#define MINION_CSR_MARCHID_ADDRESS 0x00007890ul +#define MINION_CSR_MARCHID_BYTE_ADDRESS 0x00007890ul +#define MINION_CSR_MARCHID_OFFSET 0x00007890ul +#define MINION_CSR_MARCHID_BYTE_OFFSET 0x00007890ul +#define MINION_CSR_MARCHID_SIZE 0x00000008ul +#define MINION_CSR_MARCHID_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MARCHID_READ_ACCESS 1u +#define MINION_CSR_MARCHID_WRITE_ACCESS 0u +#define MINION_CSR_MARCHID_RESET_VALUE 0x8000000000000001ull +#define MINION_CSR_MARCHID_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MARCHID_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MARCHID_WRITE_MASK 0x0000000000000000ull + +/* Field: MINION_CSR_MARCHID.marchid */ +#define MINION_CSR_MARCHID_MARCHID_MSB 63u +#define MINION_CSR_MARCHID_MARCHID_LSB 0u +#define MINION_CSR_MARCHID_MARCHID_WIDTH 64u +#define MINION_CSR_MARCHID_MARCHID_READ_ACCESS 1u +#define MINION_CSR_MARCHID_MARCHID_WRITE_ACCESS 0u +#define MINION_CSR_MARCHID_MARCHID_RESET 0x8000000000000001ull +#define MINION_CSR_MARCHID_MARCHID_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MARCHID_MARCHID_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MARCHID_MARCHID_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MARCHID_MARCHID_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mimpid */ +#define MINION_CSR_MIMPID_ADDRESS 0x00007898ul +#define MINION_CSR_MIMPID_BYTE_ADDRESS 0x00007898ul +#define MINION_CSR_MIMPID_OFFSET 0x00007898ul +#define MINION_CSR_MIMPID_BYTE_OFFSET 0x00007898ul +#define MINION_CSR_MIMPID_SIZE 0x00000008ul +#define MINION_CSR_MIMPID_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MIMPID_READ_ACCESS 1u +#define MINION_CSR_MIMPID_WRITE_ACCESS 0u +#define MINION_CSR_MIMPID_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MIMPID_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MIMPID_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MIMPID_WRITE_MASK 0x0000000000000000ull + +/* Field: MINION_CSR_MIMPID.mimpid */ +#define MINION_CSR_MIMPID_MIMPID_MSB 63u +#define MINION_CSR_MIMPID_MIMPID_LSB 0u +#define MINION_CSR_MIMPID_MIMPID_WIDTH 64u +#define MINION_CSR_MIMPID_MIMPID_READ_ACCESS 1u +#define MINION_CSR_MIMPID_MIMPID_WRITE_ACCESS 0u +#define MINION_CSR_MIMPID_MIMPID_RESET 0x0000000000000000ull +#define MINION_CSR_MIMPID_MIMPID_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MIMPID_MIMPID_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MIMPID_MIMPID_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MIMPID_MIMPID_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.mhartid */ +#define MINION_CSR_MHARTID_ADDRESS 0x000078A0ul +#define MINION_CSR_MHARTID_BYTE_ADDRESS 0x000078A0ul +#define MINION_CSR_MHARTID_OFFSET 0x000078A0ul +#define MINION_CSR_MHARTID_BYTE_OFFSET 0x000078A0ul +#define MINION_CSR_MHARTID_SIZE 0x00000008ul +#define MINION_CSR_MHARTID_BYTE_SIZE 0x00000008ul +#define MINION_CSR_MHARTID_READ_ACCESS 1u +#define MINION_CSR_MHARTID_WRITE_ACCESS 0u +#define MINION_CSR_MHARTID_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_MHARTID_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHARTID_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHARTID_WRITE_MASK 0x0000000000000000ull + +/* Field: MINION_CSR_MHARTID.mhartid */ +#define MINION_CSR_MHARTID_MHARTID_MSB 63u +#define MINION_CSR_MHARTID_MHARTID_LSB 0u +#define MINION_CSR_MHARTID_MHARTID_WIDTH 64u +#define MINION_CSR_MHARTID_MHARTID_READ_ACCESS 1u +#define MINION_CSR_MHARTID_MHARTID_WRITE_ACCESS 0u +#define MINION_CSR_MHARTID_MHARTID_RESET 0x0000000000000000ull +#define MINION_CSR_MHARTID_MHARTID_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_MHARTID_MHARTID_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHARTID_MHARTID_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_MHARTID_MHARTID_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Register: MINION_CSR.dcache_debug */ +#define MINION_CSR_DCACHE_DEBUG_ADDRESS 0x00007E00ul +#define MINION_CSR_DCACHE_DEBUG_BYTE_ADDRESS 0x00007E00ul +#define MINION_CSR_DCACHE_DEBUG_OFFSET 0x00007E00ul +#define MINION_CSR_DCACHE_DEBUG_BYTE_OFFSET 0x00007E00ul +#define MINION_CSR_DCACHE_DEBUG_SIZE 0x00000008ul +#define MINION_CSR_DCACHE_DEBUG_BYTE_SIZE 0x00000008ul +#define MINION_CSR_DCACHE_DEBUG_READ_ACCESS 1u +#define MINION_CSR_DCACHE_DEBUG_WRITE_ACCESS 0u +#define MINION_CSR_DCACHE_DEBUG_RESET_VALUE 0x0000000000000000ull +#define MINION_CSR_DCACHE_DEBUG_RESET_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_DCACHE_DEBUG_READ_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_DCACHE_DEBUG_WRITE_MASK 0x0000000000000000ull + +/* Field: MINION_CSR_DCACHE_DEBUG.dcache_debug */ +#define MINION_CSR_DCACHE_DEBUG_DCACHE_DEBUG_MSB 63u +#define MINION_CSR_DCACHE_DEBUG_DCACHE_DEBUG_LSB 0u +#define MINION_CSR_DCACHE_DEBUG_DCACHE_DEBUG_WIDTH 64u +#define MINION_CSR_DCACHE_DEBUG_DCACHE_DEBUG_READ_ACCESS 1u +#define MINION_CSR_DCACHE_DEBUG_DCACHE_DEBUG_WRITE_ACCESS 0u +#define MINION_CSR_DCACHE_DEBUG_DCACHE_DEBUG_RESET 0x0000000000000000ull +#define MINION_CSR_DCACHE_DEBUG_DCACHE_DEBUG_FIELD_MASK 0xFFFFFFFFFFFFFFFFull +#define MINION_CSR_DCACHE_DEBUG_DCACHE_DEBUG_GET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_DCACHE_DEBUG_DCACHE_DEBUG_SET(x) ((x) & 0xFFFFFFFFFFFFFFFFull) +#define MINION_CSR_DCACHE_DEBUG_DCACHE_DEBUG_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFFFFFFFFFull) | ((r) & 0x0000000000000000ull)) + +/* Block-level typedef: MINION_CSR */ +typedef struct { + volatile uint64_t ustatus; /* Offset 0x0 (R) */ + volatile uint64_t fflags; /* Offset 0x8 (R/W) */ + volatile uint64_t frm; /* Offset 0x10 (R/W) */ + volatile uint64_t fcsr; /* Offset 0x18 (R/W) */ + volatile uint64_t uie; /* Offset 0x20 (R) */ + volatile uint64_t utvec; /* Offset 0x28 (R) */ + uint8_t _pad0[0x1D0]; /* 0x30..0x1FF reserved */ + volatile uint64_t uscratch; /* Offset 0x200 (R) */ + volatile uint64_t uepc; /* Offset 0x208 (R) */ + volatile uint64_t ucause; /* Offset 0x210 (R) */ + volatile uint64_t utval; /* Offset 0x218 (R) */ + volatile uint64_t uip; /* Offset 0x220 (R) */ + uint8_t _pad1[0x5D8]; /* 0x228..0x7FF reserved */ + volatile uint64_t sstatus; /* Offset 0x800 (R/W) */ + uint8_t _pad2[0x8]; /* 0x808..0x80F reserved */ + volatile uint64_t sedeleg; /* Offset 0x810 (R/W) */ + volatile uint64_t sideleg; /* Offset 0x818 (R/W) */ + volatile uint64_t sie; /* Offset 0x820 (R/W) */ + volatile uint64_t stvec; /* Offset 0x828 (R/W) */ + volatile uint64_t scounteren; /* Offset 0x830 (R/W) */ + uint8_t _pad3[0x1C8]; /* 0x838..0x9FF reserved */ + volatile uint64_t sscratch; /* Offset 0xA00 (R/W) */ + volatile uint64_t sepc; /* Offset 0xA08 (R/W) */ + volatile uint64_t scause; /* Offset 0xA10 (R/W) */ + volatile uint64_t stval; /* Offset 0xA18 (R/W) */ + volatile uint64_t sip; /* Offset 0xA20 (R/W) */ + uint8_t _pad4[0x1D8]; /* 0xA28..0xBFF reserved */ + volatile uint64_t satp; /* Offset 0xC00 (R) */ + uint8_t _pad5[0xBF8]; /* 0xC08..0x17FF reserved */ + volatile uint64_t mstatus; /* Offset 0x1800 (R/W) */ + volatile uint64_t misa; /* Offset 0x1808 (R/W) */ + volatile uint64_t medeleg; /* Offset 0x1810 (R/W) */ + volatile uint64_t mideleg; /* Offset 0x1818 (R/W) */ + volatile uint64_t mie; /* Offset 0x1820 (R/W) */ + volatile uint64_t mtvec; /* Offset 0x1828 (R/W) */ + volatile uint64_t mcounteren; /* Offset 0x1830 (R/W) */ + uint8_t _pad6[0xE0]; /* 0x1838..0x1917 reserved */ + volatile uint64_t mhpmevent3; /* Offset 0x1918 (R/W) */ + volatile uint64_t mhpmevent4; /* Offset 0x1920 (R/W) */ + volatile uint64_t mhpmevent5; /* Offset 0x1928 (R/W) */ + volatile uint64_t mhpmevent6; /* Offset 0x1930 (R/W) */ + volatile uint64_t mhpmevent7; /* Offset 0x1938 (R/W) */ + volatile uint64_t mhpmevent8; /* Offset 0x1940 (R/W) */ + volatile uint64_t mhpmevent9; /* Offset 0x1948 (R/W) */ + volatile uint64_t mhpmevent10; /* Offset 0x1950 (R/W) */ + volatile uint64_t mhpmevent11; /* Offset 0x1958 (R/W) */ + volatile uint64_t mhpmevent12; /* Offset 0x1960 (R/W) */ + volatile uint64_t mhpmevent13; /* Offset 0x1968 (R/W) */ + volatile uint64_t mhpmevent14; /* Offset 0x1970 (R/W) */ + volatile uint64_t mhpmevent15; /* Offset 0x1978 (R/W) */ + volatile uint64_t mhpmevent16; /* Offset 0x1980 (R/W) */ + volatile uint64_t mhpmevent17; /* Offset 0x1988 (R/W) */ + volatile uint64_t mhpmevent18; /* Offset 0x1990 (R/W) */ + volatile uint64_t mhpmevent19; /* Offset 0x1998 (R/W) */ + volatile uint64_t mhpmevent20; /* Offset 0x19A0 (R/W) */ + volatile uint64_t mhpmevent21; /* Offset 0x19A8 (R/W) */ + volatile uint64_t mhpmevent22; /* Offset 0x19B0 (R/W) */ + volatile uint64_t mhpmevent23; /* Offset 0x19B8 (R/W) */ + volatile uint64_t mhpmevent24; /* Offset 0x19C0 (R/W) */ + volatile uint64_t mhpmevent25; /* Offset 0x19C8 (R/W) */ + volatile uint64_t mhpmevent26; /* Offset 0x19D0 (R/W) */ + volatile uint64_t mhpmevent27; /* Offset 0x19D8 (R/W) */ + volatile uint64_t mhpmevent28; /* Offset 0x19E0 (R/W) */ + volatile uint64_t mhpmevent29; /* Offset 0x19E8 (R/W) */ + volatile uint64_t mhpmevent30; /* Offset 0x19F0 (R/W) */ + volatile uint64_t mhpmevent31; /* Offset 0x19F8 (R/W) */ + volatile uint64_t mscratch; /* Offset 0x1A00 (R/W) */ + volatile uint64_t mepc; /* Offset 0x1A08 (R/W) */ + volatile uint64_t mcause; /* Offset 0x1A10 (R/W) */ + volatile uint64_t mtval; /* Offset 0x1A18 (R/W) */ + volatile uint64_t mip; /* Offset 0x1A20 (R/W) */ + uint8_t _pad7[0x2D8]; /* 0x1A28..0x1CFF reserved */ + volatile uint64_t pmpcfg0; /* Offset 0x1D00 (R/W) */ + uint8_t _pad8[0x8]; /* 0x1D08..0x1D0F reserved */ + volatile uint64_t pmpcfg2; /* Offset 0x1D10 (R/W) */ + uint8_t _pad9[0x68]; /* 0x1D18..0x1D7F reserved */ + volatile uint64_t pmpaddr0; /* Offset 0x1D80 (R/W) */ + volatile uint64_t pmpaddr1; /* Offset 0x1D88 (R/W) */ + volatile uint64_t pmpaddr2; /* Offset 0x1D90 (R/W) */ + volatile uint64_t pmpaddr3; /* Offset 0x1D98 (R/W) */ + volatile uint64_t pmpaddr4; /* Offset 0x1DA0 (R/W) */ + volatile uint64_t pmpaddr5; /* Offset 0x1DA8 (R/W) */ + volatile uint64_t pmpaddr6; /* Offset 0x1DB0 (R/W) */ + volatile uint64_t pmpaddr7; /* Offset 0x1DB8 (R/W) */ + volatile uint64_t pmpaddr8; /* Offset 0x1DC0 (R/W) */ + volatile uint64_t pmpaddr9; /* Offset 0x1DC8 (R/W) */ + volatile uint64_t pmpaddr10; /* Offset 0x1DD0 (R/W) */ + volatile uint64_t pmpaddr11; /* Offset 0x1DD8 (R/W) */ + volatile uint64_t pmpaddr12; /* Offset 0x1DE0 (R/W) */ + volatile uint64_t pmpaddr13; /* Offset 0x1DE8 (R/W) */ + volatile uint64_t pmpaddr14; /* Offset 0x1DF0 (R/W) */ + volatile uint64_t pmpaddr15; /* Offset 0x1DF8 (R/W) */ + uint8_t _pad10[0x1F00]; /* 0x1E00..0x3CFF reserved */ + volatile uint64_t tselect; /* Offset 0x3D00 (R/W) */ + volatile uint64_t tdata1; /* Offset 0x3D08 (R/W) */ + volatile uint64_t tdata2; /* Offset 0x3D10 (R/W) */ + volatile uint64_t tdata3; /* Offset 0x3D18 (R/W) */ + volatile uint64_t tinfo; /* Offset 0x3D20 (R/W) */ + uint8_t _pad11[0x58]; /* 0x3D28..0x3D7F reserved */ + volatile uint64_t dcsr; /* Offset 0x3D80 (R/W) */ + volatile uint64_t dpc; /* Offset 0x3D88 (R/W) */ + volatile uint64_t dscratch0; /* Offset 0x3D90 (R/W) */ + uint8_t _pad12[0x28]; /* 0x3D98..0x3DBF reserved */ + volatile uint64_t ddata0; /* Offset 0x3DC0 (R/W) */ + uint8_t _pad13[0x38]; /* 0x3DC8..0x3DFF reserved */ + volatile uint64_t matp; /* Offset 0x3E00 (R) */ + uint8_t _pad14[0x60]; /* 0x3E08..0x3E67 reserved */ + volatile uint64_t minstmask; /* Offset 0x3E68 (R/W) */ + volatile uint64_t minstmatch; /* Offset 0x3E70 (R/W) */ + volatile uint64_t amofence_ctrl; /* Offset 0x3E78 (R/W) */ + volatile uint64_t cacheinvalidate; /* Offset 0x3E80 (R/W) */ + volatile uint64_t msleep_txfma_27; /* Offset 0x3E88 (R/W) */ + volatile uint64_t menable_shadows; /* Offset 0x3E90 (R/W) */ + volatile uint64_t excl_mode; /* Offset 0x3E98 (R/W) */ + volatile uint64_t mtxfma_sleep_traps; /* Offset 0x3EA0 (R/W) */ + volatile uint64_t mbusaddr; /* Offset 0x3EA8 (R/W) */ + volatile uint64_t mbuspc; /* Offset 0x3EB0 (R/W) */ + uint8_t _pad15[0x48]; /* 0x3EB8..0x3EFF reserved */ + volatile uint64_t mcache_control; /* Offset 0x3F00 (R/W) */ + uint8_t _pad16[0xC0]; /* 0x3F08..0x3FC7 reserved */ + volatile uint64_t co_evict_sw; /* Offset 0x3FC8 (R/W) */ + uint8_t _pad17[0x8]; /* 0x3FD0..0x3FD7 reserved */ + volatile uint64_t co_flush_sw; /* Offset 0x3FD8 (R/W) */ + uint8_t _pad18[0x8]; /* 0x3FE0..0x3FE7 reserved */ + volatile uint64_t co_lock_sw; /* Offset 0x3FE8 (R/W) */ + uint8_t _pad19[0x8]; /* 0x3FF0..0x3FF7 reserved */ + volatile uint64_t co_unlock_sw; /* Offset 0x3FF8 (R/W) */ + volatile uint64_t tensor_reduce; /* Offset 0x4000 (R/W) */ + volatile uint64_t tensor_fma; /* Offset 0x4008 (R/W) */ + volatile uint64_t tensor_conv_size; /* Offset 0x4010 (R/W) */ + volatile uint64_t tensor_conv_ctrl; /* Offset 0x4018 (R/W) */ + volatile uint64_t tensor_cooperation; /* Offset 0x4020 (R/W) */ + volatile uint64_t tensor_mask; /* Offset 0x4028 (R/W) */ + volatile uint64_t tensor_quant; /* Offset 0x4030 (R/W) */ + volatile uint64_t tex_send; /* Offset 0x4038 (R/W) */ + volatile uint64_t tensor_error; /* Offset 0x4040 (R/W) */ + uint8_t _pad20[0x38]; /* 0x4048..0x407F reserved */ + volatile uint64_t ucache_control; /* Offset 0x4080 (R/W) */ + uint8_t _pad21[0x70]; /* 0x4088..0x40F7 reserved */ + volatile uint64_t co_prefetch_va; /* Offset 0x40F8 (R/W) */ + volatile uint64_t flb; /* Offset 0x4100 (R/W) */ + volatile uint64_t fcc; /* Offset 0x4108 (R/W) */ + volatile uint64_t stall; /* Offset 0x4110 (R/W) */ + uint8_t _pad22[0x68]; /* 0x4118..0x417F reserved */ + volatile uint64_t tensor_wait; /* Offset 0x4180 (R/W) */ + uint8_t _pad23[0x70]; /* 0x4188..0x41F7 reserved */ + volatile uint64_t tensor_load; /* Offset 0x41F8 (R/W) */ + volatile uint64_t gsc_progress; /* Offset 0x4200 (R/W) */ + uint8_t _pad24[0xF0]; /* 0x4208..0x42F7 reserved */ + volatile uint64_t tensor_load_l2scp; /* Offset 0x42F8 (R/W) */ + uint8_t _pad25[0xF8]; /* 0x4300..0x43F7 reserved */ + volatile uint64_t tensor_store; /* Offset 0x43F8 (R/W) */ + uint8_t _pad26[0xF8]; /* 0x4400..0x44F7 reserved */ + volatile uint64_t co_evict_va; /* Offset 0x44F8 (R/W) */ + uint8_t _pad27[0xF8]; /* 0x4500..0x45F7 reserved */ + volatile uint64_t co_flush_va; /* Offset 0x45F8 (R/W) */ + uint8_t _pad28[0x60]; /* 0x4600..0x465F reserved */ + volatile uint64_t umsg_port0; /* Offset 0x4660 (R/W) */ + volatile uint64_t umsg_port1; /* Offset 0x4668 (R/W) */ + volatile uint64_t umsg_port2; /* Offset 0x4670 (R/W) */ + volatile uint64_t umsg_port3; /* Offset 0x4678 (R/W) */ + volatile uint64_t validation0; /* Offset 0x4680 (R/W) */ + volatile uint64_t validation1; /* Offset 0x4688 (R/W) */ + volatile uint64_t validation2; /* Offset 0x4690 (R/W) */ + volatile uint64_t validation3; /* Offset 0x4698 (R/W) */ + uint8_t _pad29[0x8]; /* 0x46A0..0x46A7 reserved */ + volatile uint64_t sleep_txfma_27; /* Offset 0x46A8 (R/W) */ + uint8_t _pad30[0x48]; /* 0x46B0..0x46F7 reserved */ + volatile uint64_t co_lock_va; /* Offset 0x46F8 (R/W) */ + uint8_t _pad31[0xF8]; /* 0x4700..0x47F7 reserved */ + volatile uint64_t co_unlock_va; /* Offset 0x47F8 (R/W) */ + uint8_t _pad32[0x660]; /* 0x4800..0x4E5F reserved */ + volatile uint64_t smsg_port0; /* Offset 0x4E60 (R/W) */ + volatile uint64_t smsg_port1; /* Offset 0x4E68 (R/W) */ + volatile uint64_t smsg_port2; /* Offset 0x4E70 (R/W) */ + volatile uint64_t smsg_port3; /* Offset 0x4E78 (R/W) */ + uint8_t _pad33[0x980]; /* 0x4E80..0x57FF reserved */ + volatile uint64_t mcycle; /* Offset 0x5800 (R/W) */ + uint8_t _pad34[0x8]; /* 0x5808..0x580F reserved */ + volatile uint64_t minstret; /* Offset 0x5810 (R/W) */ + volatile uint64_t mhpmcounter3; /* Offset 0x5818 (R/W) */ + volatile uint64_t mhpmcounter4; /* Offset 0x5820 (R/W) */ + volatile uint64_t mhpmcounter5; /* Offset 0x5828 (R/W) */ + volatile uint64_t mhpmcounter6; /* Offset 0x5830 (R/W) */ + volatile uint64_t mhpmcounter7; /* Offset 0x5838 (R/W) */ + volatile uint64_t mhpmcounter8; /* Offset 0x5840 (R/W) */ + volatile uint64_t mhpmcounter9; /* Offset 0x5848 (R/W) */ + volatile uint64_t mhpmcounter10; /* Offset 0x5850 (R/W) */ + volatile uint64_t mhpmcounter11; /* Offset 0x5858 (R/W) */ + volatile uint64_t mhpmcounter12; /* Offset 0x5860 (R/W) */ + volatile uint64_t mhpmcounter13; /* Offset 0x5868 (R/W) */ + volatile uint64_t mhpmcounter14; /* Offset 0x5870 (R/W) */ + volatile uint64_t mhpmcounter15; /* Offset 0x5878 (R/W) */ + volatile uint64_t mhpmcounter16; /* Offset 0x5880 (R/W) */ + volatile uint64_t mhpmcounter17; /* Offset 0x5888 (R/W) */ + volatile uint64_t mhpmcounter18; /* Offset 0x5890 (R/W) */ + volatile uint64_t mhpmcounter19; /* Offset 0x5898 (R/W) */ + volatile uint64_t mhpmcounter20; /* Offset 0x58A0 (R/W) */ + volatile uint64_t mhpmcounter21; /* Offset 0x58A8 (R/W) */ + volatile uint64_t mhpmcounter22; /* Offset 0x58B0 (R/W) */ + volatile uint64_t mhpmcounter23; /* Offset 0x58B8 (R/W) */ + volatile uint64_t mhpmcounter24; /* Offset 0x58C0 (R/W) */ + volatile uint64_t mhpmcounter25; /* Offset 0x58C8 (R/W) */ + volatile uint64_t mhpmcounter26; /* Offset 0x58D0 (R/W) */ + volatile uint64_t mhpmcounter27; /* Offset 0x58D8 (R/W) */ + volatile uint64_t mhpmcounter28; /* Offset 0x58E0 (R/W) */ + volatile uint64_t mhpmcounter29; /* Offset 0x58E8 (R/W) */ + volatile uint64_t mhpmcounter30; /* Offset 0x58F0 (R/W) */ + volatile uint64_t mhpmcounter31; /* Offset 0x58F8 (R/W) */ + uint8_t _pad35[0x700]; /* 0x5900..0x5FFF reserved */ + volatile uint64_t cycle; /* Offset 0x6000 (R) */ + volatile uint64_t time; /* Offset 0x6008 (R) */ + volatile uint64_t instret; /* Offset 0x6010 (R) */ + volatile uint64_t hpmcounter3; /* Offset 0x6018 (R) */ + volatile uint64_t hpmcounter4; /* Offset 0x6020 (R) */ + volatile uint64_t hpmcounter5; /* Offset 0x6028 (R) */ + volatile uint64_t hpmcounter6; /* Offset 0x6030 (R) */ + volatile uint64_t hpmcounter7; /* Offset 0x6038 (R) */ + volatile uint64_t hpmcounter8; /* Offset 0x6040 (R) */ + volatile uint64_t hpmcounter9; /* Offset 0x6048 (R) */ + volatile uint64_t hpmcounter10; /* Offset 0x6050 (R) */ + volatile uint64_t hpmcounter11; /* Offset 0x6058 (R) */ + volatile uint64_t hpmcounter12; /* Offset 0x6060 (R) */ + volatile uint64_t hpmcounter13; /* Offset 0x6068 (R) */ + volatile uint64_t hpmcounter14; /* Offset 0x6070 (R) */ + volatile uint64_t hpmcounter15; /* Offset 0x6078 (R) */ + volatile uint64_t hpmcounter16; /* Offset 0x6080 (R) */ + volatile uint64_t hpmcounter17; /* Offset 0x6088 (R) */ + volatile uint64_t hpmcounter18; /* Offset 0x6090 (R) */ + volatile uint64_t hpmcounter19; /* Offset 0x6098 (R) */ + volatile uint64_t hpmcounter20; /* Offset 0x60A0 (R) */ + volatile uint64_t hpmcounter21; /* Offset 0x60A8 (R) */ + volatile uint64_t hpmcounter22; /* Offset 0x60B0 (R) */ + volatile uint64_t hpmcounter23; /* Offset 0x60B8 (R) */ + volatile uint64_t hpmcounter24; /* Offset 0x60C0 (R) */ + volatile uint64_t hpmcounter25; /* Offset 0x60C8 (R) */ + volatile uint64_t hpmcounter26; /* Offset 0x60D0 (R) */ + volatile uint64_t hpmcounter27; /* Offset 0x60D8 (R) */ + volatile uint64_t hpmcounter28; /* Offset 0x60E0 (R) */ + volatile uint64_t hpmcounter29; /* Offset 0x60E8 (R) */ + volatile uint64_t hpmcounter30; /* Offset 0x60F0 (R) */ + volatile uint64_t hpmcounter31; /* Offset 0x60F8 (R) */ + uint8_t _pad36[0x500]; /* 0x6100..0x65FF reserved */ + volatile uint64_t nb_fcc; /* Offset 0x6600 (R) */ + uint8_t _pad37[0x38]; /* 0x6608..0x663F reserved */ + volatile uint64_t porthead0; /* Offset 0x6640 (R) */ + volatile uint64_t porthead1; /* Offset 0x6648 (R) */ + volatile uint64_t porthead2; /* Offset 0x6650 (R) */ + volatile uint64_t porthead3; /* Offset 0x6658 (R) */ + volatile uint64_t portheadnb0; /* Offset 0x6660 (R) */ + volatile uint64_t portheadnb1; /* Offset 0x6668 (R) */ + volatile uint64_t portheadnb2; /* Offset 0x6670 (R) */ + volatile uint64_t portheadnb3; /* Offset 0x6678 (R) */ + volatile uint64_t hartid; /* Offset 0x6680 (R) */ + uint8_t _pad38[0x1200]; /* 0x6688..0x7887 reserved */ + volatile uint64_t mvendorid; /* Offset 0x7888 (R) */ + volatile uint64_t marchid; /* Offset 0x7890 (R) */ + volatile uint64_t mimpid; /* Offset 0x7898 (R) */ + volatile uint64_t mhartid; /* Offset 0x78A0 (R) */ + uint8_t _pad39[0x558]; /* 0x78A8..0x7DFF reserved */ + volatile uint64_t dcache_debug; /* Offset 0x7E00 (R) */ +} Minion_csr_t, *PTR_Minion_csr_t; + +#ifdef __cplusplus +} +#endif + +#endif /* _MINION_CSR_H_ */ diff --git a/erbium-hal/include/hwinc/plic.h b/erbium-hal/include/hwinc/plic.h new file mode 100644 index 000000000..b3be3cdb6 --- /dev/null +++ b/erbium-hal/include/hwinc/plic.h @@ -0,0 +1,3266 @@ +/* Auto-generated by rdl2hal.py from SystemRDL. Do not edit. */ +#ifndef _PLIC_H_ +#define _PLIC_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* ============================================================ */ +/* Block: PLIC_cpu (macro prefix: PLIC_CPU) */ +/* ============================================================ */ + +/* Register: PLIC_CPU.priority_src01 */ +#define PLIC_CPU_PRIORITY_SRC01_ADDRESS 0x00000004ul +#define PLIC_CPU_PRIORITY_SRC01_BYTE_ADDRESS 0x00000004ul +#define PLIC_CPU_PRIORITY_SRC01_OFFSET 0x00000004ul +#define PLIC_CPU_PRIORITY_SRC01_BYTE_OFFSET 0x00000004ul +#define PLIC_CPU_PRIORITY_SRC01_SIZE 0x00000004ul +#define PLIC_CPU_PRIORITY_SRC01_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_PRIORITY_SRC01_READ_ACCESS 1u +#define PLIC_CPU_PRIORITY_SRC01_WRITE_ACCESS 0u +#define PLIC_CPU_PRIORITY_SRC01_RESET_VALUE 0x00000001ul +#define PLIC_CPU_PRIORITY_SRC01_RESET_MASK 0x00000001ul +#define PLIC_CPU_PRIORITY_SRC01_READ_MASK 0x00000001ul +#define PLIC_CPU_PRIORITY_SRC01_WRITE_MASK 0x00000000ul + +/* Field: PLIC_CPU_PRIORITY_SRC01.PRIORITY */ +#define PLIC_CPU_PRIORITY_SRC01_PRIORITY_MSB 0u +#define PLIC_CPU_PRIORITY_SRC01_PRIORITY_LSB 0u +#define PLIC_CPU_PRIORITY_SRC01_PRIORITY_WIDTH 1u +#define PLIC_CPU_PRIORITY_SRC01_PRIORITY_READ_ACCESS 1u +#define PLIC_CPU_PRIORITY_SRC01_PRIORITY_WRITE_ACCESS 0u +#define PLIC_CPU_PRIORITY_SRC01_PRIORITY_RESET 0x00000001ul +#define PLIC_CPU_PRIORITY_SRC01_PRIORITY_FIELD_MASK 0x00000001ul +#define PLIC_CPU_PRIORITY_SRC01_PRIORITY_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_PRIORITY_SRC01_PRIORITY_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_PRIORITY_SRC01_PRIORITY_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Register: PLIC_CPU.priority_src02 */ +#define PLIC_CPU_PRIORITY_SRC02_ADDRESS 0x00000008ul +#define PLIC_CPU_PRIORITY_SRC02_BYTE_ADDRESS 0x00000008ul +#define PLIC_CPU_PRIORITY_SRC02_OFFSET 0x00000008ul +#define PLIC_CPU_PRIORITY_SRC02_BYTE_OFFSET 0x00000008ul +#define PLIC_CPU_PRIORITY_SRC02_SIZE 0x00000004ul +#define PLIC_CPU_PRIORITY_SRC02_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_PRIORITY_SRC02_READ_ACCESS 1u +#define PLIC_CPU_PRIORITY_SRC02_WRITE_ACCESS 0u +#define PLIC_CPU_PRIORITY_SRC02_RESET_VALUE 0x00000001ul +#define PLIC_CPU_PRIORITY_SRC02_RESET_MASK 0x00000001ul +#define PLIC_CPU_PRIORITY_SRC02_READ_MASK 0x00000001ul +#define PLIC_CPU_PRIORITY_SRC02_WRITE_MASK 0x00000000ul + +/* Field: PLIC_CPU_PRIORITY_SRC02.PRIORITY */ +#define PLIC_CPU_PRIORITY_SRC02_PRIORITY_MSB 0u +#define PLIC_CPU_PRIORITY_SRC02_PRIORITY_LSB 0u +#define PLIC_CPU_PRIORITY_SRC02_PRIORITY_WIDTH 1u +#define PLIC_CPU_PRIORITY_SRC02_PRIORITY_READ_ACCESS 1u +#define PLIC_CPU_PRIORITY_SRC02_PRIORITY_WRITE_ACCESS 0u +#define PLIC_CPU_PRIORITY_SRC02_PRIORITY_RESET 0x00000001ul +#define PLIC_CPU_PRIORITY_SRC02_PRIORITY_FIELD_MASK 0x00000001ul +#define PLIC_CPU_PRIORITY_SRC02_PRIORITY_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_PRIORITY_SRC02_PRIORITY_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_PRIORITY_SRC02_PRIORITY_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Register: PLIC_CPU.priority_src03 */ +#define PLIC_CPU_PRIORITY_SRC03_ADDRESS 0x0000000Cul +#define PLIC_CPU_PRIORITY_SRC03_BYTE_ADDRESS 0x0000000Cul +#define PLIC_CPU_PRIORITY_SRC03_OFFSET 0x0000000Cul +#define PLIC_CPU_PRIORITY_SRC03_BYTE_OFFSET 0x0000000Cul +#define PLIC_CPU_PRIORITY_SRC03_SIZE 0x00000004ul +#define PLIC_CPU_PRIORITY_SRC03_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_PRIORITY_SRC03_READ_ACCESS 1u +#define PLIC_CPU_PRIORITY_SRC03_WRITE_ACCESS 0u +#define PLIC_CPU_PRIORITY_SRC03_RESET_VALUE 0x00000001ul +#define PLIC_CPU_PRIORITY_SRC03_RESET_MASK 0x00000001ul +#define PLIC_CPU_PRIORITY_SRC03_READ_MASK 0x00000001ul +#define PLIC_CPU_PRIORITY_SRC03_WRITE_MASK 0x00000000ul + +/* Field: PLIC_CPU_PRIORITY_SRC03.PRIORITY */ +#define PLIC_CPU_PRIORITY_SRC03_PRIORITY_MSB 0u +#define PLIC_CPU_PRIORITY_SRC03_PRIORITY_LSB 0u +#define PLIC_CPU_PRIORITY_SRC03_PRIORITY_WIDTH 1u +#define PLIC_CPU_PRIORITY_SRC03_PRIORITY_READ_ACCESS 1u +#define PLIC_CPU_PRIORITY_SRC03_PRIORITY_WRITE_ACCESS 0u +#define PLIC_CPU_PRIORITY_SRC03_PRIORITY_RESET 0x00000001ul +#define PLIC_CPU_PRIORITY_SRC03_PRIORITY_FIELD_MASK 0x00000001ul +#define PLIC_CPU_PRIORITY_SRC03_PRIORITY_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_PRIORITY_SRC03_PRIORITY_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_PRIORITY_SRC03_PRIORITY_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Register: PLIC_CPU.priority_src04 */ +#define PLIC_CPU_PRIORITY_SRC04_ADDRESS 0x00000010ul +#define PLIC_CPU_PRIORITY_SRC04_BYTE_ADDRESS 0x00000010ul +#define PLIC_CPU_PRIORITY_SRC04_OFFSET 0x00000010ul +#define PLIC_CPU_PRIORITY_SRC04_BYTE_OFFSET 0x00000010ul +#define PLIC_CPU_PRIORITY_SRC04_SIZE 0x00000004ul +#define PLIC_CPU_PRIORITY_SRC04_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_PRIORITY_SRC04_READ_ACCESS 1u +#define PLIC_CPU_PRIORITY_SRC04_WRITE_ACCESS 0u +#define PLIC_CPU_PRIORITY_SRC04_RESET_VALUE 0x00000001ul +#define PLIC_CPU_PRIORITY_SRC04_RESET_MASK 0x00000001ul +#define PLIC_CPU_PRIORITY_SRC04_READ_MASK 0x00000001ul +#define PLIC_CPU_PRIORITY_SRC04_WRITE_MASK 0x00000000ul + +/* Field: PLIC_CPU_PRIORITY_SRC04.PRIORITY */ +#define PLIC_CPU_PRIORITY_SRC04_PRIORITY_MSB 0u +#define PLIC_CPU_PRIORITY_SRC04_PRIORITY_LSB 0u +#define PLIC_CPU_PRIORITY_SRC04_PRIORITY_WIDTH 1u +#define PLIC_CPU_PRIORITY_SRC04_PRIORITY_READ_ACCESS 1u +#define PLIC_CPU_PRIORITY_SRC04_PRIORITY_WRITE_ACCESS 0u +#define PLIC_CPU_PRIORITY_SRC04_PRIORITY_RESET 0x00000001ul +#define PLIC_CPU_PRIORITY_SRC04_PRIORITY_FIELD_MASK 0x00000001ul +#define PLIC_CPU_PRIORITY_SRC04_PRIORITY_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_PRIORITY_SRC04_PRIORITY_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_PRIORITY_SRC04_PRIORITY_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Register: PLIC_CPU.priority_src05 */ +#define PLIC_CPU_PRIORITY_SRC05_ADDRESS 0x00000014ul +#define PLIC_CPU_PRIORITY_SRC05_BYTE_ADDRESS 0x00000014ul +#define PLIC_CPU_PRIORITY_SRC05_OFFSET 0x00000014ul +#define PLIC_CPU_PRIORITY_SRC05_BYTE_OFFSET 0x00000014ul +#define PLIC_CPU_PRIORITY_SRC05_SIZE 0x00000004ul +#define PLIC_CPU_PRIORITY_SRC05_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_PRIORITY_SRC05_READ_ACCESS 1u +#define PLIC_CPU_PRIORITY_SRC05_WRITE_ACCESS 0u +#define PLIC_CPU_PRIORITY_SRC05_RESET_VALUE 0x00000001ul +#define PLIC_CPU_PRIORITY_SRC05_RESET_MASK 0x00000001ul +#define PLIC_CPU_PRIORITY_SRC05_READ_MASK 0x00000001ul +#define PLIC_CPU_PRIORITY_SRC05_WRITE_MASK 0x00000000ul + +/* Field: PLIC_CPU_PRIORITY_SRC05.PRIORITY */ +#define PLIC_CPU_PRIORITY_SRC05_PRIORITY_MSB 0u +#define PLIC_CPU_PRIORITY_SRC05_PRIORITY_LSB 0u +#define PLIC_CPU_PRIORITY_SRC05_PRIORITY_WIDTH 1u +#define PLIC_CPU_PRIORITY_SRC05_PRIORITY_READ_ACCESS 1u +#define PLIC_CPU_PRIORITY_SRC05_PRIORITY_WRITE_ACCESS 0u +#define PLIC_CPU_PRIORITY_SRC05_PRIORITY_RESET 0x00000001ul +#define PLIC_CPU_PRIORITY_SRC05_PRIORITY_FIELD_MASK 0x00000001ul +#define PLIC_CPU_PRIORITY_SRC05_PRIORITY_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_PRIORITY_SRC05_PRIORITY_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_PRIORITY_SRC05_PRIORITY_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Register: PLIC_CPU.priority_src06 */ +#define PLIC_CPU_PRIORITY_SRC06_ADDRESS 0x00000018ul +#define PLIC_CPU_PRIORITY_SRC06_BYTE_ADDRESS 0x00000018ul +#define PLIC_CPU_PRIORITY_SRC06_OFFSET 0x00000018ul +#define PLIC_CPU_PRIORITY_SRC06_BYTE_OFFSET 0x00000018ul +#define PLIC_CPU_PRIORITY_SRC06_SIZE 0x00000004ul +#define PLIC_CPU_PRIORITY_SRC06_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_PRIORITY_SRC06_READ_ACCESS 1u +#define PLIC_CPU_PRIORITY_SRC06_WRITE_ACCESS 0u +#define PLIC_CPU_PRIORITY_SRC06_RESET_VALUE 0x00000001ul +#define PLIC_CPU_PRIORITY_SRC06_RESET_MASK 0x00000001ul +#define PLIC_CPU_PRIORITY_SRC06_READ_MASK 0x00000001ul +#define PLIC_CPU_PRIORITY_SRC06_WRITE_MASK 0x00000000ul + +/* Field: PLIC_CPU_PRIORITY_SRC06.PRIORITY */ +#define PLIC_CPU_PRIORITY_SRC06_PRIORITY_MSB 0u +#define PLIC_CPU_PRIORITY_SRC06_PRIORITY_LSB 0u +#define PLIC_CPU_PRIORITY_SRC06_PRIORITY_WIDTH 1u +#define PLIC_CPU_PRIORITY_SRC06_PRIORITY_READ_ACCESS 1u +#define PLIC_CPU_PRIORITY_SRC06_PRIORITY_WRITE_ACCESS 0u +#define PLIC_CPU_PRIORITY_SRC06_PRIORITY_RESET 0x00000001ul +#define PLIC_CPU_PRIORITY_SRC06_PRIORITY_FIELD_MASK 0x00000001ul +#define PLIC_CPU_PRIORITY_SRC06_PRIORITY_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_PRIORITY_SRC06_PRIORITY_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_PRIORITY_SRC06_PRIORITY_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Register: PLIC_CPU.pending */ +#define PLIC_CPU_PENDING_ADDRESS 0x00001000ul +#define PLIC_CPU_PENDING_BYTE_ADDRESS 0x00001000ul +#define PLIC_CPU_PENDING_OFFSET 0x00001000ul +#define PLIC_CPU_PENDING_BYTE_OFFSET 0x00001000ul +#define PLIC_CPU_PENDING_SIZE 0x00000004ul +#define PLIC_CPU_PENDING_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_PENDING_READ_ACCESS 1u +#define PLIC_CPU_PENDING_WRITE_ACCESS 0u +#define PLIC_CPU_PENDING_RESET_VALUE 0x00000000ul +#define PLIC_CPU_PENDING_RESET_MASK 0x0000007Ful +#define PLIC_CPU_PENDING_READ_MASK 0x0000007Ful +#define PLIC_CPU_PENDING_WRITE_MASK 0x00000000ul + +/* Field: PLIC_CPU_PENDING.RESERVED */ +#define PLIC_CPU_PENDING_RESERVED_MSB 0u +#define PLIC_CPU_PENDING_RESERVED_LSB 0u +#define PLIC_CPU_PENDING_RESERVED_WIDTH 1u +#define PLIC_CPU_PENDING_RESERVED_READ_ACCESS 1u +#define PLIC_CPU_PENDING_RESERVED_WRITE_ACCESS 0u +#define PLIC_CPU_PENDING_RESERVED_RESET 0x00000000ul +#define PLIC_CPU_PENDING_RESERVED_FIELD_MASK 0x00000001ul +#define PLIC_CPU_PENDING_RESERVED_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_PENDING_RESERVED_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_PENDING_RESERVED_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Field: PLIC_CPU_PENDING.PENDING */ +#define PLIC_CPU_PENDING_PENDING_MSB 6u +#define PLIC_CPU_PENDING_PENDING_LSB 1u +#define PLIC_CPU_PENDING_PENDING_WIDTH 6u +#define PLIC_CPU_PENDING_PENDING_READ_ACCESS 1u +#define PLIC_CPU_PENDING_PENDING_WRITE_ACCESS 0u +#define PLIC_CPU_PENDING_PENDING_RESET 0x00000000ul +#define PLIC_CPU_PENDING_PENDING_FIELD_MASK 0x0000007Eul +#define PLIC_CPU_PENDING_PENDING_GET(x) (((x) & 0x0000007Eul) >> 1) +#define PLIC_CPU_PENDING_PENDING_SET(x) (((x) << 1) & 0x0000007Eul) +#define PLIC_CPU_PENDING_PENDING_MODIFY(r, x) ((((x) << 1) & 0x0000007Eul) | ((r) & 0xFFFFFF81ul)) + +/* Register: PLIC_CPU.enable_ctx00 */ +#define PLIC_CPU_ENABLE_CTX00_ADDRESS 0x00002000ul +#define PLIC_CPU_ENABLE_CTX00_BYTE_ADDRESS 0x00002000ul +#define PLIC_CPU_ENABLE_CTX00_OFFSET 0x00002000ul +#define PLIC_CPU_ENABLE_CTX00_BYTE_OFFSET 0x00002000ul +#define PLIC_CPU_ENABLE_CTX00_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX00_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX00_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX00_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX00_RESET_VALUE 0x00000000ul +#define PLIC_CPU_ENABLE_CTX00_RESET_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX00_READ_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX00_WRITE_MASK 0x0000007Eul + +/* Field: PLIC_CPU_ENABLE_CTX00.RESERVED */ +#define PLIC_CPU_ENABLE_CTX00_RESERVED_MSB 0u +#define PLIC_CPU_ENABLE_CTX00_RESERVED_LSB 0u +#define PLIC_CPU_ENABLE_CTX00_RESERVED_WIDTH 1u +#define PLIC_CPU_ENABLE_CTX00_RESERVED_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX00_RESERVED_WRITE_ACCESS 0u +#define PLIC_CPU_ENABLE_CTX00_RESERVED_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX00_RESERVED_FIELD_MASK 0x00000001ul +#define PLIC_CPU_ENABLE_CTX00_RESERVED_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX00_RESERVED_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX00_RESERVED_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Field: PLIC_CPU_ENABLE_CTX00.ENABLE */ +#define PLIC_CPU_ENABLE_CTX00_ENABLE_MSB 6u +#define PLIC_CPU_ENABLE_CTX00_ENABLE_LSB 1u +#define PLIC_CPU_ENABLE_CTX00_ENABLE_WIDTH 6u +#define PLIC_CPU_ENABLE_CTX00_ENABLE_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX00_ENABLE_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX00_ENABLE_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX00_ENABLE_FIELD_MASK 0x0000007Eul +#define PLIC_CPU_ENABLE_CTX00_ENABLE_GET(x) (((x) & 0x0000007Eul) >> 1) +#define PLIC_CPU_ENABLE_CTX00_ENABLE_SET(x) (((x) << 1) & 0x0000007Eul) +#define PLIC_CPU_ENABLE_CTX00_ENABLE_MODIFY(r, x) ((((x) << 1) & 0x0000007Eul) | ((r) & 0xFFFFFF81ul)) + +/* Register: PLIC_CPU.enable_ctx01 */ +#define PLIC_CPU_ENABLE_CTX01_ADDRESS 0x00002080ul +#define PLIC_CPU_ENABLE_CTX01_BYTE_ADDRESS 0x00002080ul +#define PLIC_CPU_ENABLE_CTX01_OFFSET 0x00002080ul +#define PLIC_CPU_ENABLE_CTX01_BYTE_OFFSET 0x00002080ul +#define PLIC_CPU_ENABLE_CTX01_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX01_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX01_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX01_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX01_RESET_VALUE 0x00000000ul +#define PLIC_CPU_ENABLE_CTX01_RESET_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX01_READ_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX01_WRITE_MASK 0x0000007Eul + +/* Field: PLIC_CPU_ENABLE_CTX01.RESERVED */ +#define PLIC_CPU_ENABLE_CTX01_RESERVED_MSB 0u +#define PLIC_CPU_ENABLE_CTX01_RESERVED_LSB 0u +#define PLIC_CPU_ENABLE_CTX01_RESERVED_WIDTH 1u +#define PLIC_CPU_ENABLE_CTX01_RESERVED_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX01_RESERVED_WRITE_ACCESS 0u +#define PLIC_CPU_ENABLE_CTX01_RESERVED_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX01_RESERVED_FIELD_MASK 0x00000001ul +#define PLIC_CPU_ENABLE_CTX01_RESERVED_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX01_RESERVED_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX01_RESERVED_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Field: PLIC_CPU_ENABLE_CTX01.ENABLE */ +#define PLIC_CPU_ENABLE_CTX01_ENABLE_MSB 6u +#define PLIC_CPU_ENABLE_CTX01_ENABLE_LSB 1u +#define PLIC_CPU_ENABLE_CTX01_ENABLE_WIDTH 6u +#define PLIC_CPU_ENABLE_CTX01_ENABLE_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX01_ENABLE_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX01_ENABLE_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX01_ENABLE_FIELD_MASK 0x0000007Eul +#define PLIC_CPU_ENABLE_CTX01_ENABLE_GET(x) (((x) & 0x0000007Eul) >> 1) +#define PLIC_CPU_ENABLE_CTX01_ENABLE_SET(x) (((x) << 1) & 0x0000007Eul) +#define PLIC_CPU_ENABLE_CTX01_ENABLE_MODIFY(r, x) ((((x) << 1) & 0x0000007Eul) | ((r) & 0xFFFFFF81ul)) + +/* Register: PLIC_CPU.enable_ctx02 */ +#define PLIC_CPU_ENABLE_CTX02_ADDRESS 0x00002100ul +#define PLIC_CPU_ENABLE_CTX02_BYTE_ADDRESS 0x00002100ul +#define PLIC_CPU_ENABLE_CTX02_OFFSET 0x00002100ul +#define PLIC_CPU_ENABLE_CTX02_BYTE_OFFSET 0x00002100ul +#define PLIC_CPU_ENABLE_CTX02_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX02_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX02_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX02_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX02_RESET_VALUE 0x00000000ul +#define PLIC_CPU_ENABLE_CTX02_RESET_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX02_READ_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX02_WRITE_MASK 0x0000007Eul + +/* Field: PLIC_CPU_ENABLE_CTX02.RESERVED */ +#define PLIC_CPU_ENABLE_CTX02_RESERVED_MSB 0u +#define PLIC_CPU_ENABLE_CTX02_RESERVED_LSB 0u +#define PLIC_CPU_ENABLE_CTX02_RESERVED_WIDTH 1u +#define PLIC_CPU_ENABLE_CTX02_RESERVED_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX02_RESERVED_WRITE_ACCESS 0u +#define PLIC_CPU_ENABLE_CTX02_RESERVED_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX02_RESERVED_FIELD_MASK 0x00000001ul +#define PLIC_CPU_ENABLE_CTX02_RESERVED_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX02_RESERVED_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX02_RESERVED_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Field: PLIC_CPU_ENABLE_CTX02.ENABLE */ +#define PLIC_CPU_ENABLE_CTX02_ENABLE_MSB 6u +#define PLIC_CPU_ENABLE_CTX02_ENABLE_LSB 1u +#define PLIC_CPU_ENABLE_CTX02_ENABLE_WIDTH 6u +#define PLIC_CPU_ENABLE_CTX02_ENABLE_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX02_ENABLE_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX02_ENABLE_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX02_ENABLE_FIELD_MASK 0x0000007Eul +#define PLIC_CPU_ENABLE_CTX02_ENABLE_GET(x) (((x) & 0x0000007Eul) >> 1) +#define PLIC_CPU_ENABLE_CTX02_ENABLE_SET(x) (((x) << 1) & 0x0000007Eul) +#define PLIC_CPU_ENABLE_CTX02_ENABLE_MODIFY(r, x) ((((x) << 1) & 0x0000007Eul) | ((r) & 0xFFFFFF81ul)) + +/* Register: PLIC_CPU.enable_ctx03 */ +#define PLIC_CPU_ENABLE_CTX03_ADDRESS 0x00002180ul +#define PLIC_CPU_ENABLE_CTX03_BYTE_ADDRESS 0x00002180ul +#define PLIC_CPU_ENABLE_CTX03_OFFSET 0x00002180ul +#define PLIC_CPU_ENABLE_CTX03_BYTE_OFFSET 0x00002180ul +#define PLIC_CPU_ENABLE_CTX03_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX03_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX03_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX03_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX03_RESET_VALUE 0x00000000ul +#define PLIC_CPU_ENABLE_CTX03_RESET_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX03_READ_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX03_WRITE_MASK 0x0000007Eul + +/* Field: PLIC_CPU_ENABLE_CTX03.RESERVED */ +#define PLIC_CPU_ENABLE_CTX03_RESERVED_MSB 0u +#define PLIC_CPU_ENABLE_CTX03_RESERVED_LSB 0u +#define PLIC_CPU_ENABLE_CTX03_RESERVED_WIDTH 1u +#define PLIC_CPU_ENABLE_CTX03_RESERVED_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX03_RESERVED_WRITE_ACCESS 0u +#define PLIC_CPU_ENABLE_CTX03_RESERVED_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX03_RESERVED_FIELD_MASK 0x00000001ul +#define PLIC_CPU_ENABLE_CTX03_RESERVED_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX03_RESERVED_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX03_RESERVED_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Field: PLIC_CPU_ENABLE_CTX03.ENABLE */ +#define PLIC_CPU_ENABLE_CTX03_ENABLE_MSB 6u +#define PLIC_CPU_ENABLE_CTX03_ENABLE_LSB 1u +#define PLIC_CPU_ENABLE_CTX03_ENABLE_WIDTH 6u +#define PLIC_CPU_ENABLE_CTX03_ENABLE_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX03_ENABLE_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX03_ENABLE_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX03_ENABLE_FIELD_MASK 0x0000007Eul +#define PLIC_CPU_ENABLE_CTX03_ENABLE_GET(x) (((x) & 0x0000007Eul) >> 1) +#define PLIC_CPU_ENABLE_CTX03_ENABLE_SET(x) (((x) << 1) & 0x0000007Eul) +#define PLIC_CPU_ENABLE_CTX03_ENABLE_MODIFY(r, x) ((((x) << 1) & 0x0000007Eul) | ((r) & 0xFFFFFF81ul)) + +/* Register: PLIC_CPU.enable_ctx04 */ +#define PLIC_CPU_ENABLE_CTX04_ADDRESS 0x00002200ul +#define PLIC_CPU_ENABLE_CTX04_BYTE_ADDRESS 0x00002200ul +#define PLIC_CPU_ENABLE_CTX04_OFFSET 0x00002200ul +#define PLIC_CPU_ENABLE_CTX04_BYTE_OFFSET 0x00002200ul +#define PLIC_CPU_ENABLE_CTX04_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX04_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX04_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX04_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX04_RESET_VALUE 0x00000000ul +#define PLIC_CPU_ENABLE_CTX04_RESET_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX04_READ_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX04_WRITE_MASK 0x0000007Eul + +/* Field: PLIC_CPU_ENABLE_CTX04.RESERVED */ +#define PLIC_CPU_ENABLE_CTX04_RESERVED_MSB 0u +#define PLIC_CPU_ENABLE_CTX04_RESERVED_LSB 0u +#define PLIC_CPU_ENABLE_CTX04_RESERVED_WIDTH 1u +#define PLIC_CPU_ENABLE_CTX04_RESERVED_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX04_RESERVED_WRITE_ACCESS 0u +#define PLIC_CPU_ENABLE_CTX04_RESERVED_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX04_RESERVED_FIELD_MASK 0x00000001ul +#define PLIC_CPU_ENABLE_CTX04_RESERVED_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX04_RESERVED_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX04_RESERVED_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Field: PLIC_CPU_ENABLE_CTX04.ENABLE */ +#define PLIC_CPU_ENABLE_CTX04_ENABLE_MSB 6u +#define PLIC_CPU_ENABLE_CTX04_ENABLE_LSB 1u +#define PLIC_CPU_ENABLE_CTX04_ENABLE_WIDTH 6u +#define PLIC_CPU_ENABLE_CTX04_ENABLE_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX04_ENABLE_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX04_ENABLE_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX04_ENABLE_FIELD_MASK 0x0000007Eul +#define PLIC_CPU_ENABLE_CTX04_ENABLE_GET(x) (((x) & 0x0000007Eul) >> 1) +#define PLIC_CPU_ENABLE_CTX04_ENABLE_SET(x) (((x) << 1) & 0x0000007Eul) +#define PLIC_CPU_ENABLE_CTX04_ENABLE_MODIFY(r, x) ((((x) << 1) & 0x0000007Eul) | ((r) & 0xFFFFFF81ul)) + +/* Register: PLIC_CPU.enable_ctx05 */ +#define PLIC_CPU_ENABLE_CTX05_ADDRESS 0x00002280ul +#define PLIC_CPU_ENABLE_CTX05_BYTE_ADDRESS 0x00002280ul +#define PLIC_CPU_ENABLE_CTX05_OFFSET 0x00002280ul +#define PLIC_CPU_ENABLE_CTX05_BYTE_OFFSET 0x00002280ul +#define PLIC_CPU_ENABLE_CTX05_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX05_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX05_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX05_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX05_RESET_VALUE 0x00000000ul +#define PLIC_CPU_ENABLE_CTX05_RESET_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX05_READ_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX05_WRITE_MASK 0x0000007Eul + +/* Field: PLIC_CPU_ENABLE_CTX05.RESERVED */ +#define PLIC_CPU_ENABLE_CTX05_RESERVED_MSB 0u +#define PLIC_CPU_ENABLE_CTX05_RESERVED_LSB 0u +#define PLIC_CPU_ENABLE_CTX05_RESERVED_WIDTH 1u +#define PLIC_CPU_ENABLE_CTX05_RESERVED_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX05_RESERVED_WRITE_ACCESS 0u +#define PLIC_CPU_ENABLE_CTX05_RESERVED_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX05_RESERVED_FIELD_MASK 0x00000001ul +#define PLIC_CPU_ENABLE_CTX05_RESERVED_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX05_RESERVED_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX05_RESERVED_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Field: PLIC_CPU_ENABLE_CTX05.ENABLE */ +#define PLIC_CPU_ENABLE_CTX05_ENABLE_MSB 6u +#define PLIC_CPU_ENABLE_CTX05_ENABLE_LSB 1u +#define PLIC_CPU_ENABLE_CTX05_ENABLE_WIDTH 6u +#define PLIC_CPU_ENABLE_CTX05_ENABLE_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX05_ENABLE_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX05_ENABLE_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX05_ENABLE_FIELD_MASK 0x0000007Eul +#define PLIC_CPU_ENABLE_CTX05_ENABLE_GET(x) (((x) & 0x0000007Eul) >> 1) +#define PLIC_CPU_ENABLE_CTX05_ENABLE_SET(x) (((x) << 1) & 0x0000007Eul) +#define PLIC_CPU_ENABLE_CTX05_ENABLE_MODIFY(r, x) ((((x) << 1) & 0x0000007Eul) | ((r) & 0xFFFFFF81ul)) + +/* Register: PLIC_CPU.enable_ctx06 */ +#define PLIC_CPU_ENABLE_CTX06_ADDRESS 0x00002300ul +#define PLIC_CPU_ENABLE_CTX06_BYTE_ADDRESS 0x00002300ul +#define PLIC_CPU_ENABLE_CTX06_OFFSET 0x00002300ul +#define PLIC_CPU_ENABLE_CTX06_BYTE_OFFSET 0x00002300ul +#define PLIC_CPU_ENABLE_CTX06_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX06_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX06_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX06_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX06_RESET_VALUE 0x00000000ul +#define PLIC_CPU_ENABLE_CTX06_RESET_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX06_READ_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX06_WRITE_MASK 0x0000007Eul + +/* Field: PLIC_CPU_ENABLE_CTX06.RESERVED */ +#define PLIC_CPU_ENABLE_CTX06_RESERVED_MSB 0u +#define PLIC_CPU_ENABLE_CTX06_RESERVED_LSB 0u +#define PLIC_CPU_ENABLE_CTX06_RESERVED_WIDTH 1u +#define PLIC_CPU_ENABLE_CTX06_RESERVED_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX06_RESERVED_WRITE_ACCESS 0u +#define PLIC_CPU_ENABLE_CTX06_RESERVED_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX06_RESERVED_FIELD_MASK 0x00000001ul +#define PLIC_CPU_ENABLE_CTX06_RESERVED_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX06_RESERVED_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX06_RESERVED_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Field: PLIC_CPU_ENABLE_CTX06.ENABLE */ +#define PLIC_CPU_ENABLE_CTX06_ENABLE_MSB 6u +#define PLIC_CPU_ENABLE_CTX06_ENABLE_LSB 1u +#define PLIC_CPU_ENABLE_CTX06_ENABLE_WIDTH 6u +#define PLIC_CPU_ENABLE_CTX06_ENABLE_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX06_ENABLE_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX06_ENABLE_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX06_ENABLE_FIELD_MASK 0x0000007Eul +#define PLIC_CPU_ENABLE_CTX06_ENABLE_GET(x) (((x) & 0x0000007Eul) >> 1) +#define PLIC_CPU_ENABLE_CTX06_ENABLE_SET(x) (((x) << 1) & 0x0000007Eul) +#define PLIC_CPU_ENABLE_CTX06_ENABLE_MODIFY(r, x) ((((x) << 1) & 0x0000007Eul) | ((r) & 0xFFFFFF81ul)) + +/* Register: PLIC_CPU.enable_ctx07 */ +#define PLIC_CPU_ENABLE_CTX07_ADDRESS 0x00002380ul +#define PLIC_CPU_ENABLE_CTX07_BYTE_ADDRESS 0x00002380ul +#define PLIC_CPU_ENABLE_CTX07_OFFSET 0x00002380ul +#define PLIC_CPU_ENABLE_CTX07_BYTE_OFFSET 0x00002380ul +#define PLIC_CPU_ENABLE_CTX07_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX07_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX07_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX07_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX07_RESET_VALUE 0x00000000ul +#define PLIC_CPU_ENABLE_CTX07_RESET_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX07_READ_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX07_WRITE_MASK 0x0000007Eul + +/* Field: PLIC_CPU_ENABLE_CTX07.RESERVED */ +#define PLIC_CPU_ENABLE_CTX07_RESERVED_MSB 0u +#define PLIC_CPU_ENABLE_CTX07_RESERVED_LSB 0u +#define PLIC_CPU_ENABLE_CTX07_RESERVED_WIDTH 1u +#define PLIC_CPU_ENABLE_CTX07_RESERVED_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX07_RESERVED_WRITE_ACCESS 0u +#define PLIC_CPU_ENABLE_CTX07_RESERVED_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX07_RESERVED_FIELD_MASK 0x00000001ul +#define PLIC_CPU_ENABLE_CTX07_RESERVED_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX07_RESERVED_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX07_RESERVED_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Field: PLIC_CPU_ENABLE_CTX07.ENABLE */ +#define PLIC_CPU_ENABLE_CTX07_ENABLE_MSB 6u +#define PLIC_CPU_ENABLE_CTX07_ENABLE_LSB 1u +#define PLIC_CPU_ENABLE_CTX07_ENABLE_WIDTH 6u +#define PLIC_CPU_ENABLE_CTX07_ENABLE_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX07_ENABLE_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX07_ENABLE_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX07_ENABLE_FIELD_MASK 0x0000007Eul +#define PLIC_CPU_ENABLE_CTX07_ENABLE_GET(x) (((x) & 0x0000007Eul) >> 1) +#define PLIC_CPU_ENABLE_CTX07_ENABLE_SET(x) (((x) << 1) & 0x0000007Eul) +#define PLIC_CPU_ENABLE_CTX07_ENABLE_MODIFY(r, x) ((((x) << 1) & 0x0000007Eul) | ((r) & 0xFFFFFF81ul)) + +/* Register: PLIC_CPU.enable_ctx08 */ +#define PLIC_CPU_ENABLE_CTX08_ADDRESS 0x00002400ul +#define PLIC_CPU_ENABLE_CTX08_BYTE_ADDRESS 0x00002400ul +#define PLIC_CPU_ENABLE_CTX08_OFFSET 0x00002400ul +#define PLIC_CPU_ENABLE_CTX08_BYTE_OFFSET 0x00002400ul +#define PLIC_CPU_ENABLE_CTX08_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX08_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX08_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX08_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX08_RESET_VALUE 0x00000000ul +#define PLIC_CPU_ENABLE_CTX08_RESET_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX08_READ_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX08_WRITE_MASK 0x0000007Eul + +/* Field: PLIC_CPU_ENABLE_CTX08.RESERVED */ +#define PLIC_CPU_ENABLE_CTX08_RESERVED_MSB 0u +#define PLIC_CPU_ENABLE_CTX08_RESERVED_LSB 0u +#define PLIC_CPU_ENABLE_CTX08_RESERVED_WIDTH 1u +#define PLIC_CPU_ENABLE_CTX08_RESERVED_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX08_RESERVED_WRITE_ACCESS 0u +#define PLIC_CPU_ENABLE_CTX08_RESERVED_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX08_RESERVED_FIELD_MASK 0x00000001ul +#define PLIC_CPU_ENABLE_CTX08_RESERVED_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX08_RESERVED_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX08_RESERVED_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Field: PLIC_CPU_ENABLE_CTX08.ENABLE */ +#define PLIC_CPU_ENABLE_CTX08_ENABLE_MSB 6u +#define PLIC_CPU_ENABLE_CTX08_ENABLE_LSB 1u +#define PLIC_CPU_ENABLE_CTX08_ENABLE_WIDTH 6u +#define PLIC_CPU_ENABLE_CTX08_ENABLE_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX08_ENABLE_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX08_ENABLE_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX08_ENABLE_FIELD_MASK 0x0000007Eul +#define PLIC_CPU_ENABLE_CTX08_ENABLE_GET(x) (((x) & 0x0000007Eul) >> 1) +#define PLIC_CPU_ENABLE_CTX08_ENABLE_SET(x) (((x) << 1) & 0x0000007Eul) +#define PLIC_CPU_ENABLE_CTX08_ENABLE_MODIFY(r, x) ((((x) << 1) & 0x0000007Eul) | ((r) & 0xFFFFFF81ul)) + +/* Register: PLIC_CPU.enable_ctx09 */ +#define PLIC_CPU_ENABLE_CTX09_ADDRESS 0x00002480ul +#define PLIC_CPU_ENABLE_CTX09_BYTE_ADDRESS 0x00002480ul +#define PLIC_CPU_ENABLE_CTX09_OFFSET 0x00002480ul +#define PLIC_CPU_ENABLE_CTX09_BYTE_OFFSET 0x00002480ul +#define PLIC_CPU_ENABLE_CTX09_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX09_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX09_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX09_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX09_RESET_VALUE 0x00000000ul +#define PLIC_CPU_ENABLE_CTX09_RESET_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX09_READ_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX09_WRITE_MASK 0x0000007Eul + +/* Field: PLIC_CPU_ENABLE_CTX09.RESERVED */ +#define PLIC_CPU_ENABLE_CTX09_RESERVED_MSB 0u +#define PLIC_CPU_ENABLE_CTX09_RESERVED_LSB 0u +#define PLIC_CPU_ENABLE_CTX09_RESERVED_WIDTH 1u +#define PLIC_CPU_ENABLE_CTX09_RESERVED_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX09_RESERVED_WRITE_ACCESS 0u +#define PLIC_CPU_ENABLE_CTX09_RESERVED_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX09_RESERVED_FIELD_MASK 0x00000001ul +#define PLIC_CPU_ENABLE_CTX09_RESERVED_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX09_RESERVED_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX09_RESERVED_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Field: PLIC_CPU_ENABLE_CTX09.ENABLE */ +#define PLIC_CPU_ENABLE_CTX09_ENABLE_MSB 6u +#define PLIC_CPU_ENABLE_CTX09_ENABLE_LSB 1u +#define PLIC_CPU_ENABLE_CTX09_ENABLE_WIDTH 6u +#define PLIC_CPU_ENABLE_CTX09_ENABLE_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX09_ENABLE_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX09_ENABLE_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX09_ENABLE_FIELD_MASK 0x0000007Eul +#define PLIC_CPU_ENABLE_CTX09_ENABLE_GET(x) (((x) & 0x0000007Eul) >> 1) +#define PLIC_CPU_ENABLE_CTX09_ENABLE_SET(x) (((x) << 1) & 0x0000007Eul) +#define PLIC_CPU_ENABLE_CTX09_ENABLE_MODIFY(r, x) ((((x) << 1) & 0x0000007Eul) | ((r) & 0xFFFFFF81ul)) + +/* Register: PLIC_CPU.enable_ctx10 */ +#define PLIC_CPU_ENABLE_CTX10_ADDRESS 0x00002500ul +#define PLIC_CPU_ENABLE_CTX10_BYTE_ADDRESS 0x00002500ul +#define PLIC_CPU_ENABLE_CTX10_OFFSET 0x00002500ul +#define PLIC_CPU_ENABLE_CTX10_BYTE_OFFSET 0x00002500ul +#define PLIC_CPU_ENABLE_CTX10_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX10_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX10_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX10_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX10_RESET_VALUE 0x00000000ul +#define PLIC_CPU_ENABLE_CTX10_RESET_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX10_READ_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX10_WRITE_MASK 0x0000007Eul + +/* Field: PLIC_CPU_ENABLE_CTX10.RESERVED */ +#define PLIC_CPU_ENABLE_CTX10_RESERVED_MSB 0u +#define PLIC_CPU_ENABLE_CTX10_RESERVED_LSB 0u +#define PLIC_CPU_ENABLE_CTX10_RESERVED_WIDTH 1u +#define PLIC_CPU_ENABLE_CTX10_RESERVED_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX10_RESERVED_WRITE_ACCESS 0u +#define PLIC_CPU_ENABLE_CTX10_RESERVED_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX10_RESERVED_FIELD_MASK 0x00000001ul +#define PLIC_CPU_ENABLE_CTX10_RESERVED_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX10_RESERVED_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX10_RESERVED_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Field: PLIC_CPU_ENABLE_CTX10.ENABLE */ +#define PLIC_CPU_ENABLE_CTX10_ENABLE_MSB 6u +#define PLIC_CPU_ENABLE_CTX10_ENABLE_LSB 1u +#define PLIC_CPU_ENABLE_CTX10_ENABLE_WIDTH 6u +#define PLIC_CPU_ENABLE_CTX10_ENABLE_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX10_ENABLE_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX10_ENABLE_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX10_ENABLE_FIELD_MASK 0x0000007Eul +#define PLIC_CPU_ENABLE_CTX10_ENABLE_GET(x) (((x) & 0x0000007Eul) >> 1) +#define PLIC_CPU_ENABLE_CTX10_ENABLE_SET(x) (((x) << 1) & 0x0000007Eul) +#define PLIC_CPU_ENABLE_CTX10_ENABLE_MODIFY(r, x) ((((x) << 1) & 0x0000007Eul) | ((r) & 0xFFFFFF81ul)) + +/* Register: PLIC_CPU.enable_ctx11 */ +#define PLIC_CPU_ENABLE_CTX11_ADDRESS 0x00002580ul +#define PLIC_CPU_ENABLE_CTX11_BYTE_ADDRESS 0x00002580ul +#define PLIC_CPU_ENABLE_CTX11_OFFSET 0x00002580ul +#define PLIC_CPU_ENABLE_CTX11_BYTE_OFFSET 0x00002580ul +#define PLIC_CPU_ENABLE_CTX11_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX11_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX11_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX11_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX11_RESET_VALUE 0x00000000ul +#define PLIC_CPU_ENABLE_CTX11_RESET_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX11_READ_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX11_WRITE_MASK 0x0000007Eul + +/* Field: PLIC_CPU_ENABLE_CTX11.RESERVED */ +#define PLIC_CPU_ENABLE_CTX11_RESERVED_MSB 0u +#define PLIC_CPU_ENABLE_CTX11_RESERVED_LSB 0u +#define PLIC_CPU_ENABLE_CTX11_RESERVED_WIDTH 1u +#define PLIC_CPU_ENABLE_CTX11_RESERVED_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX11_RESERVED_WRITE_ACCESS 0u +#define PLIC_CPU_ENABLE_CTX11_RESERVED_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX11_RESERVED_FIELD_MASK 0x00000001ul +#define PLIC_CPU_ENABLE_CTX11_RESERVED_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX11_RESERVED_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX11_RESERVED_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Field: PLIC_CPU_ENABLE_CTX11.ENABLE */ +#define PLIC_CPU_ENABLE_CTX11_ENABLE_MSB 6u +#define PLIC_CPU_ENABLE_CTX11_ENABLE_LSB 1u +#define PLIC_CPU_ENABLE_CTX11_ENABLE_WIDTH 6u +#define PLIC_CPU_ENABLE_CTX11_ENABLE_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX11_ENABLE_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX11_ENABLE_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX11_ENABLE_FIELD_MASK 0x0000007Eul +#define PLIC_CPU_ENABLE_CTX11_ENABLE_GET(x) (((x) & 0x0000007Eul) >> 1) +#define PLIC_CPU_ENABLE_CTX11_ENABLE_SET(x) (((x) << 1) & 0x0000007Eul) +#define PLIC_CPU_ENABLE_CTX11_ENABLE_MODIFY(r, x) ((((x) << 1) & 0x0000007Eul) | ((r) & 0xFFFFFF81ul)) + +/* Register: PLIC_CPU.enable_ctx12 */ +#define PLIC_CPU_ENABLE_CTX12_ADDRESS 0x00002600ul +#define PLIC_CPU_ENABLE_CTX12_BYTE_ADDRESS 0x00002600ul +#define PLIC_CPU_ENABLE_CTX12_OFFSET 0x00002600ul +#define PLIC_CPU_ENABLE_CTX12_BYTE_OFFSET 0x00002600ul +#define PLIC_CPU_ENABLE_CTX12_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX12_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX12_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX12_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX12_RESET_VALUE 0x00000000ul +#define PLIC_CPU_ENABLE_CTX12_RESET_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX12_READ_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX12_WRITE_MASK 0x0000007Eul + +/* Field: PLIC_CPU_ENABLE_CTX12.RESERVED */ +#define PLIC_CPU_ENABLE_CTX12_RESERVED_MSB 0u +#define PLIC_CPU_ENABLE_CTX12_RESERVED_LSB 0u +#define PLIC_CPU_ENABLE_CTX12_RESERVED_WIDTH 1u +#define PLIC_CPU_ENABLE_CTX12_RESERVED_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX12_RESERVED_WRITE_ACCESS 0u +#define PLIC_CPU_ENABLE_CTX12_RESERVED_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX12_RESERVED_FIELD_MASK 0x00000001ul +#define PLIC_CPU_ENABLE_CTX12_RESERVED_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX12_RESERVED_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX12_RESERVED_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Field: PLIC_CPU_ENABLE_CTX12.ENABLE */ +#define PLIC_CPU_ENABLE_CTX12_ENABLE_MSB 6u +#define PLIC_CPU_ENABLE_CTX12_ENABLE_LSB 1u +#define PLIC_CPU_ENABLE_CTX12_ENABLE_WIDTH 6u +#define PLIC_CPU_ENABLE_CTX12_ENABLE_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX12_ENABLE_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX12_ENABLE_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX12_ENABLE_FIELD_MASK 0x0000007Eul +#define PLIC_CPU_ENABLE_CTX12_ENABLE_GET(x) (((x) & 0x0000007Eul) >> 1) +#define PLIC_CPU_ENABLE_CTX12_ENABLE_SET(x) (((x) << 1) & 0x0000007Eul) +#define PLIC_CPU_ENABLE_CTX12_ENABLE_MODIFY(r, x) ((((x) << 1) & 0x0000007Eul) | ((r) & 0xFFFFFF81ul)) + +/* Register: PLIC_CPU.enable_ctx13 */ +#define PLIC_CPU_ENABLE_CTX13_ADDRESS 0x00002680ul +#define PLIC_CPU_ENABLE_CTX13_BYTE_ADDRESS 0x00002680ul +#define PLIC_CPU_ENABLE_CTX13_OFFSET 0x00002680ul +#define PLIC_CPU_ENABLE_CTX13_BYTE_OFFSET 0x00002680ul +#define PLIC_CPU_ENABLE_CTX13_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX13_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX13_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX13_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX13_RESET_VALUE 0x00000000ul +#define PLIC_CPU_ENABLE_CTX13_RESET_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX13_READ_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX13_WRITE_MASK 0x0000007Eul + +/* Field: PLIC_CPU_ENABLE_CTX13.RESERVED */ +#define PLIC_CPU_ENABLE_CTX13_RESERVED_MSB 0u +#define PLIC_CPU_ENABLE_CTX13_RESERVED_LSB 0u +#define PLIC_CPU_ENABLE_CTX13_RESERVED_WIDTH 1u +#define PLIC_CPU_ENABLE_CTX13_RESERVED_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX13_RESERVED_WRITE_ACCESS 0u +#define PLIC_CPU_ENABLE_CTX13_RESERVED_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX13_RESERVED_FIELD_MASK 0x00000001ul +#define PLIC_CPU_ENABLE_CTX13_RESERVED_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX13_RESERVED_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX13_RESERVED_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Field: PLIC_CPU_ENABLE_CTX13.ENABLE */ +#define PLIC_CPU_ENABLE_CTX13_ENABLE_MSB 6u +#define PLIC_CPU_ENABLE_CTX13_ENABLE_LSB 1u +#define PLIC_CPU_ENABLE_CTX13_ENABLE_WIDTH 6u +#define PLIC_CPU_ENABLE_CTX13_ENABLE_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX13_ENABLE_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX13_ENABLE_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX13_ENABLE_FIELD_MASK 0x0000007Eul +#define PLIC_CPU_ENABLE_CTX13_ENABLE_GET(x) (((x) & 0x0000007Eul) >> 1) +#define PLIC_CPU_ENABLE_CTX13_ENABLE_SET(x) (((x) << 1) & 0x0000007Eul) +#define PLIC_CPU_ENABLE_CTX13_ENABLE_MODIFY(r, x) ((((x) << 1) & 0x0000007Eul) | ((r) & 0xFFFFFF81ul)) + +/* Register: PLIC_CPU.enable_ctx14 */ +#define PLIC_CPU_ENABLE_CTX14_ADDRESS 0x00002700ul +#define PLIC_CPU_ENABLE_CTX14_BYTE_ADDRESS 0x00002700ul +#define PLIC_CPU_ENABLE_CTX14_OFFSET 0x00002700ul +#define PLIC_CPU_ENABLE_CTX14_BYTE_OFFSET 0x00002700ul +#define PLIC_CPU_ENABLE_CTX14_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX14_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX14_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX14_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX14_RESET_VALUE 0x00000000ul +#define PLIC_CPU_ENABLE_CTX14_RESET_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX14_READ_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX14_WRITE_MASK 0x0000007Eul + +/* Field: PLIC_CPU_ENABLE_CTX14.RESERVED */ +#define PLIC_CPU_ENABLE_CTX14_RESERVED_MSB 0u +#define PLIC_CPU_ENABLE_CTX14_RESERVED_LSB 0u +#define PLIC_CPU_ENABLE_CTX14_RESERVED_WIDTH 1u +#define PLIC_CPU_ENABLE_CTX14_RESERVED_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX14_RESERVED_WRITE_ACCESS 0u +#define PLIC_CPU_ENABLE_CTX14_RESERVED_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX14_RESERVED_FIELD_MASK 0x00000001ul +#define PLIC_CPU_ENABLE_CTX14_RESERVED_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX14_RESERVED_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX14_RESERVED_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Field: PLIC_CPU_ENABLE_CTX14.ENABLE */ +#define PLIC_CPU_ENABLE_CTX14_ENABLE_MSB 6u +#define PLIC_CPU_ENABLE_CTX14_ENABLE_LSB 1u +#define PLIC_CPU_ENABLE_CTX14_ENABLE_WIDTH 6u +#define PLIC_CPU_ENABLE_CTX14_ENABLE_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX14_ENABLE_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX14_ENABLE_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX14_ENABLE_FIELD_MASK 0x0000007Eul +#define PLIC_CPU_ENABLE_CTX14_ENABLE_GET(x) (((x) & 0x0000007Eul) >> 1) +#define PLIC_CPU_ENABLE_CTX14_ENABLE_SET(x) (((x) << 1) & 0x0000007Eul) +#define PLIC_CPU_ENABLE_CTX14_ENABLE_MODIFY(r, x) ((((x) << 1) & 0x0000007Eul) | ((r) & 0xFFFFFF81ul)) + +/* Register: PLIC_CPU.enable_ctx15 */ +#define PLIC_CPU_ENABLE_CTX15_ADDRESS 0x00002780ul +#define PLIC_CPU_ENABLE_CTX15_BYTE_ADDRESS 0x00002780ul +#define PLIC_CPU_ENABLE_CTX15_OFFSET 0x00002780ul +#define PLIC_CPU_ENABLE_CTX15_BYTE_OFFSET 0x00002780ul +#define PLIC_CPU_ENABLE_CTX15_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX15_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX15_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX15_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX15_RESET_VALUE 0x00000000ul +#define PLIC_CPU_ENABLE_CTX15_RESET_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX15_READ_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX15_WRITE_MASK 0x0000007Eul + +/* Field: PLIC_CPU_ENABLE_CTX15.RESERVED */ +#define PLIC_CPU_ENABLE_CTX15_RESERVED_MSB 0u +#define PLIC_CPU_ENABLE_CTX15_RESERVED_LSB 0u +#define PLIC_CPU_ENABLE_CTX15_RESERVED_WIDTH 1u +#define PLIC_CPU_ENABLE_CTX15_RESERVED_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX15_RESERVED_WRITE_ACCESS 0u +#define PLIC_CPU_ENABLE_CTX15_RESERVED_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX15_RESERVED_FIELD_MASK 0x00000001ul +#define PLIC_CPU_ENABLE_CTX15_RESERVED_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX15_RESERVED_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX15_RESERVED_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Field: PLIC_CPU_ENABLE_CTX15.ENABLE */ +#define PLIC_CPU_ENABLE_CTX15_ENABLE_MSB 6u +#define PLIC_CPU_ENABLE_CTX15_ENABLE_LSB 1u +#define PLIC_CPU_ENABLE_CTX15_ENABLE_WIDTH 6u +#define PLIC_CPU_ENABLE_CTX15_ENABLE_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX15_ENABLE_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX15_ENABLE_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX15_ENABLE_FIELD_MASK 0x0000007Eul +#define PLIC_CPU_ENABLE_CTX15_ENABLE_GET(x) (((x) & 0x0000007Eul) >> 1) +#define PLIC_CPU_ENABLE_CTX15_ENABLE_SET(x) (((x) << 1) & 0x0000007Eul) +#define PLIC_CPU_ENABLE_CTX15_ENABLE_MODIFY(r, x) ((((x) << 1) & 0x0000007Eul) | ((r) & 0xFFFFFF81ul)) + +/* Register: PLIC_CPU.enable_ctx16 */ +#define PLIC_CPU_ENABLE_CTX16_ADDRESS 0x00002800ul +#define PLIC_CPU_ENABLE_CTX16_BYTE_ADDRESS 0x00002800ul +#define PLIC_CPU_ENABLE_CTX16_OFFSET 0x00002800ul +#define PLIC_CPU_ENABLE_CTX16_BYTE_OFFSET 0x00002800ul +#define PLIC_CPU_ENABLE_CTX16_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX16_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX16_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX16_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX16_RESET_VALUE 0x00000000ul +#define PLIC_CPU_ENABLE_CTX16_RESET_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX16_READ_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX16_WRITE_MASK 0x0000007Eul + +/* Field: PLIC_CPU_ENABLE_CTX16.RESERVED */ +#define PLIC_CPU_ENABLE_CTX16_RESERVED_MSB 0u +#define PLIC_CPU_ENABLE_CTX16_RESERVED_LSB 0u +#define PLIC_CPU_ENABLE_CTX16_RESERVED_WIDTH 1u +#define PLIC_CPU_ENABLE_CTX16_RESERVED_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX16_RESERVED_WRITE_ACCESS 0u +#define PLIC_CPU_ENABLE_CTX16_RESERVED_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX16_RESERVED_FIELD_MASK 0x00000001ul +#define PLIC_CPU_ENABLE_CTX16_RESERVED_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX16_RESERVED_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX16_RESERVED_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Field: PLIC_CPU_ENABLE_CTX16.ENABLE */ +#define PLIC_CPU_ENABLE_CTX16_ENABLE_MSB 6u +#define PLIC_CPU_ENABLE_CTX16_ENABLE_LSB 1u +#define PLIC_CPU_ENABLE_CTX16_ENABLE_WIDTH 6u +#define PLIC_CPU_ENABLE_CTX16_ENABLE_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX16_ENABLE_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX16_ENABLE_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX16_ENABLE_FIELD_MASK 0x0000007Eul +#define PLIC_CPU_ENABLE_CTX16_ENABLE_GET(x) (((x) & 0x0000007Eul) >> 1) +#define PLIC_CPU_ENABLE_CTX16_ENABLE_SET(x) (((x) << 1) & 0x0000007Eul) +#define PLIC_CPU_ENABLE_CTX16_ENABLE_MODIFY(r, x) ((((x) << 1) & 0x0000007Eul) | ((r) & 0xFFFFFF81ul)) + +/* Register: PLIC_CPU.enable_ctx17 */ +#define PLIC_CPU_ENABLE_CTX17_ADDRESS 0x00002880ul +#define PLIC_CPU_ENABLE_CTX17_BYTE_ADDRESS 0x00002880ul +#define PLIC_CPU_ENABLE_CTX17_OFFSET 0x00002880ul +#define PLIC_CPU_ENABLE_CTX17_BYTE_OFFSET 0x00002880ul +#define PLIC_CPU_ENABLE_CTX17_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX17_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX17_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX17_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX17_RESET_VALUE 0x00000000ul +#define PLIC_CPU_ENABLE_CTX17_RESET_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX17_READ_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX17_WRITE_MASK 0x0000007Eul + +/* Field: PLIC_CPU_ENABLE_CTX17.RESERVED */ +#define PLIC_CPU_ENABLE_CTX17_RESERVED_MSB 0u +#define PLIC_CPU_ENABLE_CTX17_RESERVED_LSB 0u +#define PLIC_CPU_ENABLE_CTX17_RESERVED_WIDTH 1u +#define PLIC_CPU_ENABLE_CTX17_RESERVED_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX17_RESERVED_WRITE_ACCESS 0u +#define PLIC_CPU_ENABLE_CTX17_RESERVED_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX17_RESERVED_FIELD_MASK 0x00000001ul +#define PLIC_CPU_ENABLE_CTX17_RESERVED_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX17_RESERVED_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX17_RESERVED_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Field: PLIC_CPU_ENABLE_CTX17.ENABLE */ +#define PLIC_CPU_ENABLE_CTX17_ENABLE_MSB 6u +#define PLIC_CPU_ENABLE_CTX17_ENABLE_LSB 1u +#define PLIC_CPU_ENABLE_CTX17_ENABLE_WIDTH 6u +#define PLIC_CPU_ENABLE_CTX17_ENABLE_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX17_ENABLE_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX17_ENABLE_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX17_ENABLE_FIELD_MASK 0x0000007Eul +#define PLIC_CPU_ENABLE_CTX17_ENABLE_GET(x) (((x) & 0x0000007Eul) >> 1) +#define PLIC_CPU_ENABLE_CTX17_ENABLE_SET(x) (((x) << 1) & 0x0000007Eul) +#define PLIC_CPU_ENABLE_CTX17_ENABLE_MODIFY(r, x) ((((x) << 1) & 0x0000007Eul) | ((r) & 0xFFFFFF81ul)) + +/* Register: PLIC_CPU.enable_ctx18 */ +#define PLIC_CPU_ENABLE_CTX18_ADDRESS 0x00002900ul +#define PLIC_CPU_ENABLE_CTX18_BYTE_ADDRESS 0x00002900ul +#define PLIC_CPU_ENABLE_CTX18_OFFSET 0x00002900ul +#define PLIC_CPU_ENABLE_CTX18_BYTE_OFFSET 0x00002900ul +#define PLIC_CPU_ENABLE_CTX18_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX18_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX18_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX18_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX18_RESET_VALUE 0x00000000ul +#define PLIC_CPU_ENABLE_CTX18_RESET_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX18_READ_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX18_WRITE_MASK 0x0000007Eul + +/* Field: PLIC_CPU_ENABLE_CTX18.RESERVED */ +#define PLIC_CPU_ENABLE_CTX18_RESERVED_MSB 0u +#define PLIC_CPU_ENABLE_CTX18_RESERVED_LSB 0u +#define PLIC_CPU_ENABLE_CTX18_RESERVED_WIDTH 1u +#define PLIC_CPU_ENABLE_CTX18_RESERVED_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX18_RESERVED_WRITE_ACCESS 0u +#define PLIC_CPU_ENABLE_CTX18_RESERVED_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX18_RESERVED_FIELD_MASK 0x00000001ul +#define PLIC_CPU_ENABLE_CTX18_RESERVED_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX18_RESERVED_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX18_RESERVED_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Field: PLIC_CPU_ENABLE_CTX18.ENABLE */ +#define PLIC_CPU_ENABLE_CTX18_ENABLE_MSB 6u +#define PLIC_CPU_ENABLE_CTX18_ENABLE_LSB 1u +#define PLIC_CPU_ENABLE_CTX18_ENABLE_WIDTH 6u +#define PLIC_CPU_ENABLE_CTX18_ENABLE_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX18_ENABLE_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX18_ENABLE_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX18_ENABLE_FIELD_MASK 0x0000007Eul +#define PLIC_CPU_ENABLE_CTX18_ENABLE_GET(x) (((x) & 0x0000007Eul) >> 1) +#define PLIC_CPU_ENABLE_CTX18_ENABLE_SET(x) (((x) << 1) & 0x0000007Eul) +#define PLIC_CPU_ENABLE_CTX18_ENABLE_MODIFY(r, x) ((((x) << 1) & 0x0000007Eul) | ((r) & 0xFFFFFF81ul)) + +/* Register: PLIC_CPU.enable_ctx19 */ +#define PLIC_CPU_ENABLE_CTX19_ADDRESS 0x00002980ul +#define PLIC_CPU_ENABLE_CTX19_BYTE_ADDRESS 0x00002980ul +#define PLIC_CPU_ENABLE_CTX19_OFFSET 0x00002980ul +#define PLIC_CPU_ENABLE_CTX19_BYTE_OFFSET 0x00002980ul +#define PLIC_CPU_ENABLE_CTX19_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX19_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX19_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX19_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX19_RESET_VALUE 0x00000000ul +#define PLIC_CPU_ENABLE_CTX19_RESET_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX19_READ_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX19_WRITE_MASK 0x0000007Eul + +/* Field: PLIC_CPU_ENABLE_CTX19.RESERVED */ +#define PLIC_CPU_ENABLE_CTX19_RESERVED_MSB 0u +#define PLIC_CPU_ENABLE_CTX19_RESERVED_LSB 0u +#define PLIC_CPU_ENABLE_CTX19_RESERVED_WIDTH 1u +#define PLIC_CPU_ENABLE_CTX19_RESERVED_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX19_RESERVED_WRITE_ACCESS 0u +#define PLIC_CPU_ENABLE_CTX19_RESERVED_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX19_RESERVED_FIELD_MASK 0x00000001ul +#define PLIC_CPU_ENABLE_CTX19_RESERVED_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX19_RESERVED_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX19_RESERVED_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Field: PLIC_CPU_ENABLE_CTX19.ENABLE */ +#define PLIC_CPU_ENABLE_CTX19_ENABLE_MSB 6u +#define PLIC_CPU_ENABLE_CTX19_ENABLE_LSB 1u +#define PLIC_CPU_ENABLE_CTX19_ENABLE_WIDTH 6u +#define PLIC_CPU_ENABLE_CTX19_ENABLE_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX19_ENABLE_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX19_ENABLE_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX19_ENABLE_FIELD_MASK 0x0000007Eul +#define PLIC_CPU_ENABLE_CTX19_ENABLE_GET(x) (((x) & 0x0000007Eul) >> 1) +#define PLIC_CPU_ENABLE_CTX19_ENABLE_SET(x) (((x) << 1) & 0x0000007Eul) +#define PLIC_CPU_ENABLE_CTX19_ENABLE_MODIFY(r, x) ((((x) << 1) & 0x0000007Eul) | ((r) & 0xFFFFFF81ul)) + +/* Register: PLIC_CPU.enable_ctx20 */ +#define PLIC_CPU_ENABLE_CTX20_ADDRESS 0x00002A00ul +#define PLIC_CPU_ENABLE_CTX20_BYTE_ADDRESS 0x00002A00ul +#define PLIC_CPU_ENABLE_CTX20_OFFSET 0x00002A00ul +#define PLIC_CPU_ENABLE_CTX20_BYTE_OFFSET 0x00002A00ul +#define PLIC_CPU_ENABLE_CTX20_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX20_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX20_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX20_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX20_RESET_VALUE 0x00000000ul +#define PLIC_CPU_ENABLE_CTX20_RESET_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX20_READ_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX20_WRITE_MASK 0x0000007Eul + +/* Field: PLIC_CPU_ENABLE_CTX20.RESERVED */ +#define PLIC_CPU_ENABLE_CTX20_RESERVED_MSB 0u +#define PLIC_CPU_ENABLE_CTX20_RESERVED_LSB 0u +#define PLIC_CPU_ENABLE_CTX20_RESERVED_WIDTH 1u +#define PLIC_CPU_ENABLE_CTX20_RESERVED_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX20_RESERVED_WRITE_ACCESS 0u +#define PLIC_CPU_ENABLE_CTX20_RESERVED_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX20_RESERVED_FIELD_MASK 0x00000001ul +#define PLIC_CPU_ENABLE_CTX20_RESERVED_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX20_RESERVED_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX20_RESERVED_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Field: PLIC_CPU_ENABLE_CTX20.ENABLE */ +#define PLIC_CPU_ENABLE_CTX20_ENABLE_MSB 6u +#define PLIC_CPU_ENABLE_CTX20_ENABLE_LSB 1u +#define PLIC_CPU_ENABLE_CTX20_ENABLE_WIDTH 6u +#define PLIC_CPU_ENABLE_CTX20_ENABLE_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX20_ENABLE_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX20_ENABLE_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX20_ENABLE_FIELD_MASK 0x0000007Eul +#define PLIC_CPU_ENABLE_CTX20_ENABLE_GET(x) (((x) & 0x0000007Eul) >> 1) +#define PLIC_CPU_ENABLE_CTX20_ENABLE_SET(x) (((x) << 1) & 0x0000007Eul) +#define PLIC_CPU_ENABLE_CTX20_ENABLE_MODIFY(r, x) ((((x) << 1) & 0x0000007Eul) | ((r) & 0xFFFFFF81ul)) + +/* Register: PLIC_CPU.enable_ctx21 */ +#define PLIC_CPU_ENABLE_CTX21_ADDRESS 0x00002A80ul +#define PLIC_CPU_ENABLE_CTX21_BYTE_ADDRESS 0x00002A80ul +#define PLIC_CPU_ENABLE_CTX21_OFFSET 0x00002A80ul +#define PLIC_CPU_ENABLE_CTX21_BYTE_OFFSET 0x00002A80ul +#define PLIC_CPU_ENABLE_CTX21_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX21_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX21_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX21_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX21_RESET_VALUE 0x00000000ul +#define PLIC_CPU_ENABLE_CTX21_RESET_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX21_READ_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX21_WRITE_MASK 0x0000007Eul + +/* Field: PLIC_CPU_ENABLE_CTX21.RESERVED */ +#define PLIC_CPU_ENABLE_CTX21_RESERVED_MSB 0u +#define PLIC_CPU_ENABLE_CTX21_RESERVED_LSB 0u +#define PLIC_CPU_ENABLE_CTX21_RESERVED_WIDTH 1u +#define PLIC_CPU_ENABLE_CTX21_RESERVED_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX21_RESERVED_WRITE_ACCESS 0u +#define PLIC_CPU_ENABLE_CTX21_RESERVED_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX21_RESERVED_FIELD_MASK 0x00000001ul +#define PLIC_CPU_ENABLE_CTX21_RESERVED_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX21_RESERVED_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX21_RESERVED_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Field: PLIC_CPU_ENABLE_CTX21.ENABLE */ +#define PLIC_CPU_ENABLE_CTX21_ENABLE_MSB 6u +#define PLIC_CPU_ENABLE_CTX21_ENABLE_LSB 1u +#define PLIC_CPU_ENABLE_CTX21_ENABLE_WIDTH 6u +#define PLIC_CPU_ENABLE_CTX21_ENABLE_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX21_ENABLE_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX21_ENABLE_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX21_ENABLE_FIELD_MASK 0x0000007Eul +#define PLIC_CPU_ENABLE_CTX21_ENABLE_GET(x) (((x) & 0x0000007Eul) >> 1) +#define PLIC_CPU_ENABLE_CTX21_ENABLE_SET(x) (((x) << 1) & 0x0000007Eul) +#define PLIC_CPU_ENABLE_CTX21_ENABLE_MODIFY(r, x) ((((x) << 1) & 0x0000007Eul) | ((r) & 0xFFFFFF81ul)) + +/* Register: PLIC_CPU.enable_ctx22 */ +#define PLIC_CPU_ENABLE_CTX22_ADDRESS 0x00002B00ul +#define PLIC_CPU_ENABLE_CTX22_BYTE_ADDRESS 0x00002B00ul +#define PLIC_CPU_ENABLE_CTX22_OFFSET 0x00002B00ul +#define PLIC_CPU_ENABLE_CTX22_BYTE_OFFSET 0x00002B00ul +#define PLIC_CPU_ENABLE_CTX22_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX22_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX22_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX22_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX22_RESET_VALUE 0x00000000ul +#define PLIC_CPU_ENABLE_CTX22_RESET_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX22_READ_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX22_WRITE_MASK 0x0000007Eul + +/* Field: PLIC_CPU_ENABLE_CTX22.RESERVED */ +#define PLIC_CPU_ENABLE_CTX22_RESERVED_MSB 0u +#define PLIC_CPU_ENABLE_CTX22_RESERVED_LSB 0u +#define PLIC_CPU_ENABLE_CTX22_RESERVED_WIDTH 1u +#define PLIC_CPU_ENABLE_CTX22_RESERVED_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX22_RESERVED_WRITE_ACCESS 0u +#define PLIC_CPU_ENABLE_CTX22_RESERVED_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX22_RESERVED_FIELD_MASK 0x00000001ul +#define PLIC_CPU_ENABLE_CTX22_RESERVED_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX22_RESERVED_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX22_RESERVED_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Field: PLIC_CPU_ENABLE_CTX22.ENABLE */ +#define PLIC_CPU_ENABLE_CTX22_ENABLE_MSB 6u +#define PLIC_CPU_ENABLE_CTX22_ENABLE_LSB 1u +#define PLIC_CPU_ENABLE_CTX22_ENABLE_WIDTH 6u +#define PLIC_CPU_ENABLE_CTX22_ENABLE_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX22_ENABLE_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX22_ENABLE_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX22_ENABLE_FIELD_MASK 0x0000007Eul +#define PLIC_CPU_ENABLE_CTX22_ENABLE_GET(x) (((x) & 0x0000007Eul) >> 1) +#define PLIC_CPU_ENABLE_CTX22_ENABLE_SET(x) (((x) << 1) & 0x0000007Eul) +#define PLIC_CPU_ENABLE_CTX22_ENABLE_MODIFY(r, x) ((((x) << 1) & 0x0000007Eul) | ((r) & 0xFFFFFF81ul)) + +/* Register: PLIC_CPU.enable_ctx23 */ +#define PLIC_CPU_ENABLE_CTX23_ADDRESS 0x00002B80ul +#define PLIC_CPU_ENABLE_CTX23_BYTE_ADDRESS 0x00002B80ul +#define PLIC_CPU_ENABLE_CTX23_OFFSET 0x00002B80ul +#define PLIC_CPU_ENABLE_CTX23_BYTE_OFFSET 0x00002B80ul +#define PLIC_CPU_ENABLE_CTX23_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX23_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX23_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX23_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX23_RESET_VALUE 0x00000000ul +#define PLIC_CPU_ENABLE_CTX23_RESET_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX23_READ_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX23_WRITE_MASK 0x0000007Eul + +/* Field: PLIC_CPU_ENABLE_CTX23.RESERVED */ +#define PLIC_CPU_ENABLE_CTX23_RESERVED_MSB 0u +#define PLIC_CPU_ENABLE_CTX23_RESERVED_LSB 0u +#define PLIC_CPU_ENABLE_CTX23_RESERVED_WIDTH 1u +#define PLIC_CPU_ENABLE_CTX23_RESERVED_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX23_RESERVED_WRITE_ACCESS 0u +#define PLIC_CPU_ENABLE_CTX23_RESERVED_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX23_RESERVED_FIELD_MASK 0x00000001ul +#define PLIC_CPU_ENABLE_CTX23_RESERVED_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX23_RESERVED_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX23_RESERVED_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Field: PLIC_CPU_ENABLE_CTX23.ENABLE */ +#define PLIC_CPU_ENABLE_CTX23_ENABLE_MSB 6u +#define PLIC_CPU_ENABLE_CTX23_ENABLE_LSB 1u +#define PLIC_CPU_ENABLE_CTX23_ENABLE_WIDTH 6u +#define PLIC_CPU_ENABLE_CTX23_ENABLE_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX23_ENABLE_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX23_ENABLE_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX23_ENABLE_FIELD_MASK 0x0000007Eul +#define PLIC_CPU_ENABLE_CTX23_ENABLE_GET(x) (((x) & 0x0000007Eul) >> 1) +#define PLIC_CPU_ENABLE_CTX23_ENABLE_SET(x) (((x) << 1) & 0x0000007Eul) +#define PLIC_CPU_ENABLE_CTX23_ENABLE_MODIFY(r, x) ((((x) << 1) & 0x0000007Eul) | ((r) & 0xFFFFFF81ul)) + +/* Register: PLIC_CPU.enable_ctx24 */ +#define PLIC_CPU_ENABLE_CTX24_ADDRESS 0x00002C00ul +#define PLIC_CPU_ENABLE_CTX24_BYTE_ADDRESS 0x00002C00ul +#define PLIC_CPU_ENABLE_CTX24_OFFSET 0x00002C00ul +#define PLIC_CPU_ENABLE_CTX24_BYTE_OFFSET 0x00002C00ul +#define PLIC_CPU_ENABLE_CTX24_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX24_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX24_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX24_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX24_RESET_VALUE 0x00000000ul +#define PLIC_CPU_ENABLE_CTX24_RESET_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX24_READ_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX24_WRITE_MASK 0x0000007Eul + +/* Field: PLIC_CPU_ENABLE_CTX24.RESERVED */ +#define PLIC_CPU_ENABLE_CTX24_RESERVED_MSB 0u +#define PLIC_CPU_ENABLE_CTX24_RESERVED_LSB 0u +#define PLIC_CPU_ENABLE_CTX24_RESERVED_WIDTH 1u +#define PLIC_CPU_ENABLE_CTX24_RESERVED_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX24_RESERVED_WRITE_ACCESS 0u +#define PLIC_CPU_ENABLE_CTX24_RESERVED_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX24_RESERVED_FIELD_MASK 0x00000001ul +#define PLIC_CPU_ENABLE_CTX24_RESERVED_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX24_RESERVED_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX24_RESERVED_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Field: PLIC_CPU_ENABLE_CTX24.ENABLE */ +#define PLIC_CPU_ENABLE_CTX24_ENABLE_MSB 6u +#define PLIC_CPU_ENABLE_CTX24_ENABLE_LSB 1u +#define PLIC_CPU_ENABLE_CTX24_ENABLE_WIDTH 6u +#define PLIC_CPU_ENABLE_CTX24_ENABLE_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX24_ENABLE_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX24_ENABLE_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX24_ENABLE_FIELD_MASK 0x0000007Eul +#define PLIC_CPU_ENABLE_CTX24_ENABLE_GET(x) (((x) & 0x0000007Eul) >> 1) +#define PLIC_CPU_ENABLE_CTX24_ENABLE_SET(x) (((x) << 1) & 0x0000007Eul) +#define PLIC_CPU_ENABLE_CTX24_ENABLE_MODIFY(r, x) ((((x) << 1) & 0x0000007Eul) | ((r) & 0xFFFFFF81ul)) + +/* Register: PLIC_CPU.enable_ctx25 */ +#define PLIC_CPU_ENABLE_CTX25_ADDRESS 0x00002C80ul +#define PLIC_CPU_ENABLE_CTX25_BYTE_ADDRESS 0x00002C80ul +#define PLIC_CPU_ENABLE_CTX25_OFFSET 0x00002C80ul +#define PLIC_CPU_ENABLE_CTX25_BYTE_OFFSET 0x00002C80ul +#define PLIC_CPU_ENABLE_CTX25_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX25_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX25_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX25_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX25_RESET_VALUE 0x00000000ul +#define PLIC_CPU_ENABLE_CTX25_RESET_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX25_READ_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX25_WRITE_MASK 0x0000007Eul + +/* Field: PLIC_CPU_ENABLE_CTX25.RESERVED */ +#define PLIC_CPU_ENABLE_CTX25_RESERVED_MSB 0u +#define PLIC_CPU_ENABLE_CTX25_RESERVED_LSB 0u +#define PLIC_CPU_ENABLE_CTX25_RESERVED_WIDTH 1u +#define PLIC_CPU_ENABLE_CTX25_RESERVED_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX25_RESERVED_WRITE_ACCESS 0u +#define PLIC_CPU_ENABLE_CTX25_RESERVED_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX25_RESERVED_FIELD_MASK 0x00000001ul +#define PLIC_CPU_ENABLE_CTX25_RESERVED_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX25_RESERVED_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX25_RESERVED_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Field: PLIC_CPU_ENABLE_CTX25.ENABLE */ +#define PLIC_CPU_ENABLE_CTX25_ENABLE_MSB 6u +#define PLIC_CPU_ENABLE_CTX25_ENABLE_LSB 1u +#define PLIC_CPU_ENABLE_CTX25_ENABLE_WIDTH 6u +#define PLIC_CPU_ENABLE_CTX25_ENABLE_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX25_ENABLE_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX25_ENABLE_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX25_ENABLE_FIELD_MASK 0x0000007Eul +#define PLIC_CPU_ENABLE_CTX25_ENABLE_GET(x) (((x) & 0x0000007Eul) >> 1) +#define PLIC_CPU_ENABLE_CTX25_ENABLE_SET(x) (((x) << 1) & 0x0000007Eul) +#define PLIC_CPU_ENABLE_CTX25_ENABLE_MODIFY(r, x) ((((x) << 1) & 0x0000007Eul) | ((r) & 0xFFFFFF81ul)) + +/* Register: PLIC_CPU.enable_ctx26 */ +#define PLIC_CPU_ENABLE_CTX26_ADDRESS 0x00002D00ul +#define PLIC_CPU_ENABLE_CTX26_BYTE_ADDRESS 0x00002D00ul +#define PLIC_CPU_ENABLE_CTX26_OFFSET 0x00002D00ul +#define PLIC_CPU_ENABLE_CTX26_BYTE_OFFSET 0x00002D00ul +#define PLIC_CPU_ENABLE_CTX26_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX26_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX26_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX26_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX26_RESET_VALUE 0x00000000ul +#define PLIC_CPU_ENABLE_CTX26_RESET_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX26_READ_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX26_WRITE_MASK 0x0000007Eul + +/* Field: PLIC_CPU_ENABLE_CTX26.RESERVED */ +#define PLIC_CPU_ENABLE_CTX26_RESERVED_MSB 0u +#define PLIC_CPU_ENABLE_CTX26_RESERVED_LSB 0u +#define PLIC_CPU_ENABLE_CTX26_RESERVED_WIDTH 1u +#define PLIC_CPU_ENABLE_CTX26_RESERVED_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX26_RESERVED_WRITE_ACCESS 0u +#define PLIC_CPU_ENABLE_CTX26_RESERVED_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX26_RESERVED_FIELD_MASK 0x00000001ul +#define PLIC_CPU_ENABLE_CTX26_RESERVED_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX26_RESERVED_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX26_RESERVED_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Field: PLIC_CPU_ENABLE_CTX26.ENABLE */ +#define PLIC_CPU_ENABLE_CTX26_ENABLE_MSB 6u +#define PLIC_CPU_ENABLE_CTX26_ENABLE_LSB 1u +#define PLIC_CPU_ENABLE_CTX26_ENABLE_WIDTH 6u +#define PLIC_CPU_ENABLE_CTX26_ENABLE_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX26_ENABLE_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX26_ENABLE_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX26_ENABLE_FIELD_MASK 0x0000007Eul +#define PLIC_CPU_ENABLE_CTX26_ENABLE_GET(x) (((x) & 0x0000007Eul) >> 1) +#define PLIC_CPU_ENABLE_CTX26_ENABLE_SET(x) (((x) << 1) & 0x0000007Eul) +#define PLIC_CPU_ENABLE_CTX26_ENABLE_MODIFY(r, x) ((((x) << 1) & 0x0000007Eul) | ((r) & 0xFFFFFF81ul)) + +/* Register: PLIC_CPU.enable_ctx27 */ +#define PLIC_CPU_ENABLE_CTX27_ADDRESS 0x00002D80ul +#define PLIC_CPU_ENABLE_CTX27_BYTE_ADDRESS 0x00002D80ul +#define PLIC_CPU_ENABLE_CTX27_OFFSET 0x00002D80ul +#define PLIC_CPU_ENABLE_CTX27_BYTE_OFFSET 0x00002D80ul +#define PLIC_CPU_ENABLE_CTX27_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX27_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX27_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX27_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX27_RESET_VALUE 0x00000000ul +#define PLIC_CPU_ENABLE_CTX27_RESET_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX27_READ_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX27_WRITE_MASK 0x0000007Eul + +/* Field: PLIC_CPU_ENABLE_CTX27.RESERVED */ +#define PLIC_CPU_ENABLE_CTX27_RESERVED_MSB 0u +#define PLIC_CPU_ENABLE_CTX27_RESERVED_LSB 0u +#define PLIC_CPU_ENABLE_CTX27_RESERVED_WIDTH 1u +#define PLIC_CPU_ENABLE_CTX27_RESERVED_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX27_RESERVED_WRITE_ACCESS 0u +#define PLIC_CPU_ENABLE_CTX27_RESERVED_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX27_RESERVED_FIELD_MASK 0x00000001ul +#define PLIC_CPU_ENABLE_CTX27_RESERVED_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX27_RESERVED_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX27_RESERVED_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Field: PLIC_CPU_ENABLE_CTX27.ENABLE */ +#define PLIC_CPU_ENABLE_CTX27_ENABLE_MSB 6u +#define PLIC_CPU_ENABLE_CTX27_ENABLE_LSB 1u +#define PLIC_CPU_ENABLE_CTX27_ENABLE_WIDTH 6u +#define PLIC_CPU_ENABLE_CTX27_ENABLE_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX27_ENABLE_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX27_ENABLE_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX27_ENABLE_FIELD_MASK 0x0000007Eul +#define PLIC_CPU_ENABLE_CTX27_ENABLE_GET(x) (((x) & 0x0000007Eul) >> 1) +#define PLIC_CPU_ENABLE_CTX27_ENABLE_SET(x) (((x) << 1) & 0x0000007Eul) +#define PLIC_CPU_ENABLE_CTX27_ENABLE_MODIFY(r, x) ((((x) << 1) & 0x0000007Eul) | ((r) & 0xFFFFFF81ul)) + +/* Register: PLIC_CPU.enable_ctx28 */ +#define PLIC_CPU_ENABLE_CTX28_ADDRESS 0x00002E00ul +#define PLIC_CPU_ENABLE_CTX28_BYTE_ADDRESS 0x00002E00ul +#define PLIC_CPU_ENABLE_CTX28_OFFSET 0x00002E00ul +#define PLIC_CPU_ENABLE_CTX28_BYTE_OFFSET 0x00002E00ul +#define PLIC_CPU_ENABLE_CTX28_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX28_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX28_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX28_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX28_RESET_VALUE 0x00000000ul +#define PLIC_CPU_ENABLE_CTX28_RESET_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX28_READ_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX28_WRITE_MASK 0x0000007Eul + +/* Field: PLIC_CPU_ENABLE_CTX28.RESERVED */ +#define PLIC_CPU_ENABLE_CTX28_RESERVED_MSB 0u +#define PLIC_CPU_ENABLE_CTX28_RESERVED_LSB 0u +#define PLIC_CPU_ENABLE_CTX28_RESERVED_WIDTH 1u +#define PLIC_CPU_ENABLE_CTX28_RESERVED_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX28_RESERVED_WRITE_ACCESS 0u +#define PLIC_CPU_ENABLE_CTX28_RESERVED_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX28_RESERVED_FIELD_MASK 0x00000001ul +#define PLIC_CPU_ENABLE_CTX28_RESERVED_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX28_RESERVED_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX28_RESERVED_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Field: PLIC_CPU_ENABLE_CTX28.ENABLE */ +#define PLIC_CPU_ENABLE_CTX28_ENABLE_MSB 6u +#define PLIC_CPU_ENABLE_CTX28_ENABLE_LSB 1u +#define PLIC_CPU_ENABLE_CTX28_ENABLE_WIDTH 6u +#define PLIC_CPU_ENABLE_CTX28_ENABLE_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX28_ENABLE_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX28_ENABLE_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX28_ENABLE_FIELD_MASK 0x0000007Eul +#define PLIC_CPU_ENABLE_CTX28_ENABLE_GET(x) (((x) & 0x0000007Eul) >> 1) +#define PLIC_CPU_ENABLE_CTX28_ENABLE_SET(x) (((x) << 1) & 0x0000007Eul) +#define PLIC_CPU_ENABLE_CTX28_ENABLE_MODIFY(r, x) ((((x) << 1) & 0x0000007Eul) | ((r) & 0xFFFFFF81ul)) + +/* Register: PLIC_CPU.enable_ctx29 */ +#define PLIC_CPU_ENABLE_CTX29_ADDRESS 0x00002E80ul +#define PLIC_CPU_ENABLE_CTX29_BYTE_ADDRESS 0x00002E80ul +#define PLIC_CPU_ENABLE_CTX29_OFFSET 0x00002E80ul +#define PLIC_CPU_ENABLE_CTX29_BYTE_OFFSET 0x00002E80ul +#define PLIC_CPU_ENABLE_CTX29_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX29_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX29_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX29_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX29_RESET_VALUE 0x00000000ul +#define PLIC_CPU_ENABLE_CTX29_RESET_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX29_READ_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX29_WRITE_MASK 0x0000007Eul + +/* Field: PLIC_CPU_ENABLE_CTX29.RESERVED */ +#define PLIC_CPU_ENABLE_CTX29_RESERVED_MSB 0u +#define PLIC_CPU_ENABLE_CTX29_RESERVED_LSB 0u +#define PLIC_CPU_ENABLE_CTX29_RESERVED_WIDTH 1u +#define PLIC_CPU_ENABLE_CTX29_RESERVED_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX29_RESERVED_WRITE_ACCESS 0u +#define PLIC_CPU_ENABLE_CTX29_RESERVED_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX29_RESERVED_FIELD_MASK 0x00000001ul +#define PLIC_CPU_ENABLE_CTX29_RESERVED_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX29_RESERVED_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX29_RESERVED_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Field: PLIC_CPU_ENABLE_CTX29.ENABLE */ +#define PLIC_CPU_ENABLE_CTX29_ENABLE_MSB 6u +#define PLIC_CPU_ENABLE_CTX29_ENABLE_LSB 1u +#define PLIC_CPU_ENABLE_CTX29_ENABLE_WIDTH 6u +#define PLIC_CPU_ENABLE_CTX29_ENABLE_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX29_ENABLE_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX29_ENABLE_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX29_ENABLE_FIELD_MASK 0x0000007Eul +#define PLIC_CPU_ENABLE_CTX29_ENABLE_GET(x) (((x) & 0x0000007Eul) >> 1) +#define PLIC_CPU_ENABLE_CTX29_ENABLE_SET(x) (((x) << 1) & 0x0000007Eul) +#define PLIC_CPU_ENABLE_CTX29_ENABLE_MODIFY(r, x) ((((x) << 1) & 0x0000007Eul) | ((r) & 0xFFFFFF81ul)) + +/* Register: PLIC_CPU.enable_ctx30 */ +#define PLIC_CPU_ENABLE_CTX30_ADDRESS 0x00002F00ul +#define PLIC_CPU_ENABLE_CTX30_BYTE_ADDRESS 0x00002F00ul +#define PLIC_CPU_ENABLE_CTX30_OFFSET 0x00002F00ul +#define PLIC_CPU_ENABLE_CTX30_BYTE_OFFSET 0x00002F00ul +#define PLIC_CPU_ENABLE_CTX30_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX30_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX30_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX30_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX30_RESET_VALUE 0x00000000ul +#define PLIC_CPU_ENABLE_CTX30_RESET_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX30_READ_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX30_WRITE_MASK 0x0000007Eul + +/* Field: PLIC_CPU_ENABLE_CTX30.RESERVED */ +#define PLIC_CPU_ENABLE_CTX30_RESERVED_MSB 0u +#define PLIC_CPU_ENABLE_CTX30_RESERVED_LSB 0u +#define PLIC_CPU_ENABLE_CTX30_RESERVED_WIDTH 1u +#define PLIC_CPU_ENABLE_CTX30_RESERVED_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX30_RESERVED_WRITE_ACCESS 0u +#define PLIC_CPU_ENABLE_CTX30_RESERVED_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX30_RESERVED_FIELD_MASK 0x00000001ul +#define PLIC_CPU_ENABLE_CTX30_RESERVED_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX30_RESERVED_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX30_RESERVED_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Field: PLIC_CPU_ENABLE_CTX30.ENABLE */ +#define PLIC_CPU_ENABLE_CTX30_ENABLE_MSB 6u +#define PLIC_CPU_ENABLE_CTX30_ENABLE_LSB 1u +#define PLIC_CPU_ENABLE_CTX30_ENABLE_WIDTH 6u +#define PLIC_CPU_ENABLE_CTX30_ENABLE_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX30_ENABLE_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX30_ENABLE_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX30_ENABLE_FIELD_MASK 0x0000007Eul +#define PLIC_CPU_ENABLE_CTX30_ENABLE_GET(x) (((x) & 0x0000007Eul) >> 1) +#define PLIC_CPU_ENABLE_CTX30_ENABLE_SET(x) (((x) << 1) & 0x0000007Eul) +#define PLIC_CPU_ENABLE_CTX30_ENABLE_MODIFY(r, x) ((((x) << 1) & 0x0000007Eul) | ((r) & 0xFFFFFF81ul)) + +/* Register: PLIC_CPU.enable_ctx31 */ +#define PLIC_CPU_ENABLE_CTX31_ADDRESS 0x00002F80ul +#define PLIC_CPU_ENABLE_CTX31_BYTE_ADDRESS 0x00002F80ul +#define PLIC_CPU_ENABLE_CTX31_OFFSET 0x00002F80ul +#define PLIC_CPU_ENABLE_CTX31_BYTE_OFFSET 0x00002F80ul +#define PLIC_CPU_ENABLE_CTX31_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX31_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_ENABLE_CTX31_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX31_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX31_RESET_VALUE 0x00000000ul +#define PLIC_CPU_ENABLE_CTX31_RESET_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX31_READ_MASK 0x0000007Ful +#define PLIC_CPU_ENABLE_CTX31_WRITE_MASK 0x0000007Eul + +/* Field: PLIC_CPU_ENABLE_CTX31.RESERVED */ +#define PLIC_CPU_ENABLE_CTX31_RESERVED_MSB 0u +#define PLIC_CPU_ENABLE_CTX31_RESERVED_LSB 0u +#define PLIC_CPU_ENABLE_CTX31_RESERVED_WIDTH 1u +#define PLIC_CPU_ENABLE_CTX31_RESERVED_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX31_RESERVED_WRITE_ACCESS 0u +#define PLIC_CPU_ENABLE_CTX31_RESERVED_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX31_RESERVED_FIELD_MASK 0x00000001ul +#define PLIC_CPU_ENABLE_CTX31_RESERVED_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX31_RESERVED_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_ENABLE_CTX31_RESERVED_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Field: PLIC_CPU_ENABLE_CTX31.ENABLE */ +#define PLIC_CPU_ENABLE_CTX31_ENABLE_MSB 6u +#define PLIC_CPU_ENABLE_CTX31_ENABLE_LSB 1u +#define PLIC_CPU_ENABLE_CTX31_ENABLE_WIDTH 6u +#define PLIC_CPU_ENABLE_CTX31_ENABLE_READ_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX31_ENABLE_WRITE_ACCESS 1u +#define PLIC_CPU_ENABLE_CTX31_ENABLE_RESET 0x00000000ul +#define PLIC_CPU_ENABLE_CTX31_ENABLE_FIELD_MASK 0x0000007Eul +#define PLIC_CPU_ENABLE_CTX31_ENABLE_GET(x) (((x) & 0x0000007Eul) >> 1) +#define PLIC_CPU_ENABLE_CTX31_ENABLE_SET(x) (((x) << 1) & 0x0000007Eul) +#define PLIC_CPU_ENABLE_CTX31_ENABLE_MODIFY(r, x) ((((x) << 1) & 0x0000007Eul) | ((r) & 0xFFFFFF81ul)) + +/* Register: PLIC_CPU.threshold_ctx00 */ +#define PLIC_CPU_THRESHOLD_CTX00_ADDRESS 0x00200000ul +#define PLIC_CPU_THRESHOLD_CTX00_BYTE_ADDRESS 0x00200000ul +#define PLIC_CPU_THRESHOLD_CTX00_OFFSET 0x00200000ul +#define PLIC_CPU_THRESHOLD_CTX00_BYTE_OFFSET 0x00200000ul +#define PLIC_CPU_THRESHOLD_CTX00_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX00_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX00_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX00_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX00_RESET_VALUE 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX00_RESET_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX00_READ_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX00_WRITE_MASK 0x00000000ul + +/* Field: PLIC_CPU_THRESHOLD_CTX00.THRESHOLD */ +#define PLIC_CPU_THRESHOLD_CTX00_THRESHOLD_MSB 0u +#define PLIC_CPU_THRESHOLD_CTX00_THRESHOLD_LSB 0u +#define PLIC_CPU_THRESHOLD_CTX00_THRESHOLD_WIDTH 1u +#define PLIC_CPU_THRESHOLD_CTX00_THRESHOLD_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX00_THRESHOLD_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX00_THRESHOLD_RESET 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX00_THRESHOLD_FIELD_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX00_THRESHOLD_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX00_THRESHOLD_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX00_THRESHOLD_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Register: PLIC_CPU.claim_complete_ctx00 */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX00_ADDRESS 0x00200004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX00_BYTE_ADDRESS 0x00200004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX00_OFFSET 0x00200004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX00_BYTE_OFFSET 0x00200004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX00_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX00_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX00_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX00_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX00_RESET_VALUE 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX00_RESET_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX00_READ_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX00_WRITE_MASK 0x00000007ul + +/* Field: PLIC_CPU_CLAIM_COMPLETE_CTX00.ID */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX00_ID_MSB 2u +#define PLIC_CPU_CLAIM_COMPLETE_CTX00_ID_LSB 0u +#define PLIC_CPU_CLAIM_COMPLETE_CTX00_ID_WIDTH 3u +#define PLIC_CPU_CLAIM_COMPLETE_CTX00_ID_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX00_ID_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX00_ID_RESET 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX00_ID_FIELD_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX00_ID_GET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX00_ID_SET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX00_ID_MODIFY(r, x) ((((x) << 0) & 0x00000007ul) | ((r) & 0xFFFFFFF8ul)) + +/* Register: PLIC_CPU.threshold_ctx01 */ +#define PLIC_CPU_THRESHOLD_CTX01_ADDRESS 0x00201000ul +#define PLIC_CPU_THRESHOLD_CTX01_BYTE_ADDRESS 0x00201000ul +#define PLIC_CPU_THRESHOLD_CTX01_OFFSET 0x00201000ul +#define PLIC_CPU_THRESHOLD_CTX01_BYTE_OFFSET 0x00201000ul +#define PLIC_CPU_THRESHOLD_CTX01_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX01_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX01_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX01_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX01_RESET_VALUE 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX01_RESET_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX01_READ_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX01_WRITE_MASK 0x00000000ul + +/* Field: PLIC_CPU_THRESHOLD_CTX01.THRESHOLD */ +#define PLIC_CPU_THRESHOLD_CTX01_THRESHOLD_MSB 0u +#define PLIC_CPU_THRESHOLD_CTX01_THRESHOLD_LSB 0u +#define PLIC_CPU_THRESHOLD_CTX01_THRESHOLD_WIDTH 1u +#define PLIC_CPU_THRESHOLD_CTX01_THRESHOLD_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX01_THRESHOLD_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX01_THRESHOLD_RESET 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX01_THRESHOLD_FIELD_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX01_THRESHOLD_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX01_THRESHOLD_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX01_THRESHOLD_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Register: PLIC_CPU.claim_complete_ctx01 */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX01_ADDRESS 0x00201004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX01_BYTE_ADDRESS 0x00201004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX01_OFFSET 0x00201004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX01_BYTE_OFFSET 0x00201004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX01_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX01_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX01_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX01_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX01_RESET_VALUE 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX01_RESET_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX01_READ_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX01_WRITE_MASK 0x00000007ul + +/* Field: PLIC_CPU_CLAIM_COMPLETE_CTX01.ID */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX01_ID_MSB 2u +#define PLIC_CPU_CLAIM_COMPLETE_CTX01_ID_LSB 0u +#define PLIC_CPU_CLAIM_COMPLETE_CTX01_ID_WIDTH 3u +#define PLIC_CPU_CLAIM_COMPLETE_CTX01_ID_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX01_ID_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX01_ID_RESET 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX01_ID_FIELD_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX01_ID_GET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX01_ID_SET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX01_ID_MODIFY(r, x) ((((x) << 0) & 0x00000007ul) | ((r) & 0xFFFFFFF8ul)) + +/* Register: PLIC_CPU.threshold_ctx02 */ +#define PLIC_CPU_THRESHOLD_CTX02_ADDRESS 0x00202000ul +#define PLIC_CPU_THRESHOLD_CTX02_BYTE_ADDRESS 0x00202000ul +#define PLIC_CPU_THRESHOLD_CTX02_OFFSET 0x00202000ul +#define PLIC_CPU_THRESHOLD_CTX02_BYTE_OFFSET 0x00202000ul +#define PLIC_CPU_THRESHOLD_CTX02_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX02_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX02_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX02_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX02_RESET_VALUE 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX02_RESET_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX02_READ_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX02_WRITE_MASK 0x00000000ul + +/* Field: PLIC_CPU_THRESHOLD_CTX02.THRESHOLD */ +#define PLIC_CPU_THRESHOLD_CTX02_THRESHOLD_MSB 0u +#define PLIC_CPU_THRESHOLD_CTX02_THRESHOLD_LSB 0u +#define PLIC_CPU_THRESHOLD_CTX02_THRESHOLD_WIDTH 1u +#define PLIC_CPU_THRESHOLD_CTX02_THRESHOLD_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX02_THRESHOLD_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX02_THRESHOLD_RESET 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX02_THRESHOLD_FIELD_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX02_THRESHOLD_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX02_THRESHOLD_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX02_THRESHOLD_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Register: PLIC_CPU.claim_complete_ctx02 */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX02_ADDRESS 0x00202004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX02_BYTE_ADDRESS 0x00202004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX02_OFFSET 0x00202004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX02_BYTE_OFFSET 0x00202004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX02_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX02_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX02_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX02_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX02_RESET_VALUE 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX02_RESET_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX02_READ_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX02_WRITE_MASK 0x00000007ul + +/* Field: PLIC_CPU_CLAIM_COMPLETE_CTX02.ID */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX02_ID_MSB 2u +#define PLIC_CPU_CLAIM_COMPLETE_CTX02_ID_LSB 0u +#define PLIC_CPU_CLAIM_COMPLETE_CTX02_ID_WIDTH 3u +#define PLIC_CPU_CLAIM_COMPLETE_CTX02_ID_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX02_ID_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX02_ID_RESET 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX02_ID_FIELD_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX02_ID_GET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX02_ID_SET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX02_ID_MODIFY(r, x) ((((x) << 0) & 0x00000007ul) | ((r) & 0xFFFFFFF8ul)) + +/* Register: PLIC_CPU.threshold_ctx03 */ +#define PLIC_CPU_THRESHOLD_CTX03_ADDRESS 0x00203000ul +#define PLIC_CPU_THRESHOLD_CTX03_BYTE_ADDRESS 0x00203000ul +#define PLIC_CPU_THRESHOLD_CTX03_OFFSET 0x00203000ul +#define PLIC_CPU_THRESHOLD_CTX03_BYTE_OFFSET 0x00203000ul +#define PLIC_CPU_THRESHOLD_CTX03_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX03_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX03_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX03_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX03_RESET_VALUE 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX03_RESET_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX03_READ_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX03_WRITE_MASK 0x00000000ul + +/* Field: PLIC_CPU_THRESHOLD_CTX03.THRESHOLD */ +#define PLIC_CPU_THRESHOLD_CTX03_THRESHOLD_MSB 0u +#define PLIC_CPU_THRESHOLD_CTX03_THRESHOLD_LSB 0u +#define PLIC_CPU_THRESHOLD_CTX03_THRESHOLD_WIDTH 1u +#define PLIC_CPU_THRESHOLD_CTX03_THRESHOLD_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX03_THRESHOLD_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX03_THRESHOLD_RESET 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX03_THRESHOLD_FIELD_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX03_THRESHOLD_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX03_THRESHOLD_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX03_THRESHOLD_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Register: PLIC_CPU.claim_complete_ctx03 */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX03_ADDRESS 0x00203004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX03_BYTE_ADDRESS 0x00203004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX03_OFFSET 0x00203004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX03_BYTE_OFFSET 0x00203004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX03_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX03_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX03_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX03_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX03_RESET_VALUE 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX03_RESET_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX03_READ_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX03_WRITE_MASK 0x00000007ul + +/* Field: PLIC_CPU_CLAIM_COMPLETE_CTX03.ID */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX03_ID_MSB 2u +#define PLIC_CPU_CLAIM_COMPLETE_CTX03_ID_LSB 0u +#define PLIC_CPU_CLAIM_COMPLETE_CTX03_ID_WIDTH 3u +#define PLIC_CPU_CLAIM_COMPLETE_CTX03_ID_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX03_ID_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX03_ID_RESET 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX03_ID_FIELD_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX03_ID_GET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX03_ID_SET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX03_ID_MODIFY(r, x) ((((x) << 0) & 0x00000007ul) | ((r) & 0xFFFFFFF8ul)) + +/* Register: PLIC_CPU.threshold_ctx04 */ +#define PLIC_CPU_THRESHOLD_CTX04_ADDRESS 0x00204000ul +#define PLIC_CPU_THRESHOLD_CTX04_BYTE_ADDRESS 0x00204000ul +#define PLIC_CPU_THRESHOLD_CTX04_OFFSET 0x00204000ul +#define PLIC_CPU_THRESHOLD_CTX04_BYTE_OFFSET 0x00204000ul +#define PLIC_CPU_THRESHOLD_CTX04_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX04_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX04_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX04_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX04_RESET_VALUE 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX04_RESET_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX04_READ_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX04_WRITE_MASK 0x00000000ul + +/* Field: PLIC_CPU_THRESHOLD_CTX04.THRESHOLD */ +#define PLIC_CPU_THRESHOLD_CTX04_THRESHOLD_MSB 0u +#define PLIC_CPU_THRESHOLD_CTX04_THRESHOLD_LSB 0u +#define PLIC_CPU_THRESHOLD_CTX04_THRESHOLD_WIDTH 1u +#define PLIC_CPU_THRESHOLD_CTX04_THRESHOLD_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX04_THRESHOLD_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX04_THRESHOLD_RESET 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX04_THRESHOLD_FIELD_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX04_THRESHOLD_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX04_THRESHOLD_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX04_THRESHOLD_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Register: PLIC_CPU.claim_complete_ctx04 */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX04_ADDRESS 0x00204004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX04_BYTE_ADDRESS 0x00204004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX04_OFFSET 0x00204004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX04_BYTE_OFFSET 0x00204004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX04_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX04_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX04_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX04_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX04_RESET_VALUE 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX04_RESET_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX04_READ_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX04_WRITE_MASK 0x00000007ul + +/* Field: PLIC_CPU_CLAIM_COMPLETE_CTX04.ID */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX04_ID_MSB 2u +#define PLIC_CPU_CLAIM_COMPLETE_CTX04_ID_LSB 0u +#define PLIC_CPU_CLAIM_COMPLETE_CTX04_ID_WIDTH 3u +#define PLIC_CPU_CLAIM_COMPLETE_CTX04_ID_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX04_ID_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX04_ID_RESET 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX04_ID_FIELD_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX04_ID_GET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX04_ID_SET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX04_ID_MODIFY(r, x) ((((x) << 0) & 0x00000007ul) | ((r) & 0xFFFFFFF8ul)) + +/* Register: PLIC_CPU.threshold_ctx05 */ +#define PLIC_CPU_THRESHOLD_CTX05_ADDRESS 0x00205000ul +#define PLIC_CPU_THRESHOLD_CTX05_BYTE_ADDRESS 0x00205000ul +#define PLIC_CPU_THRESHOLD_CTX05_OFFSET 0x00205000ul +#define PLIC_CPU_THRESHOLD_CTX05_BYTE_OFFSET 0x00205000ul +#define PLIC_CPU_THRESHOLD_CTX05_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX05_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX05_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX05_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX05_RESET_VALUE 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX05_RESET_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX05_READ_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX05_WRITE_MASK 0x00000000ul + +/* Field: PLIC_CPU_THRESHOLD_CTX05.THRESHOLD */ +#define PLIC_CPU_THRESHOLD_CTX05_THRESHOLD_MSB 0u +#define PLIC_CPU_THRESHOLD_CTX05_THRESHOLD_LSB 0u +#define PLIC_CPU_THRESHOLD_CTX05_THRESHOLD_WIDTH 1u +#define PLIC_CPU_THRESHOLD_CTX05_THRESHOLD_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX05_THRESHOLD_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX05_THRESHOLD_RESET 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX05_THRESHOLD_FIELD_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX05_THRESHOLD_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX05_THRESHOLD_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX05_THRESHOLD_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Register: PLIC_CPU.claim_complete_ctx05 */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX05_ADDRESS 0x00205004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX05_BYTE_ADDRESS 0x00205004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX05_OFFSET 0x00205004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX05_BYTE_OFFSET 0x00205004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX05_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX05_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX05_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX05_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX05_RESET_VALUE 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX05_RESET_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX05_READ_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX05_WRITE_MASK 0x00000007ul + +/* Field: PLIC_CPU_CLAIM_COMPLETE_CTX05.ID */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX05_ID_MSB 2u +#define PLIC_CPU_CLAIM_COMPLETE_CTX05_ID_LSB 0u +#define PLIC_CPU_CLAIM_COMPLETE_CTX05_ID_WIDTH 3u +#define PLIC_CPU_CLAIM_COMPLETE_CTX05_ID_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX05_ID_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX05_ID_RESET 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX05_ID_FIELD_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX05_ID_GET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX05_ID_SET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX05_ID_MODIFY(r, x) ((((x) << 0) & 0x00000007ul) | ((r) & 0xFFFFFFF8ul)) + +/* Register: PLIC_CPU.threshold_ctx06 */ +#define PLIC_CPU_THRESHOLD_CTX06_ADDRESS 0x00206000ul +#define PLIC_CPU_THRESHOLD_CTX06_BYTE_ADDRESS 0x00206000ul +#define PLIC_CPU_THRESHOLD_CTX06_OFFSET 0x00206000ul +#define PLIC_CPU_THRESHOLD_CTX06_BYTE_OFFSET 0x00206000ul +#define PLIC_CPU_THRESHOLD_CTX06_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX06_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX06_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX06_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX06_RESET_VALUE 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX06_RESET_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX06_READ_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX06_WRITE_MASK 0x00000000ul + +/* Field: PLIC_CPU_THRESHOLD_CTX06.THRESHOLD */ +#define PLIC_CPU_THRESHOLD_CTX06_THRESHOLD_MSB 0u +#define PLIC_CPU_THRESHOLD_CTX06_THRESHOLD_LSB 0u +#define PLIC_CPU_THRESHOLD_CTX06_THRESHOLD_WIDTH 1u +#define PLIC_CPU_THRESHOLD_CTX06_THRESHOLD_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX06_THRESHOLD_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX06_THRESHOLD_RESET 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX06_THRESHOLD_FIELD_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX06_THRESHOLD_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX06_THRESHOLD_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX06_THRESHOLD_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Register: PLIC_CPU.claim_complete_ctx06 */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX06_ADDRESS 0x00206004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX06_BYTE_ADDRESS 0x00206004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX06_OFFSET 0x00206004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX06_BYTE_OFFSET 0x00206004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX06_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX06_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX06_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX06_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX06_RESET_VALUE 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX06_RESET_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX06_READ_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX06_WRITE_MASK 0x00000007ul + +/* Field: PLIC_CPU_CLAIM_COMPLETE_CTX06.ID */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX06_ID_MSB 2u +#define PLIC_CPU_CLAIM_COMPLETE_CTX06_ID_LSB 0u +#define PLIC_CPU_CLAIM_COMPLETE_CTX06_ID_WIDTH 3u +#define PLIC_CPU_CLAIM_COMPLETE_CTX06_ID_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX06_ID_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX06_ID_RESET 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX06_ID_FIELD_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX06_ID_GET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX06_ID_SET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX06_ID_MODIFY(r, x) ((((x) << 0) & 0x00000007ul) | ((r) & 0xFFFFFFF8ul)) + +/* Register: PLIC_CPU.threshold_ctx07 */ +#define PLIC_CPU_THRESHOLD_CTX07_ADDRESS 0x00207000ul +#define PLIC_CPU_THRESHOLD_CTX07_BYTE_ADDRESS 0x00207000ul +#define PLIC_CPU_THRESHOLD_CTX07_OFFSET 0x00207000ul +#define PLIC_CPU_THRESHOLD_CTX07_BYTE_OFFSET 0x00207000ul +#define PLIC_CPU_THRESHOLD_CTX07_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX07_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX07_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX07_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX07_RESET_VALUE 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX07_RESET_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX07_READ_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX07_WRITE_MASK 0x00000000ul + +/* Field: PLIC_CPU_THRESHOLD_CTX07.THRESHOLD */ +#define PLIC_CPU_THRESHOLD_CTX07_THRESHOLD_MSB 0u +#define PLIC_CPU_THRESHOLD_CTX07_THRESHOLD_LSB 0u +#define PLIC_CPU_THRESHOLD_CTX07_THRESHOLD_WIDTH 1u +#define PLIC_CPU_THRESHOLD_CTX07_THRESHOLD_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX07_THRESHOLD_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX07_THRESHOLD_RESET 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX07_THRESHOLD_FIELD_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX07_THRESHOLD_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX07_THRESHOLD_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX07_THRESHOLD_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Register: PLIC_CPU.claim_complete_ctx07 */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX07_ADDRESS 0x00207004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX07_BYTE_ADDRESS 0x00207004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX07_OFFSET 0x00207004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX07_BYTE_OFFSET 0x00207004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX07_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX07_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX07_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX07_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX07_RESET_VALUE 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX07_RESET_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX07_READ_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX07_WRITE_MASK 0x00000007ul + +/* Field: PLIC_CPU_CLAIM_COMPLETE_CTX07.ID */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX07_ID_MSB 2u +#define PLIC_CPU_CLAIM_COMPLETE_CTX07_ID_LSB 0u +#define PLIC_CPU_CLAIM_COMPLETE_CTX07_ID_WIDTH 3u +#define PLIC_CPU_CLAIM_COMPLETE_CTX07_ID_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX07_ID_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX07_ID_RESET 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX07_ID_FIELD_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX07_ID_GET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX07_ID_SET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX07_ID_MODIFY(r, x) ((((x) << 0) & 0x00000007ul) | ((r) & 0xFFFFFFF8ul)) + +/* Register: PLIC_CPU.threshold_ctx08 */ +#define PLIC_CPU_THRESHOLD_CTX08_ADDRESS 0x00208000ul +#define PLIC_CPU_THRESHOLD_CTX08_BYTE_ADDRESS 0x00208000ul +#define PLIC_CPU_THRESHOLD_CTX08_OFFSET 0x00208000ul +#define PLIC_CPU_THRESHOLD_CTX08_BYTE_OFFSET 0x00208000ul +#define PLIC_CPU_THRESHOLD_CTX08_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX08_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX08_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX08_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX08_RESET_VALUE 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX08_RESET_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX08_READ_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX08_WRITE_MASK 0x00000000ul + +/* Field: PLIC_CPU_THRESHOLD_CTX08.THRESHOLD */ +#define PLIC_CPU_THRESHOLD_CTX08_THRESHOLD_MSB 0u +#define PLIC_CPU_THRESHOLD_CTX08_THRESHOLD_LSB 0u +#define PLIC_CPU_THRESHOLD_CTX08_THRESHOLD_WIDTH 1u +#define PLIC_CPU_THRESHOLD_CTX08_THRESHOLD_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX08_THRESHOLD_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX08_THRESHOLD_RESET 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX08_THRESHOLD_FIELD_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX08_THRESHOLD_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX08_THRESHOLD_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX08_THRESHOLD_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Register: PLIC_CPU.claim_complete_ctx08 */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX08_ADDRESS 0x00208004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX08_BYTE_ADDRESS 0x00208004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX08_OFFSET 0x00208004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX08_BYTE_OFFSET 0x00208004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX08_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX08_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX08_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX08_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX08_RESET_VALUE 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX08_RESET_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX08_READ_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX08_WRITE_MASK 0x00000007ul + +/* Field: PLIC_CPU_CLAIM_COMPLETE_CTX08.ID */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX08_ID_MSB 2u +#define PLIC_CPU_CLAIM_COMPLETE_CTX08_ID_LSB 0u +#define PLIC_CPU_CLAIM_COMPLETE_CTX08_ID_WIDTH 3u +#define PLIC_CPU_CLAIM_COMPLETE_CTX08_ID_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX08_ID_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX08_ID_RESET 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX08_ID_FIELD_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX08_ID_GET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX08_ID_SET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX08_ID_MODIFY(r, x) ((((x) << 0) & 0x00000007ul) | ((r) & 0xFFFFFFF8ul)) + +/* Register: PLIC_CPU.threshold_ctx09 */ +#define PLIC_CPU_THRESHOLD_CTX09_ADDRESS 0x00209000ul +#define PLIC_CPU_THRESHOLD_CTX09_BYTE_ADDRESS 0x00209000ul +#define PLIC_CPU_THRESHOLD_CTX09_OFFSET 0x00209000ul +#define PLIC_CPU_THRESHOLD_CTX09_BYTE_OFFSET 0x00209000ul +#define PLIC_CPU_THRESHOLD_CTX09_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX09_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX09_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX09_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX09_RESET_VALUE 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX09_RESET_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX09_READ_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX09_WRITE_MASK 0x00000000ul + +/* Field: PLIC_CPU_THRESHOLD_CTX09.THRESHOLD */ +#define PLIC_CPU_THRESHOLD_CTX09_THRESHOLD_MSB 0u +#define PLIC_CPU_THRESHOLD_CTX09_THRESHOLD_LSB 0u +#define PLIC_CPU_THRESHOLD_CTX09_THRESHOLD_WIDTH 1u +#define PLIC_CPU_THRESHOLD_CTX09_THRESHOLD_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX09_THRESHOLD_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX09_THRESHOLD_RESET 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX09_THRESHOLD_FIELD_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX09_THRESHOLD_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX09_THRESHOLD_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX09_THRESHOLD_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Register: PLIC_CPU.claim_complete_ctx09 */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX09_ADDRESS 0x00209004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX09_BYTE_ADDRESS 0x00209004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX09_OFFSET 0x00209004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX09_BYTE_OFFSET 0x00209004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX09_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX09_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX09_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX09_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX09_RESET_VALUE 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX09_RESET_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX09_READ_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX09_WRITE_MASK 0x00000007ul + +/* Field: PLIC_CPU_CLAIM_COMPLETE_CTX09.ID */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX09_ID_MSB 2u +#define PLIC_CPU_CLAIM_COMPLETE_CTX09_ID_LSB 0u +#define PLIC_CPU_CLAIM_COMPLETE_CTX09_ID_WIDTH 3u +#define PLIC_CPU_CLAIM_COMPLETE_CTX09_ID_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX09_ID_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX09_ID_RESET 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX09_ID_FIELD_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX09_ID_GET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX09_ID_SET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX09_ID_MODIFY(r, x) ((((x) << 0) & 0x00000007ul) | ((r) & 0xFFFFFFF8ul)) + +/* Register: PLIC_CPU.threshold_ctx10 */ +#define PLIC_CPU_THRESHOLD_CTX10_ADDRESS 0x0020A000ul +#define PLIC_CPU_THRESHOLD_CTX10_BYTE_ADDRESS 0x0020A000ul +#define PLIC_CPU_THRESHOLD_CTX10_OFFSET 0x0020A000ul +#define PLIC_CPU_THRESHOLD_CTX10_BYTE_OFFSET 0x0020A000ul +#define PLIC_CPU_THRESHOLD_CTX10_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX10_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX10_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX10_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX10_RESET_VALUE 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX10_RESET_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX10_READ_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX10_WRITE_MASK 0x00000000ul + +/* Field: PLIC_CPU_THRESHOLD_CTX10.THRESHOLD */ +#define PLIC_CPU_THRESHOLD_CTX10_THRESHOLD_MSB 0u +#define PLIC_CPU_THRESHOLD_CTX10_THRESHOLD_LSB 0u +#define PLIC_CPU_THRESHOLD_CTX10_THRESHOLD_WIDTH 1u +#define PLIC_CPU_THRESHOLD_CTX10_THRESHOLD_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX10_THRESHOLD_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX10_THRESHOLD_RESET 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX10_THRESHOLD_FIELD_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX10_THRESHOLD_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX10_THRESHOLD_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX10_THRESHOLD_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Register: PLIC_CPU.claim_complete_ctx10 */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX10_ADDRESS 0x0020A004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX10_BYTE_ADDRESS 0x0020A004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX10_OFFSET 0x0020A004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX10_BYTE_OFFSET 0x0020A004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX10_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX10_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX10_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX10_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX10_RESET_VALUE 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX10_RESET_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX10_READ_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX10_WRITE_MASK 0x00000007ul + +/* Field: PLIC_CPU_CLAIM_COMPLETE_CTX10.ID */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX10_ID_MSB 2u +#define PLIC_CPU_CLAIM_COMPLETE_CTX10_ID_LSB 0u +#define PLIC_CPU_CLAIM_COMPLETE_CTX10_ID_WIDTH 3u +#define PLIC_CPU_CLAIM_COMPLETE_CTX10_ID_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX10_ID_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX10_ID_RESET 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX10_ID_FIELD_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX10_ID_GET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX10_ID_SET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX10_ID_MODIFY(r, x) ((((x) << 0) & 0x00000007ul) | ((r) & 0xFFFFFFF8ul)) + +/* Register: PLIC_CPU.threshold_ctx11 */ +#define PLIC_CPU_THRESHOLD_CTX11_ADDRESS 0x0020B000ul +#define PLIC_CPU_THRESHOLD_CTX11_BYTE_ADDRESS 0x0020B000ul +#define PLIC_CPU_THRESHOLD_CTX11_OFFSET 0x0020B000ul +#define PLIC_CPU_THRESHOLD_CTX11_BYTE_OFFSET 0x0020B000ul +#define PLIC_CPU_THRESHOLD_CTX11_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX11_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX11_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX11_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX11_RESET_VALUE 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX11_RESET_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX11_READ_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX11_WRITE_MASK 0x00000000ul + +/* Field: PLIC_CPU_THRESHOLD_CTX11.THRESHOLD */ +#define PLIC_CPU_THRESHOLD_CTX11_THRESHOLD_MSB 0u +#define PLIC_CPU_THRESHOLD_CTX11_THRESHOLD_LSB 0u +#define PLIC_CPU_THRESHOLD_CTX11_THRESHOLD_WIDTH 1u +#define PLIC_CPU_THRESHOLD_CTX11_THRESHOLD_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX11_THRESHOLD_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX11_THRESHOLD_RESET 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX11_THRESHOLD_FIELD_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX11_THRESHOLD_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX11_THRESHOLD_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX11_THRESHOLD_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Register: PLIC_CPU.claim_complete_ctx11 */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX11_ADDRESS 0x0020B004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX11_BYTE_ADDRESS 0x0020B004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX11_OFFSET 0x0020B004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX11_BYTE_OFFSET 0x0020B004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX11_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX11_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX11_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX11_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX11_RESET_VALUE 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX11_RESET_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX11_READ_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX11_WRITE_MASK 0x00000007ul + +/* Field: PLIC_CPU_CLAIM_COMPLETE_CTX11.ID */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX11_ID_MSB 2u +#define PLIC_CPU_CLAIM_COMPLETE_CTX11_ID_LSB 0u +#define PLIC_CPU_CLAIM_COMPLETE_CTX11_ID_WIDTH 3u +#define PLIC_CPU_CLAIM_COMPLETE_CTX11_ID_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX11_ID_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX11_ID_RESET 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX11_ID_FIELD_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX11_ID_GET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX11_ID_SET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX11_ID_MODIFY(r, x) ((((x) << 0) & 0x00000007ul) | ((r) & 0xFFFFFFF8ul)) + +/* Register: PLIC_CPU.threshold_ctx12 */ +#define PLIC_CPU_THRESHOLD_CTX12_ADDRESS 0x0020C000ul +#define PLIC_CPU_THRESHOLD_CTX12_BYTE_ADDRESS 0x0020C000ul +#define PLIC_CPU_THRESHOLD_CTX12_OFFSET 0x0020C000ul +#define PLIC_CPU_THRESHOLD_CTX12_BYTE_OFFSET 0x0020C000ul +#define PLIC_CPU_THRESHOLD_CTX12_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX12_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX12_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX12_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX12_RESET_VALUE 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX12_RESET_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX12_READ_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX12_WRITE_MASK 0x00000000ul + +/* Field: PLIC_CPU_THRESHOLD_CTX12.THRESHOLD */ +#define PLIC_CPU_THRESHOLD_CTX12_THRESHOLD_MSB 0u +#define PLIC_CPU_THRESHOLD_CTX12_THRESHOLD_LSB 0u +#define PLIC_CPU_THRESHOLD_CTX12_THRESHOLD_WIDTH 1u +#define PLIC_CPU_THRESHOLD_CTX12_THRESHOLD_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX12_THRESHOLD_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX12_THRESHOLD_RESET 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX12_THRESHOLD_FIELD_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX12_THRESHOLD_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX12_THRESHOLD_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX12_THRESHOLD_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Register: PLIC_CPU.claim_complete_ctx12 */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX12_ADDRESS 0x0020C004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX12_BYTE_ADDRESS 0x0020C004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX12_OFFSET 0x0020C004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX12_BYTE_OFFSET 0x0020C004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX12_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX12_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX12_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX12_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX12_RESET_VALUE 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX12_RESET_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX12_READ_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX12_WRITE_MASK 0x00000007ul + +/* Field: PLIC_CPU_CLAIM_COMPLETE_CTX12.ID */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX12_ID_MSB 2u +#define PLIC_CPU_CLAIM_COMPLETE_CTX12_ID_LSB 0u +#define PLIC_CPU_CLAIM_COMPLETE_CTX12_ID_WIDTH 3u +#define PLIC_CPU_CLAIM_COMPLETE_CTX12_ID_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX12_ID_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX12_ID_RESET 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX12_ID_FIELD_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX12_ID_GET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX12_ID_SET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX12_ID_MODIFY(r, x) ((((x) << 0) & 0x00000007ul) | ((r) & 0xFFFFFFF8ul)) + +/* Register: PLIC_CPU.threshold_ctx13 */ +#define PLIC_CPU_THRESHOLD_CTX13_ADDRESS 0x0020D000ul +#define PLIC_CPU_THRESHOLD_CTX13_BYTE_ADDRESS 0x0020D000ul +#define PLIC_CPU_THRESHOLD_CTX13_OFFSET 0x0020D000ul +#define PLIC_CPU_THRESHOLD_CTX13_BYTE_OFFSET 0x0020D000ul +#define PLIC_CPU_THRESHOLD_CTX13_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX13_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX13_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX13_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX13_RESET_VALUE 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX13_RESET_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX13_READ_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX13_WRITE_MASK 0x00000000ul + +/* Field: PLIC_CPU_THRESHOLD_CTX13.THRESHOLD */ +#define PLIC_CPU_THRESHOLD_CTX13_THRESHOLD_MSB 0u +#define PLIC_CPU_THRESHOLD_CTX13_THRESHOLD_LSB 0u +#define PLIC_CPU_THRESHOLD_CTX13_THRESHOLD_WIDTH 1u +#define PLIC_CPU_THRESHOLD_CTX13_THRESHOLD_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX13_THRESHOLD_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX13_THRESHOLD_RESET 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX13_THRESHOLD_FIELD_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX13_THRESHOLD_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX13_THRESHOLD_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX13_THRESHOLD_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Register: PLIC_CPU.claim_complete_ctx13 */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX13_ADDRESS 0x0020D004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX13_BYTE_ADDRESS 0x0020D004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX13_OFFSET 0x0020D004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX13_BYTE_OFFSET 0x0020D004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX13_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX13_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX13_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX13_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX13_RESET_VALUE 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX13_RESET_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX13_READ_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX13_WRITE_MASK 0x00000007ul + +/* Field: PLIC_CPU_CLAIM_COMPLETE_CTX13.ID */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX13_ID_MSB 2u +#define PLIC_CPU_CLAIM_COMPLETE_CTX13_ID_LSB 0u +#define PLIC_CPU_CLAIM_COMPLETE_CTX13_ID_WIDTH 3u +#define PLIC_CPU_CLAIM_COMPLETE_CTX13_ID_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX13_ID_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX13_ID_RESET 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX13_ID_FIELD_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX13_ID_GET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX13_ID_SET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX13_ID_MODIFY(r, x) ((((x) << 0) & 0x00000007ul) | ((r) & 0xFFFFFFF8ul)) + +/* Register: PLIC_CPU.threshold_ctx14 */ +#define PLIC_CPU_THRESHOLD_CTX14_ADDRESS 0x0020E000ul +#define PLIC_CPU_THRESHOLD_CTX14_BYTE_ADDRESS 0x0020E000ul +#define PLIC_CPU_THRESHOLD_CTX14_OFFSET 0x0020E000ul +#define PLIC_CPU_THRESHOLD_CTX14_BYTE_OFFSET 0x0020E000ul +#define PLIC_CPU_THRESHOLD_CTX14_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX14_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX14_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX14_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX14_RESET_VALUE 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX14_RESET_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX14_READ_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX14_WRITE_MASK 0x00000000ul + +/* Field: PLIC_CPU_THRESHOLD_CTX14.THRESHOLD */ +#define PLIC_CPU_THRESHOLD_CTX14_THRESHOLD_MSB 0u +#define PLIC_CPU_THRESHOLD_CTX14_THRESHOLD_LSB 0u +#define PLIC_CPU_THRESHOLD_CTX14_THRESHOLD_WIDTH 1u +#define PLIC_CPU_THRESHOLD_CTX14_THRESHOLD_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX14_THRESHOLD_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX14_THRESHOLD_RESET 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX14_THRESHOLD_FIELD_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX14_THRESHOLD_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX14_THRESHOLD_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX14_THRESHOLD_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Register: PLIC_CPU.claim_complete_ctx14 */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX14_ADDRESS 0x0020E004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX14_BYTE_ADDRESS 0x0020E004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX14_OFFSET 0x0020E004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX14_BYTE_OFFSET 0x0020E004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX14_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX14_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX14_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX14_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX14_RESET_VALUE 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX14_RESET_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX14_READ_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX14_WRITE_MASK 0x00000007ul + +/* Field: PLIC_CPU_CLAIM_COMPLETE_CTX14.ID */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX14_ID_MSB 2u +#define PLIC_CPU_CLAIM_COMPLETE_CTX14_ID_LSB 0u +#define PLIC_CPU_CLAIM_COMPLETE_CTX14_ID_WIDTH 3u +#define PLIC_CPU_CLAIM_COMPLETE_CTX14_ID_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX14_ID_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX14_ID_RESET 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX14_ID_FIELD_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX14_ID_GET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX14_ID_SET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX14_ID_MODIFY(r, x) ((((x) << 0) & 0x00000007ul) | ((r) & 0xFFFFFFF8ul)) + +/* Register: PLIC_CPU.threshold_ctx15 */ +#define PLIC_CPU_THRESHOLD_CTX15_ADDRESS 0x0020F000ul +#define PLIC_CPU_THRESHOLD_CTX15_BYTE_ADDRESS 0x0020F000ul +#define PLIC_CPU_THRESHOLD_CTX15_OFFSET 0x0020F000ul +#define PLIC_CPU_THRESHOLD_CTX15_BYTE_OFFSET 0x0020F000ul +#define PLIC_CPU_THRESHOLD_CTX15_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX15_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX15_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX15_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX15_RESET_VALUE 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX15_RESET_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX15_READ_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX15_WRITE_MASK 0x00000000ul + +/* Field: PLIC_CPU_THRESHOLD_CTX15.THRESHOLD */ +#define PLIC_CPU_THRESHOLD_CTX15_THRESHOLD_MSB 0u +#define PLIC_CPU_THRESHOLD_CTX15_THRESHOLD_LSB 0u +#define PLIC_CPU_THRESHOLD_CTX15_THRESHOLD_WIDTH 1u +#define PLIC_CPU_THRESHOLD_CTX15_THRESHOLD_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX15_THRESHOLD_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX15_THRESHOLD_RESET 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX15_THRESHOLD_FIELD_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX15_THRESHOLD_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX15_THRESHOLD_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX15_THRESHOLD_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Register: PLIC_CPU.claim_complete_ctx15 */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX15_ADDRESS 0x0020F004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX15_BYTE_ADDRESS 0x0020F004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX15_OFFSET 0x0020F004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX15_BYTE_OFFSET 0x0020F004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX15_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX15_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX15_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX15_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX15_RESET_VALUE 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX15_RESET_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX15_READ_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX15_WRITE_MASK 0x00000007ul + +/* Field: PLIC_CPU_CLAIM_COMPLETE_CTX15.ID */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX15_ID_MSB 2u +#define PLIC_CPU_CLAIM_COMPLETE_CTX15_ID_LSB 0u +#define PLIC_CPU_CLAIM_COMPLETE_CTX15_ID_WIDTH 3u +#define PLIC_CPU_CLAIM_COMPLETE_CTX15_ID_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX15_ID_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX15_ID_RESET 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX15_ID_FIELD_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX15_ID_GET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX15_ID_SET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX15_ID_MODIFY(r, x) ((((x) << 0) & 0x00000007ul) | ((r) & 0xFFFFFFF8ul)) + +/* Register: PLIC_CPU.threshold_ctx16 */ +#define PLIC_CPU_THRESHOLD_CTX16_ADDRESS 0x00210000ul +#define PLIC_CPU_THRESHOLD_CTX16_BYTE_ADDRESS 0x00210000ul +#define PLIC_CPU_THRESHOLD_CTX16_OFFSET 0x00210000ul +#define PLIC_CPU_THRESHOLD_CTX16_BYTE_OFFSET 0x00210000ul +#define PLIC_CPU_THRESHOLD_CTX16_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX16_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX16_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX16_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX16_RESET_VALUE 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX16_RESET_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX16_READ_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX16_WRITE_MASK 0x00000000ul + +/* Field: PLIC_CPU_THRESHOLD_CTX16.THRESHOLD */ +#define PLIC_CPU_THRESHOLD_CTX16_THRESHOLD_MSB 0u +#define PLIC_CPU_THRESHOLD_CTX16_THRESHOLD_LSB 0u +#define PLIC_CPU_THRESHOLD_CTX16_THRESHOLD_WIDTH 1u +#define PLIC_CPU_THRESHOLD_CTX16_THRESHOLD_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX16_THRESHOLD_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX16_THRESHOLD_RESET 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX16_THRESHOLD_FIELD_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX16_THRESHOLD_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX16_THRESHOLD_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX16_THRESHOLD_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Register: PLIC_CPU.claim_complete_ctx16 */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX16_ADDRESS 0x00210004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX16_BYTE_ADDRESS 0x00210004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX16_OFFSET 0x00210004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX16_BYTE_OFFSET 0x00210004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX16_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX16_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX16_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX16_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX16_RESET_VALUE 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX16_RESET_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX16_READ_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX16_WRITE_MASK 0x00000007ul + +/* Field: PLIC_CPU_CLAIM_COMPLETE_CTX16.ID */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX16_ID_MSB 2u +#define PLIC_CPU_CLAIM_COMPLETE_CTX16_ID_LSB 0u +#define PLIC_CPU_CLAIM_COMPLETE_CTX16_ID_WIDTH 3u +#define PLIC_CPU_CLAIM_COMPLETE_CTX16_ID_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX16_ID_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX16_ID_RESET 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX16_ID_FIELD_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX16_ID_GET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX16_ID_SET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX16_ID_MODIFY(r, x) ((((x) << 0) & 0x00000007ul) | ((r) & 0xFFFFFFF8ul)) + +/* Register: PLIC_CPU.threshold_ctx17 */ +#define PLIC_CPU_THRESHOLD_CTX17_ADDRESS 0x00211000ul +#define PLIC_CPU_THRESHOLD_CTX17_BYTE_ADDRESS 0x00211000ul +#define PLIC_CPU_THRESHOLD_CTX17_OFFSET 0x00211000ul +#define PLIC_CPU_THRESHOLD_CTX17_BYTE_OFFSET 0x00211000ul +#define PLIC_CPU_THRESHOLD_CTX17_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX17_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX17_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX17_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX17_RESET_VALUE 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX17_RESET_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX17_READ_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX17_WRITE_MASK 0x00000000ul + +/* Field: PLIC_CPU_THRESHOLD_CTX17.THRESHOLD */ +#define PLIC_CPU_THRESHOLD_CTX17_THRESHOLD_MSB 0u +#define PLIC_CPU_THRESHOLD_CTX17_THRESHOLD_LSB 0u +#define PLIC_CPU_THRESHOLD_CTX17_THRESHOLD_WIDTH 1u +#define PLIC_CPU_THRESHOLD_CTX17_THRESHOLD_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX17_THRESHOLD_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX17_THRESHOLD_RESET 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX17_THRESHOLD_FIELD_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX17_THRESHOLD_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX17_THRESHOLD_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX17_THRESHOLD_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Register: PLIC_CPU.claim_complete_ctx17 */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX17_ADDRESS 0x00211004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX17_BYTE_ADDRESS 0x00211004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX17_OFFSET 0x00211004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX17_BYTE_OFFSET 0x00211004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX17_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX17_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX17_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX17_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX17_RESET_VALUE 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX17_RESET_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX17_READ_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX17_WRITE_MASK 0x00000007ul + +/* Field: PLIC_CPU_CLAIM_COMPLETE_CTX17.ID */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX17_ID_MSB 2u +#define PLIC_CPU_CLAIM_COMPLETE_CTX17_ID_LSB 0u +#define PLIC_CPU_CLAIM_COMPLETE_CTX17_ID_WIDTH 3u +#define PLIC_CPU_CLAIM_COMPLETE_CTX17_ID_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX17_ID_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX17_ID_RESET 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX17_ID_FIELD_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX17_ID_GET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX17_ID_SET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX17_ID_MODIFY(r, x) ((((x) << 0) & 0x00000007ul) | ((r) & 0xFFFFFFF8ul)) + +/* Register: PLIC_CPU.threshold_ctx18 */ +#define PLIC_CPU_THRESHOLD_CTX18_ADDRESS 0x00212000ul +#define PLIC_CPU_THRESHOLD_CTX18_BYTE_ADDRESS 0x00212000ul +#define PLIC_CPU_THRESHOLD_CTX18_OFFSET 0x00212000ul +#define PLIC_CPU_THRESHOLD_CTX18_BYTE_OFFSET 0x00212000ul +#define PLIC_CPU_THRESHOLD_CTX18_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX18_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX18_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX18_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX18_RESET_VALUE 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX18_RESET_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX18_READ_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX18_WRITE_MASK 0x00000000ul + +/* Field: PLIC_CPU_THRESHOLD_CTX18.THRESHOLD */ +#define PLIC_CPU_THRESHOLD_CTX18_THRESHOLD_MSB 0u +#define PLIC_CPU_THRESHOLD_CTX18_THRESHOLD_LSB 0u +#define PLIC_CPU_THRESHOLD_CTX18_THRESHOLD_WIDTH 1u +#define PLIC_CPU_THRESHOLD_CTX18_THRESHOLD_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX18_THRESHOLD_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX18_THRESHOLD_RESET 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX18_THRESHOLD_FIELD_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX18_THRESHOLD_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX18_THRESHOLD_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX18_THRESHOLD_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Register: PLIC_CPU.claim_complete_ctx18 */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX18_ADDRESS 0x00212004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX18_BYTE_ADDRESS 0x00212004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX18_OFFSET 0x00212004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX18_BYTE_OFFSET 0x00212004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX18_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX18_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX18_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX18_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX18_RESET_VALUE 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX18_RESET_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX18_READ_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX18_WRITE_MASK 0x00000007ul + +/* Field: PLIC_CPU_CLAIM_COMPLETE_CTX18.ID */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX18_ID_MSB 2u +#define PLIC_CPU_CLAIM_COMPLETE_CTX18_ID_LSB 0u +#define PLIC_CPU_CLAIM_COMPLETE_CTX18_ID_WIDTH 3u +#define PLIC_CPU_CLAIM_COMPLETE_CTX18_ID_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX18_ID_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX18_ID_RESET 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX18_ID_FIELD_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX18_ID_GET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX18_ID_SET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX18_ID_MODIFY(r, x) ((((x) << 0) & 0x00000007ul) | ((r) & 0xFFFFFFF8ul)) + +/* Register: PLIC_CPU.threshold_ctx19 */ +#define PLIC_CPU_THRESHOLD_CTX19_ADDRESS 0x00213000ul +#define PLIC_CPU_THRESHOLD_CTX19_BYTE_ADDRESS 0x00213000ul +#define PLIC_CPU_THRESHOLD_CTX19_OFFSET 0x00213000ul +#define PLIC_CPU_THRESHOLD_CTX19_BYTE_OFFSET 0x00213000ul +#define PLIC_CPU_THRESHOLD_CTX19_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX19_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX19_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX19_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX19_RESET_VALUE 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX19_RESET_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX19_READ_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX19_WRITE_MASK 0x00000000ul + +/* Field: PLIC_CPU_THRESHOLD_CTX19.THRESHOLD */ +#define PLIC_CPU_THRESHOLD_CTX19_THRESHOLD_MSB 0u +#define PLIC_CPU_THRESHOLD_CTX19_THRESHOLD_LSB 0u +#define PLIC_CPU_THRESHOLD_CTX19_THRESHOLD_WIDTH 1u +#define PLIC_CPU_THRESHOLD_CTX19_THRESHOLD_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX19_THRESHOLD_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX19_THRESHOLD_RESET 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX19_THRESHOLD_FIELD_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX19_THRESHOLD_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX19_THRESHOLD_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX19_THRESHOLD_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Register: PLIC_CPU.claim_complete_ctx19 */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX19_ADDRESS 0x00213004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX19_BYTE_ADDRESS 0x00213004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX19_OFFSET 0x00213004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX19_BYTE_OFFSET 0x00213004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX19_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX19_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX19_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX19_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX19_RESET_VALUE 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX19_RESET_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX19_READ_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX19_WRITE_MASK 0x00000007ul + +/* Field: PLIC_CPU_CLAIM_COMPLETE_CTX19.ID */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX19_ID_MSB 2u +#define PLIC_CPU_CLAIM_COMPLETE_CTX19_ID_LSB 0u +#define PLIC_CPU_CLAIM_COMPLETE_CTX19_ID_WIDTH 3u +#define PLIC_CPU_CLAIM_COMPLETE_CTX19_ID_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX19_ID_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX19_ID_RESET 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX19_ID_FIELD_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX19_ID_GET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX19_ID_SET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX19_ID_MODIFY(r, x) ((((x) << 0) & 0x00000007ul) | ((r) & 0xFFFFFFF8ul)) + +/* Register: PLIC_CPU.threshold_ctx20 */ +#define PLIC_CPU_THRESHOLD_CTX20_ADDRESS 0x00214000ul +#define PLIC_CPU_THRESHOLD_CTX20_BYTE_ADDRESS 0x00214000ul +#define PLIC_CPU_THRESHOLD_CTX20_OFFSET 0x00214000ul +#define PLIC_CPU_THRESHOLD_CTX20_BYTE_OFFSET 0x00214000ul +#define PLIC_CPU_THRESHOLD_CTX20_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX20_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX20_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX20_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX20_RESET_VALUE 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX20_RESET_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX20_READ_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX20_WRITE_MASK 0x00000000ul + +/* Field: PLIC_CPU_THRESHOLD_CTX20.THRESHOLD */ +#define PLIC_CPU_THRESHOLD_CTX20_THRESHOLD_MSB 0u +#define PLIC_CPU_THRESHOLD_CTX20_THRESHOLD_LSB 0u +#define PLIC_CPU_THRESHOLD_CTX20_THRESHOLD_WIDTH 1u +#define PLIC_CPU_THRESHOLD_CTX20_THRESHOLD_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX20_THRESHOLD_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX20_THRESHOLD_RESET 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX20_THRESHOLD_FIELD_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX20_THRESHOLD_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX20_THRESHOLD_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX20_THRESHOLD_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Register: PLIC_CPU.claim_complete_ctx20 */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX20_ADDRESS 0x00214004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX20_BYTE_ADDRESS 0x00214004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX20_OFFSET 0x00214004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX20_BYTE_OFFSET 0x00214004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX20_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX20_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX20_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX20_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX20_RESET_VALUE 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX20_RESET_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX20_READ_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX20_WRITE_MASK 0x00000007ul + +/* Field: PLIC_CPU_CLAIM_COMPLETE_CTX20.ID */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX20_ID_MSB 2u +#define PLIC_CPU_CLAIM_COMPLETE_CTX20_ID_LSB 0u +#define PLIC_CPU_CLAIM_COMPLETE_CTX20_ID_WIDTH 3u +#define PLIC_CPU_CLAIM_COMPLETE_CTX20_ID_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX20_ID_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX20_ID_RESET 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX20_ID_FIELD_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX20_ID_GET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX20_ID_SET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX20_ID_MODIFY(r, x) ((((x) << 0) & 0x00000007ul) | ((r) & 0xFFFFFFF8ul)) + +/* Register: PLIC_CPU.threshold_ctx21 */ +#define PLIC_CPU_THRESHOLD_CTX21_ADDRESS 0x00215000ul +#define PLIC_CPU_THRESHOLD_CTX21_BYTE_ADDRESS 0x00215000ul +#define PLIC_CPU_THRESHOLD_CTX21_OFFSET 0x00215000ul +#define PLIC_CPU_THRESHOLD_CTX21_BYTE_OFFSET 0x00215000ul +#define PLIC_CPU_THRESHOLD_CTX21_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX21_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX21_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX21_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX21_RESET_VALUE 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX21_RESET_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX21_READ_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX21_WRITE_MASK 0x00000000ul + +/* Field: PLIC_CPU_THRESHOLD_CTX21.THRESHOLD */ +#define PLIC_CPU_THRESHOLD_CTX21_THRESHOLD_MSB 0u +#define PLIC_CPU_THRESHOLD_CTX21_THRESHOLD_LSB 0u +#define PLIC_CPU_THRESHOLD_CTX21_THRESHOLD_WIDTH 1u +#define PLIC_CPU_THRESHOLD_CTX21_THRESHOLD_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX21_THRESHOLD_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX21_THRESHOLD_RESET 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX21_THRESHOLD_FIELD_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX21_THRESHOLD_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX21_THRESHOLD_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX21_THRESHOLD_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Register: PLIC_CPU.claim_complete_ctx21 */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX21_ADDRESS 0x00215004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX21_BYTE_ADDRESS 0x00215004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX21_OFFSET 0x00215004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX21_BYTE_OFFSET 0x00215004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX21_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX21_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX21_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX21_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX21_RESET_VALUE 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX21_RESET_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX21_READ_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX21_WRITE_MASK 0x00000007ul + +/* Field: PLIC_CPU_CLAIM_COMPLETE_CTX21.ID */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX21_ID_MSB 2u +#define PLIC_CPU_CLAIM_COMPLETE_CTX21_ID_LSB 0u +#define PLIC_CPU_CLAIM_COMPLETE_CTX21_ID_WIDTH 3u +#define PLIC_CPU_CLAIM_COMPLETE_CTX21_ID_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX21_ID_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX21_ID_RESET 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX21_ID_FIELD_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX21_ID_GET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX21_ID_SET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX21_ID_MODIFY(r, x) ((((x) << 0) & 0x00000007ul) | ((r) & 0xFFFFFFF8ul)) + +/* Register: PLIC_CPU.threshold_ctx22 */ +#define PLIC_CPU_THRESHOLD_CTX22_ADDRESS 0x00216000ul +#define PLIC_CPU_THRESHOLD_CTX22_BYTE_ADDRESS 0x00216000ul +#define PLIC_CPU_THRESHOLD_CTX22_OFFSET 0x00216000ul +#define PLIC_CPU_THRESHOLD_CTX22_BYTE_OFFSET 0x00216000ul +#define PLIC_CPU_THRESHOLD_CTX22_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX22_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX22_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX22_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX22_RESET_VALUE 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX22_RESET_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX22_READ_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX22_WRITE_MASK 0x00000000ul + +/* Field: PLIC_CPU_THRESHOLD_CTX22.THRESHOLD */ +#define PLIC_CPU_THRESHOLD_CTX22_THRESHOLD_MSB 0u +#define PLIC_CPU_THRESHOLD_CTX22_THRESHOLD_LSB 0u +#define PLIC_CPU_THRESHOLD_CTX22_THRESHOLD_WIDTH 1u +#define PLIC_CPU_THRESHOLD_CTX22_THRESHOLD_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX22_THRESHOLD_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX22_THRESHOLD_RESET 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX22_THRESHOLD_FIELD_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX22_THRESHOLD_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX22_THRESHOLD_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX22_THRESHOLD_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Register: PLIC_CPU.claim_complete_ctx22 */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX22_ADDRESS 0x00216004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX22_BYTE_ADDRESS 0x00216004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX22_OFFSET 0x00216004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX22_BYTE_OFFSET 0x00216004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX22_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX22_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX22_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX22_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX22_RESET_VALUE 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX22_RESET_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX22_READ_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX22_WRITE_MASK 0x00000007ul + +/* Field: PLIC_CPU_CLAIM_COMPLETE_CTX22.ID */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX22_ID_MSB 2u +#define PLIC_CPU_CLAIM_COMPLETE_CTX22_ID_LSB 0u +#define PLIC_CPU_CLAIM_COMPLETE_CTX22_ID_WIDTH 3u +#define PLIC_CPU_CLAIM_COMPLETE_CTX22_ID_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX22_ID_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX22_ID_RESET 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX22_ID_FIELD_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX22_ID_GET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX22_ID_SET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX22_ID_MODIFY(r, x) ((((x) << 0) & 0x00000007ul) | ((r) & 0xFFFFFFF8ul)) + +/* Register: PLIC_CPU.threshold_ctx23 */ +#define PLIC_CPU_THRESHOLD_CTX23_ADDRESS 0x00217000ul +#define PLIC_CPU_THRESHOLD_CTX23_BYTE_ADDRESS 0x00217000ul +#define PLIC_CPU_THRESHOLD_CTX23_OFFSET 0x00217000ul +#define PLIC_CPU_THRESHOLD_CTX23_BYTE_OFFSET 0x00217000ul +#define PLIC_CPU_THRESHOLD_CTX23_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX23_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX23_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX23_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX23_RESET_VALUE 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX23_RESET_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX23_READ_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX23_WRITE_MASK 0x00000000ul + +/* Field: PLIC_CPU_THRESHOLD_CTX23.THRESHOLD */ +#define PLIC_CPU_THRESHOLD_CTX23_THRESHOLD_MSB 0u +#define PLIC_CPU_THRESHOLD_CTX23_THRESHOLD_LSB 0u +#define PLIC_CPU_THRESHOLD_CTX23_THRESHOLD_WIDTH 1u +#define PLIC_CPU_THRESHOLD_CTX23_THRESHOLD_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX23_THRESHOLD_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX23_THRESHOLD_RESET 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX23_THRESHOLD_FIELD_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX23_THRESHOLD_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX23_THRESHOLD_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX23_THRESHOLD_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Register: PLIC_CPU.claim_complete_ctx23 */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX23_ADDRESS 0x00217004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX23_BYTE_ADDRESS 0x00217004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX23_OFFSET 0x00217004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX23_BYTE_OFFSET 0x00217004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX23_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX23_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX23_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX23_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX23_RESET_VALUE 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX23_RESET_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX23_READ_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX23_WRITE_MASK 0x00000007ul + +/* Field: PLIC_CPU_CLAIM_COMPLETE_CTX23.ID */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX23_ID_MSB 2u +#define PLIC_CPU_CLAIM_COMPLETE_CTX23_ID_LSB 0u +#define PLIC_CPU_CLAIM_COMPLETE_CTX23_ID_WIDTH 3u +#define PLIC_CPU_CLAIM_COMPLETE_CTX23_ID_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX23_ID_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX23_ID_RESET 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX23_ID_FIELD_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX23_ID_GET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX23_ID_SET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX23_ID_MODIFY(r, x) ((((x) << 0) & 0x00000007ul) | ((r) & 0xFFFFFFF8ul)) + +/* Register: PLIC_CPU.threshold_ctx24 */ +#define PLIC_CPU_THRESHOLD_CTX24_ADDRESS 0x00218000ul +#define PLIC_CPU_THRESHOLD_CTX24_BYTE_ADDRESS 0x00218000ul +#define PLIC_CPU_THRESHOLD_CTX24_OFFSET 0x00218000ul +#define PLIC_CPU_THRESHOLD_CTX24_BYTE_OFFSET 0x00218000ul +#define PLIC_CPU_THRESHOLD_CTX24_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX24_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX24_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX24_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX24_RESET_VALUE 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX24_RESET_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX24_READ_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX24_WRITE_MASK 0x00000000ul + +/* Field: PLIC_CPU_THRESHOLD_CTX24.THRESHOLD */ +#define PLIC_CPU_THRESHOLD_CTX24_THRESHOLD_MSB 0u +#define PLIC_CPU_THRESHOLD_CTX24_THRESHOLD_LSB 0u +#define PLIC_CPU_THRESHOLD_CTX24_THRESHOLD_WIDTH 1u +#define PLIC_CPU_THRESHOLD_CTX24_THRESHOLD_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX24_THRESHOLD_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX24_THRESHOLD_RESET 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX24_THRESHOLD_FIELD_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX24_THRESHOLD_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX24_THRESHOLD_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX24_THRESHOLD_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Register: PLIC_CPU.claim_complete_ctx24 */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX24_ADDRESS 0x00218004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX24_BYTE_ADDRESS 0x00218004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX24_OFFSET 0x00218004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX24_BYTE_OFFSET 0x00218004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX24_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX24_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX24_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX24_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX24_RESET_VALUE 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX24_RESET_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX24_READ_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX24_WRITE_MASK 0x00000007ul + +/* Field: PLIC_CPU_CLAIM_COMPLETE_CTX24.ID */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX24_ID_MSB 2u +#define PLIC_CPU_CLAIM_COMPLETE_CTX24_ID_LSB 0u +#define PLIC_CPU_CLAIM_COMPLETE_CTX24_ID_WIDTH 3u +#define PLIC_CPU_CLAIM_COMPLETE_CTX24_ID_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX24_ID_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX24_ID_RESET 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX24_ID_FIELD_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX24_ID_GET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX24_ID_SET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX24_ID_MODIFY(r, x) ((((x) << 0) & 0x00000007ul) | ((r) & 0xFFFFFFF8ul)) + +/* Register: PLIC_CPU.threshold_ctx25 */ +#define PLIC_CPU_THRESHOLD_CTX25_ADDRESS 0x00219000ul +#define PLIC_CPU_THRESHOLD_CTX25_BYTE_ADDRESS 0x00219000ul +#define PLIC_CPU_THRESHOLD_CTX25_OFFSET 0x00219000ul +#define PLIC_CPU_THRESHOLD_CTX25_BYTE_OFFSET 0x00219000ul +#define PLIC_CPU_THRESHOLD_CTX25_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX25_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX25_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX25_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX25_RESET_VALUE 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX25_RESET_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX25_READ_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX25_WRITE_MASK 0x00000000ul + +/* Field: PLIC_CPU_THRESHOLD_CTX25.THRESHOLD */ +#define PLIC_CPU_THRESHOLD_CTX25_THRESHOLD_MSB 0u +#define PLIC_CPU_THRESHOLD_CTX25_THRESHOLD_LSB 0u +#define PLIC_CPU_THRESHOLD_CTX25_THRESHOLD_WIDTH 1u +#define PLIC_CPU_THRESHOLD_CTX25_THRESHOLD_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX25_THRESHOLD_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX25_THRESHOLD_RESET 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX25_THRESHOLD_FIELD_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX25_THRESHOLD_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX25_THRESHOLD_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX25_THRESHOLD_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Register: PLIC_CPU.claim_complete_ctx25 */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX25_ADDRESS 0x00219004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX25_BYTE_ADDRESS 0x00219004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX25_OFFSET 0x00219004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX25_BYTE_OFFSET 0x00219004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX25_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX25_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX25_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX25_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX25_RESET_VALUE 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX25_RESET_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX25_READ_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX25_WRITE_MASK 0x00000007ul + +/* Field: PLIC_CPU_CLAIM_COMPLETE_CTX25.ID */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX25_ID_MSB 2u +#define PLIC_CPU_CLAIM_COMPLETE_CTX25_ID_LSB 0u +#define PLIC_CPU_CLAIM_COMPLETE_CTX25_ID_WIDTH 3u +#define PLIC_CPU_CLAIM_COMPLETE_CTX25_ID_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX25_ID_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX25_ID_RESET 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX25_ID_FIELD_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX25_ID_GET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX25_ID_SET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX25_ID_MODIFY(r, x) ((((x) << 0) & 0x00000007ul) | ((r) & 0xFFFFFFF8ul)) + +/* Register: PLIC_CPU.threshold_ctx26 */ +#define PLIC_CPU_THRESHOLD_CTX26_ADDRESS 0x0021A000ul +#define PLIC_CPU_THRESHOLD_CTX26_BYTE_ADDRESS 0x0021A000ul +#define PLIC_CPU_THRESHOLD_CTX26_OFFSET 0x0021A000ul +#define PLIC_CPU_THRESHOLD_CTX26_BYTE_OFFSET 0x0021A000ul +#define PLIC_CPU_THRESHOLD_CTX26_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX26_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX26_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX26_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX26_RESET_VALUE 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX26_RESET_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX26_READ_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX26_WRITE_MASK 0x00000000ul + +/* Field: PLIC_CPU_THRESHOLD_CTX26.THRESHOLD */ +#define PLIC_CPU_THRESHOLD_CTX26_THRESHOLD_MSB 0u +#define PLIC_CPU_THRESHOLD_CTX26_THRESHOLD_LSB 0u +#define PLIC_CPU_THRESHOLD_CTX26_THRESHOLD_WIDTH 1u +#define PLIC_CPU_THRESHOLD_CTX26_THRESHOLD_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX26_THRESHOLD_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX26_THRESHOLD_RESET 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX26_THRESHOLD_FIELD_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX26_THRESHOLD_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX26_THRESHOLD_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX26_THRESHOLD_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Register: PLIC_CPU.claim_complete_ctx26 */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX26_ADDRESS 0x0021A004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX26_BYTE_ADDRESS 0x0021A004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX26_OFFSET 0x0021A004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX26_BYTE_OFFSET 0x0021A004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX26_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX26_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX26_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX26_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX26_RESET_VALUE 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX26_RESET_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX26_READ_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX26_WRITE_MASK 0x00000007ul + +/* Field: PLIC_CPU_CLAIM_COMPLETE_CTX26.ID */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX26_ID_MSB 2u +#define PLIC_CPU_CLAIM_COMPLETE_CTX26_ID_LSB 0u +#define PLIC_CPU_CLAIM_COMPLETE_CTX26_ID_WIDTH 3u +#define PLIC_CPU_CLAIM_COMPLETE_CTX26_ID_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX26_ID_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX26_ID_RESET 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX26_ID_FIELD_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX26_ID_GET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX26_ID_SET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX26_ID_MODIFY(r, x) ((((x) << 0) & 0x00000007ul) | ((r) & 0xFFFFFFF8ul)) + +/* Register: PLIC_CPU.threshold_ctx27 */ +#define PLIC_CPU_THRESHOLD_CTX27_ADDRESS 0x0021B000ul +#define PLIC_CPU_THRESHOLD_CTX27_BYTE_ADDRESS 0x0021B000ul +#define PLIC_CPU_THRESHOLD_CTX27_OFFSET 0x0021B000ul +#define PLIC_CPU_THRESHOLD_CTX27_BYTE_OFFSET 0x0021B000ul +#define PLIC_CPU_THRESHOLD_CTX27_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX27_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX27_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX27_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX27_RESET_VALUE 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX27_RESET_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX27_READ_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX27_WRITE_MASK 0x00000000ul + +/* Field: PLIC_CPU_THRESHOLD_CTX27.THRESHOLD */ +#define PLIC_CPU_THRESHOLD_CTX27_THRESHOLD_MSB 0u +#define PLIC_CPU_THRESHOLD_CTX27_THRESHOLD_LSB 0u +#define PLIC_CPU_THRESHOLD_CTX27_THRESHOLD_WIDTH 1u +#define PLIC_CPU_THRESHOLD_CTX27_THRESHOLD_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX27_THRESHOLD_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX27_THRESHOLD_RESET 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX27_THRESHOLD_FIELD_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX27_THRESHOLD_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX27_THRESHOLD_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX27_THRESHOLD_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Register: PLIC_CPU.claim_complete_ctx27 */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX27_ADDRESS 0x0021B004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX27_BYTE_ADDRESS 0x0021B004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX27_OFFSET 0x0021B004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX27_BYTE_OFFSET 0x0021B004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX27_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX27_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX27_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX27_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX27_RESET_VALUE 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX27_RESET_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX27_READ_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX27_WRITE_MASK 0x00000007ul + +/* Field: PLIC_CPU_CLAIM_COMPLETE_CTX27.ID */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX27_ID_MSB 2u +#define PLIC_CPU_CLAIM_COMPLETE_CTX27_ID_LSB 0u +#define PLIC_CPU_CLAIM_COMPLETE_CTX27_ID_WIDTH 3u +#define PLIC_CPU_CLAIM_COMPLETE_CTX27_ID_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX27_ID_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX27_ID_RESET 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX27_ID_FIELD_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX27_ID_GET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX27_ID_SET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX27_ID_MODIFY(r, x) ((((x) << 0) & 0x00000007ul) | ((r) & 0xFFFFFFF8ul)) + +/* Register: PLIC_CPU.threshold_ctx28 */ +#define PLIC_CPU_THRESHOLD_CTX28_ADDRESS 0x0021C000ul +#define PLIC_CPU_THRESHOLD_CTX28_BYTE_ADDRESS 0x0021C000ul +#define PLIC_CPU_THRESHOLD_CTX28_OFFSET 0x0021C000ul +#define PLIC_CPU_THRESHOLD_CTX28_BYTE_OFFSET 0x0021C000ul +#define PLIC_CPU_THRESHOLD_CTX28_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX28_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX28_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX28_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX28_RESET_VALUE 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX28_RESET_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX28_READ_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX28_WRITE_MASK 0x00000000ul + +/* Field: PLIC_CPU_THRESHOLD_CTX28.THRESHOLD */ +#define PLIC_CPU_THRESHOLD_CTX28_THRESHOLD_MSB 0u +#define PLIC_CPU_THRESHOLD_CTX28_THRESHOLD_LSB 0u +#define PLIC_CPU_THRESHOLD_CTX28_THRESHOLD_WIDTH 1u +#define PLIC_CPU_THRESHOLD_CTX28_THRESHOLD_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX28_THRESHOLD_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX28_THRESHOLD_RESET 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX28_THRESHOLD_FIELD_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX28_THRESHOLD_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX28_THRESHOLD_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX28_THRESHOLD_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Register: PLIC_CPU.claim_complete_ctx28 */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX28_ADDRESS 0x0021C004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX28_BYTE_ADDRESS 0x0021C004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX28_OFFSET 0x0021C004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX28_BYTE_OFFSET 0x0021C004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX28_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX28_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX28_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX28_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX28_RESET_VALUE 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX28_RESET_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX28_READ_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX28_WRITE_MASK 0x00000007ul + +/* Field: PLIC_CPU_CLAIM_COMPLETE_CTX28.ID */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX28_ID_MSB 2u +#define PLIC_CPU_CLAIM_COMPLETE_CTX28_ID_LSB 0u +#define PLIC_CPU_CLAIM_COMPLETE_CTX28_ID_WIDTH 3u +#define PLIC_CPU_CLAIM_COMPLETE_CTX28_ID_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX28_ID_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX28_ID_RESET 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX28_ID_FIELD_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX28_ID_GET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX28_ID_SET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX28_ID_MODIFY(r, x) ((((x) << 0) & 0x00000007ul) | ((r) & 0xFFFFFFF8ul)) + +/* Register: PLIC_CPU.threshold_ctx29 */ +#define PLIC_CPU_THRESHOLD_CTX29_ADDRESS 0x0021D000ul +#define PLIC_CPU_THRESHOLD_CTX29_BYTE_ADDRESS 0x0021D000ul +#define PLIC_CPU_THRESHOLD_CTX29_OFFSET 0x0021D000ul +#define PLIC_CPU_THRESHOLD_CTX29_BYTE_OFFSET 0x0021D000ul +#define PLIC_CPU_THRESHOLD_CTX29_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX29_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX29_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX29_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX29_RESET_VALUE 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX29_RESET_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX29_READ_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX29_WRITE_MASK 0x00000000ul + +/* Field: PLIC_CPU_THRESHOLD_CTX29.THRESHOLD */ +#define PLIC_CPU_THRESHOLD_CTX29_THRESHOLD_MSB 0u +#define PLIC_CPU_THRESHOLD_CTX29_THRESHOLD_LSB 0u +#define PLIC_CPU_THRESHOLD_CTX29_THRESHOLD_WIDTH 1u +#define PLIC_CPU_THRESHOLD_CTX29_THRESHOLD_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX29_THRESHOLD_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX29_THRESHOLD_RESET 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX29_THRESHOLD_FIELD_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX29_THRESHOLD_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX29_THRESHOLD_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX29_THRESHOLD_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Register: PLIC_CPU.claim_complete_ctx29 */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX29_ADDRESS 0x0021D004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX29_BYTE_ADDRESS 0x0021D004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX29_OFFSET 0x0021D004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX29_BYTE_OFFSET 0x0021D004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX29_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX29_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX29_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX29_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX29_RESET_VALUE 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX29_RESET_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX29_READ_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX29_WRITE_MASK 0x00000007ul + +/* Field: PLIC_CPU_CLAIM_COMPLETE_CTX29.ID */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX29_ID_MSB 2u +#define PLIC_CPU_CLAIM_COMPLETE_CTX29_ID_LSB 0u +#define PLIC_CPU_CLAIM_COMPLETE_CTX29_ID_WIDTH 3u +#define PLIC_CPU_CLAIM_COMPLETE_CTX29_ID_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX29_ID_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX29_ID_RESET 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX29_ID_FIELD_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX29_ID_GET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX29_ID_SET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX29_ID_MODIFY(r, x) ((((x) << 0) & 0x00000007ul) | ((r) & 0xFFFFFFF8ul)) + +/* Register: PLIC_CPU.threshold_ctx30 */ +#define PLIC_CPU_THRESHOLD_CTX30_ADDRESS 0x0021E000ul +#define PLIC_CPU_THRESHOLD_CTX30_BYTE_ADDRESS 0x0021E000ul +#define PLIC_CPU_THRESHOLD_CTX30_OFFSET 0x0021E000ul +#define PLIC_CPU_THRESHOLD_CTX30_BYTE_OFFSET 0x0021E000ul +#define PLIC_CPU_THRESHOLD_CTX30_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX30_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX30_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX30_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX30_RESET_VALUE 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX30_RESET_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX30_READ_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX30_WRITE_MASK 0x00000000ul + +/* Field: PLIC_CPU_THRESHOLD_CTX30.THRESHOLD */ +#define PLIC_CPU_THRESHOLD_CTX30_THRESHOLD_MSB 0u +#define PLIC_CPU_THRESHOLD_CTX30_THRESHOLD_LSB 0u +#define PLIC_CPU_THRESHOLD_CTX30_THRESHOLD_WIDTH 1u +#define PLIC_CPU_THRESHOLD_CTX30_THRESHOLD_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX30_THRESHOLD_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX30_THRESHOLD_RESET 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX30_THRESHOLD_FIELD_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX30_THRESHOLD_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX30_THRESHOLD_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX30_THRESHOLD_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Register: PLIC_CPU.claim_complete_ctx30 */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX30_ADDRESS 0x0021E004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX30_BYTE_ADDRESS 0x0021E004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX30_OFFSET 0x0021E004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX30_BYTE_OFFSET 0x0021E004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX30_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX30_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX30_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX30_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX30_RESET_VALUE 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX30_RESET_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX30_READ_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX30_WRITE_MASK 0x00000007ul + +/* Field: PLIC_CPU_CLAIM_COMPLETE_CTX30.ID */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX30_ID_MSB 2u +#define PLIC_CPU_CLAIM_COMPLETE_CTX30_ID_LSB 0u +#define PLIC_CPU_CLAIM_COMPLETE_CTX30_ID_WIDTH 3u +#define PLIC_CPU_CLAIM_COMPLETE_CTX30_ID_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX30_ID_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX30_ID_RESET 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX30_ID_FIELD_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX30_ID_GET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX30_ID_SET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX30_ID_MODIFY(r, x) ((((x) << 0) & 0x00000007ul) | ((r) & 0xFFFFFFF8ul)) + +/* Register: PLIC_CPU.threshold_ctx31 */ +#define PLIC_CPU_THRESHOLD_CTX31_ADDRESS 0x0021F000ul +#define PLIC_CPU_THRESHOLD_CTX31_BYTE_ADDRESS 0x0021F000ul +#define PLIC_CPU_THRESHOLD_CTX31_OFFSET 0x0021F000ul +#define PLIC_CPU_THRESHOLD_CTX31_BYTE_OFFSET 0x0021F000ul +#define PLIC_CPU_THRESHOLD_CTX31_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX31_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_THRESHOLD_CTX31_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX31_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX31_RESET_VALUE 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX31_RESET_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX31_READ_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX31_WRITE_MASK 0x00000000ul + +/* Field: PLIC_CPU_THRESHOLD_CTX31.THRESHOLD */ +#define PLIC_CPU_THRESHOLD_CTX31_THRESHOLD_MSB 0u +#define PLIC_CPU_THRESHOLD_CTX31_THRESHOLD_LSB 0u +#define PLIC_CPU_THRESHOLD_CTX31_THRESHOLD_WIDTH 1u +#define PLIC_CPU_THRESHOLD_CTX31_THRESHOLD_READ_ACCESS 1u +#define PLIC_CPU_THRESHOLD_CTX31_THRESHOLD_WRITE_ACCESS 0u +#define PLIC_CPU_THRESHOLD_CTX31_THRESHOLD_RESET 0x00000000ul +#define PLIC_CPU_THRESHOLD_CTX31_THRESHOLD_FIELD_MASK 0x00000001ul +#define PLIC_CPU_THRESHOLD_CTX31_THRESHOLD_GET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX31_THRESHOLD_SET(x) ((x) & 0x00000001ul) +#define PLIC_CPU_THRESHOLD_CTX31_THRESHOLD_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Register: PLIC_CPU.claim_complete_ctx31 */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX31_ADDRESS 0x0021F004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX31_BYTE_ADDRESS 0x0021F004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX31_OFFSET 0x0021F004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX31_BYTE_OFFSET 0x0021F004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX31_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX31_BYTE_SIZE 0x00000004ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX31_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX31_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX31_RESET_VALUE 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX31_RESET_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX31_READ_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX31_WRITE_MASK 0x00000007ul + +/* Field: PLIC_CPU_CLAIM_COMPLETE_CTX31.ID */ +#define PLIC_CPU_CLAIM_COMPLETE_CTX31_ID_MSB 2u +#define PLIC_CPU_CLAIM_COMPLETE_CTX31_ID_LSB 0u +#define PLIC_CPU_CLAIM_COMPLETE_CTX31_ID_WIDTH 3u +#define PLIC_CPU_CLAIM_COMPLETE_CTX31_ID_READ_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX31_ID_WRITE_ACCESS 1u +#define PLIC_CPU_CLAIM_COMPLETE_CTX31_ID_RESET 0x00000000ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX31_ID_FIELD_MASK 0x00000007ul +#define PLIC_CPU_CLAIM_COMPLETE_CTX31_ID_GET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX31_ID_SET(x) ((x) & 0x00000007ul) +#define PLIC_CPU_CLAIM_COMPLETE_CTX31_ID_MODIFY(r, x) ((((x) << 0) & 0x00000007ul) | ((r) & 0xFFFFFFF8ul)) + +/* Block-level typedef: PLIC_CPU */ +typedef struct { + uint8_t _pad0[0x4]; /* 0x0..0x3 reserved */ + volatile uint32_t priority_src01; /* Offset 0x4 (R) */ + volatile uint32_t priority_src02; /* Offset 0x8 (R) */ + volatile uint32_t priority_src03; /* Offset 0xC (R) */ + volatile uint32_t priority_src04; /* Offset 0x10 (R) */ + volatile uint32_t priority_src05; /* Offset 0x14 (R) */ + volatile uint32_t priority_src06; /* Offset 0x18 (R) */ + uint8_t _pad1[0xFE4]; /* 0x1C..0xFFF reserved */ + volatile uint32_t pending; /* Offset 0x1000 (R) */ + uint8_t _pad2[0xFFC]; /* 0x1004..0x1FFF reserved */ + volatile uint32_t enable_ctx00; /* Offset 0x2000 (R/W) */ + uint8_t _pad3[0x7C]; /* 0x2004..0x207F reserved */ + volatile uint32_t enable_ctx01; /* Offset 0x2080 (R/W) */ + uint8_t _pad4[0x7C]; /* 0x2084..0x20FF reserved */ + volatile uint32_t enable_ctx02; /* Offset 0x2100 (R/W) */ + uint8_t _pad5[0x7C]; /* 0x2104..0x217F reserved */ + volatile uint32_t enable_ctx03; /* Offset 0x2180 (R/W) */ + uint8_t _pad6[0x7C]; /* 0x2184..0x21FF reserved */ + volatile uint32_t enable_ctx04; /* Offset 0x2200 (R/W) */ + uint8_t _pad7[0x7C]; /* 0x2204..0x227F reserved */ + volatile uint32_t enable_ctx05; /* Offset 0x2280 (R/W) */ + uint8_t _pad8[0x7C]; /* 0x2284..0x22FF reserved */ + volatile uint32_t enable_ctx06; /* Offset 0x2300 (R/W) */ + uint8_t _pad9[0x7C]; /* 0x2304..0x237F reserved */ + volatile uint32_t enable_ctx07; /* Offset 0x2380 (R/W) */ + uint8_t _pad10[0x7C]; /* 0x2384..0x23FF reserved */ + volatile uint32_t enable_ctx08; /* Offset 0x2400 (R/W) */ + uint8_t _pad11[0x7C]; /* 0x2404..0x247F reserved */ + volatile uint32_t enable_ctx09; /* Offset 0x2480 (R/W) */ + uint8_t _pad12[0x7C]; /* 0x2484..0x24FF reserved */ + volatile uint32_t enable_ctx10; /* Offset 0x2500 (R/W) */ + uint8_t _pad13[0x7C]; /* 0x2504..0x257F reserved */ + volatile uint32_t enable_ctx11; /* Offset 0x2580 (R/W) */ + uint8_t _pad14[0x7C]; /* 0x2584..0x25FF reserved */ + volatile uint32_t enable_ctx12; /* Offset 0x2600 (R/W) */ + uint8_t _pad15[0x7C]; /* 0x2604..0x267F reserved */ + volatile uint32_t enable_ctx13; /* Offset 0x2680 (R/W) */ + uint8_t _pad16[0x7C]; /* 0x2684..0x26FF reserved */ + volatile uint32_t enable_ctx14; /* Offset 0x2700 (R/W) */ + uint8_t _pad17[0x7C]; /* 0x2704..0x277F reserved */ + volatile uint32_t enable_ctx15; /* Offset 0x2780 (R/W) */ + uint8_t _pad18[0x7C]; /* 0x2784..0x27FF reserved */ + volatile uint32_t enable_ctx16; /* Offset 0x2800 (R/W) */ + uint8_t _pad19[0x7C]; /* 0x2804..0x287F reserved */ + volatile uint32_t enable_ctx17; /* Offset 0x2880 (R/W) */ + uint8_t _pad20[0x7C]; /* 0x2884..0x28FF reserved */ + volatile uint32_t enable_ctx18; /* Offset 0x2900 (R/W) */ + uint8_t _pad21[0x7C]; /* 0x2904..0x297F reserved */ + volatile uint32_t enable_ctx19; /* Offset 0x2980 (R/W) */ + uint8_t _pad22[0x7C]; /* 0x2984..0x29FF reserved */ + volatile uint32_t enable_ctx20; /* Offset 0x2A00 (R/W) */ + uint8_t _pad23[0x7C]; /* 0x2A04..0x2A7F reserved */ + volatile uint32_t enable_ctx21; /* Offset 0x2A80 (R/W) */ + uint8_t _pad24[0x7C]; /* 0x2A84..0x2AFF reserved */ + volatile uint32_t enable_ctx22; /* Offset 0x2B00 (R/W) */ + uint8_t _pad25[0x7C]; /* 0x2B04..0x2B7F reserved */ + volatile uint32_t enable_ctx23; /* Offset 0x2B80 (R/W) */ + uint8_t _pad26[0x7C]; /* 0x2B84..0x2BFF reserved */ + volatile uint32_t enable_ctx24; /* Offset 0x2C00 (R/W) */ + uint8_t _pad27[0x7C]; /* 0x2C04..0x2C7F reserved */ + volatile uint32_t enable_ctx25; /* Offset 0x2C80 (R/W) */ + uint8_t _pad28[0x7C]; /* 0x2C84..0x2CFF reserved */ + volatile uint32_t enable_ctx26; /* Offset 0x2D00 (R/W) */ + uint8_t _pad29[0x7C]; /* 0x2D04..0x2D7F reserved */ + volatile uint32_t enable_ctx27; /* Offset 0x2D80 (R/W) */ + uint8_t _pad30[0x7C]; /* 0x2D84..0x2DFF reserved */ + volatile uint32_t enable_ctx28; /* Offset 0x2E00 (R/W) */ + uint8_t _pad31[0x7C]; /* 0x2E04..0x2E7F reserved */ + volatile uint32_t enable_ctx29; /* Offset 0x2E80 (R/W) */ + uint8_t _pad32[0x7C]; /* 0x2E84..0x2EFF reserved */ + volatile uint32_t enable_ctx30; /* Offset 0x2F00 (R/W) */ + uint8_t _pad33[0x7C]; /* 0x2F04..0x2F7F reserved */ + volatile uint32_t enable_ctx31; /* Offset 0x2F80 (R/W) */ + uint8_t _pad34[0x1FD07C]; /* 0x2F84..0x1FFFFF reserved */ + volatile uint32_t threshold_ctx00; /* Offset 0x200000 (R) */ + volatile uint32_t claim_complete_ctx00; /* Offset 0x200004 (R/W) */ + uint8_t _pad35[0xFF8]; /* 0x200008..0x200FFF reserved */ + volatile uint32_t threshold_ctx01; /* Offset 0x201000 (R) */ + volatile uint32_t claim_complete_ctx01; /* Offset 0x201004 (R/W) */ + uint8_t _pad36[0xFF8]; /* 0x201008..0x201FFF reserved */ + volatile uint32_t threshold_ctx02; /* Offset 0x202000 (R) */ + volatile uint32_t claim_complete_ctx02; /* Offset 0x202004 (R/W) */ + uint8_t _pad37[0xFF8]; /* 0x202008..0x202FFF reserved */ + volatile uint32_t threshold_ctx03; /* Offset 0x203000 (R) */ + volatile uint32_t claim_complete_ctx03; /* Offset 0x203004 (R/W) */ + uint8_t _pad38[0xFF8]; /* 0x203008..0x203FFF reserved */ + volatile uint32_t threshold_ctx04; /* Offset 0x204000 (R) */ + volatile uint32_t claim_complete_ctx04; /* Offset 0x204004 (R/W) */ + uint8_t _pad39[0xFF8]; /* 0x204008..0x204FFF reserved */ + volatile uint32_t threshold_ctx05; /* Offset 0x205000 (R) */ + volatile uint32_t claim_complete_ctx05; /* Offset 0x205004 (R/W) */ + uint8_t _pad40[0xFF8]; /* 0x205008..0x205FFF reserved */ + volatile uint32_t threshold_ctx06; /* Offset 0x206000 (R) */ + volatile uint32_t claim_complete_ctx06; /* Offset 0x206004 (R/W) */ + uint8_t _pad41[0xFF8]; /* 0x206008..0x206FFF reserved */ + volatile uint32_t threshold_ctx07; /* Offset 0x207000 (R) */ + volatile uint32_t claim_complete_ctx07; /* Offset 0x207004 (R/W) */ + uint8_t _pad42[0xFF8]; /* 0x207008..0x207FFF reserved */ + volatile uint32_t threshold_ctx08; /* Offset 0x208000 (R) */ + volatile uint32_t claim_complete_ctx08; /* Offset 0x208004 (R/W) */ + uint8_t _pad43[0xFF8]; /* 0x208008..0x208FFF reserved */ + volatile uint32_t threshold_ctx09; /* Offset 0x209000 (R) */ + volatile uint32_t claim_complete_ctx09; /* Offset 0x209004 (R/W) */ + uint8_t _pad44[0xFF8]; /* 0x209008..0x209FFF reserved */ + volatile uint32_t threshold_ctx10; /* Offset 0x20A000 (R) */ + volatile uint32_t claim_complete_ctx10; /* Offset 0x20A004 (R/W) */ + uint8_t _pad45[0xFF8]; /* 0x20A008..0x20AFFF reserved */ + volatile uint32_t threshold_ctx11; /* Offset 0x20B000 (R) */ + volatile uint32_t claim_complete_ctx11; /* Offset 0x20B004 (R/W) */ + uint8_t _pad46[0xFF8]; /* 0x20B008..0x20BFFF reserved */ + volatile uint32_t threshold_ctx12; /* Offset 0x20C000 (R) */ + volatile uint32_t claim_complete_ctx12; /* Offset 0x20C004 (R/W) */ + uint8_t _pad47[0xFF8]; /* 0x20C008..0x20CFFF reserved */ + volatile uint32_t threshold_ctx13; /* Offset 0x20D000 (R) */ + volatile uint32_t claim_complete_ctx13; /* Offset 0x20D004 (R/W) */ + uint8_t _pad48[0xFF8]; /* 0x20D008..0x20DFFF reserved */ + volatile uint32_t threshold_ctx14; /* Offset 0x20E000 (R) */ + volatile uint32_t claim_complete_ctx14; /* Offset 0x20E004 (R/W) */ + uint8_t _pad49[0xFF8]; /* 0x20E008..0x20EFFF reserved */ + volatile uint32_t threshold_ctx15; /* Offset 0x20F000 (R) */ + volatile uint32_t claim_complete_ctx15; /* Offset 0x20F004 (R/W) */ + uint8_t _pad50[0xFF8]; /* 0x20F008..0x20FFFF reserved */ + volatile uint32_t threshold_ctx16; /* Offset 0x210000 (R) */ + volatile uint32_t claim_complete_ctx16; /* Offset 0x210004 (R/W) */ + uint8_t _pad51[0xFF8]; /* 0x210008..0x210FFF reserved */ + volatile uint32_t threshold_ctx17; /* Offset 0x211000 (R) */ + volatile uint32_t claim_complete_ctx17; /* Offset 0x211004 (R/W) */ + uint8_t _pad52[0xFF8]; /* 0x211008..0x211FFF reserved */ + volatile uint32_t threshold_ctx18; /* Offset 0x212000 (R) */ + volatile uint32_t claim_complete_ctx18; /* Offset 0x212004 (R/W) */ + uint8_t _pad53[0xFF8]; /* 0x212008..0x212FFF reserved */ + volatile uint32_t threshold_ctx19; /* Offset 0x213000 (R) */ + volatile uint32_t claim_complete_ctx19; /* Offset 0x213004 (R/W) */ + uint8_t _pad54[0xFF8]; /* 0x213008..0x213FFF reserved */ + volatile uint32_t threshold_ctx20; /* Offset 0x214000 (R) */ + volatile uint32_t claim_complete_ctx20; /* Offset 0x214004 (R/W) */ + uint8_t _pad55[0xFF8]; /* 0x214008..0x214FFF reserved */ + volatile uint32_t threshold_ctx21; /* Offset 0x215000 (R) */ + volatile uint32_t claim_complete_ctx21; /* Offset 0x215004 (R/W) */ + uint8_t _pad56[0xFF8]; /* 0x215008..0x215FFF reserved */ + volatile uint32_t threshold_ctx22; /* Offset 0x216000 (R) */ + volatile uint32_t claim_complete_ctx22; /* Offset 0x216004 (R/W) */ + uint8_t _pad57[0xFF8]; /* 0x216008..0x216FFF reserved */ + volatile uint32_t threshold_ctx23; /* Offset 0x217000 (R) */ + volatile uint32_t claim_complete_ctx23; /* Offset 0x217004 (R/W) */ + uint8_t _pad58[0xFF8]; /* 0x217008..0x217FFF reserved */ + volatile uint32_t threshold_ctx24; /* Offset 0x218000 (R) */ + volatile uint32_t claim_complete_ctx24; /* Offset 0x218004 (R/W) */ + uint8_t _pad59[0xFF8]; /* 0x218008..0x218FFF reserved */ + volatile uint32_t threshold_ctx25; /* Offset 0x219000 (R) */ + volatile uint32_t claim_complete_ctx25; /* Offset 0x219004 (R/W) */ + uint8_t _pad60[0xFF8]; /* 0x219008..0x219FFF reserved */ + volatile uint32_t threshold_ctx26; /* Offset 0x21A000 (R) */ + volatile uint32_t claim_complete_ctx26; /* Offset 0x21A004 (R/W) */ + uint8_t _pad61[0xFF8]; /* 0x21A008..0x21AFFF reserved */ + volatile uint32_t threshold_ctx27; /* Offset 0x21B000 (R) */ + volatile uint32_t claim_complete_ctx27; /* Offset 0x21B004 (R/W) */ + uint8_t _pad62[0xFF8]; /* 0x21B008..0x21BFFF reserved */ + volatile uint32_t threshold_ctx28; /* Offset 0x21C000 (R) */ + volatile uint32_t claim_complete_ctx28; /* Offset 0x21C004 (R/W) */ + uint8_t _pad63[0xFF8]; /* 0x21C008..0x21CFFF reserved */ + volatile uint32_t threshold_ctx29; /* Offset 0x21D000 (R) */ + volatile uint32_t claim_complete_ctx29; /* Offset 0x21D004 (R/W) */ + uint8_t _pad64[0xFF8]; /* 0x21D008..0x21DFFF reserved */ + volatile uint32_t threshold_ctx30; /* Offset 0x21E000 (R) */ + volatile uint32_t claim_complete_ctx30; /* Offset 0x21E004 (R/W) */ + uint8_t _pad65[0xFF8]; /* 0x21E008..0x21EFFF reserved */ + volatile uint32_t threshold_ctx31; /* Offset 0x21F000 (R) */ + volatile uint32_t claim_complete_ctx31; /* Offset 0x21F004 (R/W) */ +} PLIC_cpu_t, *PTR_PLIC_cpu_t; + +#ifdef __cplusplus +} +#endif + +#endif /* _PLIC_H_ */ diff --git a/erbium-hal/include/hwinc/qspi.h b/erbium-hal/include/hwinc/qspi.h new file mode 100644 index 000000000..219ec32a8 --- /dev/null +++ b/erbium-hal/include/hwinc/qspi.h @@ -0,0 +1,842 @@ +/* Auto-generated by rdl2hal.py from SystemRDL. Do not edit. */ +#ifndef _QSPI_H_ +#define _QSPI_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* ============================================================ */ +/* Block: QSPI_Reg (macro prefix: QSPI) */ +/* ============================================================ */ + +/* Register: QSPI.CR */ +#define QSPI_CR_ADDRESS 0x00000000ul +#define QSPI_CR_BYTE_ADDRESS 0x00000000ul +#define QSPI_CR_OFFSET 0x00000000ul +#define QSPI_CR_BYTE_OFFSET 0x00000000ul +#define QSPI_CR_SIZE 0x00000004ul +#define QSPI_CR_BYTE_SIZE 0x00000004ul +#define QSPI_CR_READ_ACCESS 1u +#define QSPI_CR_WRITE_ACCESS 1u +#define QSPI_CR_RESET_VALUE 0x00000000ul +#define QSPI_CR_RESET_MASK 0xFFDF1FDFul +#define QSPI_CR_READ_MASK 0xFFDF1FDFul +#define QSPI_CR_WRITE_MASK 0xFFDF1FDFul + +/* Field: QSPI_CR.qspi_enable */ +#define QSPI_CR_QSPI_ENABLE_MSB 0u +#define QSPI_CR_QSPI_ENABLE_LSB 0u +#define QSPI_CR_QSPI_ENABLE_WIDTH 1u +#define QSPI_CR_QSPI_ENABLE_READ_ACCESS 1u +#define QSPI_CR_QSPI_ENABLE_WRITE_ACCESS 1u +#define QSPI_CR_QSPI_ENABLE_RESET 0x00000000ul +#define QSPI_CR_QSPI_ENABLE_FIELD_MASK 0x00000001ul +#define QSPI_CR_QSPI_ENABLE_GET(x) ((x) & 0x00000001ul) +#define QSPI_CR_QSPI_ENABLE_SET(x) ((x) & 0x00000001ul) +#define QSPI_CR_QSPI_ENABLE_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Field: QSPI_CR.abort */ +#define QSPI_CR_ABORT_MSB 1u +#define QSPI_CR_ABORT_LSB 1u +#define QSPI_CR_ABORT_WIDTH 1u +#define QSPI_CR_ABORT_READ_ACCESS 1u +#define QSPI_CR_ABORT_WRITE_ACCESS 1u +#define QSPI_CR_ABORT_RESET 0x00000000ul +#define QSPI_CR_ABORT_FIELD_MASK 0x00000002ul +#define QSPI_CR_ABORT_GET(x) (((x) & 0x00000002ul) >> 1) +#define QSPI_CR_ABORT_SET(x) (((x) << 1) & 0x00000002ul) +#define QSPI_CR_ABORT_MODIFY(r, x) ((((x) << 1) & 0x00000002ul) | ((r) & 0xFFFFFFFDul)) + +/* Field: QSPI_CR.dmaen */ +#define QSPI_CR_DMAEN_MSB 2u +#define QSPI_CR_DMAEN_LSB 2u +#define QSPI_CR_DMAEN_WIDTH 1u +#define QSPI_CR_DMAEN_READ_ACCESS 1u +#define QSPI_CR_DMAEN_WRITE_ACCESS 1u +#define QSPI_CR_DMAEN_RESET 0x00000000ul +#define QSPI_CR_DMAEN_FIELD_MASK 0x00000004ul +#define QSPI_CR_DMAEN_GET(x) (((x) & 0x00000004ul) >> 2) +#define QSPI_CR_DMAEN_SET(x) (((x) << 2) & 0x00000004ul) +#define QSPI_CR_DMAEN_MODIFY(r, x) ((((x) << 2) & 0x00000004ul) | ((r) & 0xFFFFFFFBul)) + +/* Field: QSPI_CR.tcen */ +#define QSPI_CR_TCEN_MSB 3u +#define QSPI_CR_TCEN_LSB 3u +#define QSPI_CR_TCEN_WIDTH 1u +#define QSPI_CR_TCEN_READ_ACCESS 1u +#define QSPI_CR_TCEN_WRITE_ACCESS 1u +#define QSPI_CR_TCEN_RESET 0x00000000ul +#define QSPI_CR_TCEN_FIELD_MASK 0x00000008ul +#define QSPI_CR_TCEN_GET(x) (((x) & 0x00000008ul) >> 3) +#define QSPI_CR_TCEN_SET(x) (((x) << 3) & 0x00000008ul) +#define QSPI_CR_TCEN_MODIFY(r, x) ((((x) << 3) & 0x00000008ul) | ((r) & 0xFFFFFFF7ul)) + +/* Field: QSPI_CR.sshift */ +#define QSPI_CR_SSHIFT_MSB 4u +#define QSPI_CR_SSHIFT_LSB 4u +#define QSPI_CR_SSHIFT_WIDTH 1u +#define QSPI_CR_SSHIFT_READ_ACCESS 1u +#define QSPI_CR_SSHIFT_WRITE_ACCESS 1u +#define QSPI_CR_SSHIFT_RESET 0x00000000ul +#define QSPI_CR_SSHIFT_FIELD_MASK 0x00000010ul +#define QSPI_CR_SSHIFT_GET(x) (((x) & 0x00000010ul) >> 4) +#define QSPI_CR_SSHIFT_SET(x) (((x) << 4) & 0x00000010ul) +#define QSPI_CR_SSHIFT_MODIFY(r, x) ((((x) << 4) & 0x00000010ul) | ((r) & 0xFFFFFFEFul)) + +/* Field: QSPI_CR.dfm */ +#define QSPI_CR_DFM_MSB 6u +#define QSPI_CR_DFM_LSB 6u +#define QSPI_CR_DFM_WIDTH 1u +#define QSPI_CR_DFM_READ_ACCESS 1u +#define QSPI_CR_DFM_WRITE_ACCESS 1u +#define QSPI_CR_DFM_RESET 0x00000000ul +#define QSPI_CR_DFM_FIELD_MASK 0x00000040ul +#define QSPI_CR_DFM_GET(x) (((x) & 0x00000040ul) >> 6) +#define QSPI_CR_DFM_SET(x) (((x) << 6) & 0x00000040ul) +#define QSPI_CR_DFM_MODIFY(r, x) ((((x) << 6) & 0x00000040ul) | ((r) & 0xFFFFFFBFul)) + +/* Field: QSPI_CR.fsel */ +#define QSPI_CR_FSEL_MSB 7u +#define QSPI_CR_FSEL_LSB 7u +#define QSPI_CR_FSEL_WIDTH 1u +#define QSPI_CR_FSEL_READ_ACCESS 1u +#define QSPI_CR_FSEL_WRITE_ACCESS 1u +#define QSPI_CR_FSEL_RESET 0x00000000ul +#define QSPI_CR_FSEL_FIELD_MASK 0x00000080ul +#define QSPI_CR_FSEL_GET(x) (((x) & 0x00000080ul) >> 7) +#define QSPI_CR_FSEL_SET(x) (((x) << 7) & 0x00000080ul) +#define QSPI_CR_FSEL_MODIFY(r, x) ((((x) << 7) & 0x00000080ul) | ((r) & 0xFFFFFF7Ful)) + +/* Field: QSPI_CR.fthres */ +#define QSPI_CR_FTHRES_MSB 12u +#define QSPI_CR_FTHRES_LSB 8u +#define QSPI_CR_FTHRES_WIDTH 5u +#define QSPI_CR_FTHRES_READ_ACCESS 1u +#define QSPI_CR_FTHRES_WRITE_ACCESS 1u +#define QSPI_CR_FTHRES_RESET 0x00000000ul +#define QSPI_CR_FTHRES_FIELD_MASK 0x00001F00ul +#define QSPI_CR_FTHRES_GET(x) (((x) & 0x00001F00ul) >> 8) +#define QSPI_CR_FTHRES_SET(x) (((x) << 8) & 0x00001F00ul) +#define QSPI_CR_FTHRES_MODIFY(r, x) ((((x) << 8) & 0x00001F00ul) | ((r) & 0xFFFFE0FFul)) + +/* Field: QSPI_CR.teie */ +#define QSPI_CR_TEIE_MSB 16u +#define QSPI_CR_TEIE_LSB 16u +#define QSPI_CR_TEIE_WIDTH 1u +#define QSPI_CR_TEIE_READ_ACCESS 1u +#define QSPI_CR_TEIE_WRITE_ACCESS 1u +#define QSPI_CR_TEIE_RESET 0x00000000ul +#define QSPI_CR_TEIE_FIELD_MASK 0x00010000ul +#define QSPI_CR_TEIE_GET(x) (((x) & 0x00010000ul) >> 16) +#define QSPI_CR_TEIE_SET(x) (((x) << 16) & 0x00010000ul) +#define QSPI_CR_TEIE_MODIFY(r, x) ((((x) << 16) & 0x00010000ul) | ((r) & 0xFFFEFFFFul)) + +/* Field: QSPI_CR.tcie */ +#define QSPI_CR_TCIE_MSB 17u +#define QSPI_CR_TCIE_LSB 17u +#define QSPI_CR_TCIE_WIDTH 1u +#define QSPI_CR_TCIE_READ_ACCESS 1u +#define QSPI_CR_TCIE_WRITE_ACCESS 1u +#define QSPI_CR_TCIE_RESET 0x00000000ul +#define QSPI_CR_TCIE_FIELD_MASK 0x00020000ul +#define QSPI_CR_TCIE_GET(x) (((x) & 0x00020000ul) >> 17) +#define QSPI_CR_TCIE_SET(x) (((x) << 17) & 0x00020000ul) +#define QSPI_CR_TCIE_MODIFY(r, x) ((((x) << 17) & 0x00020000ul) | ((r) & 0xFFFDFFFFul)) + +/* Field: QSPI_CR.ftie */ +#define QSPI_CR_FTIE_MSB 18u +#define QSPI_CR_FTIE_LSB 18u +#define QSPI_CR_FTIE_WIDTH 1u +#define QSPI_CR_FTIE_READ_ACCESS 1u +#define QSPI_CR_FTIE_WRITE_ACCESS 1u +#define QSPI_CR_FTIE_RESET 0x00000000ul +#define QSPI_CR_FTIE_FIELD_MASK 0x00040000ul +#define QSPI_CR_FTIE_GET(x) (((x) & 0x00040000ul) >> 18) +#define QSPI_CR_FTIE_SET(x) (((x) << 18) & 0x00040000ul) +#define QSPI_CR_FTIE_MODIFY(r, x) ((((x) << 18) & 0x00040000ul) | ((r) & 0xFFFBFFFFul)) + +/* Field: QSPI_CR.smie */ +#define QSPI_CR_SMIE_MSB 19u +#define QSPI_CR_SMIE_LSB 19u +#define QSPI_CR_SMIE_WIDTH 1u +#define QSPI_CR_SMIE_READ_ACCESS 1u +#define QSPI_CR_SMIE_WRITE_ACCESS 1u +#define QSPI_CR_SMIE_RESET 0x00000000ul +#define QSPI_CR_SMIE_FIELD_MASK 0x00080000ul +#define QSPI_CR_SMIE_GET(x) (((x) & 0x00080000ul) >> 19) +#define QSPI_CR_SMIE_SET(x) (((x) << 19) & 0x00080000ul) +#define QSPI_CR_SMIE_MODIFY(r, x) ((((x) << 19) & 0x00080000ul) | ((r) & 0xFFF7FFFFul)) + +/* Field: QSPI_CR.toie */ +#define QSPI_CR_TOIE_MSB 20u +#define QSPI_CR_TOIE_LSB 20u +#define QSPI_CR_TOIE_WIDTH 1u +#define QSPI_CR_TOIE_READ_ACCESS 1u +#define QSPI_CR_TOIE_WRITE_ACCESS 1u +#define QSPI_CR_TOIE_RESET 0x00000000ul +#define QSPI_CR_TOIE_FIELD_MASK 0x00100000ul +#define QSPI_CR_TOIE_GET(x) (((x) & 0x00100000ul) >> 20) +#define QSPI_CR_TOIE_SET(x) (((x) << 20) & 0x00100000ul) +#define QSPI_CR_TOIE_MODIFY(r, x) ((((x) << 20) & 0x00100000ul) | ((r) & 0xFFEFFFFFul)) + +/* Field: QSPI_CR.apms */ +#define QSPI_CR_APMS_MSB 22u +#define QSPI_CR_APMS_LSB 22u +#define QSPI_CR_APMS_WIDTH 1u +#define QSPI_CR_APMS_READ_ACCESS 1u +#define QSPI_CR_APMS_WRITE_ACCESS 1u +#define QSPI_CR_APMS_RESET 0x00000000ul +#define QSPI_CR_APMS_FIELD_MASK 0x00400000ul +#define QSPI_CR_APMS_GET(x) (((x) & 0x00400000ul) >> 22) +#define QSPI_CR_APMS_SET(x) (((x) << 22) & 0x00400000ul) +#define QSPI_CR_APMS_MODIFY(r, x) ((((x) << 22) & 0x00400000ul) | ((r) & 0xFFBFFFFFul)) + +/* Field: QSPI_CR.pmm */ +#define QSPI_CR_PMM_MSB 23u +#define QSPI_CR_PMM_LSB 23u +#define QSPI_CR_PMM_WIDTH 1u +#define QSPI_CR_PMM_READ_ACCESS 1u +#define QSPI_CR_PMM_WRITE_ACCESS 1u +#define QSPI_CR_PMM_RESET 0x00000000ul +#define QSPI_CR_PMM_FIELD_MASK 0x00800000ul +#define QSPI_CR_PMM_GET(x) (((x) & 0x00800000ul) >> 23) +#define QSPI_CR_PMM_SET(x) (((x) << 23) & 0x00800000ul) +#define QSPI_CR_PMM_MODIFY(r, x) ((((x) << 23) & 0x00800000ul) | ((r) & 0xFF7FFFFFul)) + +/* Field: QSPI_CR.prescaler */ +#define QSPI_CR_PRESCALER_MSB 31u +#define QSPI_CR_PRESCALER_LSB 24u +#define QSPI_CR_PRESCALER_WIDTH 8u +#define QSPI_CR_PRESCALER_READ_ACCESS 1u +#define QSPI_CR_PRESCALER_WRITE_ACCESS 1u +#define QSPI_CR_PRESCALER_RESET 0x00000000ul +#define QSPI_CR_PRESCALER_FIELD_MASK 0xFF000000ul +#define QSPI_CR_PRESCALER_GET(x) (((x) & 0xFF000000ul) >> 24) +#define QSPI_CR_PRESCALER_SET(x) (((x) << 24) & 0xFF000000ul) +#define QSPI_CR_PRESCALER_MODIFY(r, x) ((((x) << 24) & 0xFF000000ul) | ((r) & 0x00FFFFFFul)) + +/* Register: QSPI.DCR */ +#define QSPI_DCR_ADDRESS 0x00000008ul +#define QSPI_DCR_BYTE_ADDRESS 0x00000008ul +#define QSPI_DCR_OFFSET 0x00000008ul +#define QSPI_DCR_BYTE_OFFSET 0x00000008ul +#define QSPI_DCR_SIZE 0x00000004ul +#define QSPI_DCR_BYTE_SIZE 0x00000004ul +#define QSPI_DCR_READ_ACCESS 1u +#define QSPI_DCR_WRITE_ACCESS 1u +#define QSPI_DCR_RESET_VALUE 0x00000000ul +#define QSPI_DCR_RESET_MASK 0x001F0701ul +#define QSPI_DCR_READ_MASK 0x001F0701ul +#define QSPI_DCR_WRITE_MASK 0x001F0701ul + +/* Field: QSPI_DCR.ckmode */ +#define QSPI_DCR_CKMODE_MSB 0u +#define QSPI_DCR_CKMODE_LSB 0u +#define QSPI_DCR_CKMODE_WIDTH 1u +#define QSPI_DCR_CKMODE_READ_ACCESS 1u +#define QSPI_DCR_CKMODE_WRITE_ACCESS 1u +#define QSPI_DCR_CKMODE_RESET 0x00000000ul +#define QSPI_DCR_CKMODE_FIELD_MASK 0x00000001ul +#define QSPI_DCR_CKMODE_GET(x) ((x) & 0x00000001ul) +#define QSPI_DCR_CKMODE_SET(x) ((x) & 0x00000001ul) +#define QSPI_DCR_CKMODE_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Field: QSPI_DCR.csht */ +#define QSPI_DCR_CSHT_MSB 10u +#define QSPI_DCR_CSHT_LSB 8u +#define QSPI_DCR_CSHT_WIDTH 3u +#define QSPI_DCR_CSHT_READ_ACCESS 1u +#define QSPI_DCR_CSHT_WRITE_ACCESS 1u +#define QSPI_DCR_CSHT_RESET 0x00000000ul +#define QSPI_DCR_CSHT_FIELD_MASK 0x00000700ul +#define QSPI_DCR_CSHT_GET(x) (((x) & 0x00000700ul) >> 8) +#define QSPI_DCR_CSHT_SET(x) (((x) << 8) & 0x00000700ul) +#define QSPI_DCR_CSHT_MODIFY(r, x) ((((x) << 8) & 0x00000700ul) | ((r) & 0xFFFFF8FFul)) + +/* Field: QSPI_DCR.fsize */ +#define QSPI_DCR_FSIZE_MSB 20u +#define QSPI_DCR_FSIZE_LSB 16u +#define QSPI_DCR_FSIZE_WIDTH 5u +#define QSPI_DCR_FSIZE_READ_ACCESS 1u +#define QSPI_DCR_FSIZE_WRITE_ACCESS 1u +#define QSPI_DCR_FSIZE_RESET 0x00000000ul +#define QSPI_DCR_FSIZE_FIELD_MASK 0x001F0000ul +#define QSPI_DCR_FSIZE_GET(x) (((x) & 0x001F0000ul) >> 16) +#define QSPI_DCR_FSIZE_SET(x) (((x) << 16) & 0x001F0000ul) +#define QSPI_DCR_FSIZE_MODIFY(r, x) ((((x) << 16) & 0x001F0000ul) | ((r) & 0xFFE0FFFFul)) + +/* Register: QSPI.SR */ +#define QSPI_SR_ADDRESS 0x00000010ul +#define QSPI_SR_BYTE_ADDRESS 0x00000010ul +#define QSPI_SR_OFFSET 0x00000010ul +#define QSPI_SR_BYTE_OFFSET 0x00000010ul +#define QSPI_SR_SIZE 0x00000004ul +#define QSPI_SR_BYTE_SIZE 0x00000004ul +#define QSPI_SR_READ_ACCESS 1u +#define QSPI_SR_WRITE_ACCESS 0u +#define QSPI_SR_RESET_VALUE 0x00000000ul +#define QSPI_SR_RESET_MASK 0x00003F3Ful +#define QSPI_SR_READ_MASK 0x00003F3Ful +#define QSPI_SR_WRITE_MASK 0x00000000ul + +/* Field: QSPI_SR.tef */ +#define QSPI_SR_TEF_MSB 0u +#define QSPI_SR_TEF_LSB 0u +#define QSPI_SR_TEF_WIDTH 1u +#define QSPI_SR_TEF_READ_ACCESS 1u +#define QSPI_SR_TEF_WRITE_ACCESS 0u +#define QSPI_SR_TEF_RESET 0x00000000ul +#define QSPI_SR_TEF_FIELD_MASK 0x00000001ul +#define QSPI_SR_TEF_GET(x) ((x) & 0x00000001ul) +#define QSPI_SR_TEF_SET(x) ((x) & 0x00000001ul) +#define QSPI_SR_TEF_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Field: QSPI_SR.tcf */ +#define QSPI_SR_TCF_MSB 1u +#define QSPI_SR_TCF_LSB 1u +#define QSPI_SR_TCF_WIDTH 1u +#define QSPI_SR_TCF_READ_ACCESS 1u +#define QSPI_SR_TCF_WRITE_ACCESS 0u +#define QSPI_SR_TCF_RESET 0x00000000ul +#define QSPI_SR_TCF_FIELD_MASK 0x00000002ul +#define QSPI_SR_TCF_GET(x) (((x) & 0x00000002ul) >> 1) +#define QSPI_SR_TCF_SET(x) (((x) << 1) & 0x00000002ul) +#define QSPI_SR_TCF_MODIFY(r, x) ((((x) << 1) & 0x00000002ul) | ((r) & 0xFFFFFFFDul)) + +/* Field: QSPI_SR.ftf */ +#define QSPI_SR_FTF_MSB 2u +#define QSPI_SR_FTF_LSB 2u +#define QSPI_SR_FTF_WIDTH 1u +#define QSPI_SR_FTF_READ_ACCESS 1u +#define QSPI_SR_FTF_WRITE_ACCESS 0u +#define QSPI_SR_FTF_RESET 0x00000000ul +#define QSPI_SR_FTF_FIELD_MASK 0x00000004ul +#define QSPI_SR_FTF_GET(x) (((x) & 0x00000004ul) >> 2) +#define QSPI_SR_FTF_SET(x) (((x) << 2) & 0x00000004ul) +#define QSPI_SR_FTF_MODIFY(r, x) ((((x) << 2) & 0x00000004ul) | ((r) & 0xFFFFFFFBul)) + +/* Field: QSPI_SR.smf */ +#define QSPI_SR_SMF_MSB 3u +#define QSPI_SR_SMF_LSB 3u +#define QSPI_SR_SMF_WIDTH 1u +#define QSPI_SR_SMF_READ_ACCESS 1u +#define QSPI_SR_SMF_WRITE_ACCESS 0u +#define QSPI_SR_SMF_RESET 0x00000000ul +#define QSPI_SR_SMF_FIELD_MASK 0x00000008ul +#define QSPI_SR_SMF_GET(x) (((x) & 0x00000008ul) >> 3) +#define QSPI_SR_SMF_SET(x) (((x) << 3) & 0x00000008ul) +#define QSPI_SR_SMF_MODIFY(r, x) ((((x) << 3) & 0x00000008ul) | ((r) & 0xFFFFFFF7ul)) + +/* Field: QSPI_SR.tof */ +#define QSPI_SR_TOF_MSB 4u +#define QSPI_SR_TOF_LSB 4u +#define QSPI_SR_TOF_WIDTH 1u +#define QSPI_SR_TOF_READ_ACCESS 1u +#define QSPI_SR_TOF_WRITE_ACCESS 0u +#define QSPI_SR_TOF_RESET 0x00000000ul +#define QSPI_SR_TOF_FIELD_MASK 0x00000010ul +#define QSPI_SR_TOF_GET(x) (((x) & 0x00000010ul) >> 4) +#define QSPI_SR_TOF_SET(x) (((x) << 4) & 0x00000010ul) +#define QSPI_SR_TOF_MODIFY(r, x) ((((x) << 4) & 0x00000010ul) | ((r) & 0xFFFFFFEFul)) + +/* Field: QSPI_SR.busy */ +#define QSPI_SR_BUSY_MSB 5u +#define QSPI_SR_BUSY_LSB 5u +#define QSPI_SR_BUSY_WIDTH 1u +#define QSPI_SR_BUSY_READ_ACCESS 1u +#define QSPI_SR_BUSY_WRITE_ACCESS 0u +#define QSPI_SR_BUSY_RESET 0x00000000ul +#define QSPI_SR_BUSY_FIELD_MASK 0x00000020ul +#define QSPI_SR_BUSY_GET(x) (((x) & 0x00000020ul) >> 5) +#define QSPI_SR_BUSY_SET(x) (((x) << 5) & 0x00000020ul) +#define QSPI_SR_BUSY_MODIFY(r, x) ((((x) << 5) & 0x00000020ul) | ((r) & 0xFFFFFFDFul)) + +/* Field: QSPI_SR.flevel */ +#define QSPI_SR_FLEVEL_MSB 13u +#define QSPI_SR_FLEVEL_LSB 8u +#define QSPI_SR_FLEVEL_WIDTH 6u +#define QSPI_SR_FLEVEL_READ_ACCESS 1u +#define QSPI_SR_FLEVEL_WRITE_ACCESS 0u +#define QSPI_SR_FLEVEL_RESET 0x00000000ul +#define QSPI_SR_FLEVEL_FIELD_MASK 0x00003F00ul +#define QSPI_SR_FLEVEL_GET(x) (((x) & 0x00003F00ul) >> 8) +#define QSPI_SR_FLEVEL_SET(x) (((x) << 8) & 0x00003F00ul) +#define QSPI_SR_FLEVEL_MODIFY(r, x) ((((x) << 8) & 0x00003F00ul) | ((r) & 0xFFFFC0FFul)) + +/* Register: QSPI.FCR */ +#define QSPI_FCR_ADDRESS 0x00000018ul +#define QSPI_FCR_BYTE_ADDRESS 0x00000018ul +#define QSPI_FCR_OFFSET 0x00000018ul +#define QSPI_FCR_BYTE_OFFSET 0x00000018ul +#define QSPI_FCR_SIZE 0x00000004ul +#define QSPI_FCR_BYTE_SIZE 0x00000004ul +#define QSPI_FCR_READ_ACCESS 1u +#define QSPI_FCR_WRITE_ACCESS 1u +#define QSPI_FCR_RESET_VALUE 0x00000000ul +#define QSPI_FCR_RESET_MASK 0x0000001Bul +#define QSPI_FCR_READ_MASK 0x0000001Bul +#define QSPI_FCR_WRITE_MASK 0x0000001Bul + +/* Field: QSPI_FCR.ctef */ +#define QSPI_FCR_CTEF_MSB 0u +#define QSPI_FCR_CTEF_LSB 0u +#define QSPI_FCR_CTEF_WIDTH 1u +#define QSPI_FCR_CTEF_READ_ACCESS 1u +#define QSPI_FCR_CTEF_WRITE_ACCESS 1u +#define QSPI_FCR_CTEF_RESET 0x00000000ul +#define QSPI_FCR_CTEF_FIELD_MASK 0x00000001ul +#define QSPI_FCR_CTEF_GET(x) ((x) & 0x00000001ul) +#define QSPI_FCR_CTEF_SET(x) ((x) & 0x00000001ul) +#define QSPI_FCR_CTEF_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Field: QSPI_FCR.ctcf */ +#define QSPI_FCR_CTCF_MSB 1u +#define QSPI_FCR_CTCF_LSB 1u +#define QSPI_FCR_CTCF_WIDTH 1u +#define QSPI_FCR_CTCF_READ_ACCESS 1u +#define QSPI_FCR_CTCF_WRITE_ACCESS 1u +#define QSPI_FCR_CTCF_RESET 0x00000000ul +#define QSPI_FCR_CTCF_FIELD_MASK 0x00000002ul +#define QSPI_FCR_CTCF_GET(x) (((x) & 0x00000002ul) >> 1) +#define QSPI_FCR_CTCF_SET(x) (((x) << 1) & 0x00000002ul) +#define QSPI_FCR_CTCF_MODIFY(r, x) ((((x) << 1) & 0x00000002ul) | ((r) & 0xFFFFFFFDul)) + +/* Field: QSPI_FCR.csmf */ +#define QSPI_FCR_CSMF_MSB 3u +#define QSPI_FCR_CSMF_LSB 3u +#define QSPI_FCR_CSMF_WIDTH 1u +#define QSPI_FCR_CSMF_READ_ACCESS 1u +#define QSPI_FCR_CSMF_WRITE_ACCESS 1u +#define QSPI_FCR_CSMF_RESET 0x00000000ul +#define QSPI_FCR_CSMF_FIELD_MASK 0x00000008ul +#define QSPI_FCR_CSMF_GET(x) (((x) & 0x00000008ul) >> 3) +#define QSPI_FCR_CSMF_SET(x) (((x) << 3) & 0x00000008ul) +#define QSPI_FCR_CSMF_MODIFY(r, x) ((((x) << 3) & 0x00000008ul) | ((r) & 0xFFFFFFF7ul)) + +/* Field: QSPI_FCR.ctof */ +#define QSPI_FCR_CTOF_MSB 4u +#define QSPI_FCR_CTOF_LSB 4u +#define QSPI_FCR_CTOF_WIDTH 1u +#define QSPI_FCR_CTOF_READ_ACCESS 1u +#define QSPI_FCR_CTOF_WRITE_ACCESS 1u +#define QSPI_FCR_CTOF_RESET 0x00000000ul +#define QSPI_FCR_CTOF_FIELD_MASK 0x00000010ul +#define QSPI_FCR_CTOF_GET(x) (((x) & 0x00000010ul) >> 4) +#define QSPI_FCR_CTOF_SET(x) (((x) << 4) & 0x00000010ul) +#define QSPI_FCR_CTOF_MODIFY(r, x) ((((x) << 4) & 0x00000010ul) | ((r) & 0xFFFFFFEFul)) + +/* Register: QSPI.DLR */ +#define QSPI_DLR_ADDRESS 0x00000020ul +#define QSPI_DLR_BYTE_ADDRESS 0x00000020ul +#define QSPI_DLR_OFFSET 0x00000020ul +#define QSPI_DLR_BYTE_OFFSET 0x00000020ul +#define QSPI_DLR_SIZE 0x00000004ul +#define QSPI_DLR_BYTE_SIZE 0x00000004ul +#define QSPI_DLR_READ_ACCESS 1u +#define QSPI_DLR_WRITE_ACCESS 1u +#define QSPI_DLR_RESET_VALUE 0x00000000ul +#define QSPI_DLR_RESET_MASK 0xFFFFFFFFul +#define QSPI_DLR_READ_MASK 0xFFFFFFFFul +#define QSPI_DLR_WRITE_MASK 0xFFFFFFFFul + +/* Field: QSPI_DLR.dl */ +#define QSPI_DLR_DL_MSB 31u +#define QSPI_DLR_DL_LSB 0u +#define QSPI_DLR_DL_WIDTH 32u +#define QSPI_DLR_DL_READ_ACCESS 1u +#define QSPI_DLR_DL_WRITE_ACCESS 1u +#define QSPI_DLR_DL_RESET 0x00000000ul +#define QSPI_DLR_DL_FIELD_MASK 0xFFFFFFFFul +#define QSPI_DLR_DL_GET(x) ((x) & 0xFFFFFFFFul) +#define QSPI_DLR_DL_SET(x) ((x) & 0xFFFFFFFFul) +#define QSPI_DLR_DL_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFul) | ((r) & 0x00000000ul)) + +/* Register: QSPI.CCR */ +#define QSPI_CCR_ADDRESS 0x00000028ul +#define QSPI_CCR_BYTE_ADDRESS 0x00000028ul +#define QSPI_CCR_OFFSET 0x00000028ul +#define QSPI_CCR_BYTE_OFFSET 0x00000028ul +#define QSPI_CCR_SIZE 0x00000004ul +#define QSPI_CCR_BYTE_SIZE 0x00000004ul +#define QSPI_CCR_READ_ACCESS 1u +#define QSPI_CCR_WRITE_ACCESS 1u +#define QSPI_CCR_RESET_VALUE 0x00000000ul +#define QSPI_CCR_RESET_MASK 0xDFFFFFFFul +#define QSPI_CCR_READ_MASK 0xDFFFFFFFul +#define QSPI_CCR_WRITE_MASK 0xDFFFFFFFul + +/* Field: QSPI_CCR.instr */ +#define QSPI_CCR_INSTR_MSB 7u +#define QSPI_CCR_INSTR_LSB 0u +#define QSPI_CCR_INSTR_WIDTH 8u +#define QSPI_CCR_INSTR_READ_ACCESS 1u +#define QSPI_CCR_INSTR_WRITE_ACCESS 1u +#define QSPI_CCR_INSTR_RESET 0x00000000ul +#define QSPI_CCR_INSTR_FIELD_MASK 0x000000FFul +#define QSPI_CCR_INSTR_GET(x) ((x) & 0x000000FFul) +#define QSPI_CCR_INSTR_SET(x) ((x) & 0x000000FFul) +#define QSPI_CCR_INSTR_MODIFY(r, x) ((((x) << 0) & 0x000000FFul) | ((r) & 0xFFFFFF00ul)) + +/* Field: QSPI_CCR.imode */ +#define QSPI_CCR_IMODE_MSB 9u +#define QSPI_CCR_IMODE_LSB 8u +#define QSPI_CCR_IMODE_WIDTH 2u +#define QSPI_CCR_IMODE_READ_ACCESS 1u +#define QSPI_CCR_IMODE_WRITE_ACCESS 1u +#define QSPI_CCR_IMODE_RESET 0x00000000ul +#define QSPI_CCR_IMODE_FIELD_MASK 0x00000300ul +#define QSPI_CCR_IMODE_GET(x) (((x) & 0x00000300ul) >> 8) +#define QSPI_CCR_IMODE_SET(x) (((x) << 8) & 0x00000300ul) +#define QSPI_CCR_IMODE_MODIFY(r, x) ((((x) << 8) & 0x00000300ul) | ((r) & 0xFFFFFCFFul)) + +/* Field: QSPI_CCR.admode */ +#define QSPI_CCR_ADMODE_MSB 11u +#define QSPI_CCR_ADMODE_LSB 10u +#define QSPI_CCR_ADMODE_WIDTH 2u +#define QSPI_CCR_ADMODE_READ_ACCESS 1u +#define QSPI_CCR_ADMODE_WRITE_ACCESS 1u +#define QSPI_CCR_ADMODE_RESET 0x00000000ul +#define QSPI_CCR_ADMODE_FIELD_MASK 0x00000C00ul +#define QSPI_CCR_ADMODE_GET(x) (((x) & 0x00000C00ul) >> 10) +#define QSPI_CCR_ADMODE_SET(x) (((x) << 10) & 0x00000C00ul) +#define QSPI_CCR_ADMODE_MODIFY(r, x) ((((x) << 10) & 0x00000C00ul) | ((r) & 0xFFFFF3FFul)) + +/* Field: QSPI_CCR.adsize */ +#define QSPI_CCR_ADSIZE_MSB 13u +#define QSPI_CCR_ADSIZE_LSB 12u +#define QSPI_CCR_ADSIZE_WIDTH 2u +#define QSPI_CCR_ADSIZE_READ_ACCESS 1u +#define QSPI_CCR_ADSIZE_WRITE_ACCESS 1u +#define QSPI_CCR_ADSIZE_RESET 0x00000000ul +#define QSPI_CCR_ADSIZE_FIELD_MASK 0x00003000ul +#define QSPI_CCR_ADSIZE_GET(x) (((x) & 0x00003000ul) >> 12) +#define QSPI_CCR_ADSIZE_SET(x) (((x) << 12) & 0x00003000ul) +#define QSPI_CCR_ADSIZE_MODIFY(r, x) ((((x) << 12) & 0x00003000ul) | ((r) & 0xFFFFCFFFul)) + +/* Field: QSPI_CCR.abmode */ +#define QSPI_CCR_ABMODE_MSB 15u +#define QSPI_CCR_ABMODE_LSB 14u +#define QSPI_CCR_ABMODE_WIDTH 2u +#define QSPI_CCR_ABMODE_READ_ACCESS 1u +#define QSPI_CCR_ABMODE_WRITE_ACCESS 1u +#define QSPI_CCR_ABMODE_RESET 0x00000000ul +#define QSPI_CCR_ABMODE_FIELD_MASK 0x0000C000ul +#define QSPI_CCR_ABMODE_GET(x) (((x) & 0x0000C000ul) >> 14) +#define QSPI_CCR_ABMODE_SET(x) (((x) << 14) & 0x0000C000ul) +#define QSPI_CCR_ABMODE_MODIFY(r, x) ((((x) << 14) & 0x0000C000ul) | ((r) & 0xFFFF3FFFul)) + +/* Field: QSPI_CCR.absize */ +#define QSPI_CCR_ABSIZE_MSB 17u +#define QSPI_CCR_ABSIZE_LSB 16u +#define QSPI_CCR_ABSIZE_WIDTH 2u +#define QSPI_CCR_ABSIZE_READ_ACCESS 1u +#define QSPI_CCR_ABSIZE_WRITE_ACCESS 1u +#define QSPI_CCR_ABSIZE_RESET 0x00000000ul +#define QSPI_CCR_ABSIZE_FIELD_MASK 0x00030000ul +#define QSPI_CCR_ABSIZE_GET(x) (((x) & 0x00030000ul) >> 16) +#define QSPI_CCR_ABSIZE_SET(x) (((x) << 16) & 0x00030000ul) +#define QSPI_CCR_ABSIZE_MODIFY(r, x) ((((x) << 16) & 0x00030000ul) | ((r) & 0xFFFCFFFFul)) + +/* Field: QSPI_CCR.dcyc */ +#define QSPI_CCR_DCYC_MSB 22u +#define QSPI_CCR_DCYC_LSB 18u +#define QSPI_CCR_DCYC_WIDTH 5u +#define QSPI_CCR_DCYC_READ_ACCESS 1u +#define QSPI_CCR_DCYC_WRITE_ACCESS 1u +#define QSPI_CCR_DCYC_RESET 0x00000000ul +#define QSPI_CCR_DCYC_FIELD_MASK 0x007C0000ul +#define QSPI_CCR_DCYC_GET(x) (((x) & 0x007C0000ul) >> 18) +#define QSPI_CCR_DCYC_SET(x) (((x) << 18) & 0x007C0000ul) +#define QSPI_CCR_DCYC_MODIFY(r, x) ((((x) << 18) & 0x007C0000ul) | ((r) & 0xFF83FFFFul)) + +/* Field: QSPI_CCR.d_conf */ +#define QSPI_CCR_D_CONF_MSB 23u +#define QSPI_CCR_D_CONF_LSB 23u +#define QSPI_CCR_D_CONF_WIDTH 1u +#define QSPI_CCR_D_CONF_READ_ACCESS 1u +#define QSPI_CCR_D_CONF_WRITE_ACCESS 1u +#define QSPI_CCR_D_CONF_RESET 0x00000000ul +#define QSPI_CCR_D_CONF_FIELD_MASK 0x00800000ul +#define QSPI_CCR_D_CONF_GET(x) (((x) & 0x00800000ul) >> 23) +#define QSPI_CCR_D_CONF_SET(x) (((x) << 23) & 0x00800000ul) +#define QSPI_CCR_D_CONF_MODIFY(r, x) ((((x) << 23) & 0x00800000ul) | ((r) & 0xFF7FFFFFul)) + +/* Field: QSPI_CCR.dmode */ +#define QSPI_CCR_DMODE_MSB 25u +#define QSPI_CCR_DMODE_LSB 24u +#define QSPI_CCR_DMODE_WIDTH 2u +#define QSPI_CCR_DMODE_READ_ACCESS 1u +#define QSPI_CCR_DMODE_WRITE_ACCESS 1u +#define QSPI_CCR_DMODE_RESET 0x00000000ul +#define QSPI_CCR_DMODE_FIELD_MASK 0x03000000ul +#define QSPI_CCR_DMODE_GET(x) (((x) & 0x03000000ul) >> 24) +#define QSPI_CCR_DMODE_SET(x) (((x) << 24) & 0x03000000ul) +#define QSPI_CCR_DMODE_MODIFY(r, x) ((((x) << 24) & 0x03000000ul) | ((r) & 0xFCFFFFFFul)) + +/* Field: QSPI_CCR.fmode */ +#define QSPI_CCR_FMODE_MSB 27u +#define QSPI_CCR_FMODE_LSB 26u +#define QSPI_CCR_FMODE_WIDTH 2u +#define QSPI_CCR_FMODE_READ_ACCESS 1u +#define QSPI_CCR_FMODE_WRITE_ACCESS 1u +#define QSPI_CCR_FMODE_RESET 0x00000000ul +#define QSPI_CCR_FMODE_FIELD_MASK 0x0C000000ul +#define QSPI_CCR_FMODE_GET(x) (((x) & 0x0C000000ul) >> 26) +#define QSPI_CCR_FMODE_SET(x) (((x) << 26) & 0x0C000000ul) +#define QSPI_CCR_FMODE_MODIFY(r, x) ((((x) << 26) & 0x0C000000ul) | ((r) & 0xF3FFFFFFul)) + +/* Field: QSPI_CCR.sioo */ +#define QSPI_CCR_SIOO_MSB 28u +#define QSPI_CCR_SIOO_LSB 28u +#define QSPI_CCR_SIOO_WIDTH 1u +#define QSPI_CCR_SIOO_READ_ACCESS 1u +#define QSPI_CCR_SIOO_WRITE_ACCESS 1u +#define QSPI_CCR_SIOO_RESET 0x00000000ul +#define QSPI_CCR_SIOO_FIELD_MASK 0x10000000ul +#define QSPI_CCR_SIOO_GET(x) (((x) & 0x10000000ul) >> 28) +#define QSPI_CCR_SIOO_SET(x) (((x) << 28) & 0x10000000ul) +#define QSPI_CCR_SIOO_MODIFY(r, x) ((((x) << 28) & 0x10000000ul) | ((r) & 0xEFFFFFFFul)) + +/* Field: QSPI_CCR.dhhc */ +#define QSPI_CCR_DHHC_MSB 30u +#define QSPI_CCR_DHHC_LSB 30u +#define QSPI_CCR_DHHC_WIDTH 1u +#define QSPI_CCR_DHHC_READ_ACCESS 1u +#define QSPI_CCR_DHHC_WRITE_ACCESS 1u +#define QSPI_CCR_DHHC_RESET 0x00000000ul +#define QSPI_CCR_DHHC_FIELD_MASK 0x40000000ul +#define QSPI_CCR_DHHC_GET(x) (((x) & 0x40000000ul) >> 30) +#define QSPI_CCR_DHHC_SET(x) (((x) << 30) & 0x40000000ul) +#define QSPI_CCR_DHHC_MODIFY(r, x) ((((x) << 30) & 0x40000000ul) | ((r) & 0xBFFFFFFFul)) + +/* Field: QSPI_CCR.ddrm */ +#define QSPI_CCR_DDRM_MSB 31u +#define QSPI_CCR_DDRM_LSB 31u +#define QSPI_CCR_DDRM_WIDTH 1u +#define QSPI_CCR_DDRM_READ_ACCESS 1u +#define QSPI_CCR_DDRM_WRITE_ACCESS 1u +#define QSPI_CCR_DDRM_RESET 0x00000000ul +#define QSPI_CCR_DDRM_FIELD_MASK 0x80000000ul +#define QSPI_CCR_DDRM_GET(x) (((x) & 0x80000000ul) >> 31) +#define QSPI_CCR_DDRM_SET(x) (((x) << 31) & 0x80000000ul) +#define QSPI_CCR_DDRM_MODIFY(r, x) ((((x) << 31) & 0x80000000ul) | ((r) & 0x7FFFFFFFul)) + +/* Register: QSPI.AR */ +#define QSPI_AR_ADDRESS 0x00000030ul +#define QSPI_AR_BYTE_ADDRESS 0x00000030ul +#define QSPI_AR_OFFSET 0x00000030ul +#define QSPI_AR_BYTE_OFFSET 0x00000030ul +#define QSPI_AR_SIZE 0x00000004ul +#define QSPI_AR_BYTE_SIZE 0x00000004ul +#define QSPI_AR_READ_ACCESS 1u +#define QSPI_AR_WRITE_ACCESS 1u +#define QSPI_AR_RESET_VALUE 0x00000000ul +#define QSPI_AR_RESET_MASK 0xFFFFFFFFul +#define QSPI_AR_READ_MASK 0xFFFFFFFFul +#define QSPI_AR_WRITE_MASK 0xFFFFFFFFul + +/* Field: QSPI_AR.address */ +#define QSPI_AR_ADDRESS_MSB 31u +#define QSPI_AR_ADDRESS_LSB 0u +#define QSPI_AR_ADDRESS_WIDTH 32u +#define QSPI_AR_ADDRESS_READ_ACCESS 1u +#define QSPI_AR_ADDRESS_WRITE_ACCESS 1u +#define QSPI_AR_ADDRESS_RESET 0x00000000ul +#define QSPI_AR_ADDRESS_FIELD_MASK 0xFFFFFFFFul +#define QSPI_AR_ADDRESS_GET(x) ((x) & 0xFFFFFFFFul) +#define QSPI_AR_ADDRESS_SET(x) ((x) & 0xFFFFFFFFul) +#define QSPI_AR_ADDRESS_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFul) | ((r) & 0x00000000ul)) + +/* Register: QSPI.ABR */ +#define QSPI_ABR_ADDRESS 0x00000038ul +#define QSPI_ABR_BYTE_ADDRESS 0x00000038ul +#define QSPI_ABR_OFFSET 0x00000038ul +#define QSPI_ABR_BYTE_OFFSET 0x00000038ul +#define QSPI_ABR_SIZE 0x00000004ul +#define QSPI_ABR_BYTE_SIZE 0x00000004ul +#define QSPI_ABR_READ_ACCESS 1u +#define QSPI_ABR_WRITE_ACCESS 1u +#define QSPI_ABR_RESET_VALUE 0x00000000ul +#define QSPI_ABR_RESET_MASK 0xFFFFFFFFul +#define QSPI_ABR_READ_MASK 0xFFFFFFFFul +#define QSPI_ABR_WRITE_MASK 0xFFFFFFFFul + +/* Field: QSPI_ABR.alternate_bytes */ +#define QSPI_ABR_ALTERNATE_BYTES_MSB 31u +#define QSPI_ABR_ALTERNATE_BYTES_LSB 0u +#define QSPI_ABR_ALTERNATE_BYTES_WIDTH 32u +#define QSPI_ABR_ALTERNATE_BYTES_READ_ACCESS 1u +#define QSPI_ABR_ALTERNATE_BYTES_WRITE_ACCESS 1u +#define QSPI_ABR_ALTERNATE_BYTES_RESET 0x00000000ul +#define QSPI_ABR_ALTERNATE_BYTES_FIELD_MASK 0xFFFFFFFFul +#define QSPI_ABR_ALTERNATE_BYTES_GET(x) ((x) & 0xFFFFFFFFul) +#define QSPI_ABR_ALTERNATE_BYTES_SET(x) ((x) & 0xFFFFFFFFul) +#define QSPI_ABR_ALTERNATE_BYTES_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFul) | ((r) & 0x00000000ul)) + +/* Register: QSPI.DR */ +#define QSPI_DR_ADDRESS 0x00000040ul +#define QSPI_DR_BYTE_ADDRESS 0x00000040ul +#define QSPI_DR_OFFSET 0x00000040ul +#define QSPI_DR_BYTE_OFFSET 0x00000040ul +#define QSPI_DR_SIZE 0x00000004ul +#define QSPI_DR_BYTE_SIZE 0x00000004ul +#define QSPI_DR_READ_ACCESS 1u +#define QSPI_DR_WRITE_ACCESS 1u +#define QSPI_DR_RESET_VALUE 0x00000000ul +#define QSPI_DR_RESET_MASK 0xFFFFFFFFul +#define QSPI_DR_READ_MASK 0xFFFFFFFFul +#define QSPI_DR_WRITE_MASK 0xFFFFFFFFul + +/* Field: QSPI_DR.data */ +#define QSPI_DR_DATA_MSB 31u +#define QSPI_DR_DATA_LSB 0u +#define QSPI_DR_DATA_WIDTH 32u +#define QSPI_DR_DATA_READ_ACCESS 1u +#define QSPI_DR_DATA_WRITE_ACCESS 1u +#define QSPI_DR_DATA_RESET 0x00000000ul +#define QSPI_DR_DATA_FIELD_MASK 0xFFFFFFFFul +#define QSPI_DR_DATA_GET(x) ((x) & 0xFFFFFFFFul) +#define QSPI_DR_DATA_SET(x) ((x) & 0xFFFFFFFFul) +#define QSPI_DR_DATA_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFul) | ((r) & 0x00000000ul)) + +/* Register: QSPI.PSMKR */ +#define QSPI_PSMKR_ADDRESS 0x00000048ul +#define QSPI_PSMKR_BYTE_ADDRESS 0x00000048ul +#define QSPI_PSMKR_OFFSET 0x00000048ul +#define QSPI_PSMKR_BYTE_OFFSET 0x00000048ul +#define QSPI_PSMKR_SIZE 0x00000004ul +#define QSPI_PSMKR_BYTE_SIZE 0x00000004ul +#define QSPI_PSMKR_READ_ACCESS 1u +#define QSPI_PSMKR_WRITE_ACCESS 1u +#define QSPI_PSMKR_RESET_VALUE 0x00000000ul +#define QSPI_PSMKR_RESET_MASK 0xFFFFFFFFul +#define QSPI_PSMKR_READ_MASK 0xFFFFFFFFul +#define QSPI_PSMKR_WRITE_MASK 0xFFFFFFFFul + +/* Field: QSPI_PSMKR.mask */ +#define QSPI_PSMKR_MASK_MSB 31u +#define QSPI_PSMKR_MASK_LSB 0u +#define QSPI_PSMKR_MASK_WIDTH 32u +#define QSPI_PSMKR_MASK_READ_ACCESS 1u +#define QSPI_PSMKR_MASK_WRITE_ACCESS 1u +#define QSPI_PSMKR_MASK_RESET 0x00000000ul +#define QSPI_PSMKR_MASK_FIELD_MASK 0xFFFFFFFFul +#define QSPI_PSMKR_MASK_GET(x) ((x) & 0xFFFFFFFFul) +#define QSPI_PSMKR_MASK_SET(x) ((x) & 0xFFFFFFFFul) +#define QSPI_PSMKR_MASK_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFul) | ((r) & 0x00000000ul)) + +/* Register: QSPI.PSMAR */ +#define QSPI_PSMAR_ADDRESS 0x00000050ul +#define QSPI_PSMAR_BYTE_ADDRESS 0x00000050ul +#define QSPI_PSMAR_OFFSET 0x00000050ul +#define QSPI_PSMAR_BYTE_OFFSET 0x00000050ul +#define QSPI_PSMAR_SIZE 0x00000004ul +#define QSPI_PSMAR_BYTE_SIZE 0x00000004ul +#define QSPI_PSMAR_READ_ACCESS 1u +#define QSPI_PSMAR_WRITE_ACCESS 1u +#define QSPI_PSMAR_RESET_VALUE 0x00000000ul +#define QSPI_PSMAR_RESET_MASK 0xFFFFFFFFul +#define QSPI_PSMAR_READ_MASK 0xFFFFFFFFul +#define QSPI_PSMAR_WRITE_MASK 0xFFFFFFFFul + +/* Field: QSPI_PSMAR.match */ +#define QSPI_PSMAR_MATCH_MSB 31u +#define QSPI_PSMAR_MATCH_LSB 0u +#define QSPI_PSMAR_MATCH_WIDTH 32u +#define QSPI_PSMAR_MATCH_READ_ACCESS 1u +#define QSPI_PSMAR_MATCH_WRITE_ACCESS 1u +#define QSPI_PSMAR_MATCH_RESET 0x00000000ul +#define QSPI_PSMAR_MATCH_FIELD_MASK 0xFFFFFFFFul +#define QSPI_PSMAR_MATCH_GET(x) ((x) & 0xFFFFFFFFul) +#define QSPI_PSMAR_MATCH_SET(x) ((x) & 0xFFFFFFFFul) +#define QSPI_PSMAR_MATCH_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFul) | ((r) & 0x00000000ul)) + +/* Register: QSPI.PIR */ +#define QSPI_PIR_ADDRESS 0x00000058ul +#define QSPI_PIR_BYTE_ADDRESS 0x00000058ul +#define QSPI_PIR_OFFSET 0x00000058ul +#define QSPI_PIR_BYTE_OFFSET 0x00000058ul +#define QSPI_PIR_SIZE 0x00000004ul +#define QSPI_PIR_BYTE_SIZE 0x00000004ul +#define QSPI_PIR_READ_ACCESS 1u +#define QSPI_PIR_WRITE_ACCESS 1u +#define QSPI_PIR_RESET_VALUE 0x00000000ul +#define QSPI_PIR_RESET_MASK 0xFFFFFFFFul +#define QSPI_PIR_READ_MASK 0xFFFFFFFFul +#define QSPI_PIR_WRITE_MASK 0xFFFFFFFFul + +/* Field: QSPI_PIR.interval */ +#define QSPI_PIR_INTERVAL_MSB 31u +#define QSPI_PIR_INTERVAL_LSB 0u +#define QSPI_PIR_INTERVAL_WIDTH 32u +#define QSPI_PIR_INTERVAL_READ_ACCESS 1u +#define QSPI_PIR_INTERVAL_WRITE_ACCESS 1u +#define QSPI_PIR_INTERVAL_RESET 0x00000000ul +#define QSPI_PIR_INTERVAL_FIELD_MASK 0xFFFFFFFFul +#define QSPI_PIR_INTERVAL_GET(x) ((x) & 0xFFFFFFFFul) +#define QSPI_PIR_INTERVAL_SET(x) ((x) & 0xFFFFFFFFul) +#define QSPI_PIR_INTERVAL_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFul) | ((r) & 0x00000000ul)) + +/* Register: QSPI.LPTR */ +#define QSPI_LPTR_ADDRESS 0x00000060ul +#define QSPI_LPTR_BYTE_ADDRESS 0x00000060ul +#define QSPI_LPTR_OFFSET 0x00000060ul +#define QSPI_LPTR_BYTE_OFFSET 0x00000060ul +#define QSPI_LPTR_SIZE 0x00000004ul +#define QSPI_LPTR_BYTE_SIZE 0x00000004ul +#define QSPI_LPTR_READ_ACCESS 1u +#define QSPI_LPTR_WRITE_ACCESS 1u +#define QSPI_LPTR_RESET_VALUE 0x00000000ul +#define QSPI_LPTR_RESET_MASK 0xFFFFFFFFul +#define QSPI_LPTR_READ_MASK 0xFFFFFFFFul +#define QSPI_LPTR_WRITE_MASK 0xFFFFFFFFul + +/* Field: QSPI_LPTR.timeout */ +#define QSPI_LPTR_TIMEOUT_MSB 31u +#define QSPI_LPTR_TIMEOUT_LSB 0u +#define QSPI_LPTR_TIMEOUT_WIDTH 32u +#define QSPI_LPTR_TIMEOUT_READ_ACCESS 1u +#define QSPI_LPTR_TIMEOUT_WRITE_ACCESS 1u +#define QSPI_LPTR_TIMEOUT_RESET 0x00000000ul +#define QSPI_LPTR_TIMEOUT_FIELD_MASK 0xFFFFFFFFul +#define QSPI_LPTR_TIMEOUT_GET(x) ((x) & 0xFFFFFFFFul) +#define QSPI_LPTR_TIMEOUT_SET(x) ((x) & 0xFFFFFFFFul) +#define QSPI_LPTR_TIMEOUT_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFul) | ((r) & 0x00000000ul)) + +/* Block-level typedef: QSPI */ +typedef struct { + volatile uint32_t CR; /* Offset 0x0 (R/W) */ + uint8_t _pad0[0x4]; /* 0x4..0x7 reserved */ + volatile uint32_t DCR; /* Offset 0x8 (R/W) */ + uint8_t _pad1[0x4]; /* 0xC..0xF reserved */ + volatile uint32_t SR; /* Offset 0x10 (R) */ + uint8_t _pad2[0x4]; /* 0x14..0x17 reserved */ + volatile uint32_t FCR; /* Offset 0x18 (R/W) */ + uint8_t _pad3[0x4]; /* 0x1C..0x1F reserved */ + volatile uint32_t DLR; /* Offset 0x20 (R/W) */ + uint8_t _pad4[0x4]; /* 0x24..0x27 reserved */ + volatile uint32_t CCR; /* Offset 0x28 (R/W) */ + uint8_t _pad5[0x4]; /* 0x2C..0x2F reserved */ + volatile uint32_t AR; /* Offset 0x30 (R/W) */ + uint8_t _pad6[0x4]; /* 0x34..0x37 reserved */ + volatile uint32_t ABR; /* Offset 0x38 (R/W) */ + uint8_t _pad7[0x4]; /* 0x3C..0x3F reserved */ + volatile uint32_t DR; /* Offset 0x40 (R/W) */ + uint8_t _pad8[0x4]; /* 0x44..0x47 reserved */ + volatile uint32_t PSMKR; /* Offset 0x48 (R/W) */ + uint8_t _pad9[0x4]; /* 0x4C..0x4F reserved */ + volatile uint32_t PSMAR; /* Offset 0x50 (R/W) */ + uint8_t _pad10[0x4]; /* 0x54..0x57 reserved */ + volatile uint32_t PIR; /* Offset 0x58 (R/W) */ + uint8_t _pad11[0x4]; /* 0x5C..0x5F reserved */ + volatile uint32_t LPTR; /* Offset 0x60 (R/W) */ +} Qspi_t, *PTR_Qspi_t; + +#ifdef __cplusplus +} +#endif + +#endif /* _QSPI_H_ */ diff --git a/erbium-hal/include/hwinc/system.h b/erbium-hal/include/hwinc/system.h new file mode 100644 index 000000000..ddf43e2ca --- /dev/null +++ b/erbium-hal/include/hwinc/system.h @@ -0,0 +1,1298 @@ +/* Auto-generated by rdl2hal.py from SystemRDL. Do not edit. */ +#ifndef _SYSTEM_H_ +#define _SYSTEM_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* ============================================================ */ +/* Block: System_Reg (macro prefix: SYSTEM) */ +/* ============================================================ */ + +/* Register: SYSTEM.Version */ +#define SYSTEM_VERSION_ADDRESS 0x00000000ul +#define SYSTEM_VERSION_BYTE_ADDRESS 0x00000000ul +#define SYSTEM_VERSION_OFFSET 0x00000000ul +#define SYSTEM_VERSION_BYTE_OFFSET 0x00000000ul +#define SYSTEM_VERSION_SIZE 0x00000004ul +#define SYSTEM_VERSION_BYTE_SIZE 0x00000004ul +#define SYSTEM_VERSION_READ_ACCESS 1u +#define SYSTEM_VERSION_WRITE_ACCESS 0u +#define SYSTEM_VERSION_RESET_VALUE 0xEB680000ul +#define SYSTEM_VERSION_RESET_MASK 0xFFFFFFFFul +#define SYSTEM_VERSION_READ_MASK 0xFFFFFFFFul +#define SYSTEM_VERSION_WRITE_MASK 0x00000000ul + +/* Field: SYSTEM_VERSION.respin */ +#define SYSTEM_VERSION_RESPIN_MSB 7u +#define SYSTEM_VERSION_RESPIN_LSB 0u +#define SYSTEM_VERSION_RESPIN_WIDTH 8u +#define SYSTEM_VERSION_RESPIN_READ_ACCESS 1u +#define SYSTEM_VERSION_RESPIN_WRITE_ACCESS 0u +#define SYSTEM_VERSION_RESPIN_RESET 0x00000000ul +#define SYSTEM_VERSION_RESPIN_FIELD_MASK 0x000000FFul +#define SYSTEM_VERSION_RESPIN_GET(x) ((x) & 0x000000FFul) +#define SYSTEM_VERSION_RESPIN_SET(x) ((x) & 0x000000FFul) +#define SYSTEM_VERSION_RESPIN_MODIFY(r, x) ((((x) << 0) & 0x000000FFul) | ((r) & 0xFFFFFF00ul)) + +/* Field: SYSTEM_VERSION.variation */ +#define SYSTEM_VERSION_VARIATION_MSB 15u +#define SYSTEM_VERSION_VARIATION_LSB 8u +#define SYSTEM_VERSION_VARIATION_WIDTH 8u +#define SYSTEM_VERSION_VARIATION_READ_ACCESS 1u +#define SYSTEM_VERSION_VARIATION_WRITE_ACCESS 0u +#define SYSTEM_VERSION_VARIATION_RESET 0x00000000ul +#define SYSTEM_VERSION_VARIATION_FIELD_MASK 0x0000FF00ul +#define SYSTEM_VERSION_VARIATION_GET(x) (((x) & 0x0000FF00ul) >> 8) +#define SYSTEM_VERSION_VARIATION_SET(x) (((x) << 8) & 0x0000FF00ul) +#define SYSTEM_VERSION_VARIATION_MODIFY(r, x) ((((x) << 8) & 0x0000FF00ul) | ((r) & 0xFFFF00FFul)) + +/* Field: SYSTEM_VERSION.chipid */ +#define SYSTEM_VERSION_CHIPID_MSB 31u +#define SYSTEM_VERSION_CHIPID_LSB 16u +#define SYSTEM_VERSION_CHIPID_WIDTH 16u +#define SYSTEM_VERSION_CHIPID_READ_ACCESS 1u +#define SYSTEM_VERSION_CHIPID_WRITE_ACCESS 0u +#define SYSTEM_VERSION_CHIPID_RESET 0x0000EB68ul +#define SYSTEM_VERSION_CHIPID_FIELD_MASK 0xFFFF0000ul +#define SYSTEM_VERSION_CHIPID_GET(x) (((x) & 0xFFFF0000ul) >> 16) +#define SYSTEM_VERSION_CHIPID_SET(x) (((x) << 16) & 0xFFFF0000ul) +#define SYSTEM_VERSION_CHIPID_MODIFY(r, x) ((((x) << 16) & 0xFFFF0000ul) | ((r) & 0x0000FFFFul)) + +/* Register: SYSTEM.SystemConfig */ +#define SYSTEM_SYSTEMCONFIG_ADDRESS 0x00000008ul +#define SYSTEM_SYSTEMCONFIG_BYTE_ADDRESS 0x00000008ul +#define SYSTEM_SYSTEMCONFIG_OFFSET 0x00000008ul +#define SYSTEM_SYSTEMCONFIG_BYTE_OFFSET 0x00000008ul +#define SYSTEM_SYSTEMCONFIG_SIZE 0x00000004ul +#define SYSTEM_SYSTEMCONFIG_BYTE_SIZE 0x00000004ul +#define SYSTEM_SYSTEMCONFIG_READ_ACCESS 1u +#define SYSTEM_SYSTEMCONFIG_WRITE_ACCESS 1u +#define SYSTEM_SYSTEMCONFIG_RESET_VALUE 0x00000014ul +#define SYSTEM_SYSTEMCONFIG_RESET_MASK 0x000000FFul +#define SYSTEM_SYSTEMCONFIG_READ_MASK 0x000000FFul +#define SYSTEM_SYSTEMCONFIG_WRITE_MASK 0x000000FFul + +/* Field: SYSTEM_SYSTEMCONFIG.sys_interrupt_enable */ +#define SYSTEM_SYSTEMCONFIG_SYS_INTERRUPT_ENABLE_MSB 0u +#define SYSTEM_SYSTEMCONFIG_SYS_INTERRUPT_ENABLE_LSB 0u +#define SYSTEM_SYSTEMCONFIG_SYS_INTERRUPT_ENABLE_WIDTH 1u +#define SYSTEM_SYSTEMCONFIG_SYS_INTERRUPT_ENABLE_READ_ACCESS 1u +#define SYSTEM_SYSTEMCONFIG_SYS_INTERRUPT_ENABLE_WRITE_ACCESS 1u +#define SYSTEM_SYSTEMCONFIG_SYS_INTERRUPT_ENABLE_RESET 0x00000000ul +#define SYSTEM_SYSTEMCONFIG_SYS_INTERRUPT_ENABLE_FIELD_MASK 0x00000001ul +#define SYSTEM_SYSTEMCONFIG_SYS_INTERRUPT_ENABLE_GET(x) ((x) & 0x00000001ul) +#define SYSTEM_SYSTEMCONFIG_SYS_INTERRUPT_ENABLE_SET(x) ((x) & 0x00000001ul) +#define SYSTEM_SYSTEMCONFIG_SYS_INTERRUPT_ENABLE_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Field: SYSTEM_SYSTEMCONFIG.mram_startup_bypass */ +#define SYSTEM_SYSTEMCONFIG_MRAM_STARTUP_BYPASS_MSB 1u +#define SYSTEM_SYSTEMCONFIG_MRAM_STARTUP_BYPASS_LSB 1u +#define SYSTEM_SYSTEMCONFIG_MRAM_STARTUP_BYPASS_WIDTH 1u +#define SYSTEM_SYSTEMCONFIG_MRAM_STARTUP_BYPASS_READ_ACCESS 1u +#define SYSTEM_SYSTEMCONFIG_MRAM_STARTUP_BYPASS_WRITE_ACCESS 1u +#define SYSTEM_SYSTEMCONFIG_MRAM_STARTUP_BYPASS_RESET 0x00000000ul +#define SYSTEM_SYSTEMCONFIG_MRAM_STARTUP_BYPASS_FIELD_MASK 0x00000002ul +#define SYSTEM_SYSTEMCONFIG_MRAM_STARTUP_BYPASS_GET(x) (((x) & 0x00000002ul) >> 1) +#define SYSTEM_SYSTEMCONFIG_MRAM_STARTUP_BYPASS_SET(x) (((x) << 1) & 0x00000002ul) +#define SYSTEM_SYSTEMCONFIG_MRAM_STARTUP_BYPASS_MODIFY(r, x) ((((x) << 1) & 0x00000002ul) | ((r) & 0xFFFFFFFDul)) + +/* Field: SYSTEM_SYSTEMCONFIG.wdog_disable */ +#define SYSTEM_SYSTEMCONFIG_WDOG_DISABLE_MSB 2u +#define SYSTEM_SYSTEMCONFIG_WDOG_DISABLE_LSB 2u +#define SYSTEM_SYSTEMCONFIG_WDOG_DISABLE_WIDTH 1u +#define SYSTEM_SYSTEMCONFIG_WDOG_DISABLE_READ_ACCESS 1u +#define SYSTEM_SYSTEMCONFIG_WDOG_DISABLE_WRITE_ACCESS 1u +#define SYSTEM_SYSTEMCONFIG_WDOG_DISABLE_RESET 0x00000001ul +#define SYSTEM_SYSTEMCONFIG_WDOG_DISABLE_FIELD_MASK 0x00000004ul +#define SYSTEM_SYSTEMCONFIG_WDOG_DISABLE_GET(x) (((x) & 0x00000004ul) >> 2) +#define SYSTEM_SYSTEMCONFIG_WDOG_DISABLE_SET(x) (((x) << 2) & 0x00000004ul) +#define SYSTEM_SYSTEMCONFIG_WDOG_DISABLE_MODIFY(r, x) ((((x) << 2) & 0x00000004ul) | ((r) & 0xFFFFFFFBul)) + +/* Field: SYSTEM_SYSTEMCONFIG.i2c_enable */ +#define SYSTEM_SYSTEMCONFIG_I2C_ENABLE_MSB 3u +#define SYSTEM_SYSTEMCONFIG_I2C_ENABLE_LSB 3u +#define SYSTEM_SYSTEMCONFIG_I2C_ENABLE_WIDTH 1u +#define SYSTEM_SYSTEMCONFIG_I2C_ENABLE_READ_ACCESS 1u +#define SYSTEM_SYSTEMCONFIG_I2C_ENABLE_WRITE_ACCESS 1u +#define SYSTEM_SYSTEMCONFIG_I2C_ENABLE_RESET 0x00000000ul +#define SYSTEM_SYSTEMCONFIG_I2C_ENABLE_FIELD_MASK 0x00000008ul +#define SYSTEM_SYSTEMCONFIG_I2C_ENABLE_GET(x) (((x) & 0x00000008ul) >> 3) +#define SYSTEM_SYSTEMCONFIG_I2C_ENABLE_SET(x) (((x) << 3) & 0x00000008ul) +#define SYSTEM_SYSTEMCONFIG_I2C_ENABLE_MODIFY(r, x) ((((x) << 3) & 0x00000008ul) | ((r) & 0xFFFFFFF7ul)) + +/* Field: SYSTEM_SYSTEMCONFIG.spi_enable */ +#define SYSTEM_SYSTEMCONFIG_SPI_ENABLE_MSB 4u +#define SYSTEM_SYSTEMCONFIG_SPI_ENABLE_LSB 4u +#define SYSTEM_SYSTEMCONFIG_SPI_ENABLE_WIDTH 1u +#define SYSTEM_SYSTEMCONFIG_SPI_ENABLE_READ_ACCESS 1u +#define SYSTEM_SYSTEMCONFIG_SPI_ENABLE_WRITE_ACCESS 1u +#define SYSTEM_SYSTEMCONFIG_SPI_ENABLE_RESET 0x00000001ul +#define SYSTEM_SYSTEMCONFIG_SPI_ENABLE_FIELD_MASK 0x00000010ul +#define SYSTEM_SYSTEMCONFIG_SPI_ENABLE_GET(x) (((x) & 0x00000010ul) >> 4) +#define SYSTEM_SYSTEMCONFIG_SPI_ENABLE_SET(x) (((x) << 4) & 0x00000010ul) +#define SYSTEM_SYSTEMCONFIG_SPI_ENABLE_MODIFY(r, x) ((((x) << 4) & 0x00000010ul) | ((r) & 0xFFFFFFEFul)) + +/* Field: SYSTEM_SYSTEMCONFIG.qspi_enable */ +#define SYSTEM_SYSTEMCONFIG_QSPI_ENABLE_MSB 5u +#define SYSTEM_SYSTEMCONFIG_QSPI_ENABLE_LSB 5u +#define SYSTEM_SYSTEMCONFIG_QSPI_ENABLE_WIDTH 1u +#define SYSTEM_SYSTEMCONFIG_QSPI_ENABLE_READ_ACCESS 1u +#define SYSTEM_SYSTEMCONFIG_QSPI_ENABLE_WRITE_ACCESS 1u +#define SYSTEM_SYSTEMCONFIG_QSPI_ENABLE_RESET 0x00000000ul +#define SYSTEM_SYSTEMCONFIG_QSPI_ENABLE_FIELD_MASK 0x00000020ul +#define SYSTEM_SYSTEMCONFIG_QSPI_ENABLE_GET(x) (((x) & 0x00000020ul) >> 5) +#define SYSTEM_SYSTEMCONFIG_QSPI_ENABLE_SET(x) (((x) << 5) & 0x00000020ul) +#define SYSTEM_SYSTEMCONFIG_QSPI_ENABLE_MODIFY(r, x) ((((x) << 5) & 0x00000020ul) | ((r) & 0xFFFFFFDFul)) + +/* Field: SYSTEM_SYSTEMCONFIG.uart_enable */ +#define SYSTEM_SYSTEMCONFIG_UART_ENABLE_MSB 6u +#define SYSTEM_SYSTEMCONFIG_UART_ENABLE_LSB 6u +#define SYSTEM_SYSTEMCONFIG_UART_ENABLE_WIDTH 1u +#define SYSTEM_SYSTEMCONFIG_UART_ENABLE_READ_ACCESS 1u +#define SYSTEM_SYSTEMCONFIG_UART_ENABLE_WRITE_ACCESS 1u +#define SYSTEM_SYSTEMCONFIG_UART_ENABLE_RESET 0x00000000ul +#define SYSTEM_SYSTEMCONFIG_UART_ENABLE_FIELD_MASK 0x00000040ul +#define SYSTEM_SYSTEMCONFIG_UART_ENABLE_GET(x) (((x) & 0x00000040ul) >> 6) +#define SYSTEM_SYSTEMCONFIG_UART_ENABLE_SET(x) (((x) << 6) & 0x00000040ul) +#define SYSTEM_SYSTEMCONFIG_UART_ENABLE_MODIFY(r, x) ((((x) << 6) & 0x00000040ul) | ((r) & 0xFFFFFFBFul)) + +/* Field: SYSTEM_SYSTEMCONFIG.osc_out_enable */ +#define SYSTEM_SYSTEMCONFIG_OSC_OUT_ENABLE_MSB 7u +#define SYSTEM_SYSTEMCONFIG_OSC_OUT_ENABLE_LSB 7u +#define SYSTEM_SYSTEMCONFIG_OSC_OUT_ENABLE_WIDTH 1u +#define SYSTEM_SYSTEMCONFIG_OSC_OUT_ENABLE_READ_ACCESS 1u +#define SYSTEM_SYSTEMCONFIG_OSC_OUT_ENABLE_WRITE_ACCESS 1u +#define SYSTEM_SYSTEMCONFIG_OSC_OUT_ENABLE_RESET 0x00000000ul +#define SYSTEM_SYSTEMCONFIG_OSC_OUT_ENABLE_FIELD_MASK 0x00000080ul +#define SYSTEM_SYSTEMCONFIG_OSC_OUT_ENABLE_GET(x) (((x) & 0x00000080ul) >> 7) +#define SYSTEM_SYSTEMCONFIG_OSC_OUT_ENABLE_SET(x) (((x) << 7) & 0x00000080ul) +#define SYSTEM_SYSTEMCONFIG_OSC_OUT_ENABLE_MODIFY(r, x) ((((x) << 7) & 0x00000080ul) | ((r) & 0xFFFFFF7Ful)) + +/* Register: SYSTEM.watchdog_count */ +#define SYSTEM_WATCHDOG_COUNT_ADDRESS 0x00000010ul +#define SYSTEM_WATCHDOG_COUNT_BYTE_ADDRESS 0x00000010ul +#define SYSTEM_WATCHDOG_COUNT_OFFSET 0x00000010ul +#define SYSTEM_WATCHDOG_COUNT_BYTE_OFFSET 0x00000010ul +#define SYSTEM_WATCHDOG_COUNT_SIZE 0x00000004ul +#define SYSTEM_WATCHDOG_COUNT_BYTE_SIZE 0x00000004ul +#define SYSTEM_WATCHDOG_COUNT_READ_ACCESS 1u +#define SYSTEM_WATCHDOG_COUNT_WRITE_ACCESS 1u +#define SYSTEM_WATCHDOG_COUNT_RESET_VALUE 0x0000FFFFul +#define SYSTEM_WATCHDOG_COUNT_RESET_MASK 0xFFFFFFFFul +#define SYSTEM_WATCHDOG_COUNT_READ_MASK 0xFFFFFFFFul +#define SYSTEM_WATCHDOG_COUNT_WRITE_MASK 0xFFFFFFFFul + +/* Field: SYSTEM_WATCHDOG_COUNT.watchdog_count */ +#define SYSTEM_WATCHDOG_COUNT_WATCHDOG_COUNT_MSB 31u +#define SYSTEM_WATCHDOG_COUNT_WATCHDOG_COUNT_LSB 0u +#define SYSTEM_WATCHDOG_COUNT_WATCHDOG_COUNT_WIDTH 32u +#define SYSTEM_WATCHDOG_COUNT_WATCHDOG_COUNT_READ_ACCESS 1u +#define SYSTEM_WATCHDOG_COUNT_WATCHDOG_COUNT_WRITE_ACCESS 1u +#define SYSTEM_WATCHDOG_COUNT_WATCHDOG_COUNT_RESET 0x0000FFFFul +#define SYSTEM_WATCHDOG_COUNT_WATCHDOG_COUNT_FIELD_MASK 0xFFFFFFFFul +#define SYSTEM_WATCHDOG_COUNT_WATCHDOG_COUNT_GET(x) ((x) & 0xFFFFFFFFul) +#define SYSTEM_WATCHDOG_COUNT_WATCHDOG_COUNT_SET(x) ((x) & 0xFFFFFFFFul) +#define SYSTEM_WATCHDOG_COUNT_WATCHDOG_COUNT_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFul) | ((r) & 0x00000000ul)) + +/* Register: SYSTEM.Watchdog */ +#define SYSTEM_WATCHDOG_ADDRESS 0x00000018ul +#define SYSTEM_WATCHDOG_BYTE_ADDRESS 0x00000018ul +#define SYSTEM_WATCHDOG_OFFSET 0x00000018ul +#define SYSTEM_WATCHDOG_BYTE_OFFSET 0x00000018ul +#define SYSTEM_WATCHDOG_SIZE 0x00000004ul +#define SYSTEM_WATCHDOG_BYTE_SIZE 0x00000004ul +#define SYSTEM_WATCHDOG_READ_ACCESS 1u +#define SYSTEM_WATCHDOG_WRITE_ACCESS 1u +#define SYSTEM_WATCHDOG_RESET_VALUE 0x00000000ul +#define SYSTEM_WATCHDOG_RESET_MASK 0x00000080ul +#define SYSTEM_WATCHDOG_READ_MASK 0x00000080ul +#define SYSTEM_WATCHDOG_WRITE_MASK 0x00000080ul + +/* Field: SYSTEM_WATCHDOG.kick */ +#define SYSTEM_WATCHDOG_KICK_MSB 7u +#define SYSTEM_WATCHDOG_KICK_LSB 7u +#define SYSTEM_WATCHDOG_KICK_WIDTH 1u +#define SYSTEM_WATCHDOG_KICK_READ_ACCESS 1u +#define SYSTEM_WATCHDOG_KICK_WRITE_ACCESS 1u +#define SYSTEM_WATCHDOG_KICK_RESET 0x00000000ul +#define SYSTEM_WATCHDOG_KICK_FIELD_MASK 0x00000080ul +#define SYSTEM_WATCHDOG_KICK_GET(x) (((x) & 0x00000080ul) >> 7) +#define SYSTEM_WATCHDOG_KICK_SET(x) (((x) << 7) & 0x00000080ul) +#define SYSTEM_WATCHDOG_KICK_MODIFY(r, x) ((((x) << 7) & 0x00000080ul) | ((r) & 0xFFFFFF7Ful)) + +/* Register: SYSTEM.SysInterrupt */ +#define SYSTEM_SYSINTERRUPT_ADDRESS 0x00000020ul +#define SYSTEM_SYSINTERRUPT_BYTE_ADDRESS 0x00000020ul +#define SYSTEM_SYSINTERRUPT_OFFSET 0x00000020ul +#define SYSTEM_SYSINTERRUPT_BYTE_OFFSET 0x00000020ul +#define SYSTEM_SYSINTERRUPT_SIZE 0x00000004ul +#define SYSTEM_SYSINTERRUPT_BYTE_SIZE 0x00000004ul +#define SYSTEM_SYSINTERRUPT_READ_ACCESS 1u +#define SYSTEM_SYSINTERRUPT_WRITE_ACCESS 1u +#define SYSTEM_SYSINTERRUPT_RESET_VALUE 0x00000000ul +#define SYSTEM_SYSINTERRUPT_RESET_MASK 0x00000001ul +#define SYSTEM_SYSINTERRUPT_READ_MASK 0x00000001ul +#define SYSTEM_SYSINTERRUPT_WRITE_MASK 0x00000001ul + +/* Field: SYSTEM_SYSINTERRUPT.interrupt */ +#define SYSTEM_SYSINTERRUPT_INTERRUPT_MSB 0u +#define SYSTEM_SYSINTERRUPT_INTERRUPT_LSB 0u +#define SYSTEM_SYSINTERRUPT_INTERRUPT_WIDTH 1u +#define SYSTEM_SYSINTERRUPT_INTERRUPT_READ_ACCESS 1u +#define SYSTEM_SYSINTERRUPT_INTERRUPT_WRITE_ACCESS 1u +#define SYSTEM_SYSINTERRUPT_INTERRUPT_RESET 0x00000000ul +#define SYSTEM_SYSINTERRUPT_INTERRUPT_FIELD_MASK 0x00000001ul +#define SYSTEM_SYSINTERRUPT_INTERRUPT_GET(x) ((x) & 0x00000001ul) +#define SYSTEM_SYSINTERRUPT_INTERRUPT_SET(x) ((x) & 0x00000001ul) +#define SYSTEM_SYSINTERRUPT_INTERRUPT_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Register: SYSTEM.SoftReset */ +#define SYSTEM_SOFTRESET_ADDRESS 0x00000028ul +#define SYSTEM_SOFTRESET_BYTE_ADDRESS 0x00000028ul +#define SYSTEM_SOFTRESET_OFFSET 0x00000028ul +#define SYSTEM_SOFTRESET_BYTE_OFFSET 0x00000028ul +#define SYSTEM_SOFTRESET_SIZE 0x00000004ul +#define SYSTEM_SOFTRESET_BYTE_SIZE 0x00000004ul +#define SYSTEM_SOFTRESET_READ_ACCESS 1u +#define SYSTEM_SOFTRESET_WRITE_ACCESS 1u +#define SYSTEM_SOFTRESET_RESET_VALUE 0x00000004ul +#define SYSTEM_SOFTRESET_RESET_MASK 0x0000000Ful +#define SYSTEM_SOFTRESET_READ_MASK 0x0000000Ful +#define SYSTEM_SOFTRESET_WRITE_MASK 0x0000000Ful + +/* Field: SYSTEM_SOFTRESET.soft_reset */ +#define SYSTEM_SOFTRESET_SOFT_RESET_MSB 0u +#define SYSTEM_SOFTRESET_SOFT_RESET_LSB 0u +#define SYSTEM_SOFTRESET_SOFT_RESET_WIDTH 1u +#define SYSTEM_SOFTRESET_SOFT_RESET_READ_ACCESS 1u +#define SYSTEM_SOFTRESET_SOFT_RESET_WRITE_ACCESS 1u +#define SYSTEM_SOFTRESET_SOFT_RESET_RESET 0x00000000ul +#define SYSTEM_SOFTRESET_SOFT_RESET_FIELD_MASK 0x00000001ul +#define SYSTEM_SOFTRESET_SOFT_RESET_GET(x) ((x) & 0x00000001ul) +#define SYSTEM_SOFTRESET_SOFT_RESET_SET(x) ((x) & 0x00000001ul) +#define SYSTEM_SOFTRESET_SOFT_RESET_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Field: SYSTEM_SOFTRESET.cpu_warm_reset */ +#define SYSTEM_SOFTRESET_CPU_WARM_RESET_MSB 1u +#define SYSTEM_SOFTRESET_CPU_WARM_RESET_LSB 1u +#define SYSTEM_SOFTRESET_CPU_WARM_RESET_WIDTH 1u +#define SYSTEM_SOFTRESET_CPU_WARM_RESET_READ_ACCESS 1u +#define SYSTEM_SOFTRESET_CPU_WARM_RESET_WRITE_ACCESS 1u +#define SYSTEM_SOFTRESET_CPU_WARM_RESET_RESET 0x00000000ul +#define SYSTEM_SOFTRESET_CPU_WARM_RESET_FIELD_MASK 0x00000002ul +#define SYSTEM_SOFTRESET_CPU_WARM_RESET_GET(x) (((x) & 0x00000002ul) >> 1) +#define SYSTEM_SOFTRESET_CPU_WARM_RESET_SET(x) (((x) << 1) & 0x00000002ul) +#define SYSTEM_SOFTRESET_CPU_WARM_RESET_MODIFY(r, x) ((((x) << 1) & 0x00000002ul) | ((r) & 0xFFFFFFFDul)) + +/* Field: SYSTEM_SOFTRESET.mram_rst_b */ +#define SYSTEM_SOFTRESET_MRAM_RST_B_MSB 2u +#define SYSTEM_SOFTRESET_MRAM_RST_B_LSB 2u +#define SYSTEM_SOFTRESET_MRAM_RST_B_WIDTH 1u +#define SYSTEM_SOFTRESET_MRAM_RST_B_READ_ACCESS 1u +#define SYSTEM_SOFTRESET_MRAM_RST_B_WRITE_ACCESS 1u +#define SYSTEM_SOFTRESET_MRAM_RST_B_RESET 0x00000001ul +#define SYSTEM_SOFTRESET_MRAM_RST_B_FIELD_MASK 0x00000004ul +#define SYSTEM_SOFTRESET_MRAM_RST_B_GET(x) (((x) & 0x00000004ul) >> 2) +#define SYSTEM_SOFTRESET_MRAM_RST_B_SET(x) (((x) << 2) & 0x00000004ul) +#define SYSTEM_SOFTRESET_MRAM_RST_B_MODIFY(r, x) ((((x) << 2) & 0x00000004ul) | ((r) & 0xFFFFFFFBul)) + +/* Field: SYSTEM_SOFTRESET.cpu_soft_reset */ +#define SYSTEM_SOFTRESET_CPU_SOFT_RESET_MSB 3u +#define SYSTEM_SOFTRESET_CPU_SOFT_RESET_LSB 3u +#define SYSTEM_SOFTRESET_CPU_SOFT_RESET_WIDTH 1u +#define SYSTEM_SOFTRESET_CPU_SOFT_RESET_READ_ACCESS 1u +#define SYSTEM_SOFTRESET_CPU_SOFT_RESET_WRITE_ACCESS 1u +#define SYSTEM_SOFTRESET_CPU_SOFT_RESET_RESET 0x00000000ul +#define SYSTEM_SOFTRESET_CPU_SOFT_RESET_FIELD_MASK 0x00000008ul +#define SYSTEM_SOFTRESET_CPU_SOFT_RESET_GET(x) (((x) & 0x00000008ul) >> 3) +#define SYSTEM_SOFTRESET_CPU_SOFT_RESET_SET(x) (((x) << 3) & 0x00000008ul) +#define SYSTEM_SOFTRESET_CPU_SOFT_RESET_MODIFY(r, x) ((((x) << 3) & 0x00000008ul) | ((r) & 0xFFFFFFF7ul)) + +/* Register: SYSTEM.ResetCause */ +#define SYSTEM_RESETCAUSE_ADDRESS 0x00000030ul +#define SYSTEM_RESETCAUSE_BYTE_ADDRESS 0x00000030ul +#define SYSTEM_RESETCAUSE_OFFSET 0x00000030ul +#define SYSTEM_RESETCAUSE_BYTE_OFFSET 0x00000030ul +#define SYSTEM_RESETCAUSE_SIZE 0x00000004ul +#define SYSTEM_RESETCAUSE_BYTE_SIZE 0x00000004ul +#define SYSTEM_RESETCAUSE_READ_ACCESS 1u +#define SYSTEM_RESETCAUSE_WRITE_ACCESS 0u +#define SYSTEM_RESETCAUSE_RESET_VALUE 0x00000000ul +#define SYSTEM_RESETCAUSE_RESET_MASK 0x0000003Ful +#define SYSTEM_RESETCAUSE_READ_MASK 0x0000003Ful +#define SYSTEM_RESETCAUSE_WRITE_MASK 0x00000000ul + +/* Field: SYSTEM_RESETCAUSE.por */ +#define SYSTEM_RESETCAUSE_POR_MSB 0u +#define SYSTEM_RESETCAUSE_POR_LSB 0u +#define SYSTEM_RESETCAUSE_POR_WIDTH 1u +#define SYSTEM_RESETCAUSE_POR_READ_ACCESS 1u +#define SYSTEM_RESETCAUSE_POR_WRITE_ACCESS 0u +#define SYSTEM_RESETCAUSE_POR_RESET 0x00000000ul +#define SYSTEM_RESETCAUSE_POR_FIELD_MASK 0x00000001ul +#define SYSTEM_RESETCAUSE_POR_GET(x) ((x) & 0x00000001ul) +#define SYSTEM_RESETCAUSE_POR_SET(x) ((x) & 0x00000001ul) +#define SYSTEM_RESETCAUSE_POR_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Field: SYSTEM_RESETCAUSE.watchdog_timedout */ +#define SYSTEM_RESETCAUSE_WATCHDOG_TIMEDOUT_MSB 1u +#define SYSTEM_RESETCAUSE_WATCHDOG_TIMEDOUT_LSB 1u +#define SYSTEM_RESETCAUSE_WATCHDOG_TIMEDOUT_WIDTH 1u +#define SYSTEM_RESETCAUSE_WATCHDOG_TIMEDOUT_READ_ACCESS 1u +#define SYSTEM_RESETCAUSE_WATCHDOG_TIMEDOUT_WRITE_ACCESS 0u +#define SYSTEM_RESETCAUSE_WATCHDOG_TIMEDOUT_RESET 0x00000000ul +#define SYSTEM_RESETCAUSE_WATCHDOG_TIMEDOUT_FIELD_MASK 0x00000002ul +#define SYSTEM_RESETCAUSE_WATCHDOG_TIMEDOUT_GET(x) (((x) & 0x00000002ul) >> 1) +#define SYSTEM_RESETCAUSE_WATCHDOG_TIMEDOUT_SET(x) (((x) << 1) & 0x00000002ul) +#define SYSTEM_RESETCAUSE_WATCHDOG_TIMEDOUT_MODIFY(r, x) ((((x) << 1) & 0x00000002ul) | ((r) & 0xFFFFFFFDul)) + +/* Field: SYSTEM_RESETCAUSE.sysreset_req */ +#define SYSTEM_RESETCAUSE_SYSRESET_REQ_MSB 2u +#define SYSTEM_RESETCAUSE_SYSRESET_REQ_LSB 2u +#define SYSTEM_RESETCAUSE_SYSRESET_REQ_WIDTH 1u +#define SYSTEM_RESETCAUSE_SYSRESET_REQ_READ_ACCESS 1u +#define SYSTEM_RESETCAUSE_SYSRESET_REQ_WRITE_ACCESS 0u +#define SYSTEM_RESETCAUSE_SYSRESET_REQ_RESET 0x00000000ul +#define SYSTEM_RESETCAUSE_SYSRESET_REQ_FIELD_MASK 0x00000004ul +#define SYSTEM_RESETCAUSE_SYSRESET_REQ_GET(x) (((x) & 0x00000004ul) >> 2) +#define SYSTEM_RESETCAUSE_SYSRESET_REQ_SET(x) (((x) << 2) & 0x00000004ul) +#define SYSTEM_RESETCAUSE_SYSRESET_REQ_MODIFY(r, x) ((((x) << 2) & 0x00000004ul) | ((r) & 0xFFFFFFFBul)) + +/* Field: SYSTEM_RESETCAUSE.brownout */ +#define SYSTEM_RESETCAUSE_BROWNOUT_MSB 3u +#define SYSTEM_RESETCAUSE_BROWNOUT_LSB 3u +#define SYSTEM_RESETCAUSE_BROWNOUT_WIDTH 1u +#define SYSTEM_RESETCAUSE_BROWNOUT_READ_ACCESS 1u +#define SYSTEM_RESETCAUSE_BROWNOUT_WRITE_ACCESS 0u +#define SYSTEM_RESETCAUSE_BROWNOUT_RESET 0x00000000ul +#define SYSTEM_RESETCAUSE_BROWNOUT_FIELD_MASK 0x00000008ul +#define SYSTEM_RESETCAUSE_BROWNOUT_GET(x) (((x) & 0x00000008ul) >> 3) +#define SYSTEM_RESETCAUSE_BROWNOUT_SET(x) (((x) << 3) & 0x00000008ul) +#define SYSTEM_RESETCAUSE_BROWNOUT_MODIFY(r, x) ((((x) << 3) & 0x00000008ul) | ((r) & 0xFFFFFFF7ul)) + +/* Field: SYSTEM_RESETCAUSE.softreset */ +#define SYSTEM_RESETCAUSE_SOFTRESET_MSB 4u +#define SYSTEM_RESETCAUSE_SOFTRESET_LSB 4u +#define SYSTEM_RESETCAUSE_SOFTRESET_WIDTH 1u +#define SYSTEM_RESETCAUSE_SOFTRESET_READ_ACCESS 1u +#define SYSTEM_RESETCAUSE_SOFTRESET_WRITE_ACCESS 0u +#define SYSTEM_RESETCAUSE_SOFTRESET_RESET 0x00000000ul +#define SYSTEM_RESETCAUSE_SOFTRESET_FIELD_MASK 0x00000010ul +#define SYSTEM_RESETCAUSE_SOFTRESET_GET(x) (((x) & 0x00000010ul) >> 4) +#define SYSTEM_RESETCAUSE_SOFTRESET_SET(x) (((x) << 4) & 0x00000010ul) +#define SYSTEM_RESETCAUSE_SOFTRESET_MODIFY(r, x) ((((x) << 4) & 0x00000010ul) | ((r) & 0xFFFFFFEFul)) + +/* Field: SYSTEM_RESETCAUSE.cpu_warm_reset */ +#define SYSTEM_RESETCAUSE_CPU_WARM_RESET_MSB 5u +#define SYSTEM_RESETCAUSE_CPU_WARM_RESET_LSB 5u +#define SYSTEM_RESETCAUSE_CPU_WARM_RESET_WIDTH 1u +#define SYSTEM_RESETCAUSE_CPU_WARM_RESET_READ_ACCESS 1u +#define SYSTEM_RESETCAUSE_CPU_WARM_RESET_WRITE_ACCESS 0u +#define SYSTEM_RESETCAUSE_CPU_WARM_RESET_RESET 0x00000000ul +#define SYSTEM_RESETCAUSE_CPU_WARM_RESET_FIELD_MASK 0x00000020ul +#define SYSTEM_RESETCAUSE_CPU_WARM_RESET_GET(x) (((x) & 0x00000020ul) >> 5) +#define SYSTEM_RESETCAUSE_CPU_WARM_RESET_SET(x) (((x) << 5) & 0x00000020ul) +#define SYSTEM_RESETCAUSE_CPU_WARM_RESET_MODIFY(r, x) ((((x) << 5) & 0x00000020ul) | ((r) & 0xFFFFFFDFul)) + +/* Register: SYSTEM.PowerDomainReq */ +#define SYSTEM_POWERDOMAINREQ_ADDRESS 0x00000038ul +#define SYSTEM_POWERDOMAINREQ_BYTE_ADDRESS 0x00000038ul +#define SYSTEM_POWERDOMAINREQ_OFFSET 0x00000038ul +#define SYSTEM_POWERDOMAINREQ_BYTE_OFFSET 0x00000038ul +#define SYSTEM_POWERDOMAINREQ_SIZE 0x00000004ul +#define SYSTEM_POWERDOMAINREQ_BYTE_SIZE 0x00000004ul +#define SYSTEM_POWERDOMAINREQ_READ_ACCESS 1u +#define SYSTEM_POWERDOMAINREQ_WRITE_ACCESS 1u +#define SYSTEM_POWERDOMAINREQ_RESET_VALUE 0x00000000ul +#define SYSTEM_POWERDOMAINREQ_RESET_MASK 0x0003FF7Ful +#define SYSTEM_POWERDOMAINREQ_READ_MASK 0x0003FF7Ful +#define SYSTEM_POWERDOMAINREQ_WRITE_MASK 0x0003FF7Ful + +/* Field: SYSTEM_POWERDOMAINREQ.cpu_pd */ +#define SYSTEM_POWERDOMAINREQ_CPU_PD_MSB 0u +#define SYSTEM_POWERDOMAINREQ_CPU_PD_LSB 0u +#define SYSTEM_POWERDOMAINREQ_CPU_PD_WIDTH 1u +#define SYSTEM_POWERDOMAINREQ_CPU_PD_READ_ACCESS 1u +#define SYSTEM_POWERDOMAINREQ_CPU_PD_WRITE_ACCESS 1u +#define SYSTEM_POWERDOMAINREQ_CPU_PD_RESET 0x00000000ul +#define SYSTEM_POWERDOMAINREQ_CPU_PD_FIELD_MASK 0x00000001ul +#define SYSTEM_POWERDOMAINREQ_CPU_PD_GET(x) ((x) & 0x00000001ul) +#define SYSTEM_POWERDOMAINREQ_CPU_PD_SET(x) ((x) & 0x00000001ul) +#define SYSTEM_POWERDOMAINREQ_CPU_PD_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Field: SYSTEM_POWERDOMAINREQ.cpu_rom_powerdown */ +#define SYSTEM_POWERDOMAINREQ_CPU_ROM_POWERDOWN_MSB 1u +#define SYSTEM_POWERDOMAINREQ_CPU_ROM_POWERDOWN_LSB 1u +#define SYSTEM_POWERDOMAINREQ_CPU_ROM_POWERDOWN_WIDTH 1u +#define SYSTEM_POWERDOMAINREQ_CPU_ROM_POWERDOWN_READ_ACCESS 1u +#define SYSTEM_POWERDOMAINREQ_CPU_ROM_POWERDOWN_WRITE_ACCESS 1u +#define SYSTEM_POWERDOMAINREQ_CPU_ROM_POWERDOWN_RESET 0x00000000ul +#define SYSTEM_POWERDOMAINREQ_CPU_ROM_POWERDOWN_FIELD_MASK 0x00000002ul +#define SYSTEM_POWERDOMAINREQ_CPU_ROM_POWERDOWN_GET(x) (((x) & 0x00000002ul) >> 1) +#define SYSTEM_POWERDOMAINREQ_CPU_ROM_POWERDOWN_SET(x) (((x) << 1) & 0x00000002ul) +#define SYSTEM_POWERDOMAINREQ_CPU_ROM_POWERDOWN_MODIFY(r, x) ((((x) << 1) & 0x00000002ul) | ((r) & 0xFFFFFFFDul)) + +/* Field: SYSTEM_POWERDOMAINREQ.cpu_ram_powerdown */ +#define SYSTEM_POWERDOMAINREQ_CPU_RAM_POWERDOWN_MSB 2u +#define SYSTEM_POWERDOMAINREQ_CPU_RAM_POWERDOWN_LSB 2u +#define SYSTEM_POWERDOMAINREQ_CPU_RAM_POWERDOWN_WIDTH 1u +#define SYSTEM_POWERDOMAINREQ_CPU_RAM_POWERDOWN_READ_ACCESS 1u +#define SYSTEM_POWERDOMAINREQ_CPU_RAM_POWERDOWN_WRITE_ACCESS 1u +#define SYSTEM_POWERDOMAINREQ_CPU_RAM_POWERDOWN_RESET 0x00000000ul +#define SYSTEM_POWERDOMAINREQ_CPU_RAM_POWERDOWN_FIELD_MASK 0x00000004ul +#define SYSTEM_POWERDOMAINREQ_CPU_RAM_POWERDOWN_GET(x) (((x) & 0x00000004ul) >> 2) +#define SYSTEM_POWERDOMAINREQ_CPU_RAM_POWERDOWN_SET(x) (((x) << 2) & 0x00000004ul) +#define SYSTEM_POWERDOMAINREQ_CPU_RAM_POWERDOWN_MODIFY(r, x) ((((x) << 2) & 0x00000004ul) | ((r) & 0xFFFFFFFBul)) + +/* Field: SYSTEM_POWERDOMAINREQ.chiplet_pd */ +#define SYSTEM_POWERDOMAINREQ_CHIPLET_PD_MSB 3u +#define SYSTEM_POWERDOMAINREQ_CHIPLET_PD_LSB 3u +#define SYSTEM_POWERDOMAINREQ_CHIPLET_PD_WIDTH 1u +#define SYSTEM_POWERDOMAINREQ_CHIPLET_PD_READ_ACCESS 1u +#define SYSTEM_POWERDOMAINREQ_CHIPLET_PD_WRITE_ACCESS 1u +#define SYSTEM_POWERDOMAINREQ_CHIPLET_PD_RESET 0x00000000ul +#define SYSTEM_POWERDOMAINREQ_CHIPLET_PD_FIELD_MASK 0x00000008ul +#define SYSTEM_POWERDOMAINREQ_CHIPLET_PD_GET(x) (((x) & 0x00000008ul) >> 3) +#define SYSTEM_POWERDOMAINREQ_CHIPLET_PD_SET(x) (((x) << 3) & 0x00000008ul) +#define SYSTEM_POWERDOMAINREQ_CHIPLET_PD_MODIFY(r, x) ((((x) << 3) & 0x00000008ul) | ((r) & 0xFFFFFFF7ul)) + +/* Field: SYSTEM_POWERDOMAINREQ.mram_pd */ +#define SYSTEM_POWERDOMAINREQ_MRAM_PD_MSB 4u +#define SYSTEM_POWERDOMAINREQ_MRAM_PD_LSB 4u +#define SYSTEM_POWERDOMAINREQ_MRAM_PD_WIDTH 1u +#define SYSTEM_POWERDOMAINREQ_MRAM_PD_READ_ACCESS 1u +#define SYSTEM_POWERDOMAINREQ_MRAM_PD_WRITE_ACCESS 1u +#define SYSTEM_POWERDOMAINREQ_MRAM_PD_RESET 0x00000000ul +#define SYSTEM_POWERDOMAINREQ_MRAM_PD_FIELD_MASK 0x00000010ul +#define SYSTEM_POWERDOMAINREQ_MRAM_PD_GET(x) (((x) & 0x00000010ul) >> 4) +#define SYSTEM_POWERDOMAINREQ_MRAM_PD_SET(x) (((x) << 4) & 0x00000010ul) +#define SYSTEM_POWERDOMAINREQ_MRAM_PD_MODIFY(r, x) ((((x) << 4) & 0x00000010ul) | ((r) & 0xFFFFFFEFul)) + +/* Field: SYSTEM_POWERDOMAINREQ.system_poweroff */ +#define SYSTEM_POWERDOMAINREQ_SYSTEM_POWEROFF_MSB 5u +#define SYSTEM_POWERDOMAINREQ_SYSTEM_POWEROFF_LSB 5u +#define SYSTEM_POWERDOMAINREQ_SYSTEM_POWEROFF_WIDTH 1u +#define SYSTEM_POWERDOMAINREQ_SYSTEM_POWEROFF_READ_ACCESS 1u +#define SYSTEM_POWERDOMAINREQ_SYSTEM_POWEROFF_WRITE_ACCESS 1u +#define SYSTEM_POWERDOMAINREQ_SYSTEM_POWEROFF_RESET 0x00000000ul +#define SYSTEM_POWERDOMAINREQ_SYSTEM_POWEROFF_FIELD_MASK 0x00000020ul +#define SYSTEM_POWERDOMAINREQ_SYSTEM_POWEROFF_GET(x) (((x) & 0x00000020ul) >> 5) +#define SYSTEM_POWERDOMAINREQ_SYSTEM_POWEROFF_SET(x) (((x) << 5) & 0x00000020ul) +#define SYSTEM_POWERDOMAINREQ_SYSTEM_POWEROFF_MODIFY(r, x) ((((x) << 5) & 0x00000020ul) | ((r) & 0xFFFFFFDFul)) + +/* Field: SYSTEM_POWERDOMAINREQ.xspi_pd */ +#define SYSTEM_POWERDOMAINREQ_XSPI_PD_MSB 6u +#define SYSTEM_POWERDOMAINREQ_XSPI_PD_LSB 6u +#define SYSTEM_POWERDOMAINREQ_XSPI_PD_WIDTH 1u +#define SYSTEM_POWERDOMAINREQ_XSPI_PD_READ_ACCESS 1u +#define SYSTEM_POWERDOMAINREQ_XSPI_PD_WRITE_ACCESS 1u +#define SYSTEM_POWERDOMAINREQ_XSPI_PD_RESET 0x00000000ul +#define SYSTEM_POWERDOMAINREQ_XSPI_PD_FIELD_MASK 0x00000040ul +#define SYSTEM_POWERDOMAINREQ_XSPI_PD_GET(x) (((x) & 0x00000040ul) >> 6) +#define SYSTEM_POWERDOMAINREQ_XSPI_PD_SET(x) (((x) << 6) & 0x00000040ul) +#define SYSTEM_POWERDOMAINREQ_XSPI_PD_MODIFY(r, x) ((((x) << 6) & 0x00000040ul) | ((r) & 0xFFFFFFBFul)) + +/* Field: SYSTEM_POWERDOMAINREQ.minion_pd */ +#define SYSTEM_POWERDOMAINREQ_MINION_PD_MSB 15u +#define SYSTEM_POWERDOMAINREQ_MINION_PD_LSB 8u +#define SYSTEM_POWERDOMAINREQ_MINION_PD_WIDTH 8u +#define SYSTEM_POWERDOMAINREQ_MINION_PD_READ_ACCESS 1u +#define SYSTEM_POWERDOMAINREQ_MINION_PD_WRITE_ACCESS 1u +#define SYSTEM_POWERDOMAINREQ_MINION_PD_RESET 0x00000000ul +#define SYSTEM_POWERDOMAINREQ_MINION_PD_FIELD_MASK 0x0000FF00ul +#define SYSTEM_POWERDOMAINREQ_MINION_PD_GET(x) (((x) & 0x0000FF00ul) >> 8) +#define SYSTEM_POWERDOMAINREQ_MINION_PD_SET(x) (((x) << 8) & 0x0000FF00ul) +#define SYSTEM_POWERDOMAINREQ_MINION_PD_MODIFY(r, x) ((((x) << 8) & 0x0000FF00ul) | ((r) & 0xFFFF00FFul)) + +/* Field: SYSTEM_POWERDOMAINREQ.mram_dsleep_en */ +#define SYSTEM_POWERDOMAINREQ_MRAM_DSLEEP_EN_MSB 16u +#define SYSTEM_POWERDOMAINREQ_MRAM_DSLEEP_EN_LSB 16u +#define SYSTEM_POWERDOMAINREQ_MRAM_DSLEEP_EN_WIDTH 1u +#define SYSTEM_POWERDOMAINREQ_MRAM_DSLEEP_EN_READ_ACCESS 1u +#define SYSTEM_POWERDOMAINREQ_MRAM_DSLEEP_EN_WRITE_ACCESS 1u +#define SYSTEM_POWERDOMAINREQ_MRAM_DSLEEP_EN_RESET 0x00000000ul +#define SYSTEM_POWERDOMAINREQ_MRAM_DSLEEP_EN_FIELD_MASK 0x00010000ul +#define SYSTEM_POWERDOMAINREQ_MRAM_DSLEEP_EN_GET(x) (((x) & 0x00010000ul) >> 16) +#define SYSTEM_POWERDOMAINREQ_MRAM_DSLEEP_EN_SET(x) (((x) << 16) & 0x00010000ul) +#define SYSTEM_POWERDOMAINREQ_MRAM_DSLEEP_EN_MODIFY(r, x) ((((x) << 16) & 0x00010000ul) | ((r) & 0xFFFEFFFFul)) + +/* Field: SYSTEM_POWERDOMAINREQ.cpu_sleep_en */ +#define SYSTEM_POWERDOMAINREQ_CPU_SLEEP_EN_MSB 17u +#define SYSTEM_POWERDOMAINREQ_CPU_SLEEP_EN_LSB 17u +#define SYSTEM_POWERDOMAINREQ_CPU_SLEEP_EN_WIDTH 1u +#define SYSTEM_POWERDOMAINREQ_CPU_SLEEP_EN_READ_ACCESS 1u +#define SYSTEM_POWERDOMAINREQ_CPU_SLEEP_EN_WRITE_ACCESS 1u +#define SYSTEM_POWERDOMAINREQ_CPU_SLEEP_EN_RESET 0x00000000ul +#define SYSTEM_POWERDOMAINREQ_CPU_SLEEP_EN_FIELD_MASK 0x00020000ul +#define SYSTEM_POWERDOMAINREQ_CPU_SLEEP_EN_GET(x) (((x) & 0x00020000ul) >> 17) +#define SYSTEM_POWERDOMAINREQ_CPU_SLEEP_EN_SET(x) (((x) << 17) & 0x00020000ul) +#define SYSTEM_POWERDOMAINREQ_CPU_SLEEP_EN_MODIFY(r, x) ((((x) << 17) & 0x00020000ul) | ((r) & 0xFFFDFFFFul)) + +/* Register: SYSTEM.PowerDomainAck */ +#define SYSTEM_POWERDOMAINACK_ADDRESS 0x00000040ul +#define SYSTEM_POWERDOMAINACK_BYTE_ADDRESS 0x00000040ul +#define SYSTEM_POWERDOMAINACK_OFFSET 0x00000040ul +#define SYSTEM_POWERDOMAINACK_BYTE_OFFSET 0x00000040ul +#define SYSTEM_POWERDOMAINACK_SIZE 0x00000004ul +#define SYSTEM_POWERDOMAINACK_BYTE_SIZE 0x00000004ul +#define SYSTEM_POWERDOMAINACK_READ_ACCESS 1u +#define SYSTEM_POWERDOMAINACK_WRITE_ACCESS 0u +#define SYSTEM_POWERDOMAINACK_RESET_VALUE 0x00000000ul +#define SYSTEM_POWERDOMAINACK_RESET_MASK 0x0000FF7Bul +#define SYSTEM_POWERDOMAINACK_READ_MASK 0x0000FF7Bul +#define SYSTEM_POWERDOMAINACK_WRITE_MASK 0x00000000ul + +/* Field: SYSTEM_POWERDOMAINACK.cpu_pd_ack */ +#define SYSTEM_POWERDOMAINACK_CPU_PD_ACK_MSB 0u +#define SYSTEM_POWERDOMAINACK_CPU_PD_ACK_LSB 0u +#define SYSTEM_POWERDOMAINACK_CPU_PD_ACK_WIDTH 1u +#define SYSTEM_POWERDOMAINACK_CPU_PD_ACK_READ_ACCESS 1u +#define SYSTEM_POWERDOMAINACK_CPU_PD_ACK_WRITE_ACCESS 0u +#define SYSTEM_POWERDOMAINACK_CPU_PD_ACK_RESET 0x00000000ul +#define SYSTEM_POWERDOMAINACK_CPU_PD_ACK_FIELD_MASK 0x00000001ul +#define SYSTEM_POWERDOMAINACK_CPU_PD_ACK_GET(x) ((x) & 0x00000001ul) +#define SYSTEM_POWERDOMAINACK_CPU_PD_ACK_SET(x) ((x) & 0x00000001ul) +#define SYSTEM_POWERDOMAINACK_CPU_PD_ACK_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Field: SYSTEM_POWERDOMAINACK.sram_pd_ack */ +#define SYSTEM_POWERDOMAINACK_SRAM_PD_ACK_MSB 1u +#define SYSTEM_POWERDOMAINACK_SRAM_PD_ACK_LSB 1u +#define SYSTEM_POWERDOMAINACK_SRAM_PD_ACK_WIDTH 1u +#define SYSTEM_POWERDOMAINACK_SRAM_PD_ACK_READ_ACCESS 1u +#define SYSTEM_POWERDOMAINACK_SRAM_PD_ACK_WRITE_ACCESS 0u +#define SYSTEM_POWERDOMAINACK_SRAM_PD_ACK_RESET 0x00000000ul +#define SYSTEM_POWERDOMAINACK_SRAM_PD_ACK_FIELD_MASK 0x00000002ul +#define SYSTEM_POWERDOMAINACK_SRAM_PD_ACK_GET(x) (((x) & 0x00000002ul) >> 1) +#define SYSTEM_POWERDOMAINACK_SRAM_PD_ACK_SET(x) (((x) << 1) & 0x00000002ul) +#define SYSTEM_POWERDOMAINACK_SRAM_PD_ACK_MODIFY(r, x) ((((x) << 1) & 0x00000002ul) | ((r) & 0xFFFFFFFDul)) + +/* Field: SYSTEM_POWERDOMAINACK.chiplet_pd_ack */ +#define SYSTEM_POWERDOMAINACK_CHIPLET_PD_ACK_MSB 3u +#define SYSTEM_POWERDOMAINACK_CHIPLET_PD_ACK_LSB 3u +#define SYSTEM_POWERDOMAINACK_CHIPLET_PD_ACK_WIDTH 1u +#define SYSTEM_POWERDOMAINACK_CHIPLET_PD_ACK_READ_ACCESS 1u +#define SYSTEM_POWERDOMAINACK_CHIPLET_PD_ACK_WRITE_ACCESS 0u +#define SYSTEM_POWERDOMAINACK_CHIPLET_PD_ACK_RESET 0x00000000ul +#define SYSTEM_POWERDOMAINACK_CHIPLET_PD_ACK_FIELD_MASK 0x00000008ul +#define SYSTEM_POWERDOMAINACK_CHIPLET_PD_ACK_GET(x) (((x) & 0x00000008ul) >> 3) +#define SYSTEM_POWERDOMAINACK_CHIPLET_PD_ACK_SET(x) (((x) << 3) & 0x00000008ul) +#define SYSTEM_POWERDOMAINACK_CHIPLET_PD_ACK_MODIFY(r, x) ((((x) << 3) & 0x00000008ul) | ((r) & 0xFFFFFFF7ul)) + +/* Field: SYSTEM_POWERDOMAINACK.mram_pd_ack */ +#define SYSTEM_POWERDOMAINACK_MRAM_PD_ACK_MSB 4u +#define SYSTEM_POWERDOMAINACK_MRAM_PD_ACK_LSB 4u +#define SYSTEM_POWERDOMAINACK_MRAM_PD_ACK_WIDTH 1u +#define SYSTEM_POWERDOMAINACK_MRAM_PD_ACK_READ_ACCESS 1u +#define SYSTEM_POWERDOMAINACK_MRAM_PD_ACK_WRITE_ACCESS 0u +#define SYSTEM_POWERDOMAINACK_MRAM_PD_ACK_RESET 0x00000000ul +#define SYSTEM_POWERDOMAINACK_MRAM_PD_ACK_FIELD_MASK 0x00000010ul +#define SYSTEM_POWERDOMAINACK_MRAM_PD_ACK_GET(x) (((x) & 0x00000010ul) >> 4) +#define SYSTEM_POWERDOMAINACK_MRAM_PD_ACK_SET(x) (((x) << 4) & 0x00000010ul) +#define SYSTEM_POWERDOMAINACK_MRAM_PD_ACK_MODIFY(r, x) ((((x) << 4) & 0x00000010ul) | ((r) & 0xFFFFFFEFul)) + +/* Field: SYSTEM_POWERDOMAINACK.system_pd_ack */ +#define SYSTEM_POWERDOMAINACK_SYSTEM_PD_ACK_MSB 5u +#define SYSTEM_POWERDOMAINACK_SYSTEM_PD_ACK_LSB 5u +#define SYSTEM_POWERDOMAINACK_SYSTEM_PD_ACK_WIDTH 1u +#define SYSTEM_POWERDOMAINACK_SYSTEM_PD_ACK_READ_ACCESS 1u +#define SYSTEM_POWERDOMAINACK_SYSTEM_PD_ACK_WRITE_ACCESS 0u +#define SYSTEM_POWERDOMAINACK_SYSTEM_PD_ACK_RESET 0x00000000ul +#define SYSTEM_POWERDOMAINACK_SYSTEM_PD_ACK_FIELD_MASK 0x00000020ul +#define SYSTEM_POWERDOMAINACK_SYSTEM_PD_ACK_GET(x) (((x) & 0x00000020ul) >> 5) +#define SYSTEM_POWERDOMAINACK_SYSTEM_PD_ACK_SET(x) (((x) << 5) & 0x00000020ul) +#define SYSTEM_POWERDOMAINACK_SYSTEM_PD_ACK_MODIFY(r, x) ((((x) << 5) & 0x00000020ul) | ((r) & 0xFFFFFFDFul)) + +/* Field: SYSTEM_POWERDOMAINACK.hyperbus_pd_ack */ +#define SYSTEM_POWERDOMAINACK_HYPERBUS_PD_ACK_MSB 6u +#define SYSTEM_POWERDOMAINACK_HYPERBUS_PD_ACK_LSB 6u +#define SYSTEM_POWERDOMAINACK_HYPERBUS_PD_ACK_WIDTH 1u +#define SYSTEM_POWERDOMAINACK_HYPERBUS_PD_ACK_READ_ACCESS 1u +#define SYSTEM_POWERDOMAINACK_HYPERBUS_PD_ACK_WRITE_ACCESS 0u +#define SYSTEM_POWERDOMAINACK_HYPERBUS_PD_ACK_RESET 0x00000000ul +#define SYSTEM_POWERDOMAINACK_HYPERBUS_PD_ACK_FIELD_MASK 0x00000040ul +#define SYSTEM_POWERDOMAINACK_HYPERBUS_PD_ACK_GET(x) (((x) & 0x00000040ul) >> 6) +#define SYSTEM_POWERDOMAINACK_HYPERBUS_PD_ACK_SET(x) (((x) << 6) & 0x00000040ul) +#define SYSTEM_POWERDOMAINACK_HYPERBUS_PD_ACK_MODIFY(r, x) ((((x) << 6) & 0x00000040ul) | ((r) & 0xFFFFFFBFul)) + +/* Field: SYSTEM_POWERDOMAINACK.minion_pd_ack */ +#define SYSTEM_POWERDOMAINACK_MINION_PD_ACK_MSB 15u +#define SYSTEM_POWERDOMAINACK_MINION_PD_ACK_LSB 8u +#define SYSTEM_POWERDOMAINACK_MINION_PD_ACK_WIDTH 8u +#define SYSTEM_POWERDOMAINACK_MINION_PD_ACK_READ_ACCESS 1u +#define SYSTEM_POWERDOMAINACK_MINION_PD_ACK_WRITE_ACCESS 0u +#define SYSTEM_POWERDOMAINACK_MINION_PD_ACK_RESET 0x00000000ul +#define SYSTEM_POWERDOMAINACK_MINION_PD_ACK_FIELD_MASK 0x0000FF00ul +#define SYSTEM_POWERDOMAINACK_MINION_PD_ACK_GET(x) (((x) & 0x0000FF00ul) >> 8) +#define SYSTEM_POWERDOMAINACK_MINION_PD_ACK_SET(x) (((x) << 8) & 0x0000FF00ul) +#define SYSTEM_POWERDOMAINACK_MINION_PD_ACK_MODIFY(r, x) ((((x) << 8) & 0x0000FF00ul) | ((r) & 0xFFFF00FFul)) + +/* Register: SYSTEM.PowerGood */ +#define SYSTEM_POWERGOOD_ADDRESS 0x00000048ul +#define SYSTEM_POWERGOOD_BYTE_ADDRESS 0x00000048ul +#define SYSTEM_POWERGOOD_OFFSET 0x00000048ul +#define SYSTEM_POWERGOOD_BYTE_OFFSET 0x00000048ul +#define SYSTEM_POWERGOOD_SIZE 0x00000004ul +#define SYSTEM_POWERGOOD_BYTE_SIZE 0x00000004ul +#define SYSTEM_POWERGOOD_READ_ACCESS 1u +#define SYSTEM_POWERGOOD_WRITE_ACCESS 1u +#define SYSTEM_POWERGOOD_RESET_VALUE 0x000FFFFFul +#define SYSTEM_POWERGOOD_RESET_MASK 0x001FFFFFul +#define SYSTEM_POWERGOOD_READ_MASK 0x001FFFFFul +#define SYSTEM_POWERGOOD_WRITE_MASK 0x001FFFFFul + +/* Field: SYSTEM_POWERGOOD.counter */ +#define SYSTEM_POWERGOOD_COUNTER_MSB 20u +#define SYSTEM_POWERGOOD_COUNTER_LSB 0u +#define SYSTEM_POWERGOOD_COUNTER_WIDTH 21u +#define SYSTEM_POWERGOOD_COUNTER_READ_ACCESS 1u +#define SYSTEM_POWERGOOD_COUNTER_WRITE_ACCESS 1u +#define SYSTEM_POWERGOOD_COUNTER_RESET 0x000FFFFFul +#define SYSTEM_POWERGOOD_COUNTER_FIELD_MASK 0x001FFFFFul +#define SYSTEM_POWERGOOD_COUNTER_GET(x) ((x) & 0x001FFFFFul) +#define SYSTEM_POWERGOOD_COUNTER_SET(x) ((x) & 0x001FFFFFul) +#define SYSTEM_POWERGOOD_COUNTER_MODIFY(r, x) ((((x) << 0) & 0x001FFFFFul) | ((r) & 0xFFE00000ul)) + +/* Register: SYSTEM.PowerStatus */ +#define SYSTEM_POWERSTATUS_ADDRESS 0x00000050ul +#define SYSTEM_POWERSTATUS_BYTE_ADDRESS 0x00000050ul +#define SYSTEM_POWERSTATUS_OFFSET 0x00000050ul +#define SYSTEM_POWERSTATUS_BYTE_OFFSET 0x00000050ul +#define SYSTEM_POWERSTATUS_SIZE 0x00000004ul +#define SYSTEM_POWERSTATUS_BYTE_SIZE 0x00000004ul +#define SYSTEM_POWERSTATUS_READ_ACCESS 1u +#define SYSTEM_POWERSTATUS_WRITE_ACCESS 0u +#define SYSTEM_POWERSTATUS_RESET_VALUE 0x00000000ul +#define SYSTEM_POWERSTATUS_RESET_MASK 0x0000000Ful +#define SYSTEM_POWERSTATUS_READ_MASK 0x0000000Ful +#define SYSTEM_POWERSTATUS_WRITE_MASK 0x00000000ul + +/* Field: SYSTEM_POWERSTATUS.reserved */ +#define SYSTEM_POWERSTATUS_RESERVED_MSB 3u +#define SYSTEM_POWERSTATUS_RESERVED_LSB 0u +#define SYSTEM_POWERSTATUS_RESERVED_WIDTH 4u +#define SYSTEM_POWERSTATUS_RESERVED_READ_ACCESS 1u +#define SYSTEM_POWERSTATUS_RESERVED_WRITE_ACCESS 0u +#define SYSTEM_POWERSTATUS_RESERVED_RESET 0x00000000ul +#define SYSTEM_POWERSTATUS_RESERVED_FIELD_MASK 0x0000000Ful +#define SYSTEM_POWERSTATUS_RESERVED_GET(x) ((x) & 0x0000000Ful) +#define SYSTEM_POWERSTATUS_RESERVED_SET(x) ((x) & 0x0000000Ful) +#define SYSTEM_POWERSTATUS_RESERVED_MODIFY(r, x) ((((x) << 0) & 0x0000000Ful) | ((r) & 0xFFFFFFF0ul)) + +/* Register: SYSTEM.SpinLock */ +#define SYSTEM_SPINLOCK_ADDRESS 0x00000058ul +#define SYSTEM_SPINLOCK_BYTE_ADDRESS 0x00000058ul +#define SYSTEM_SPINLOCK_OFFSET 0x00000058ul +#define SYSTEM_SPINLOCK_BYTE_OFFSET 0x00000058ul +#define SYSTEM_SPINLOCK_SIZE 0x00000004ul +#define SYSTEM_SPINLOCK_BYTE_SIZE 0x00000004ul +#define SYSTEM_SPINLOCK_READ_ACCESS 1u +#define SYSTEM_SPINLOCK_WRITE_ACCESS 1u +#define SYSTEM_SPINLOCK_RESET_VALUE 0x00000000ul +#define SYSTEM_SPINLOCK_RESET_MASK 0x00000001ul +#define SYSTEM_SPINLOCK_READ_MASK 0x00000001ul +#define SYSTEM_SPINLOCK_WRITE_MASK 0x00000001ul + +/* Field: SYSTEM_SPINLOCK.lock */ +#define SYSTEM_SPINLOCK_LOCK_MSB 0u +#define SYSTEM_SPINLOCK_LOCK_LSB 0u +#define SYSTEM_SPINLOCK_LOCK_WIDTH 1u +#define SYSTEM_SPINLOCK_LOCK_READ_ACCESS 1u +#define SYSTEM_SPINLOCK_LOCK_WRITE_ACCESS 1u +#define SYSTEM_SPINLOCK_LOCK_RESET 0x00000000ul +#define SYSTEM_SPINLOCK_LOCK_FIELD_MASK 0x00000001ul +#define SYSTEM_SPINLOCK_LOCK_GET(x) ((x) & 0x00000001ul) +#define SYSTEM_SPINLOCK_LOCK_SET(x) ((x) & 0x00000001ul) +#define SYSTEM_SPINLOCK_LOCK_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Register: SYSTEM.ChipMode */ +#define SYSTEM_CHIPMODE_ADDRESS 0x00000060ul +#define SYSTEM_CHIPMODE_BYTE_ADDRESS 0x00000060ul +#define SYSTEM_CHIPMODE_OFFSET 0x00000060ul +#define SYSTEM_CHIPMODE_BYTE_OFFSET 0x00000060ul +#define SYSTEM_CHIPMODE_SIZE 0x00000004ul +#define SYSTEM_CHIPMODE_BYTE_SIZE 0x00000004ul +#define SYSTEM_CHIPMODE_READ_ACCESS 1u +#define SYSTEM_CHIPMODE_WRITE_ACCESS 1u +#define SYSTEM_CHIPMODE_RESET_VALUE 0x00000000ul +#define SYSTEM_CHIPMODE_RESET_MASK 0x0000007Ful +#define SYSTEM_CHIPMODE_READ_MASK 0x0000007Ful +#define SYSTEM_CHIPMODE_WRITE_MASK 0x00000078ul + +/* Field: SYSTEM_CHIPMODE.chip_mode */ +#define SYSTEM_CHIPMODE_CHIP_MODE_MSB 1u +#define SYSTEM_CHIPMODE_CHIP_MODE_LSB 0u +#define SYSTEM_CHIPMODE_CHIP_MODE_WIDTH 2u +#define SYSTEM_CHIPMODE_CHIP_MODE_READ_ACCESS 1u +#define SYSTEM_CHIPMODE_CHIP_MODE_WRITE_ACCESS 0u +#define SYSTEM_CHIPMODE_CHIP_MODE_RESET 0x00000000ul +#define SYSTEM_CHIPMODE_CHIP_MODE_FIELD_MASK 0x00000003ul +#define SYSTEM_CHIPMODE_CHIP_MODE_GET(x) ((x) & 0x00000003ul) +#define SYSTEM_CHIPMODE_CHIP_MODE_SET(x) ((x) & 0x00000003ul) +#define SYSTEM_CHIPMODE_CHIP_MODE_MODIFY(r, x) ((((x) << 0) & 0x00000003ul) | ((r) & 0xFFFFFFFCul)) + +/* Field: SYSTEM_CHIPMODE.ifc_width */ +#define SYSTEM_CHIPMODE_IFC_WIDTH_MSB 2u +#define SYSTEM_CHIPMODE_IFC_WIDTH_LSB 2u +#define SYSTEM_CHIPMODE_IFC_WIDTH_WIDTH 1u +#define SYSTEM_CHIPMODE_IFC_WIDTH_READ_ACCESS 1u +#define SYSTEM_CHIPMODE_IFC_WIDTH_WRITE_ACCESS 0u +#define SYSTEM_CHIPMODE_IFC_WIDTH_RESET 0x00000000ul +#define SYSTEM_CHIPMODE_IFC_WIDTH_FIELD_MASK 0x00000004ul +#define SYSTEM_CHIPMODE_IFC_WIDTH_GET(x) (((x) & 0x00000004ul) >> 2) +#define SYSTEM_CHIPMODE_IFC_WIDTH_SET(x) (((x) << 2) & 0x00000004ul) +#define SYSTEM_CHIPMODE_IFC_WIDTH_MODIFY(r, x) ((((x) << 2) & 0x00000004ul) | ((r) & 0xFFFFFFFBul)) + +/* Field: SYSTEM_CHIPMODE.bootload */ +#define SYSTEM_CHIPMODE_BOOTLOAD_MSB 4u +#define SYSTEM_CHIPMODE_BOOTLOAD_LSB 3u +#define SYSTEM_CHIPMODE_BOOTLOAD_WIDTH 2u +#define SYSTEM_CHIPMODE_BOOTLOAD_READ_ACCESS 1u +#define SYSTEM_CHIPMODE_BOOTLOAD_WRITE_ACCESS 1u +#define SYSTEM_CHIPMODE_BOOTLOAD_RESET 0x00000000ul +#define SYSTEM_CHIPMODE_BOOTLOAD_FIELD_MASK 0x00000018ul +#define SYSTEM_CHIPMODE_BOOTLOAD_GET(x) (((x) & 0x00000018ul) >> 3) +#define SYSTEM_CHIPMODE_BOOTLOAD_SET(x) (((x) << 3) & 0x00000018ul) +#define SYSTEM_CHIPMODE_BOOTLOAD_MODIFY(r, x) ((((x) << 3) & 0x00000018ul) | ((r) & 0xFFFFFFE7ul)) + +/* Field: SYSTEM_CHIPMODE.load_external */ +#define SYSTEM_CHIPMODE_LOAD_EXTERNAL_MSB 6u +#define SYSTEM_CHIPMODE_LOAD_EXTERNAL_LSB 5u +#define SYSTEM_CHIPMODE_LOAD_EXTERNAL_WIDTH 2u +#define SYSTEM_CHIPMODE_LOAD_EXTERNAL_READ_ACCESS 1u +#define SYSTEM_CHIPMODE_LOAD_EXTERNAL_WRITE_ACCESS 1u +#define SYSTEM_CHIPMODE_LOAD_EXTERNAL_RESET 0x00000000ul +#define SYSTEM_CHIPMODE_LOAD_EXTERNAL_FIELD_MASK 0x00000060ul +#define SYSTEM_CHIPMODE_LOAD_EXTERNAL_GET(x) (((x) & 0x00000060ul) >> 5) +#define SYSTEM_CHIPMODE_LOAD_EXTERNAL_SET(x) (((x) << 5) & 0x00000060ul) +#define SYSTEM_CHIPMODE_LOAD_EXTERNAL_MODIFY(r, x) ((((x) << 5) & 0x00000060ul) | ((r) & 0xFFFFFF9Ful)) + +/* Register: SYSTEM.Mailbox0 */ +#define SYSTEM_MAILBOX0_ADDRESS 0x00000068ul +#define SYSTEM_MAILBOX0_BYTE_ADDRESS 0x00000068ul +#define SYSTEM_MAILBOX0_OFFSET 0x00000068ul +#define SYSTEM_MAILBOX0_BYTE_OFFSET 0x00000068ul +#define SYSTEM_MAILBOX0_SIZE 0x00000004ul +#define SYSTEM_MAILBOX0_BYTE_SIZE 0x00000004ul +#define SYSTEM_MAILBOX0_READ_ACCESS 1u +#define SYSTEM_MAILBOX0_WRITE_ACCESS 1u +#define SYSTEM_MAILBOX0_RESET_VALUE 0x00000000ul +#define SYSTEM_MAILBOX0_RESET_MASK 0xFFFFFFFFul +#define SYSTEM_MAILBOX0_READ_MASK 0xFFFFFFFFul +#define SYSTEM_MAILBOX0_WRITE_MASK 0xFFFFFFFFul + +/* Field: SYSTEM_MAILBOX0.mbox0 */ +#define SYSTEM_MAILBOX0_MBOX0_MSB 31u +#define SYSTEM_MAILBOX0_MBOX0_LSB 0u +#define SYSTEM_MAILBOX0_MBOX0_WIDTH 32u +#define SYSTEM_MAILBOX0_MBOX0_READ_ACCESS 1u +#define SYSTEM_MAILBOX0_MBOX0_WRITE_ACCESS 1u +#define SYSTEM_MAILBOX0_MBOX0_RESET 0x00000000ul +#define SYSTEM_MAILBOX0_MBOX0_FIELD_MASK 0xFFFFFFFFul +#define SYSTEM_MAILBOX0_MBOX0_GET(x) ((x) & 0xFFFFFFFFul) +#define SYSTEM_MAILBOX0_MBOX0_SET(x) ((x) & 0xFFFFFFFFul) +#define SYSTEM_MAILBOX0_MBOX0_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFul) | ((r) & 0x00000000ul)) + +/* Register: SYSTEM.Mailbox1 */ +#define SYSTEM_MAILBOX1_ADDRESS 0x00000070ul +#define SYSTEM_MAILBOX1_BYTE_ADDRESS 0x00000070ul +#define SYSTEM_MAILBOX1_OFFSET 0x00000070ul +#define SYSTEM_MAILBOX1_BYTE_OFFSET 0x00000070ul +#define SYSTEM_MAILBOX1_SIZE 0x00000004ul +#define SYSTEM_MAILBOX1_BYTE_SIZE 0x00000004ul +#define SYSTEM_MAILBOX1_READ_ACCESS 1u +#define SYSTEM_MAILBOX1_WRITE_ACCESS 1u +#define SYSTEM_MAILBOX1_RESET_VALUE 0x00000000ul +#define SYSTEM_MAILBOX1_RESET_MASK 0xFFFFFFFFul +#define SYSTEM_MAILBOX1_READ_MASK 0xFFFFFFFFul +#define SYSTEM_MAILBOX1_WRITE_MASK 0xFFFFFFFFul + +/* Field: SYSTEM_MAILBOX1.mbox1 */ +#define SYSTEM_MAILBOX1_MBOX1_MSB 31u +#define SYSTEM_MAILBOX1_MBOX1_LSB 0u +#define SYSTEM_MAILBOX1_MBOX1_WIDTH 32u +#define SYSTEM_MAILBOX1_MBOX1_READ_ACCESS 1u +#define SYSTEM_MAILBOX1_MBOX1_WRITE_ACCESS 1u +#define SYSTEM_MAILBOX1_MBOX1_RESET 0x00000000ul +#define SYSTEM_MAILBOX1_MBOX1_FIELD_MASK 0xFFFFFFFFul +#define SYSTEM_MAILBOX1_MBOX1_GET(x) ((x) & 0xFFFFFFFFul) +#define SYSTEM_MAILBOX1_MBOX1_SET(x) ((x) & 0xFFFFFFFFul) +#define SYSTEM_MAILBOX1_MBOX1_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFul) | ((r) & 0x00000000ul)) + +/* Register: SYSTEM.GPIO_OE */ +#define SYSTEM_GPIO_OE_ADDRESS 0x00000078ul +#define SYSTEM_GPIO_OE_BYTE_ADDRESS 0x00000078ul +#define SYSTEM_GPIO_OE_OFFSET 0x00000078ul +#define SYSTEM_GPIO_OE_BYTE_OFFSET 0x00000078ul +#define SYSTEM_GPIO_OE_SIZE 0x00000004ul +#define SYSTEM_GPIO_OE_BYTE_SIZE 0x00000004ul +#define SYSTEM_GPIO_OE_READ_ACCESS 1u +#define SYSTEM_GPIO_OE_WRITE_ACCESS 1u +#define SYSTEM_GPIO_OE_RESET_VALUE 0x00000000ul +#define SYSTEM_GPIO_OE_RESET_MASK 0x000007FFul +#define SYSTEM_GPIO_OE_READ_MASK 0x000007FFul +#define SYSTEM_GPIO_OE_WRITE_MASK 0x000007FFul + +/* Field: SYSTEM_GPIO_OE.gpio_oe */ +#define SYSTEM_GPIO_OE_GPIO_OE_MSB 10u +#define SYSTEM_GPIO_OE_GPIO_OE_LSB 0u +#define SYSTEM_GPIO_OE_GPIO_OE_WIDTH 11u +#define SYSTEM_GPIO_OE_GPIO_OE_READ_ACCESS 1u +#define SYSTEM_GPIO_OE_GPIO_OE_WRITE_ACCESS 1u +#define SYSTEM_GPIO_OE_GPIO_OE_RESET 0x00000000ul +#define SYSTEM_GPIO_OE_GPIO_OE_FIELD_MASK 0x000007FFul +#define SYSTEM_GPIO_OE_GPIO_OE_GET(x) ((x) & 0x000007FFul) +#define SYSTEM_GPIO_OE_GPIO_OE_SET(x) ((x) & 0x000007FFul) +#define SYSTEM_GPIO_OE_GPIO_OE_MODIFY(r, x) ((((x) << 0) & 0x000007FFul) | ((r) & 0xFFFFF800ul)) + +/* Register: SYSTEM.GPIO_I */ +#define SYSTEM_GPIO_I_ADDRESS 0x00000080ul +#define SYSTEM_GPIO_I_BYTE_ADDRESS 0x00000080ul +#define SYSTEM_GPIO_I_OFFSET 0x00000080ul +#define SYSTEM_GPIO_I_BYTE_OFFSET 0x00000080ul +#define SYSTEM_GPIO_I_SIZE 0x00000004ul +#define SYSTEM_GPIO_I_BYTE_SIZE 0x00000004ul +#define SYSTEM_GPIO_I_READ_ACCESS 1u +#define SYSTEM_GPIO_I_WRITE_ACCESS 0u +#define SYSTEM_GPIO_I_RESET_VALUE 0x00000000ul +#define SYSTEM_GPIO_I_RESET_MASK 0x000007FFul +#define SYSTEM_GPIO_I_READ_MASK 0x000007FFul +#define SYSTEM_GPIO_I_WRITE_MASK 0x00000000ul + +/* Field: SYSTEM_GPIO_I.gpio_i */ +#define SYSTEM_GPIO_I_GPIO_I_MSB 10u +#define SYSTEM_GPIO_I_GPIO_I_LSB 0u +#define SYSTEM_GPIO_I_GPIO_I_WIDTH 11u +#define SYSTEM_GPIO_I_GPIO_I_READ_ACCESS 1u +#define SYSTEM_GPIO_I_GPIO_I_WRITE_ACCESS 0u +#define SYSTEM_GPIO_I_GPIO_I_RESET 0x00000000ul +#define SYSTEM_GPIO_I_GPIO_I_FIELD_MASK 0x000007FFul +#define SYSTEM_GPIO_I_GPIO_I_GET(x) ((x) & 0x000007FFul) +#define SYSTEM_GPIO_I_GPIO_I_SET(x) ((x) & 0x000007FFul) +#define SYSTEM_GPIO_I_GPIO_I_MODIFY(r, x) ((((x) << 0) & 0x000007FFul) | ((r) & 0xFFFFF800ul)) + +/* Register: SYSTEM.GPIO_O */ +#define SYSTEM_GPIO_O_ADDRESS 0x00000088ul +#define SYSTEM_GPIO_O_BYTE_ADDRESS 0x00000088ul +#define SYSTEM_GPIO_O_OFFSET 0x00000088ul +#define SYSTEM_GPIO_O_BYTE_OFFSET 0x00000088ul +#define SYSTEM_GPIO_O_SIZE 0x00000004ul +#define SYSTEM_GPIO_O_BYTE_SIZE 0x00000004ul +#define SYSTEM_GPIO_O_READ_ACCESS 1u +#define SYSTEM_GPIO_O_WRITE_ACCESS 1u +#define SYSTEM_GPIO_O_RESET_VALUE 0x00000000ul +#define SYSTEM_GPIO_O_RESET_MASK 0x000007FFul +#define SYSTEM_GPIO_O_READ_MASK 0x000007FFul +#define SYSTEM_GPIO_O_WRITE_MASK 0x000007FFul + +/* Field: SYSTEM_GPIO_O.gpio_o */ +#define SYSTEM_GPIO_O_GPIO_O_MSB 10u +#define SYSTEM_GPIO_O_GPIO_O_LSB 0u +#define SYSTEM_GPIO_O_GPIO_O_WIDTH 11u +#define SYSTEM_GPIO_O_GPIO_O_READ_ACCESS 1u +#define SYSTEM_GPIO_O_GPIO_O_WRITE_ACCESS 1u +#define SYSTEM_GPIO_O_GPIO_O_RESET 0x00000000ul +#define SYSTEM_GPIO_O_GPIO_O_FIELD_MASK 0x000007FFul +#define SYSTEM_GPIO_O_GPIO_O_GET(x) ((x) & 0x000007FFul) +#define SYSTEM_GPIO_O_GPIO_O_SET(x) ((x) & 0x000007FFul) +#define SYSTEM_GPIO_O_GPIO_O_MODIFY(r, x) ((((x) << 0) & 0x000007FFul) | ((r) & 0xFFFFF800ul)) + +/* Register: SYSTEM.GPIO_Interrupt_Enable */ +#define SYSTEM_GPIO_INTERRUPT_ENABLE_ADDRESS 0x00000090ul +#define SYSTEM_GPIO_INTERRUPT_ENABLE_BYTE_ADDRESS 0x00000090ul +#define SYSTEM_GPIO_INTERRUPT_ENABLE_OFFSET 0x00000090ul +#define SYSTEM_GPIO_INTERRUPT_ENABLE_BYTE_OFFSET 0x00000090ul +#define SYSTEM_GPIO_INTERRUPT_ENABLE_SIZE 0x00000004ul +#define SYSTEM_GPIO_INTERRUPT_ENABLE_BYTE_SIZE 0x00000004ul +#define SYSTEM_GPIO_INTERRUPT_ENABLE_READ_ACCESS 1u +#define SYSTEM_GPIO_INTERRUPT_ENABLE_WRITE_ACCESS 1u +#define SYSTEM_GPIO_INTERRUPT_ENABLE_RESET_VALUE 0x00000000ul +#define SYSTEM_GPIO_INTERRUPT_ENABLE_RESET_MASK 0x000007FFul +#define SYSTEM_GPIO_INTERRUPT_ENABLE_READ_MASK 0x000007FFul +#define SYSTEM_GPIO_INTERRUPT_ENABLE_WRITE_MASK 0x000007FFul + +/* Field: SYSTEM_GPIO_INTERRUPT_ENABLE.gpio_interrupt_en */ +#define SYSTEM_GPIO_INTERRUPT_ENABLE_GPIO_INTERRUPT_EN_MSB 10u +#define SYSTEM_GPIO_INTERRUPT_ENABLE_GPIO_INTERRUPT_EN_LSB 0u +#define SYSTEM_GPIO_INTERRUPT_ENABLE_GPIO_INTERRUPT_EN_WIDTH 11u +#define SYSTEM_GPIO_INTERRUPT_ENABLE_GPIO_INTERRUPT_EN_READ_ACCESS 1u +#define SYSTEM_GPIO_INTERRUPT_ENABLE_GPIO_INTERRUPT_EN_WRITE_ACCESS 1u +#define SYSTEM_GPIO_INTERRUPT_ENABLE_GPIO_INTERRUPT_EN_RESET 0x00000000ul +#define SYSTEM_GPIO_INTERRUPT_ENABLE_GPIO_INTERRUPT_EN_FIELD_MASK 0x000007FFul +#define SYSTEM_GPIO_INTERRUPT_ENABLE_GPIO_INTERRUPT_EN_GET(x) ((x) & 0x000007FFul) +#define SYSTEM_GPIO_INTERRUPT_ENABLE_GPIO_INTERRUPT_EN_SET(x) ((x) & 0x000007FFul) +#define SYSTEM_GPIO_INTERRUPT_ENABLE_GPIO_INTERRUPT_EN_MODIFY(r, x) ((((x) << 0) & 0x000007FFul) | ((r) & 0xFFFFF800ul)) + +/* Register: SYSTEM.ring_osc */ +#define SYSTEM_RING_OSC_ADDRESS 0x00000098ul +#define SYSTEM_RING_OSC_BYTE_ADDRESS 0x00000098ul +#define SYSTEM_RING_OSC_OFFSET 0x00000098ul +#define SYSTEM_RING_OSC_BYTE_OFFSET 0x00000098ul +#define SYSTEM_RING_OSC_SIZE 0x00000004ul +#define SYSTEM_RING_OSC_BYTE_SIZE 0x00000004ul +#define SYSTEM_RING_OSC_READ_ACCESS 1u +#define SYSTEM_RING_OSC_WRITE_ACCESS 1u +#define SYSTEM_RING_OSC_RESET_VALUE 0x0000007Ful +#define SYSTEM_RING_OSC_RESET_MASK 0x000007FFul +#define SYSTEM_RING_OSC_READ_MASK 0x000007FFul +#define SYSTEM_RING_OSC_WRITE_MASK 0x000007FFul + +/* Field: SYSTEM_RING_OSC.en */ +#define SYSTEM_RING_OSC_EN_MSB 0u +#define SYSTEM_RING_OSC_EN_LSB 0u +#define SYSTEM_RING_OSC_EN_WIDTH 1u +#define SYSTEM_RING_OSC_EN_READ_ACCESS 1u +#define SYSTEM_RING_OSC_EN_WRITE_ACCESS 1u +#define SYSTEM_RING_OSC_EN_RESET 0x00000001ul +#define SYSTEM_RING_OSC_EN_FIELD_MASK 0x00000001ul +#define SYSTEM_RING_OSC_EN_GET(x) ((x) & 0x00000001ul) +#define SYSTEM_RING_OSC_EN_SET(x) ((x) & 0x00000001ul) +#define SYSTEM_RING_OSC_EN_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Field: SYSTEM_RING_OSC.divby2_sel */ +#define SYSTEM_RING_OSC_DIVBY2_SEL_MSB 1u +#define SYSTEM_RING_OSC_DIVBY2_SEL_LSB 1u +#define SYSTEM_RING_OSC_DIVBY2_SEL_WIDTH 1u +#define SYSTEM_RING_OSC_DIVBY2_SEL_READ_ACCESS 1u +#define SYSTEM_RING_OSC_DIVBY2_SEL_WRITE_ACCESS 1u +#define SYSTEM_RING_OSC_DIVBY2_SEL_RESET 0x00000001ul +#define SYSTEM_RING_OSC_DIVBY2_SEL_FIELD_MASK 0x00000002ul +#define SYSTEM_RING_OSC_DIVBY2_SEL_GET(x) (((x) & 0x00000002ul) >> 1) +#define SYSTEM_RING_OSC_DIVBY2_SEL_SET(x) (((x) << 1) & 0x00000002ul) +#define SYSTEM_RING_OSC_DIVBY2_SEL_MODIFY(r, x) ((((x) << 1) & 0x00000002ul) | ((r) & 0xFFFFFFFDul)) + +/* Field: SYSTEM_RING_OSC.trm */ +#define SYSTEM_RING_OSC_TRM_MSB 6u +#define SYSTEM_RING_OSC_TRM_LSB 2u +#define SYSTEM_RING_OSC_TRM_WIDTH 5u +#define SYSTEM_RING_OSC_TRM_READ_ACCESS 1u +#define SYSTEM_RING_OSC_TRM_WRITE_ACCESS 1u +#define SYSTEM_RING_OSC_TRM_RESET 0x0000001Ful +#define SYSTEM_RING_OSC_TRM_FIELD_MASK 0x0000007Cul +#define SYSTEM_RING_OSC_TRM_GET(x) (((x) & 0x0000007Cul) >> 2) +#define SYSTEM_RING_OSC_TRM_SET(x) (((x) << 2) & 0x0000007Cul) +#define SYSTEM_RING_OSC_TRM_MODIFY(r, x) ((((x) << 2) & 0x0000007Cul) | ((r) & 0xFFFFFF83ul)) + +/* Field: SYSTEM_RING_OSC.dbg_en */ +#define SYSTEM_RING_OSC_DBG_EN_MSB 7u +#define SYSTEM_RING_OSC_DBG_EN_LSB 7u +#define SYSTEM_RING_OSC_DBG_EN_WIDTH 1u +#define SYSTEM_RING_OSC_DBG_EN_READ_ACCESS 1u +#define SYSTEM_RING_OSC_DBG_EN_WRITE_ACCESS 1u +#define SYSTEM_RING_OSC_DBG_EN_RESET 0x00000000ul +#define SYSTEM_RING_OSC_DBG_EN_FIELD_MASK 0x00000080ul +#define SYSTEM_RING_OSC_DBG_EN_GET(x) (((x) & 0x00000080ul) >> 7) +#define SYSTEM_RING_OSC_DBG_EN_SET(x) (((x) << 7) & 0x00000080ul) +#define SYSTEM_RING_OSC_DBG_EN_MODIFY(r, x) ((((x) << 7) & 0x00000080ul) | ((r) & 0xFFFFFF7Ful)) + +/* Field: SYSTEM_RING_OSC.dbg_anachip_en */ +#define SYSTEM_RING_OSC_DBG_ANACHIP_EN_MSB 8u +#define SYSTEM_RING_OSC_DBG_ANACHIP_EN_LSB 8u +#define SYSTEM_RING_OSC_DBG_ANACHIP_EN_WIDTH 1u +#define SYSTEM_RING_OSC_DBG_ANACHIP_EN_READ_ACCESS 1u +#define SYSTEM_RING_OSC_DBG_ANACHIP_EN_WRITE_ACCESS 1u +#define SYSTEM_RING_OSC_DBG_ANACHIP_EN_RESET 0x00000000ul +#define SYSTEM_RING_OSC_DBG_ANACHIP_EN_FIELD_MASK 0x00000100ul +#define SYSTEM_RING_OSC_DBG_ANACHIP_EN_GET(x) (((x) & 0x00000100ul) >> 8) +#define SYSTEM_RING_OSC_DBG_ANACHIP_EN_SET(x) (((x) << 8) & 0x00000100ul) +#define SYSTEM_RING_OSC_DBG_ANACHIP_EN_MODIFY(r, x) ((((x) << 8) & 0x00000100ul) | ((r) & 0xFFFFFEFFul)) + +/* Field: SYSTEM_RING_OSC.dbg_rohcip_en */ +#define SYSTEM_RING_OSC_DBG_ROHCIP_EN_MSB 9u +#define SYSTEM_RING_OSC_DBG_ROHCIP_EN_LSB 9u +#define SYSTEM_RING_OSC_DBG_ROHCIP_EN_WIDTH 1u +#define SYSTEM_RING_OSC_DBG_ROHCIP_EN_READ_ACCESS 1u +#define SYSTEM_RING_OSC_DBG_ROHCIP_EN_WRITE_ACCESS 1u +#define SYSTEM_RING_OSC_DBG_ROHCIP_EN_RESET 0x00000000ul +#define SYSTEM_RING_OSC_DBG_ROHCIP_EN_FIELD_MASK 0x00000200ul +#define SYSTEM_RING_OSC_DBG_ROHCIP_EN_GET(x) (((x) & 0x00000200ul) >> 9) +#define SYSTEM_RING_OSC_DBG_ROHCIP_EN_SET(x) (((x) << 9) & 0x00000200ul) +#define SYSTEM_RING_OSC_DBG_ROHCIP_EN_MODIFY(r, x) ((((x) << 9) & 0x00000200ul) | ((r) & 0xFFFFFDFFul)) + +/* Field: SYSTEM_RING_OSC.dbg_sah_en_b */ +#define SYSTEM_RING_OSC_DBG_SAH_EN_B_MSB 10u +#define SYSTEM_RING_OSC_DBG_SAH_EN_B_LSB 10u +#define SYSTEM_RING_OSC_DBG_SAH_EN_B_WIDTH 1u +#define SYSTEM_RING_OSC_DBG_SAH_EN_B_READ_ACCESS 1u +#define SYSTEM_RING_OSC_DBG_SAH_EN_B_WRITE_ACCESS 1u +#define SYSTEM_RING_OSC_DBG_SAH_EN_B_RESET 0x00000000ul +#define SYSTEM_RING_OSC_DBG_SAH_EN_B_FIELD_MASK 0x00000400ul +#define SYSTEM_RING_OSC_DBG_SAH_EN_B_GET(x) (((x) & 0x00000400ul) >> 10) +#define SYSTEM_RING_OSC_DBG_SAH_EN_B_SET(x) (((x) << 10) & 0x00000400ul) +#define SYSTEM_RING_OSC_DBG_SAH_EN_B_MODIFY(r, x) ((((x) << 10) & 0x00000400ul) | ((r) & 0xFFFFFBFFul)) + +/* Register: SYSTEM.cpu_divider */ +#define SYSTEM_CPU_DIVIDER_ADDRESS 0x000000A0ul +#define SYSTEM_CPU_DIVIDER_BYTE_ADDRESS 0x000000A0ul +#define SYSTEM_CPU_DIVIDER_OFFSET 0x000000A0ul +#define SYSTEM_CPU_DIVIDER_BYTE_OFFSET 0x000000A0ul +#define SYSTEM_CPU_DIVIDER_SIZE 0x00000004ul +#define SYSTEM_CPU_DIVIDER_BYTE_SIZE 0x00000004ul +#define SYSTEM_CPU_DIVIDER_READ_ACCESS 1u +#define SYSTEM_CPU_DIVIDER_WRITE_ACCESS 1u +#define SYSTEM_CPU_DIVIDER_RESET_VALUE 0x0000001Ful +#define SYSTEM_CPU_DIVIDER_RESET_MASK 0x0000001Ful +#define SYSTEM_CPU_DIVIDER_READ_MASK 0x0000001Ful +#define SYSTEM_CPU_DIVIDER_WRITE_MASK 0x0000001Ful + +/* Field: SYSTEM_CPU_DIVIDER.count */ +#define SYSTEM_CPU_DIVIDER_COUNT_MSB 3u +#define SYSTEM_CPU_DIVIDER_COUNT_LSB 0u +#define SYSTEM_CPU_DIVIDER_COUNT_WIDTH 4u +#define SYSTEM_CPU_DIVIDER_COUNT_READ_ACCESS 1u +#define SYSTEM_CPU_DIVIDER_COUNT_WRITE_ACCESS 1u +#define SYSTEM_CPU_DIVIDER_COUNT_RESET 0x0000000Ful +#define SYSTEM_CPU_DIVIDER_COUNT_FIELD_MASK 0x0000000Ful +#define SYSTEM_CPU_DIVIDER_COUNT_GET(x) ((x) & 0x0000000Ful) +#define SYSTEM_CPU_DIVIDER_COUNT_SET(x) ((x) & 0x0000000Ful) +#define SYSTEM_CPU_DIVIDER_COUNT_MODIFY(r, x) ((((x) << 0) & 0x0000000Ful) | ((r) & 0xFFFFFFF0ul)) + +/* Field: SYSTEM_CPU_DIVIDER.div_enable */ +#define SYSTEM_CPU_DIVIDER_DIV_ENABLE_MSB 4u +#define SYSTEM_CPU_DIVIDER_DIV_ENABLE_LSB 4u +#define SYSTEM_CPU_DIVIDER_DIV_ENABLE_WIDTH 1u +#define SYSTEM_CPU_DIVIDER_DIV_ENABLE_READ_ACCESS 1u +#define SYSTEM_CPU_DIVIDER_DIV_ENABLE_WRITE_ACCESS 1u +#define SYSTEM_CPU_DIVIDER_DIV_ENABLE_RESET 0x00000001ul +#define SYSTEM_CPU_DIVIDER_DIV_ENABLE_FIELD_MASK 0x00000010ul +#define SYSTEM_CPU_DIVIDER_DIV_ENABLE_GET(x) (((x) & 0x00000010ul) >> 4) +#define SYSTEM_CPU_DIVIDER_DIV_ENABLE_SET(x) (((x) << 4) & 0x00000010ul) +#define SYSTEM_CPU_DIVIDER_DIV_ENABLE_MODIFY(r, x) ((((x) << 4) & 0x00000010ul) | ((r) & 0xFFFFFFEFul)) + +/* Register: SYSTEM.system_divider */ +#define SYSTEM_SYSTEM_DIVIDER_ADDRESS 0x000000A8ul +#define SYSTEM_SYSTEM_DIVIDER_BYTE_ADDRESS 0x000000A8ul +#define SYSTEM_SYSTEM_DIVIDER_OFFSET 0x000000A8ul +#define SYSTEM_SYSTEM_DIVIDER_BYTE_OFFSET 0x000000A8ul +#define SYSTEM_SYSTEM_DIVIDER_SIZE 0x00000004ul +#define SYSTEM_SYSTEM_DIVIDER_BYTE_SIZE 0x00000004ul +#define SYSTEM_SYSTEM_DIVIDER_READ_ACCESS 1u +#define SYSTEM_SYSTEM_DIVIDER_WRITE_ACCESS 1u +#define SYSTEM_SYSTEM_DIVIDER_RESET_VALUE 0x0000001Ful +#define SYSTEM_SYSTEM_DIVIDER_RESET_MASK 0x0000001Ful +#define SYSTEM_SYSTEM_DIVIDER_READ_MASK 0x0000001Ful +#define SYSTEM_SYSTEM_DIVIDER_WRITE_MASK 0x0000001Ful + +/* Field: SYSTEM_SYSTEM_DIVIDER.count */ +#define SYSTEM_SYSTEM_DIVIDER_COUNT_MSB 3u +#define SYSTEM_SYSTEM_DIVIDER_COUNT_LSB 0u +#define SYSTEM_SYSTEM_DIVIDER_COUNT_WIDTH 4u +#define SYSTEM_SYSTEM_DIVIDER_COUNT_READ_ACCESS 1u +#define SYSTEM_SYSTEM_DIVIDER_COUNT_WRITE_ACCESS 1u +#define SYSTEM_SYSTEM_DIVIDER_COUNT_RESET 0x0000000Ful +#define SYSTEM_SYSTEM_DIVIDER_COUNT_FIELD_MASK 0x0000000Ful +#define SYSTEM_SYSTEM_DIVIDER_COUNT_GET(x) ((x) & 0x0000000Ful) +#define SYSTEM_SYSTEM_DIVIDER_COUNT_SET(x) ((x) & 0x0000000Ful) +#define SYSTEM_SYSTEM_DIVIDER_COUNT_MODIFY(r, x) ((((x) << 0) & 0x0000000Ful) | ((r) & 0xFFFFFFF0ul)) + +/* Field: SYSTEM_SYSTEM_DIVIDER.div_enable */ +#define SYSTEM_SYSTEM_DIVIDER_DIV_ENABLE_MSB 4u +#define SYSTEM_SYSTEM_DIVIDER_DIV_ENABLE_LSB 4u +#define SYSTEM_SYSTEM_DIVIDER_DIV_ENABLE_WIDTH 1u +#define SYSTEM_SYSTEM_DIVIDER_DIV_ENABLE_READ_ACCESS 1u +#define SYSTEM_SYSTEM_DIVIDER_DIV_ENABLE_WRITE_ACCESS 1u +#define SYSTEM_SYSTEM_DIVIDER_DIV_ENABLE_RESET 0x00000001ul +#define SYSTEM_SYSTEM_DIVIDER_DIV_ENABLE_FIELD_MASK 0x00000010ul +#define SYSTEM_SYSTEM_DIVIDER_DIV_ENABLE_GET(x) (((x) & 0x00000010ul) >> 4) +#define SYSTEM_SYSTEM_DIVIDER_DIV_ENABLE_SET(x) (((x) << 4) & 0x00000010ul) +#define SYSTEM_SYSTEM_DIVIDER_DIV_ENABLE_MODIFY(r, x) ((((x) << 4) & 0x00000010ul) | ((r) & 0xFFFFFFEFul)) + +/* Register: SYSTEM.periph_divider */ +#define SYSTEM_PERIPH_DIVIDER_ADDRESS 0x000000B0ul +#define SYSTEM_PERIPH_DIVIDER_BYTE_ADDRESS 0x000000B0ul +#define SYSTEM_PERIPH_DIVIDER_OFFSET 0x000000B0ul +#define SYSTEM_PERIPH_DIVIDER_BYTE_OFFSET 0x000000B0ul +#define SYSTEM_PERIPH_DIVIDER_SIZE 0x00000004ul +#define SYSTEM_PERIPH_DIVIDER_BYTE_SIZE 0x00000004ul +#define SYSTEM_PERIPH_DIVIDER_READ_ACCESS 1u +#define SYSTEM_PERIPH_DIVIDER_WRITE_ACCESS 1u +#define SYSTEM_PERIPH_DIVIDER_RESET_VALUE 0x0000001Ful +#define SYSTEM_PERIPH_DIVIDER_RESET_MASK 0x0000001Ful +#define SYSTEM_PERIPH_DIVIDER_READ_MASK 0x0000001Ful +#define SYSTEM_PERIPH_DIVIDER_WRITE_MASK 0x0000001Ful + +/* Field: SYSTEM_PERIPH_DIVIDER.count */ +#define SYSTEM_PERIPH_DIVIDER_COUNT_MSB 3u +#define SYSTEM_PERIPH_DIVIDER_COUNT_LSB 0u +#define SYSTEM_PERIPH_DIVIDER_COUNT_WIDTH 4u +#define SYSTEM_PERIPH_DIVIDER_COUNT_READ_ACCESS 1u +#define SYSTEM_PERIPH_DIVIDER_COUNT_WRITE_ACCESS 1u +#define SYSTEM_PERIPH_DIVIDER_COUNT_RESET 0x0000000Ful +#define SYSTEM_PERIPH_DIVIDER_COUNT_FIELD_MASK 0x0000000Ful +#define SYSTEM_PERIPH_DIVIDER_COUNT_GET(x) ((x) & 0x0000000Ful) +#define SYSTEM_PERIPH_DIVIDER_COUNT_SET(x) ((x) & 0x0000000Ful) +#define SYSTEM_PERIPH_DIVIDER_COUNT_MODIFY(r, x) ((((x) << 0) & 0x0000000Ful) | ((r) & 0xFFFFFFF0ul)) + +/* Field: SYSTEM_PERIPH_DIVIDER.div_enable */ +#define SYSTEM_PERIPH_DIVIDER_DIV_ENABLE_MSB 4u +#define SYSTEM_PERIPH_DIVIDER_DIV_ENABLE_LSB 4u +#define SYSTEM_PERIPH_DIVIDER_DIV_ENABLE_WIDTH 1u +#define SYSTEM_PERIPH_DIVIDER_DIV_ENABLE_READ_ACCESS 1u +#define SYSTEM_PERIPH_DIVIDER_DIV_ENABLE_WRITE_ACCESS 1u +#define SYSTEM_PERIPH_DIVIDER_DIV_ENABLE_RESET 0x00000001ul +#define SYSTEM_PERIPH_DIVIDER_DIV_ENABLE_FIELD_MASK 0x00000010ul +#define SYSTEM_PERIPH_DIVIDER_DIV_ENABLE_GET(x) (((x) & 0x00000010ul) >> 4) +#define SYSTEM_PERIPH_DIVIDER_DIV_ENABLE_SET(x) (((x) << 4) & 0x00000010ul) +#define SYSTEM_PERIPH_DIVIDER_DIV_ENABLE_MODIFY(r, x) ((((x) << 4) & 0x00000010ul) | ((r) & 0xFFFFFFEFul)) + +/* Register: SYSTEM.tsense_ctrl */ +#define SYSTEM_TSENSE_CTRL_ADDRESS 0x000000B8ul +#define SYSTEM_TSENSE_CTRL_BYTE_ADDRESS 0x000000B8ul +#define SYSTEM_TSENSE_CTRL_OFFSET 0x000000B8ul +#define SYSTEM_TSENSE_CTRL_BYTE_OFFSET 0x000000B8ul +#define SYSTEM_TSENSE_CTRL_SIZE 0x00000004ul +#define SYSTEM_TSENSE_CTRL_BYTE_SIZE 0x00000004ul +#define SYSTEM_TSENSE_CTRL_READ_ACCESS 1u +#define SYSTEM_TSENSE_CTRL_WRITE_ACCESS 1u +#define SYSTEM_TSENSE_CTRL_RESET_VALUE 0x00000010ul +#define SYSTEM_TSENSE_CTRL_RESET_MASK 0x00000FFFul +#define SYSTEM_TSENSE_CTRL_READ_MASK 0x00000FFFul +#define SYSTEM_TSENSE_CTRL_WRITE_MASK 0x00000FFFul + +/* Field: SYSTEM_TSENSE_CTRL.conv */ +#define SYSTEM_TSENSE_CTRL_CONV_MSB 0u +#define SYSTEM_TSENSE_CTRL_CONV_LSB 0u +#define SYSTEM_TSENSE_CTRL_CONV_WIDTH 1u +#define SYSTEM_TSENSE_CTRL_CONV_READ_ACCESS 1u +#define SYSTEM_TSENSE_CTRL_CONV_WRITE_ACCESS 1u +#define SYSTEM_TSENSE_CTRL_CONV_RESET 0x00000000ul +#define SYSTEM_TSENSE_CTRL_CONV_FIELD_MASK 0x00000001ul +#define SYSTEM_TSENSE_CTRL_CONV_GET(x) ((x) & 0x00000001ul) +#define SYSTEM_TSENSE_CTRL_CONV_SET(x) ((x) & 0x00000001ul) +#define SYSTEM_TSENSE_CTRL_CONV_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Field: SYSTEM_TSENSE_CTRL.sen_en */ +#define SYSTEM_TSENSE_CTRL_SEN_EN_MSB 1u +#define SYSTEM_TSENSE_CTRL_SEN_EN_LSB 1u +#define SYSTEM_TSENSE_CTRL_SEN_EN_WIDTH 1u +#define SYSTEM_TSENSE_CTRL_SEN_EN_READ_ACCESS 1u +#define SYSTEM_TSENSE_CTRL_SEN_EN_WRITE_ACCESS 1u +#define SYSTEM_TSENSE_CTRL_SEN_EN_RESET 0x00000000ul +#define SYSTEM_TSENSE_CTRL_SEN_EN_FIELD_MASK 0x00000002ul +#define SYSTEM_TSENSE_CTRL_SEN_EN_GET(x) (((x) & 0x00000002ul) >> 1) +#define SYSTEM_TSENSE_CTRL_SEN_EN_SET(x) (((x) << 1) & 0x00000002ul) +#define SYSTEM_TSENSE_CTRL_SEN_EN_MODIFY(r, x) ((((x) << 1) & 0x00000002ul) | ((r) & 0xFFFFFFFDul)) + +/* Field: SYSTEM_TSENSE_CTRL.sen_sel */ +#define SYSTEM_TSENSE_CTRL_SEN_SEL_MSB 3u +#define SYSTEM_TSENSE_CTRL_SEN_SEL_LSB 2u +#define SYSTEM_TSENSE_CTRL_SEN_SEL_WIDTH 2u +#define SYSTEM_TSENSE_CTRL_SEN_SEL_READ_ACCESS 1u +#define SYSTEM_TSENSE_CTRL_SEN_SEL_WRITE_ACCESS 1u +#define SYSTEM_TSENSE_CTRL_SEN_SEL_RESET 0x00000000ul +#define SYSTEM_TSENSE_CTRL_SEN_SEL_FIELD_MASK 0x0000000Cul +#define SYSTEM_TSENSE_CTRL_SEN_SEL_GET(x) (((x) & 0x0000000Cul) >> 2) +#define SYSTEM_TSENSE_CTRL_SEN_SEL_SET(x) (((x) << 2) & 0x0000000Cul) +#define SYSTEM_TSENSE_CTRL_SEN_SEL_MODIFY(r, x) ((((x) << 2) & 0x0000000Cul) | ((r) & 0xFFFFFFF3ul)) + +/* Field: SYSTEM_TSENSE_CTRL.clk_div */ +#define SYSTEM_TSENSE_CTRL_CLK_DIV_MSB 11u +#define SYSTEM_TSENSE_CTRL_CLK_DIV_LSB 4u +#define SYSTEM_TSENSE_CTRL_CLK_DIV_WIDTH 8u +#define SYSTEM_TSENSE_CTRL_CLK_DIV_READ_ACCESS 1u +#define SYSTEM_TSENSE_CTRL_CLK_DIV_WRITE_ACCESS 1u +#define SYSTEM_TSENSE_CTRL_CLK_DIV_RESET 0x00000001ul +#define SYSTEM_TSENSE_CTRL_CLK_DIV_FIELD_MASK 0x00000FF0ul +#define SYSTEM_TSENSE_CTRL_CLK_DIV_GET(x) (((x) & 0x00000FF0ul) >> 4) +#define SYSTEM_TSENSE_CTRL_CLK_DIV_SET(x) (((x) << 4) & 0x00000FF0ul) +#define SYSTEM_TSENSE_CTRL_CLK_DIV_MODIFY(r, x) ((((x) << 4) & 0x00000FF0ul) | ((r) & 0xFFFFF00Ful)) + +/* Register: SYSTEM.tsense_status */ +#define SYSTEM_TSENSE_STATUS_ADDRESS 0x000000C0ul +#define SYSTEM_TSENSE_STATUS_BYTE_ADDRESS 0x000000C0ul +#define SYSTEM_TSENSE_STATUS_OFFSET 0x000000C0ul +#define SYSTEM_TSENSE_STATUS_BYTE_OFFSET 0x000000C0ul +#define SYSTEM_TSENSE_STATUS_SIZE 0x00000004ul +#define SYSTEM_TSENSE_STATUS_BYTE_SIZE 0x00000004ul +#define SYSTEM_TSENSE_STATUS_READ_ACCESS 1u +#define SYSTEM_TSENSE_STATUS_WRITE_ACCESS 0u +#define SYSTEM_TSENSE_STATUS_RESET_VALUE 0x00000000ul +#define SYSTEM_TSENSE_STATUS_RESET_MASK 0x0000001Ful +#define SYSTEM_TSENSE_STATUS_READ_MASK 0x0000001Ful +#define SYSTEM_TSENSE_STATUS_WRITE_MASK 0x00000000ul + +/* Field: SYSTEM_TSENSE_STATUS.data */ +#define SYSTEM_TSENSE_STATUS_DATA_MSB 3u +#define SYSTEM_TSENSE_STATUS_DATA_LSB 0u +#define SYSTEM_TSENSE_STATUS_DATA_WIDTH 4u +#define SYSTEM_TSENSE_STATUS_DATA_READ_ACCESS 1u +#define SYSTEM_TSENSE_STATUS_DATA_WRITE_ACCESS 0u +#define SYSTEM_TSENSE_STATUS_DATA_RESET 0x00000000ul +#define SYSTEM_TSENSE_STATUS_DATA_FIELD_MASK 0x0000000Ful +#define SYSTEM_TSENSE_STATUS_DATA_GET(x) ((x) & 0x0000000Ful) +#define SYSTEM_TSENSE_STATUS_DATA_SET(x) ((x) & 0x0000000Ful) +#define SYSTEM_TSENSE_STATUS_DATA_MODIFY(r, x) ((((x) << 0) & 0x0000000Ful) | ((r) & 0xFFFFFFF0ul)) + +/* Field: SYSTEM_TSENSE_STATUS.valid */ +#define SYSTEM_TSENSE_STATUS_VALID_MSB 4u +#define SYSTEM_TSENSE_STATUS_VALID_LSB 4u +#define SYSTEM_TSENSE_STATUS_VALID_WIDTH 1u +#define SYSTEM_TSENSE_STATUS_VALID_READ_ACCESS 1u +#define SYSTEM_TSENSE_STATUS_VALID_WRITE_ACCESS 0u +#define SYSTEM_TSENSE_STATUS_VALID_RESET 0x00000000ul +#define SYSTEM_TSENSE_STATUS_VALID_FIELD_MASK 0x00000010ul +#define SYSTEM_TSENSE_STATUS_VALID_GET(x) (((x) & 0x00000010ul) >> 4) +#define SYSTEM_TSENSE_STATUS_VALID_SET(x) (((x) << 4) & 0x00000010ul) +#define SYSTEM_TSENSE_STATUS_VALID_MODIFY(r, x) ((((x) << 4) & 0x00000010ul) | ((r) & 0xFFFFFFEFul)) + +/* Block-level typedef: SYSTEM */ +typedef struct { + volatile uint32_t Version; /* Offset 0x0 (R) */ + uint8_t _pad0[0x4]; /* 0x4..0x7 reserved */ + volatile uint32_t SystemConfig; /* Offset 0x8 (R/W) */ + uint8_t _pad1[0x4]; /* 0xC..0xF reserved */ + volatile uint32_t watchdog_count; /* Offset 0x10 (R/W) */ + uint8_t _pad2[0x4]; /* 0x14..0x17 reserved */ + volatile uint32_t Watchdog; /* Offset 0x18 (R/W) */ + uint8_t _pad3[0x4]; /* 0x1C..0x1F reserved */ + volatile uint32_t SysInterrupt; /* Offset 0x20 (R/W) */ + uint8_t _pad4[0x4]; /* 0x24..0x27 reserved */ + volatile uint32_t SoftReset; /* Offset 0x28 (R/W) */ + uint8_t _pad5[0x4]; /* 0x2C..0x2F reserved */ + volatile uint32_t ResetCause; /* Offset 0x30 (R) */ + uint8_t _pad6[0x4]; /* 0x34..0x37 reserved */ + volatile uint32_t PowerDomainReq; /* Offset 0x38 (R/W) */ + uint8_t _pad7[0x4]; /* 0x3C..0x3F reserved */ + volatile uint32_t PowerDomainAck; /* Offset 0x40 (R) */ + uint8_t _pad8[0x4]; /* 0x44..0x47 reserved */ + volatile uint32_t PowerGood; /* Offset 0x48 (R/W) */ + uint8_t _pad9[0x4]; /* 0x4C..0x4F reserved */ + volatile uint32_t PowerStatus; /* Offset 0x50 (R) */ + uint8_t _pad10[0x4]; /* 0x54..0x57 reserved */ + volatile uint32_t SpinLock; /* Offset 0x58 (R/W) */ + uint8_t _pad11[0x4]; /* 0x5C..0x5F reserved */ + volatile uint32_t ChipMode; /* Offset 0x60 (R/W) */ + uint8_t _pad12[0x4]; /* 0x64..0x67 reserved */ + volatile uint32_t Mailbox0; /* Offset 0x68 (R/W) */ + uint8_t _pad13[0x4]; /* 0x6C..0x6F reserved */ + volatile uint32_t Mailbox1; /* Offset 0x70 (R/W) */ + uint8_t _pad14[0x4]; /* 0x74..0x77 reserved */ + volatile uint32_t GPIO_OE; /* Offset 0x78 (R/W) */ + uint8_t _pad15[0x4]; /* 0x7C..0x7F reserved */ + volatile uint32_t GPIO_I; /* Offset 0x80 (R) */ + uint8_t _pad16[0x4]; /* 0x84..0x87 reserved */ + volatile uint32_t GPIO_O; /* Offset 0x88 (R/W) */ + uint8_t _pad17[0x4]; /* 0x8C..0x8F reserved */ + volatile uint32_t GPIO_Interrupt_Enable; /* Offset 0x90 (R/W) */ + uint8_t _pad18[0x4]; /* 0x94..0x97 reserved */ + volatile uint32_t ring_osc; /* Offset 0x98 (R/W) */ + uint8_t _pad19[0x4]; /* 0x9C..0x9F reserved */ + volatile uint32_t cpu_divider; /* Offset 0xA0 (R/W) */ + uint8_t _pad20[0x4]; /* 0xA4..0xA7 reserved */ + volatile uint32_t system_divider; /* Offset 0xA8 (R/W) */ + uint8_t _pad21[0x4]; /* 0xAC..0xAF reserved */ + volatile uint32_t periph_divider; /* Offset 0xB0 (R/W) */ + uint8_t _pad22[0x4]; /* 0xB4..0xB7 reserved */ + volatile uint32_t tsense_ctrl; /* Offset 0xB8 (R/W) */ + uint8_t _pad23[0x4]; /* 0xBC..0xBF reserved */ + volatile uint32_t tsense_status; /* Offset 0xC0 (R) */ +} System_t, *PTR_System_t; + +#ifdef __cplusplus +} +#endif + +#endif /* _SYSTEM_H_ */ diff --git a/erbium-hal/include/hwinc/top.h b/erbium-hal/include/hwinc/top.h new file mode 100644 index 000000000..0cdc95075 --- /dev/null +++ b/erbium-hal/include/hwinc/top.h @@ -0,0 +1,79 @@ +/* Auto-generated by top2h.py from top_cpu_mm.rdl. Do not edit. */ +#ifndef _TOP_H_ +#define _TOP_H_ + +/* ============================================================ */ +/* Top map: ErbiumCPU_MemoryMap */ +/* ============================================================ */ + +/* Instance: System_Reg system_registers */ +#define ERBIUM_TOP_SYSTEM_REGISTERS_BASE 0x02000000ul +#define ERBIUM_TOP_SYSTEM_REGISTERS_SIZE 0x00000094ul +#define ERBIUM_TOP_SYSTEM_REGISTERS_END 0x02000094ul + +/* Instance: axi2mram_bridge_registers mram_registers */ +#define ERBIUM_TOP_MRAM_REGISTERS_BASE 0x02001000ul +#define ERBIUM_TOP_MRAM_REGISTERS_SIZE 0x00000470ul +#define ERBIUM_TOP_MRAM_REGISTERS_END 0x02001470ul + +/* Instance: I2C_Reg i2c_registers */ +#define ERBIUM_TOP_I2C_REGISTERS_BASE 0x02002000ul +#define ERBIUM_TOP_I2C_REGISTERS_SIZE 0x00000024ul +#define ERBIUM_TOP_I2C_REGISTERS_END 0x02002024ul + +/* Instance: QSPI_Reg qspi_registers */ +#define ERBIUM_TOP_QSPI_REGISTERS_BASE 0x02003000ul +#define ERBIUM_TOP_QSPI_REGISTERS_SIZE 0x00000064ul +#define ERBIUM_TOP_QSPI_REGISTERS_END 0x02003064ul + +/* Instance: UART_Reg uart_registers */ +#define ERBIUM_TOP_UART_REGISTERS_BASE 0x02004000ul +#define ERBIUM_TOP_UART_REGISTERS_SIZE 0x00000044ul +#define ERBIUM_TOP_UART_REGISTERS_END 0x02004044ul + +/* Instance: memories ROMRAM */ +#define ERBIUM_TOP_ROMRAM_BASE 0x02008000ul +#define ERBIUM_TOP_ROMRAM_SIZE 0x00005000ul +#define ERBIUM_TOP_ROMRAM_END 0x0200D000ul + +/* Instance: external bootrom ROM */ +#define ERBIUM_TOP_BOOTROM_BASE 0x02008000ul +#define ERBIUM_TOP_BOOTROM_SIZE 0x00002000ul +#define ERBIUM_TOP_BOOTROM_END 0x0200A000ul + +/* Instance: external sram SRAM */ +#define ERBIUM_TOP_SRAM_BASE 0x0200C000ul +#define ERBIUM_TOP_SRAM_SIZE 0x00001000ul +#define ERBIUM_TOP_SRAM_END 0x0200D000ul + +/* Instance: SCCR_Reg xspi_registers */ +#define ERBIUM_TOP_XSPI_REGISTERS_BASE 0x0200F000ul +#define ERBIUM_TOP_XSPI_REGISTERS_SIZE 0x0000001Cul +#define ERBIUM_TOP_XSPI_REGISTERS_END 0x0200F01Cul + +/* Instance: config nic_config */ +#define ERBIUM_TOP_NIC_CONFIG_BASE 0xFE000000ul +#define ERBIUM_TOP_NIC_CONFIG_SIZE 0x00016000ul +#define ERBIUM_TOP_NIC_CONFIG_END 0xFE016000ul + +/* Instance: external ni700_registers ni700_registers */ +#define ERBIUM_TOP_NI700_REGISTERS_BASE 0xFE000000ul +#define ERBIUM_TOP_NI700_REGISTERS_SIZE 0x00016000ul +#define ERBIUM_TOP_NI700_REGISTERS_END 0xFE016000ul + +/* Instance: external mram mram */ +#define ERBIUM_TOP_MRAM_BASE 0x40000000ul +#define ERBIUM_TOP_MRAM_SIZE 0x01000000ul +#define ERBIUM_TOP_MRAM_END 0x41000000ul + +/* Instance: Erbium_ESR cpu_registers */ +#define ERBIUM_TOP_CPU_REGISTERS_BASE 0x80000000ul +#define ERBIUM_TOP_CPU_REGISTERS_SIZE 0x00F40318ul +#define ERBIUM_TOP_CPU_REGISTERS_END 0x80F40318ul + +/* Instance: PLIC_cpu plic */ +#define ERBIUM_TOP_PLIC_BASE 0xA0000000ul +#define ERBIUM_TOP_PLIC_SIZE 0x0021F008ul +#define ERBIUM_TOP_PLIC_END 0xA021F008ul + +#endif /* _TOP_H_ */ diff --git a/erbium-hal/include/hwinc/uart.h b/erbium-hal/include/hwinc/uart.h new file mode 100644 index 000000000..2f6c42b4a --- /dev/null +++ b/erbium-hal/include/hwinc/uart.h @@ -0,0 +1,490 @@ +/* Auto-generated by rdl2hal.py from SystemRDL. Do not edit. */ +#ifndef _UART_H_ +#define _UART_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* ============================================================ */ +/* Block: UART_Reg (macro prefix: UART) */ +/* ============================================================ */ + +/* Register: UART.BaudReg */ +#define UART_BAUDREG_ADDRESS 0x00000000ul +#define UART_BAUDREG_BYTE_ADDRESS 0x00000000ul +#define UART_BAUDREG_OFFSET 0x00000000ul +#define UART_BAUDREG_BYTE_OFFSET 0x00000000ul +#define UART_BAUDREG_SIZE 0x00000004ul +#define UART_BAUDREG_BYTE_SIZE 0x00000004ul +#define UART_BAUDREG_READ_ACCESS 1u +#define UART_BAUDREG_WRITE_ACCESS 1u +#define UART_BAUDREG_RESET_VALUE 0x00000005ul +#define UART_BAUDREG_RESET_MASK 0x0000FFFFul +#define UART_BAUDREG_READ_MASK 0x0000FFFFul +#define UART_BAUDREG_WRITE_MASK 0x0000FFFFul + +/* Field: UART_BAUDREG.baud_value */ +#define UART_BAUDREG_BAUD_VALUE_MSB 15u +#define UART_BAUDREG_BAUD_VALUE_LSB 0u +#define UART_BAUDREG_BAUD_VALUE_WIDTH 16u +#define UART_BAUDREG_BAUD_VALUE_READ_ACCESS 1u +#define UART_BAUDREG_BAUD_VALUE_WRITE_ACCESS 1u +#define UART_BAUDREG_BAUD_VALUE_RESET 0x00000005ul +#define UART_BAUDREG_BAUD_VALUE_FIELD_MASK 0x0000FFFFul +#define UART_BAUDREG_BAUD_VALUE_GET(x) ((x) & 0x0000FFFFul) +#define UART_BAUDREG_BAUD_VALUE_SET(x) ((x) & 0x0000FFFFul) +#define UART_BAUDREG_BAUD_VALUE_MODIFY(r, x) ((((x) << 0) & 0x0000FFFFul) | ((r) & 0xFFFF0000ul)) + +/* Register: UART.TxReg */ +#define UART_TXREG_ADDRESS 0x00000008ul +#define UART_TXREG_BYTE_ADDRESS 0x00000008ul +#define UART_TXREG_OFFSET 0x00000008ul +#define UART_TXREG_BYTE_OFFSET 0x00000008ul +#define UART_TXREG_SIZE 0x00000004ul +#define UART_TXREG_BYTE_SIZE 0x00000004ul +#define UART_TXREG_READ_ACCESS 0u +#define UART_TXREG_WRITE_ACCESS 1u +#define UART_TXREG_RESET_VALUE 0x00000000ul +#define UART_TXREG_RESET_MASK 0xFFFFFFFFul +#define UART_TXREG_READ_MASK 0x00000000ul +#define UART_TXREG_WRITE_MASK 0xFFFFFFFFul + +/* Field: UART_TXREG.data */ +#define UART_TXREG_DATA_MSB 31u +#define UART_TXREG_DATA_LSB 0u +#define UART_TXREG_DATA_WIDTH 32u +#define UART_TXREG_DATA_READ_ACCESS 0u +#define UART_TXREG_DATA_WRITE_ACCESS 1u +#define UART_TXREG_DATA_RESET 0x00000000ul +#define UART_TXREG_DATA_FIELD_MASK 0xFFFFFFFFul +#define UART_TXREG_DATA_GET(x) ((x) & 0xFFFFFFFFul) +#define UART_TXREG_DATA_SET(x) ((x) & 0xFFFFFFFFul) +#define UART_TXREG_DATA_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFul) | ((r) & 0x00000000ul)) + +/* Register: UART.RxReg */ +#define UART_RXREG_ADDRESS 0x00000010ul +#define UART_RXREG_BYTE_ADDRESS 0x00000010ul +#define UART_RXREG_OFFSET 0x00000010ul +#define UART_RXREG_BYTE_OFFSET 0x00000010ul +#define UART_RXREG_SIZE 0x00000004ul +#define UART_RXREG_BYTE_SIZE 0x00000004ul +#define UART_RXREG_READ_ACCESS 1u +#define UART_RXREG_WRITE_ACCESS 0u +#define UART_RXREG_RESET_VALUE 0x00000000ul +#define UART_RXREG_RESET_MASK 0xFFFFFFFFul +#define UART_RXREG_READ_MASK 0xFFFFFFFFul +#define UART_RXREG_WRITE_MASK 0x00000000ul + +/* Field: UART_RXREG.data */ +#define UART_RXREG_DATA_MSB 31u +#define UART_RXREG_DATA_LSB 0u +#define UART_RXREG_DATA_WIDTH 32u +#define UART_RXREG_DATA_READ_ACCESS 1u +#define UART_RXREG_DATA_WRITE_ACCESS 0u +#define UART_RXREG_DATA_RESET 0x00000000ul +#define UART_RXREG_DATA_FIELD_MASK 0xFFFFFFFFul +#define UART_RXREG_DATA_GET(x) ((x) & 0xFFFFFFFFul) +#define UART_RXREG_DATA_SET(x) ((x) & 0xFFFFFFFFul) +#define UART_RXREG_DATA_MODIFY(r, x) ((((x) << 0) & 0xFFFFFFFFul) | ((r) & 0x00000000ul)) + +/* Register: UART.StatusReg */ +#define UART_STATUSREG_ADDRESS 0x00000018ul +#define UART_STATUSREG_BYTE_ADDRESS 0x00000018ul +#define UART_STATUSREG_OFFSET 0x00000018ul +#define UART_STATUSREG_BYTE_OFFSET 0x00000018ul +#define UART_STATUSREG_SIZE 0x00000004ul +#define UART_STATUSREG_BYTE_SIZE 0x00000004ul +#define UART_STATUSREG_READ_ACCESS 1u +#define UART_STATUSREG_WRITE_ACCESS 0u +#define UART_STATUSREG_RESET_VALUE 0x00000000ul +#define UART_STATUSREG_RESET_MASK 0x000001FFul +#define UART_STATUSREG_READ_MASK 0x000001FFul +#define UART_STATUSREG_WRITE_MASK 0x00000000ul + +/* Field: UART_STATUSREG.tx_empty */ +#define UART_STATUSREG_TX_EMPTY_MSB 0u +#define UART_STATUSREG_TX_EMPTY_LSB 0u +#define UART_STATUSREG_TX_EMPTY_WIDTH 1u +#define UART_STATUSREG_TX_EMPTY_READ_ACCESS 1u +#define UART_STATUSREG_TX_EMPTY_WRITE_ACCESS 0u +#define UART_STATUSREG_TX_EMPTY_RESET 0x00000000ul +#define UART_STATUSREG_TX_EMPTY_FIELD_MASK 0x00000001ul +#define UART_STATUSREG_TX_EMPTY_GET(x) ((x) & 0x00000001ul) +#define UART_STATUSREG_TX_EMPTY_SET(x) ((x) & 0x00000001ul) +#define UART_STATUSREG_TX_EMPTY_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Field: UART_STATUSREG.tx_full */ +#define UART_STATUSREG_TX_FULL_MSB 1u +#define UART_STATUSREG_TX_FULL_LSB 1u +#define UART_STATUSREG_TX_FULL_WIDTH 1u +#define UART_STATUSREG_TX_FULL_READ_ACCESS 1u +#define UART_STATUSREG_TX_FULL_WRITE_ACCESS 0u +#define UART_STATUSREG_TX_FULL_RESET 0x00000000ul +#define UART_STATUSREG_TX_FULL_FIELD_MASK 0x00000002ul +#define UART_STATUSREG_TX_FULL_GET(x) (((x) & 0x00000002ul) >> 1) +#define UART_STATUSREG_TX_FULL_SET(x) (((x) << 1) & 0x00000002ul) +#define UART_STATUSREG_TX_FULL_MODIFY(r, x) ((((x) << 1) & 0x00000002ul) | ((r) & 0xFFFFFFFDul)) + +/* Field: UART_STATUSREG.rx_notEmpty */ +#define UART_STATUSREG_RX_NOTEMPTY_MSB 2u +#define UART_STATUSREG_RX_NOTEMPTY_LSB 2u +#define UART_STATUSREG_RX_NOTEMPTY_WIDTH 1u +#define UART_STATUSREG_RX_NOTEMPTY_READ_ACCESS 1u +#define UART_STATUSREG_RX_NOTEMPTY_WRITE_ACCESS 0u +#define UART_STATUSREG_RX_NOTEMPTY_RESET 0x00000000ul +#define UART_STATUSREG_RX_NOTEMPTY_FIELD_MASK 0x00000004ul +#define UART_STATUSREG_RX_NOTEMPTY_GET(x) (((x) & 0x00000004ul) >> 2) +#define UART_STATUSREG_RX_NOTEMPTY_SET(x) (((x) << 2) & 0x00000004ul) +#define UART_STATUSREG_RX_NOTEMPTY_MODIFY(r, x) ((((x) << 2) & 0x00000004ul) | ((r) & 0xFFFFFFFBul)) + +/* Field: UART_STATUSREG.rx_full */ +#define UART_STATUSREG_RX_FULL_MSB 3u +#define UART_STATUSREG_RX_FULL_LSB 3u +#define UART_STATUSREG_RX_FULL_WIDTH 1u +#define UART_STATUSREG_RX_FULL_READ_ACCESS 1u +#define UART_STATUSREG_RX_FULL_WRITE_ACCESS 0u +#define UART_STATUSREG_RX_FULL_RESET 0x00000000ul +#define UART_STATUSREG_RX_FULL_FIELD_MASK 0x00000008ul +#define UART_STATUSREG_RX_FULL_GET(x) (((x) & 0x00000008ul) >> 3) +#define UART_STATUSREG_RX_FULL_SET(x) (((x) << 3) & 0x00000008ul) +#define UART_STATUSREG_RX_FULL_MODIFY(r, x) ((((x) << 3) & 0x00000008ul) | ((r) & 0xFFFFFFF7ul)) + +/* Field: UART_STATUSREG.parity_error */ +#define UART_STATUSREG_PARITY_ERROR_MSB 4u +#define UART_STATUSREG_PARITY_ERROR_LSB 4u +#define UART_STATUSREG_PARITY_ERROR_WIDTH 1u +#define UART_STATUSREG_PARITY_ERROR_READ_ACCESS 1u +#define UART_STATUSREG_PARITY_ERROR_WRITE_ACCESS 0u +#define UART_STATUSREG_PARITY_ERROR_RESET 0x00000000ul +#define UART_STATUSREG_PARITY_ERROR_FIELD_MASK 0x00000010ul +#define UART_STATUSREG_PARITY_ERROR_GET(x) (((x) & 0x00000010ul) >> 4) +#define UART_STATUSREG_PARITY_ERROR_SET(x) (((x) << 4) & 0x00000010ul) +#define UART_STATUSREG_PARITY_ERROR_MODIFY(r, x) ((((x) << 4) & 0x00000010ul) | ((r) & 0xFFFFFFEFul)) + +/* Field: UART_STATUSREG.overrun_error */ +#define UART_STATUSREG_OVERRUN_ERROR_MSB 5u +#define UART_STATUSREG_OVERRUN_ERROR_LSB 5u +#define UART_STATUSREG_OVERRUN_ERROR_WIDTH 1u +#define UART_STATUSREG_OVERRUN_ERROR_READ_ACCESS 1u +#define UART_STATUSREG_OVERRUN_ERROR_WRITE_ACCESS 0u +#define UART_STATUSREG_OVERRUN_ERROR_RESET 0x00000000ul +#define UART_STATUSREG_OVERRUN_ERROR_FIELD_MASK 0x00000020ul +#define UART_STATUSREG_OVERRUN_ERROR_GET(x) (((x) & 0x00000020ul) >> 5) +#define UART_STATUSREG_OVERRUN_ERROR_SET(x) (((x) << 5) & 0x00000020ul) +#define UART_STATUSREG_OVERRUN_ERROR_MODIFY(r, x) ((((x) << 5) & 0x00000020ul) | ((r) & 0xFFFFFFDFul)) + +/* Field: UART_STATUSREG.frame_error */ +#define UART_STATUSREG_FRAME_ERROR_MSB 6u +#define UART_STATUSREG_FRAME_ERROR_LSB 6u +#define UART_STATUSREG_FRAME_ERROR_WIDTH 1u +#define UART_STATUSREG_FRAME_ERROR_READ_ACCESS 1u +#define UART_STATUSREG_FRAME_ERROR_WRITE_ACCESS 0u +#define UART_STATUSREG_FRAME_ERROR_RESET 0x00000000ul +#define UART_STATUSREG_FRAME_ERROR_FIELD_MASK 0x00000040ul +#define UART_STATUSREG_FRAME_ERROR_GET(x) (((x) & 0x00000040ul) >> 6) +#define UART_STATUSREG_FRAME_ERROR_SET(x) (((x) << 6) & 0x00000040ul) +#define UART_STATUSREG_FRAME_ERROR_MODIFY(r, x) ((((x) << 6) & 0x00000040ul) | ((r) & 0xFFFFFFBFul)) + +/* Field: UART_STATUSREG.break_error */ +#define UART_STATUSREG_BREAK_ERROR_MSB 7u +#define UART_STATUSREG_BREAK_ERROR_LSB 7u +#define UART_STATUSREG_BREAK_ERROR_WIDTH 1u +#define UART_STATUSREG_BREAK_ERROR_READ_ACCESS 1u +#define UART_STATUSREG_BREAK_ERROR_WRITE_ACCESS 0u +#define UART_STATUSREG_BREAK_ERROR_RESET 0x00000000ul +#define UART_STATUSREG_BREAK_ERROR_FIELD_MASK 0x00000080ul +#define UART_STATUSREG_BREAK_ERROR_GET(x) (((x) & 0x00000080ul) >> 7) +#define UART_STATUSREG_BREAK_ERROR_SET(x) (((x) << 7) & 0x00000080ul) +#define UART_STATUSREG_BREAK_ERROR_MODIFY(r, x) ((((x) << 7) & 0x00000080ul) | ((r) & 0xFFFFFF7Ful)) + +/* Field: UART_STATUSREG.rx_fifo_threshold */ +#define UART_STATUSREG_RX_FIFO_THRESHOLD_MSB 8u +#define UART_STATUSREG_RX_FIFO_THRESHOLD_LSB 8u +#define UART_STATUSREG_RX_FIFO_THRESHOLD_WIDTH 1u +#define UART_STATUSREG_RX_FIFO_THRESHOLD_READ_ACCESS 1u +#define UART_STATUSREG_RX_FIFO_THRESHOLD_WRITE_ACCESS 0u +#define UART_STATUSREG_RX_FIFO_THRESHOLD_RESET 0x00000000ul +#define UART_STATUSREG_RX_FIFO_THRESHOLD_FIELD_MASK 0x00000100ul +#define UART_STATUSREG_RX_FIFO_THRESHOLD_GET(x) (((x) & 0x00000100ul) >> 8) +#define UART_STATUSREG_RX_FIFO_THRESHOLD_SET(x) (((x) << 8) & 0x00000100ul) +#define UART_STATUSREG_RX_FIFO_THRESHOLD_MODIFY(r, x) ((((x) << 8) & 0x00000100ul) | ((r) & 0xFFFFFEFFul)) + +/* Register: UART.DelayReg */ +#define UART_DELAYREG_ADDRESS 0x00000020ul +#define UART_DELAYREG_BYTE_ADDRESS 0x00000020ul +#define UART_DELAYREG_OFFSET 0x00000020ul +#define UART_DELAYREG_BYTE_OFFSET 0x00000020ul +#define UART_DELAYREG_SIZE 0x00000004ul +#define UART_DELAYREG_BYTE_SIZE 0x00000004ul +#define UART_DELAYREG_READ_ACCESS 1u +#define UART_DELAYREG_WRITE_ACCESS 1u +#define UART_DELAYREG_RESET_VALUE 0x00000000ul +#define UART_DELAYREG_RESET_MASK 0x0000FFFFul +#define UART_DELAYREG_READ_MASK 0x0000FFFFul +#define UART_DELAYREG_WRITE_MASK 0x0000FFFFul + +/* Field: UART_DELAYREG.delay_control */ +#define UART_DELAYREG_DELAY_CONTROL_MSB 15u +#define UART_DELAYREG_DELAY_CONTROL_LSB 0u +#define UART_DELAYREG_DELAY_CONTROL_WIDTH 16u +#define UART_DELAYREG_DELAY_CONTROL_READ_ACCESS 1u +#define UART_DELAYREG_DELAY_CONTROL_WRITE_ACCESS 1u +#define UART_DELAYREG_DELAY_CONTROL_RESET 0x00000000ul +#define UART_DELAYREG_DELAY_CONTROL_FIELD_MASK 0x0000FFFFul +#define UART_DELAYREG_DELAY_CONTROL_GET(x) ((x) & 0x0000FFFFul) +#define UART_DELAYREG_DELAY_CONTROL_SET(x) ((x) & 0x0000FFFFul) +#define UART_DELAYREG_DELAY_CONTROL_MODIFY(r, x) ((((x) << 0) & 0x0000FFFFul) | ((r) & 0xFFFF0000ul)) + +/* Register: UART.ControlReg */ +#define UART_CONTROLREG_ADDRESS 0x00000028ul +#define UART_CONTROLREG_BYTE_ADDRESS 0x00000028ul +#define UART_CONTROLREG_OFFSET 0x00000028ul +#define UART_CONTROLREG_BYTE_OFFSET 0x00000028ul +#define UART_CONTROLREG_SIZE 0x00000004ul +#define UART_CONTROLREG_BYTE_SIZE 0x00000004ul +#define UART_CONTROLREG_READ_ACCESS 1u +#define UART_CONTROLREG_WRITE_ACCESS 1u +#define UART_CONTROLREG_RESET_VALUE 0x00000100ul +#define UART_CONTROLREG_RESET_MASK 0x000007FEul +#define UART_CONTROLREG_READ_MASK 0x000007FEul +#define UART_CONTROLREG_WRITE_MASK 0x000007FEul + +/* Field: UART_CONTROLREG.stopbits */ +#define UART_CONTROLREG_STOPBITS_MSB 2u +#define UART_CONTROLREG_STOPBITS_LSB 1u +#define UART_CONTROLREG_STOPBITS_WIDTH 2u +#define UART_CONTROLREG_STOPBITS_READ_ACCESS 1u +#define UART_CONTROLREG_STOPBITS_WRITE_ACCESS 1u +#define UART_CONTROLREG_STOPBITS_RESET 0x00000000ul +#define UART_CONTROLREG_STOPBITS_FIELD_MASK 0x00000006ul +#define UART_CONTROLREG_STOPBITS_GET(x) (((x) & 0x00000006ul) >> 1) +#define UART_CONTROLREG_STOPBITS_SET(x) (((x) << 1) & 0x00000006ul) +#define UART_CONTROLREG_STOPBITS_MODIFY(r, x) ((((x) << 1) & 0x00000006ul) | ((r) & 0xFFFFFFF9ul)) + +/* Field: UART_CONTROLREG.parity */ +#define UART_CONTROLREG_PARITY_MSB 4u +#define UART_CONTROLREG_PARITY_LSB 3u +#define UART_CONTROLREG_PARITY_WIDTH 2u +#define UART_CONTROLREG_PARITY_READ_ACCESS 1u +#define UART_CONTROLREG_PARITY_WRITE_ACCESS 1u +#define UART_CONTROLREG_PARITY_RESET 0x00000000ul +#define UART_CONTROLREG_PARITY_FIELD_MASK 0x00000018ul +#define UART_CONTROLREG_PARITY_GET(x) (((x) & 0x00000018ul) >> 3) +#define UART_CONTROLREG_PARITY_SET(x) (((x) << 3) & 0x00000018ul) +#define UART_CONTROLREG_PARITY_MODIFY(r, x) ((((x) << 3) & 0x00000018ul) | ((r) & 0xFFFFFFE7ul)) + +/* Field: UART_CONTROLREG.charsize */ +#define UART_CONTROLREG_CHARSIZE_MSB 10u +#define UART_CONTROLREG_CHARSIZE_LSB 5u +#define UART_CONTROLREG_CHARSIZE_WIDTH 6u +#define UART_CONTROLREG_CHARSIZE_READ_ACCESS 1u +#define UART_CONTROLREG_CHARSIZE_WRITE_ACCESS 1u +#define UART_CONTROLREG_CHARSIZE_RESET 0x00000008ul +#define UART_CONTROLREG_CHARSIZE_FIELD_MASK 0x000007E0ul +#define UART_CONTROLREG_CHARSIZE_GET(x) (((x) & 0x000007E0ul) >> 5) +#define UART_CONTROLREG_CHARSIZE_SET(x) (((x) << 5) & 0x000007E0ul) +#define UART_CONTROLREG_CHARSIZE_MODIFY(r, x) ((((x) << 5) & 0x000007E0ul) | ((r) & 0xFFFFF81Ful)) + +/* Register: UART.InterruptEn */ +#define UART_INTERRUPTEN_ADDRESS 0x00000030ul +#define UART_INTERRUPTEN_BYTE_ADDRESS 0x00000030ul +#define UART_INTERRUPTEN_OFFSET 0x00000030ul +#define UART_INTERRUPTEN_BYTE_OFFSET 0x00000030ul +#define UART_INTERRUPTEN_SIZE 0x00000004ul +#define UART_INTERRUPTEN_BYTE_SIZE 0x00000004ul +#define UART_INTERRUPTEN_READ_ACCESS 1u +#define UART_INTERRUPTEN_WRITE_ACCESS 1u +#define UART_INTERRUPTEN_RESET_VALUE 0x00000000ul +#define UART_INTERRUPTEN_RESET_MASK 0x000001FFul +#define UART_INTERRUPTEN_READ_MASK 0x000001FFul +#define UART_INTERRUPTEN_WRITE_MASK 0x000001FFul + +/* Field: UART_INTERRUPTEN.tx_done_en */ +#define UART_INTERRUPTEN_TX_DONE_EN_MSB 0u +#define UART_INTERRUPTEN_TX_DONE_EN_LSB 0u +#define UART_INTERRUPTEN_TX_DONE_EN_WIDTH 1u +#define UART_INTERRUPTEN_TX_DONE_EN_READ_ACCESS 1u +#define UART_INTERRUPTEN_TX_DONE_EN_WRITE_ACCESS 1u +#define UART_INTERRUPTEN_TX_DONE_EN_RESET 0x00000000ul +#define UART_INTERRUPTEN_TX_DONE_EN_FIELD_MASK 0x00000001ul +#define UART_INTERRUPTEN_TX_DONE_EN_GET(x) ((x) & 0x00000001ul) +#define UART_INTERRUPTEN_TX_DONE_EN_SET(x) ((x) & 0x00000001ul) +#define UART_INTERRUPTEN_TX_DONE_EN_MODIFY(r, x) ((((x) << 0) & 0x00000001ul) | ((r) & 0xFFFFFFFEul)) + +/* Field: UART_INTERRUPTEN.tx_not_full_en */ +#define UART_INTERRUPTEN_TX_NOT_FULL_EN_MSB 1u +#define UART_INTERRUPTEN_TX_NOT_FULL_EN_LSB 1u +#define UART_INTERRUPTEN_TX_NOT_FULL_EN_WIDTH 1u +#define UART_INTERRUPTEN_TX_NOT_FULL_EN_READ_ACCESS 1u +#define UART_INTERRUPTEN_TX_NOT_FULL_EN_WRITE_ACCESS 1u +#define UART_INTERRUPTEN_TX_NOT_FULL_EN_RESET 0x00000000ul +#define UART_INTERRUPTEN_TX_NOT_FULL_EN_FIELD_MASK 0x00000002ul +#define UART_INTERRUPTEN_TX_NOT_FULL_EN_GET(x) (((x) & 0x00000002ul) >> 1) +#define UART_INTERRUPTEN_TX_NOT_FULL_EN_SET(x) (((x) << 1) & 0x00000002ul) +#define UART_INTERRUPTEN_TX_NOT_FULL_EN_MODIFY(r, x) ((((x) << 1) & 0x00000002ul) | ((r) & 0xFFFFFFFDul)) + +/* Field: UART_INTERRUPTEN.rx_not_full_en */ +#define UART_INTERRUPTEN_RX_NOT_FULL_EN_MSB 2u +#define UART_INTERRUPTEN_RX_NOT_FULL_EN_LSB 2u +#define UART_INTERRUPTEN_RX_NOT_FULL_EN_WIDTH 1u +#define UART_INTERRUPTEN_RX_NOT_FULL_EN_READ_ACCESS 1u +#define UART_INTERRUPTEN_RX_NOT_FULL_EN_WRITE_ACCESS 1u +#define UART_INTERRUPTEN_RX_NOT_FULL_EN_RESET 0x00000000ul +#define UART_INTERRUPTEN_RX_NOT_FULL_EN_FIELD_MASK 0x00000004ul +#define UART_INTERRUPTEN_RX_NOT_FULL_EN_GET(x) (((x) & 0x00000004ul) >> 2) +#define UART_INTERRUPTEN_RX_NOT_FULL_EN_SET(x) (((x) << 2) & 0x00000004ul) +#define UART_INTERRUPTEN_RX_NOT_FULL_EN_MODIFY(r, x) ((((x) << 2) & 0x00000004ul) | ((r) & 0xFFFFFFFBul)) + +/* Field: UART_INTERRUPTEN.rx_not_empty_en */ +#define UART_INTERRUPTEN_RX_NOT_EMPTY_EN_MSB 3u +#define UART_INTERRUPTEN_RX_NOT_EMPTY_EN_LSB 3u +#define UART_INTERRUPTEN_RX_NOT_EMPTY_EN_WIDTH 1u +#define UART_INTERRUPTEN_RX_NOT_EMPTY_EN_READ_ACCESS 1u +#define UART_INTERRUPTEN_RX_NOT_EMPTY_EN_WRITE_ACCESS 1u +#define UART_INTERRUPTEN_RX_NOT_EMPTY_EN_RESET 0x00000000ul +#define UART_INTERRUPTEN_RX_NOT_EMPTY_EN_FIELD_MASK 0x00000008ul +#define UART_INTERRUPTEN_RX_NOT_EMPTY_EN_GET(x) (((x) & 0x00000008ul) >> 3) +#define UART_INTERRUPTEN_RX_NOT_EMPTY_EN_SET(x) (((x) << 3) & 0x00000008ul) +#define UART_INTERRUPTEN_RX_NOT_EMPTY_EN_MODIFY(r, x) ((((x) << 3) & 0x00000008ul) | ((r) & 0xFFFFFFF7ul)) + +/* Field: UART_INTERRUPTEN.parity_error_en */ +#define UART_INTERRUPTEN_PARITY_ERROR_EN_MSB 4u +#define UART_INTERRUPTEN_PARITY_ERROR_EN_LSB 4u +#define UART_INTERRUPTEN_PARITY_ERROR_EN_WIDTH 1u +#define UART_INTERRUPTEN_PARITY_ERROR_EN_READ_ACCESS 1u +#define UART_INTERRUPTEN_PARITY_ERROR_EN_WRITE_ACCESS 1u +#define UART_INTERRUPTEN_PARITY_ERROR_EN_RESET 0x00000000ul +#define UART_INTERRUPTEN_PARITY_ERROR_EN_FIELD_MASK 0x00000010ul +#define UART_INTERRUPTEN_PARITY_ERROR_EN_GET(x) (((x) & 0x00000010ul) >> 4) +#define UART_INTERRUPTEN_PARITY_ERROR_EN_SET(x) (((x) << 4) & 0x00000010ul) +#define UART_INTERRUPTEN_PARITY_ERROR_EN_MODIFY(r, x) ((((x) << 4) & 0x00000010ul) | ((r) & 0xFFFFFFEFul)) + +/* Field: UART_INTERRUPTEN.overrun_error_en */ +#define UART_INTERRUPTEN_OVERRUN_ERROR_EN_MSB 5u +#define UART_INTERRUPTEN_OVERRUN_ERROR_EN_LSB 5u +#define UART_INTERRUPTEN_OVERRUN_ERROR_EN_WIDTH 1u +#define UART_INTERRUPTEN_OVERRUN_ERROR_EN_READ_ACCESS 1u +#define UART_INTERRUPTEN_OVERRUN_ERROR_EN_WRITE_ACCESS 1u +#define UART_INTERRUPTEN_OVERRUN_ERROR_EN_RESET 0x00000000ul +#define UART_INTERRUPTEN_OVERRUN_ERROR_EN_FIELD_MASK 0x00000020ul +#define UART_INTERRUPTEN_OVERRUN_ERROR_EN_GET(x) (((x) & 0x00000020ul) >> 5) +#define UART_INTERRUPTEN_OVERRUN_ERROR_EN_SET(x) (((x) << 5) & 0x00000020ul) +#define UART_INTERRUPTEN_OVERRUN_ERROR_EN_MODIFY(r, x) ((((x) << 5) & 0x00000020ul) | ((r) & 0xFFFFFFDFul)) + +/* Field: UART_INTERRUPTEN.frame_error_en */ +#define UART_INTERRUPTEN_FRAME_ERROR_EN_MSB 6u +#define UART_INTERRUPTEN_FRAME_ERROR_EN_LSB 6u +#define UART_INTERRUPTEN_FRAME_ERROR_EN_WIDTH 1u +#define UART_INTERRUPTEN_FRAME_ERROR_EN_READ_ACCESS 1u +#define UART_INTERRUPTEN_FRAME_ERROR_EN_WRITE_ACCESS 1u +#define UART_INTERRUPTEN_FRAME_ERROR_EN_RESET 0x00000000ul +#define UART_INTERRUPTEN_FRAME_ERROR_EN_FIELD_MASK 0x00000040ul +#define UART_INTERRUPTEN_FRAME_ERROR_EN_GET(x) (((x) & 0x00000040ul) >> 6) +#define UART_INTERRUPTEN_FRAME_ERROR_EN_SET(x) (((x) << 6) & 0x00000040ul) +#define UART_INTERRUPTEN_FRAME_ERROR_EN_MODIFY(r, x) ((((x) << 6) & 0x00000040ul) | ((r) & 0xFFFFFFBFul)) + +/* Field: UART_INTERRUPTEN.break_error_en */ +#define UART_INTERRUPTEN_BREAK_ERROR_EN_MSB 7u +#define UART_INTERRUPTEN_BREAK_ERROR_EN_LSB 7u +#define UART_INTERRUPTEN_BREAK_ERROR_EN_WIDTH 1u +#define UART_INTERRUPTEN_BREAK_ERROR_EN_READ_ACCESS 1u +#define UART_INTERRUPTEN_BREAK_ERROR_EN_WRITE_ACCESS 1u +#define UART_INTERRUPTEN_BREAK_ERROR_EN_RESET 0x00000000ul +#define UART_INTERRUPTEN_BREAK_ERROR_EN_FIELD_MASK 0x00000080ul +#define UART_INTERRUPTEN_BREAK_ERROR_EN_GET(x) (((x) & 0x00000080ul) >> 7) +#define UART_INTERRUPTEN_BREAK_ERROR_EN_SET(x) (((x) << 7) & 0x00000080ul) +#define UART_INTERRUPTEN_BREAK_ERROR_EN_MODIFY(r, x) ((((x) << 7) & 0x00000080ul) | ((r) & 0xFFFFFF7Ful)) + +/* Field: UART_INTERRUPTEN.rx_fifo_threshold_en */ +#define UART_INTERRUPTEN_RX_FIFO_THRESHOLD_EN_MSB 8u +#define UART_INTERRUPTEN_RX_FIFO_THRESHOLD_EN_LSB 8u +#define UART_INTERRUPTEN_RX_FIFO_THRESHOLD_EN_WIDTH 1u +#define UART_INTERRUPTEN_RX_FIFO_THRESHOLD_EN_READ_ACCESS 1u +#define UART_INTERRUPTEN_RX_FIFO_THRESHOLD_EN_WRITE_ACCESS 1u +#define UART_INTERRUPTEN_RX_FIFO_THRESHOLD_EN_RESET 0x00000000ul +#define UART_INTERRUPTEN_RX_FIFO_THRESHOLD_EN_FIELD_MASK 0x00000100ul +#define UART_INTERRUPTEN_RX_FIFO_THRESHOLD_EN_GET(x) (((x) & 0x00000100ul) >> 8) +#define UART_INTERRUPTEN_RX_FIFO_THRESHOLD_EN_SET(x) (((x) << 8) & 0x00000100ul) +#define UART_INTERRUPTEN_RX_FIFO_THRESHOLD_EN_MODIFY(r, x) ((((x) << 8) & 0x00000100ul) | ((r) & 0xFFFFFEFFul)) + +/* Register: UART.IQC */ +#define UART_IQC_ADDRESS 0x00000038ul +#define UART_IQC_BYTE_ADDRESS 0x00000038ul +#define UART_IQC_OFFSET 0x00000038ul +#define UART_IQC_BYTE_OFFSET 0x00000038ul +#define UART_IQC_SIZE 0x00000004ul +#define UART_IQC_BYTE_SIZE 0x00000004ul +#define UART_IQC_READ_ACCESS 1u +#define UART_IQC_WRITE_ACCESS 1u +#define UART_IQC_RESET_VALUE 0x00000000ul +#define UART_IQC_RESET_MASK 0x000000FFul +#define UART_IQC_READ_MASK 0x000000FFul +#define UART_IQC_WRITE_MASK 0x000000FFul + +/* Field: UART_IQC.qual_cycles */ +#define UART_IQC_QUAL_CYCLES_MSB 7u +#define UART_IQC_QUAL_CYCLES_LSB 0u +#define UART_IQC_QUAL_CYCLES_WIDTH 8u +#define UART_IQC_QUAL_CYCLES_READ_ACCESS 1u +#define UART_IQC_QUAL_CYCLES_WRITE_ACCESS 1u +#define UART_IQC_QUAL_CYCLES_RESET 0x00000000ul +#define UART_IQC_QUAL_CYCLES_FIELD_MASK 0x000000FFul +#define UART_IQC_QUAL_CYCLES_GET(x) ((x) & 0x000000FFul) +#define UART_IQC_QUAL_CYCLES_SET(x) ((x) & 0x000000FFul) +#define UART_IQC_QUAL_CYCLES_MODIFY(r, x) ((((x) << 0) & 0x000000FFul) | ((r) & 0xFFFFFF00ul)) + +/* Register: UART.Rx_Threshold */ +#define UART_RX_THRESHOLD_ADDRESS 0x00000040ul +#define UART_RX_THRESHOLD_BYTE_ADDRESS 0x00000040ul +#define UART_RX_THRESHOLD_OFFSET 0x00000040ul +#define UART_RX_THRESHOLD_BYTE_OFFSET 0x00000040ul +#define UART_RX_THRESHOLD_SIZE 0x00000004ul +#define UART_RX_THRESHOLD_BYTE_SIZE 0x00000004ul +#define UART_RX_THRESHOLD_READ_ACCESS 1u +#define UART_RX_THRESHOLD_WRITE_ACCESS 1u +#define UART_RX_THRESHOLD_RESET_VALUE 0x00000005ul +#define UART_RX_THRESHOLD_RESET_MASK 0x000000FFul +#define UART_RX_THRESHOLD_READ_MASK 0x000000FFul +#define UART_RX_THRESHOLD_WRITE_MASK 0x000000FFul + +/* Field: UART_RX_THRESHOLD.rx_level */ +#define UART_RX_THRESHOLD_RX_LEVEL_MSB 7u +#define UART_RX_THRESHOLD_RX_LEVEL_LSB 0u +#define UART_RX_THRESHOLD_RX_LEVEL_WIDTH 8u +#define UART_RX_THRESHOLD_RX_LEVEL_READ_ACCESS 1u +#define UART_RX_THRESHOLD_RX_LEVEL_WRITE_ACCESS 1u +#define UART_RX_THRESHOLD_RX_LEVEL_RESET 0x00000005ul +#define UART_RX_THRESHOLD_RX_LEVEL_FIELD_MASK 0x000000FFul +#define UART_RX_THRESHOLD_RX_LEVEL_GET(x) ((x) & 0x000000FFul) +#define UART_RX_THRESHOLD_RX_LEVEL_SET(x) ((x) & 0x000000FFul) +#define UART_RX_THRESHOLD_RX_LEVEL_MODIFY(r, x) ((((x) << 0) & 0x000000FFul) | ((r) & 0xFFFFFF00ul)) + +/* Block-level typedef: UART */ +typedef struct { + volatile uint32_t BaudReg; /* Offset 0x0 (R/W) */ + uint8_t _pad0[0x4]; /* 0x4..0x7 reserved */ + volatile uint32_t TxReg; /* Offset 0x8 (R/W) */ + uint8_t _pad1[0x4]; /* 0xC..0xF reserved */ + volatile uint32_t RxReg; /* Offset 0x10 (R) */ + uint8_t _pad2[0x4]; /* 0x14..0x17 reserved */ + volatile uint32_t StatusReg; /* Offset 0x18 (R) */ + uint8_t _pad3[0x4]; /* 0x1C..0x1F reserved */ + volatile uint32_t DelayReg; /* Offset 0x20 (R/W) */ + uint8_t _pad4[0x4]; /* 0x24..0x27 reserved */ + volatile uint32_t ControlReg; /* Offset 0x28 (R/W) */ + uint8_t _pad5[0x4]; /* 0x2C..0x2F reserved */ + volatile uint32_t InterruptEn; /* Offset 0x30 (R/W) */ + uint8_t _pad6[0x4]; /* 0x34..0x37 reserved */ + volatile uint32_t IQC; /* Offset 0x38 (R/W) */ + uint8_t _pad7[0x4]; /* 0x3C..0x3F reserved */ + volatile uint32_t Rx_Threshold; /* Offset 0x40 (R/W) */ +} Uart_t, *PTR_Uart_t; + +#ifdef __cplusplus +} +#endif + +#endif /* _UART_H_ */ From 4de5358272dce027d6bef71c99166691c6c0ad92 Mon Sep 17 00:00:00 2001 From: Afonso Oliveira Date: Fri, 1 May 2026 17:26:52 +0100 Subject: [PATCH 3/3] [sw-sysemu] reuse Erbium HAL hwinc metadata Replace hardcoded Erbium memory-map addresses, register addresses, field layouts, and read/write masks in sw-sysemu with macros from the Erbium HAL hwinc/ headers. Updated areas: - pma_er.cpp uses hwinc/top.h for paddr_is_* region predicates and the MRAM PMP MRAM_BASE constant. - esrs.h and esrs_er.cpp use hwinc/esr.h for neigh_esrs_t::cold_reset minion_boot defaults plus ESR addresses and reset values. - devices/shakti_uart.h uses hwinc/uart.h for UART register addresses and field masks. - devices/sysregs_er.{cpp,h} use hwinc/system.h for system register addresses and fields. - memory/erbium/main_memory.h pulls the Erbium region layout from hwinc/top.h. - emu_defines.h and sys_emu.h replace remaining Erbium literals with HAL-derived constants where applicable. sw-sysemu/CMakeLists.txt now finds erbium_hal and links sw-erbium with erbium_hal::erbium_hal. The top-level build adds erbium-hal to HostProject(sw-sysemu ...) so the Erbium HAL package is installed before sw-sysemu configures. --- CMakeLists.txt | 2 +- sw-sysemu/CMakeLists.txt | 7 ++- sw-sysemu/devices/shakti_uart.h | 47 +++++++++-------- sw-sysemu/devices/sysregs_er.cpp | 47 +++++++++-------- sw-sysemu/devices/sysregs_er.h | 74 +++++++++++++-------------- sw-sysemu/emu_defines.h | 8 ++- sw-sysemu/esrs.h | 7 ++- sw-sysemu/esrs_er.cpp | 6 ++- sw-sysemu/memory/erbium/main_memory.h | 27 +++++----- sw-sysemu/pma_er.cpp | 37 +++++++++----- sw-sysemu/sys_emu/sys_emu.h | 12 ++++- 11 files changed, 150 insertions(+), 124 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index ebd269c15..4a168a9d7 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -78,7 +78,7 @@ DeviceProject(test-compute-kernels "" # # Runtime # -HostProject(sw-sysemu "" g3log common-sw et-driver) +HostProject(sw-sysemu "" g3log common-sw et-driver erbium-hal) HostProject(devicelayer "" common-sw sw-sysemu) HostProject(esperanto-tools-libs "" devicelayer device-api g3log cereal easy_profiler diff --git a/sw-sysemu/CMakeLists.txt b/sw-sysemu/CMakeLists.txt index 911538b92..d3a15da4f 100644 --- a/sw-sysemu/CMakeLists.txt +++ b/sw-sysemu/CMakeLists.txt @@ -66,6 +66,9 @@ include(GNUInstallDirs) find_package(glog REQUIRED) find_package(lz4 REQUIRED) +# Erbium HAL: hwinc/ register headers and platform encoders. Header-only. +find_package(erbium_hal REQUIRED) + # dependencies if (BACKTRACE) find_package(libunwind REQUIRED) @@ -457,6 +460,7 @@ target_link_libraries(sw-erbium $<$:libunwind::libunwind> lz4::lz4 glog::glog + erbium_hal::erbium_hal $<$,$,9.0.0>>:stdc++fs> ) target_link_options(sw-erbium PRIVATE LINKER:-Bsymbolic) @@ -567,11 +571,12 @@ else() ) add_executable(erbium_emu sw-sysemu/main.cpp) - target_link_libraries(erbium_emu PRIVATE sw-erbium) + target_link_libraries(erbium_emu PRIVATE sw-erbium erbium_hal::erbium_hal) target_include_directories(erbium_emu PRIVATE $ $ + $ ) target_compile_definitions(erbium_emu PRIVATE ERBIUM) install(TARGETS erbium_emu diff --git a/sw-sysemu/devices/shakti_uart.h b/sw-sysemu/devices/shakti_uart.h index fe1e04760..724be4e1a 100644 --- a/sw-sysemu/devices/shakti_uart.h +++ b/sw-sysemu/devices/shakti_uart.h @@ -17,6 +17,7 @@ #include "memory/memory_error.h" #include "memory/memory_region.h" +#include namespace bemu { template @@ -27,29 +28,27 @@ struct ShaktiUart : public MemoryRegion { using pointer = typename MemoryRegion::pointer; using const_pointer = typename MemoryRegion::const_pointer; - // Shakti UART register offsets (64-bit aligned) enum : size_type { - SHAKTI_UART_BAUD = 0x00, - SHAKTI_UART_TX_REG = 0x08, - SHAKTI_UART_RCV_REG = 0x10, - SHAKTI_UART_STATUS = 0x18, - SHAKTI_UART_DELAY = 0x20, - SHAKTI_UART_CONTROL = 0x28, - SHAKTI_UART_IEN = 0x30, - SHAKTI_UART_RX_THRESHOLD = 0x40, + SHAKTI_UART_BAUD = UART_BAUDREG_OFFSET, + SHAKTI_UART_TX_REG = UART_TXREG_OFFSET, + SHAKTI_UART_RCV_REG = UART_RXREG_OFFSET, + SHAKTI_UART_STATUS = UART_STATUSREG_OFFSET, + SHAKTI_UART_DELAY = UART_DELAYREG_OFFSET, + SHAKTI_UART_CONTROL = UART_CONTROLREG_OFFSET, + SHAKTI_UART_IEN = UART_INTERRUPTEN_OFFSET, + SHAKTI_UART_RX_THRESHOLD = UART_RX_THRESHOLD_OFFSET, }; - // STATUS register bits enum : uint32_t { - STATUS_TX_EMPTY = (1u << 0), - STATUS_TX_FULL = (1u << 1), - STATUS_RX_NOT_EMPTY = (1u << 2), - STATUS_RX_FULL = (1u << 3), - STATUS_PARITY_ERROR = (1u << 4), - STATUS_OVERRUN = (1u << 5), - STATUS_FRAME_ERROR = (1u << 6), - STATUS_BREAK_ERROR = (1u << 7), - STATUS_RXFIFOTHRE = (1u << 8), + STATUS_TX_EMPTY = UART_STATUSREG_TX_EMPTY_FIELD_MASK, + STATUS_TX_FULL = UART_STATUSREG_TX_FULL_FIELD_MASK, + STATUS_RX_NOT_EMPTY = UART_STATUSREG_RX_NOTEMPTY_FIELD_MASK, + STATUS_RX_FULL = UART_STATUSREG_RX_FULL_FIELD_MASK, + STATUS_PARITY_ERROR = UART_STATUSREG_PARITY_ERROR_FIELD_MASK, + STATUS_OVERRUN = UART_STATUSREG_OVERRUN_ERROR_FIELD_MASK, + STATUS_FRAME_ERROR = UART_STATUSREG_FRAME_ERROR_FIELD_MASK, + STATUS_BREAK_ERROR = UART_STATUSREG_BREAK_ERROR_FIELD_MASK, + STATUS_RXFIFOTHRE = UART_STATUSREG_RX_FIFO_THRESHOLD_FIELD_MASK, }; static constexpr size_t FIFO_DEPTH = 16; @@ -114,20 +113,20 @@ struct ShaktiUart : public MemoryRegion { sync_interrupt_line(agent, false); break; case SHAKTI_UART_BAUD: - reg_baud = value & 0xFFFFu; + reg_baud = value & UART_BAUDREG_WRITE_MASK; break; case SHAKTI_UART_DELAY: - reg_delay = value & 0xFFFFu; + reg_delay = value & UART_DELAYREG_WRITE_MASK; break; case SHAKTI_UART_CONTROL: - reg_control = value & 0x07FEu; // charsize, parity, stopbits + reg_control = value & UART_CONTROLREG_WRITE_MASK; break; case SHAKTI_UART_IEN: - reg_ien = value & 0x01FFu; // bits [8:0] + reg_ien = value & UART_INTERRUPTEN_WRITE_MASK; sync_interrupt_line(agent, true); break; case SHAKTI_UART_RX_THRESHOLD: - reg_rx_threshold = value & 0xFFu; + reg_rx_threshold = value & UART_RX_THRESHOLD_WRITE_MASK; sync_interrupt_line(agent, true); break; case SHAKTI_UART_STATUS: diff --git a/sw-sysemu/devices/sysregs_er.cpp b/sw-sysemu/devices/sysregs_er.cpp index 55492bd70..93747883a 100644 --- a/sw-sysemu/devices/sysregs_er.cpp +++ b/sw-sysemu/devices/sysregs_er.cpp @@ -10,8 +10,7 @@ #include "memory/memory_error.h" #include "emu_gio.h" -#define SYSREGS_ER_REGION_BASE 0x0002000000ULL - +#include namespace bemu { @@ -20,25 +19,25 @@ void SysregsEr::reset(ResetCause cause) { // TODO: use methods to write some of the registers (once implemented), // because that can have side effects - version = 0xEB680000; // chipid=0xEB68, variation=0, respin=0 - system_config = SYSTEM_CONFIG_WDOG_DISABLE | SYSTEM_CONFIG_SPI_ENABLE; + version = SYSTEM_VERSION_RESET_VALUE; + system_config = SYSTEM_SYSTEMCONFIG_RESET_VALUE; sys_interrupt = 0; reset_cause = static_cast(cause); // Set reset cause - power_domain_req = 0; - power_domain_ack = 0; - spin_lock = 0; - chip_mode = 0; - soft_reset = SOFT_RESET_MRAM_RST_B; - mailbox0 = 0; - mailbox1 = 0; - power_good = 0xFFFFF; - ring_osc = 0x7F; // en=1, divby2_sel=1, trm=0x1F - cpu_divider = 0x1F; // count=0xF, div_enable=1 - system_divider = 0x1F; // count=0xF, div_enable=1 - periph_divider = 0x1F; // count=0xF, div_enable=1 + power_domain_req = SYSTEM_POWERDOMAINREQ_RESET_VALUE; + power_domain_ack = SYSTEM_POWERDOMAINACK_RESET_VALUE; + spin_lock = SYSTEM_SPINLOCK_RESET_VALUE; + chip_mode = SYSTEM_CHIPMODE_RESET_VALUE; + soft_reset = SYSTEM_SOFTRESET_RESET_VALUE; + mailbox0 = SYSTEM_MAILBOX0_RESET_VALUE; + mailbox1 = SYSTEM_MAILBOX1_RESET_VALUE; + power_good = SYSTEM_POWERGOOD_RESET_VALUE; + ring_osc = SYSTEM_RING_OSC_RESET_VALUE; + cpu_divider = SYSTEM_CPU_DIVIDER_RESET_VALUE; + system_divider = SYSTEM_SYSTEM_DIVIDER_RESET_VALUE; + periph_divider = SYSTEM_PERIPH_DIVIDER_RESET_VALUE; // Initialize watchdog with default count and disabled state - watchdog.set_count_from(0xFFFF); + watchdog.set_count_from(SYSTEM_WATCHDOG_COUNT_RESET_VALUE); watchdog.kick(); watchdog.set_enabled((system_config & SYSTEM_CONFIG_WDOG_DISABLE) == 0); // Set timeout handler (system pointer will be extracted from agent at runtime) @@ -71,7 +70,7 @@ uint32_t SysregsEr::read_register(const Agent& agent, uint64_t offset) case WATCHDOG: // Watchdog register always reads as 0 - return 0; + return SYSTEM_WATCHDOG_RESET_VALUE; case RESET_CAUSE: { // Read-clear operation: return current value, then clear all bits @@ -89,7 +88,7 @@ uint32_t SysregsEr::read_register(const Agent& agent, uint64_t offset) case POWER_STATUS: // Simplified: no power sequencing modeled, MRAM is always ready. - return 0; + return SYSTEM_POWERSTATUS_RESET_VALUE; case SPIN_LOCK: { // Read-set atomic operation: return current value, then set lock bit @@ -181,19 +180,19 @@ void SysregsEr::write_register(const Agent& agent, uint64_t offset, uint32 break; case RING_OSC: - ring_osc = value & 0x7FF; // bits [10:0] + ring_osc = value & SYSTEM_RING_OSC_WRITE_MASK; break; case CPU_DIVIDER: - cpu_divider = value & 0x1F; // bits [4:0] + cpu_divider = value & SYSTEM_CPU_DIVIDER_WRITE_MASK; break; case SYSTEM_DIVIDER: - system_divider = value & 0x1F; // bits [4:0] + system_divider = value & SYSTEM_SYSTEM_DIVIDER_WRITE_MASK; break; case PERIPH_DIVIDER: - periph_divider = value & 0x1F; // bits [4:0] + periph_divider = value & SYSTEM_PERIPH_DIVIDER_WRITE_MASK; break; default: @@ -245,6 +244,6 @@ void SysregsEr::wdt_clock_tick(const Agent& agent, uint64_t cycle) } -template struct SysregsEr; +template struct SysregsEr; } // namespace bemu diff --git a/sw-sysemu/devices/sysregs_er.h b/sw-sysemu/devices/sysregs_er.h index 48a5b5e2f..343428072 100644 --- a/sw-sysemu/devices/sysregs_er.h +++ b/sw-sysemu/devices/sysregs_er.h @@ -14,16 +14,17 @@ #include "devices/watchdog.h" #include "emu_defines.h" +#include namespace bemu { // TODO: move to reset // Reset cause reasons enum class ResetCause { NONE = 0x0, - POR = (1 << 0), // Power-On Reset - WATCHDOG = (1 << 1), // Watchdog timeout - SYSRESET = (1 << 2), // System reset request - BROWNOUT = (1 << 3), // Brownout detector + POR = SYSTEM_RESETCAUSE_POR_FIELD_MASK, + WATCHDOG = SYSTEM_RESETCAUSE_WATCHDOG_TIMEDOUT_FIELD_MASK, + SYSRESET = SYSTEM_RESETCAUSE_SYSRESET_REQ_FIELD_MASK, + BROWNOUT = SYSTEM_RESETCAUSE_BROWNOUT_FIELD_MASK, }; @@ -59,41 +60,36 @@ struct SysregsEr : public MemoryRegion { private: - // Register Offsets - static constexpr uint64_t VERSION = 0x00; - static constexpr uint64_t SYSTEM_CONFIG = 0x08; - static constexpr uint64_t WATCHDOG_COUNT = 0x10; - static constexpr uint64_t WATCHDOG = 0x18; - static constexpr uint64_t SYS_INTERRUPT = 0x20; - static constexpr uint64_t SOFT_RESET = 0x28; - static constexpr uint64_t RESET_CAUSE = 0x30; - static constexpr uint64_t POWER_DOMAIN_REQ = 0x38; - static constexpr uint64_t POWER_DOMAIN_ACK = 0x40; - static constexpr uint64_t POWER_GOOD = 0x48; - static constexpr uint64_t POWER_STATUS = 0x50; - static constexpr uint64_t SPIN_LOCK = 0x58; - static constexpr uint64_t CHIP_MODE = 0x60; - static constexpr uint64_t MAILBOX0 = 0x68; - static constexpr uint64_t MAILBOX1 = 0x70; - static constexpr uint64_t RING_OSC = 0x98; - static constexpr uint64_t CPU_DIVIDER = 0xA0; - static constexpr uint64_t SYSTEM_DIVIDER = 0xA8; - static constexpr uint64_t PERIPH_DIVIDER = 0xB0; - // Must match the highest offset - static constexpr uint64_t LAST_OFFSET = 0xB0; - - // Register Bit Masks - static constexpr uint32_t SYSTEM_CONFIG_SYS_INTR_EN = 1 << 0; - static constexpr uint32_t SYSTEM_CONFIG_MRAM_STARTUP_BYPASS = 1 << 1; - static constexpr uint32_t SYSTEM_CONFIG_WDOG_DISABLE = 1 << 2; - static constexpr uint32_t SYSTEM_CONFIG_SPI_ENABLE = 1 << 4; - static constexpr uint32_t SYSTEM_CONFIG_UART_ENABLE = 1 << 6; - - static constexpr uint32_t WATCHDOG_KICK = 1 << 7; - - static constexpr uint32_t SPIN_LOCK_LOCK = 1 << 0; - - static constexpr uint32_t SOFT_RESET_MRAM_RST_B = 1 << 2; + static constexpr uint64_t VERSION = SYSTEM_VERSION_OFFSET; + static constexpr uint64_t SYSTEM_CONFIG = SYSTEM_SYSTEMCONFIG_OFFSET; + static constexpr uint64_t WATCHDOG_COUNT = SYSTEM_WATCHDOG_COUNT_OFFSET; + static constexpr uint64_t WATCHDOG = SYSTEM_WATCHDOG_OFFSET; + static constexpr uint64_t SYS_INTERRUPT = SYSTEM_SYSINTERRUPT_OFFSET; + static constexpr uint64_t SOFT_RESET = SYSTEM_SOFTRESET_OFFSET; + static constexpr uint64_t RESET_CAUSE = SYSTEM_RESETCAUSE_OFFSET; + static constexpr uint64_t POWER_DOMAIN_REQ = SYSTEM_POWERDOMAINREQ_OFFSET; + static constexpr uint64_t POWER_DOMAIN_ACK = SYSTEM_POWERDOMAINACK_OFFSET; + static constexpr uint64_t POWER_GOOD = SYSTEM_POWERGOOD_OFFSET; + static constexpr uint64_t POWER_STATUS = SYSTEM_POWERSTATUS_OFFSET; + static constexpr uint64_t SPIN_LOCK = SYSTEM_SPINLOCK_OFFSET; + static constexpr uint64_t CHIP_MODE = SYSTEM_CHIPMODE_OFFSET; + static constexpr uint64_t MAILBOX0 = SYSTEM_MAILBOX0_OFFSET; + static constexpr uint64_t MAILBOX1 = SYSTEM_MAILBOX1_OFFSET; + static constexpr uint64_t RING_OSC = SYSTEM_RING_OSC_OFFSET; + static constexpr uint64_t CPU_DIVIDER = SYSTEM_CPU_DIVIDER_OFFSET; + static constexpr uint64_t SYSTEM_DIVIDER = SYSTEM_SYSTEM_DIVIDER_OFFSET; + static constexpr uint64_t PERIPH_DIVIDER = SYSTEM_PERIPH_DIVIDER_OFFSET; + static constexpr uint64_t LAST_OFFSET = SYSTEM_PERIPH_DIVIDER_OFFSET; + + static constexpr uint32_t SYSTEM_CONFIG_SYS_INTR_EN = SYSTEM_SYSTEMCONFIG_SYS_INTERRUPT_ENABLE_FIELD_MASK; + static constexpr uint32_t SYSTEM_CONFIG_MRAM_STARTUP_BYPASS = SYSTEM_SYSTEMCONFIG_MRAM_STARTUP_BYPASS_FIELD_MASK; + static constexpr uint32_t SYSTEM_CONFIG_WDOG_DISABLE = SYSTEM_SYSTEMCONFIG_WDOG_DISABLE_FIELD_MASK; + static constexpr uint32_t SYSTEM_CONFIG_SPI_ENABLE = SYSTEM_SYSTEMCONFIG_SPI_ENABLE_FIELD_MASK; + static constexpr uint32_t SYSTEM_CONFIG_UART_ENABLE = SYSTEM_SYSTEMCONFIG_UART_ENABLE_FIELD_MASK; + + static constexpr uint32_t WATCHDOG_KICK = SYSTEM_WATCHDOG_KICK_FIELD_MASK; + static constexpr uint32_t SPIN_LOCK_LOCK = SYSTEM_SPINLOCK_LOCK_FIELD_MASK; + static constexpr uint32_t SOFT_RESET_MRAM_RST_B = SYSTEM_SOFTRESET_MRAM_RST_B_FIELD_MASK; // Register Values uint32_t version; diff --git a/sw-sysemu/emu_defines.h b/sw-sysemu/emu_defines.h index d8e56c494..8cd0a76cb 100644 --- a/sw-sysemu/emu_defines.h +++ b/sw-sysemu/emu_defines.h @@ -9,6 +9,10 @@ #include "state.h" #include "traps.h" +#ifdef ERBIUM +#include +#endif + namespace bemu { #ifdef ERBIUM @@ -58,8 +62,8 @@ namespace bemu { // PLIC interrupt source IDs #define ER_PLIC_UART0_INTR_ID 3 -// Main memory size (16MB of MRAM) -#define EMU_DRAM_SIZE (16ULL*1024ULL*1024ULL) +// Main memory size (generated from the Erbium top map) +#define EMU_DRAM_SIZE ERBIUM_TOP_MRAM_SIZE #define PA_SIZE 32 diff --git a/sw-sysemu/esrs.h b/sw-sysemu/esrs.h index dd0133d8b..9379c6061 100644 --- a/sw-sysemu/esrs.h +++ b/sw-sysemu/esrs.h @@ -11,6 +11,10 @@ #include "emu_defines.h" #include "agent.h" +#if EMU_ERBIUM +#include +#endif + namespace bemu { @@ -27,9 +31,8 @@ namespace bemu { #define ESR_REGION_PROT_SHIFT 22 // Base address and size of ESR region - used by memory/sysreg_region.h -// Base: bit 31 = 1, all else = 0 -> 0x80000000 // Size: 24 bits of address space (including PP) -> 0x01000000 (16MB) -#define ESR_REGION_BASE 0x80000000ull +#define ESR_REGION_BASE ERBIUM_TOP_CPU_REGISTERS_BASE #define ESR_REGION_SIZE 0x01000000ull // Hart ESR addresses used by processor.cpp for debug/program buffer diff --git a/sw-sysemu/esrs_er.cpp b/sw-sysemu/esrs_er.cpp index f7ef7e7fe..8e036306c 100644 --- a/sw-sysemu/esrs_er.cpp +++ b/sw-sysemu/esrs_er.cpp @@ -14,6 +14,8 @@ #include "sysreg_error.h" #include "system.h" #include "memory/memory_error.h" + +#include #ifdef SYS_EMU #include "checkers/mem_checker.h" #include "sys_emu.h" @@ -46,7 +48,7 @@ namespace bemu { #define ESR_SREGION_EXT_MASK 0x00803E0000ull // Base addresses for ESR subregions -#define ESR_HART_REGION 0x0080000000ull +#define ESR_HART_REGION ESR_REGION_BASE #define ESR_NEIGH_REGION 0x0080100000ull #define ESR_SHIRE_REGION 0x0080340000ull @@ -164,7 +166,7 @@ void neigh_esrs_t::warm_reset() void neigh_esrs_t::cold_reset() { - minion_boot = 0x02008000; // boot rom + minion_boot = ERBIUM_TOP_BOOTROM_BASE; mprot = 0; dummy0 = 0; dummy2 = false; diff --git a/sw-sysemu/memory/erbium/main_memory.h b/sw-sysemu/memory/erbium/main_memory.h index 8f0b12af5..644bff3d8 100644 --- a/sw-sysemu/memory/erbium/main_memory.h +++ b/sw-sysemu/memory/erbium/main_memory.h @@ -16,6 +16,7 @@ #include "memory/memory_error.h" #include "memory/memory_region.h" +#include namespace bemu { @@ -59,24 +60,24 @@ struct MainMemory { }; constexpr static uint64_t region_bases[REGION_COUNT] = { - /* erbreg */ 0x0002000000ull, - /* mram_bridge */ 0x0002001000ull, - /* uart */ 0x0002004000ull, - /* bootrom */ 0x0002008000ull, - /* sram */ 0x000200C000ull, - /* dram */ 0x0040000000ull, /* Actually MRAM */ + /* erbreg */ ERBIUM_TOP_SYSTEM_REGISTERS_BASE, + /* mram_bridge */ ERBIUM_TOP_MRAM_REGISTERS_BASE, + /* uart */ ERBIUM_TOP_UART_REGISTERS_BASE, + /* bootrom */ ERBIUM_TOP_BOOTROM_BASE, + /* sram */ ERBIUM_TOP_SRAM_BASE, + /* dram */ ERBIUM_TOP_MRAM_BASE, /* otp */ 0x007FFFD000ull, - /* sysreg */ 0x0080000000ull, - /* plic */ 0x00A0000000ull, + /* sysreg */ ERBIUM_TOP_CPU_REGISTERS_BASE, + /* plic */ ERBIUM_TOP_PLIC_BASE, }; constexpr static size_t region_sizes[REGION_COUNT] = { - /* erbreg */ 4_KiB, - /* mram_bridge */ 4_KiB, + /* erbreg */ ERBIUM_TOP_MRAM_REGISTERS_BASE - ERBIUM_TOP_SYSTEM_REGISTERS_BASE, + /* mram_bridge */ ERBIUM_TOP_I2C_REGISTERS_BASE - ERBIUM_TOP_MRAM_REGISTERS_BASE, /* uart */ 4_KiB, - /* bootrom */ 8_KiB, - /* sram */ 4_KiB, - /* dram */ 16_MiB, + /* bootrom */ ERBIUM_TOP_BOOTROM_SIZE, + /* sram */ ERBIUM_TOP_SRAM_SIZE, + /* dram */ ERBIUM_TOP_MRAM_SIZE, /* otp */ 12_KiB, /* sysreg */ 16_MiB, /* plic */ 64_MiB, diff --git a/sw-sysemu/pma_er.cpp b/sw-sysemu/pma_er.cpp index 4115fb77b..b8bf90a0b 100644 --- a/sw-sysemu/pma_er.cpp +++ b/sw-sysemu/pma_er.cpp @@ -11,6 +11,7 @@ #include "system.h" #include "utility.h" +#include namespace bemu { //------------------------------------------------------------------------------ @@ -27,39 +28,48 @@ namespace bemu { // 0x7FFF_D000 - 0x7FFF_FFFF: OTP (12K, read-only) // 0x8000_0000 - 0x9FFF_FFFF: ESR/CPU registers (512M) // 0xA000_0000 - 0xA3FF_FFFF: PLIC (64M) +// +// Bases come from hwinc/top.h (regenerated from the top-level RDL); +// upper bounds either come from the next region's base or, where the +// gap is intentionally large, are kept numeric with a comment. static inline bool paddr_is_sysreg(uint64_t addr) -{ return (addr >= 0x02000000ull) && (addr < 0x02001000ull); } +{ return (addr >= ERBIUM_TOP_SYSTEM_REGISTERS_BASE) && (addr < ERBIUM_TOP_MRAM_REGISTERS_BASE); } static inline bool paddr_is_mramreg(uint64_t addr) -{ return (addr >= 0x02001000ull) && (addr < 0x02002000ull); } +{ return (addr >= ERBIUM_TOP_MRAM_REGISTERS_BASE) && (addr < ERBIUM_TOP_I2C_REGISTERS_BASE); } static inline bool paddr_is_periph(uint64_t addr) -{ return (addr >= 0x02002000ull) && (addr < 0x02003000ull); } +{ return (addr >= ERBIUM_TOP_I2C_REGISTERS_BASE) && (addr < ERBIUM_TOP_QSPI_REGISTERS_BASE); } static inline bool paddr_is_xspi(uint64_t addr) -{ return (addr >= 0x0200F000ull) && (addr < 0x02010000ull); } +{ return (addr >= ERBIUM_TOP_XSPI_REGISTERS_BASE) && (addr < ERBIUM_TOP_XSPI_REGISTERS_END); } static inline bool paddr_is_uart(uint64_t addr) -{ return (addr >= 0x02004000ull) && (addr < 0x02005000ull); } +{ return (addr >= ERBIUM_TOP_UART_REGISTERS_BASE) && (addr < ERBIUM_TOP_UART_REGISTERS_END); } +// BootROM is 8KB inside the ROMRAM region. static inline bool paddr_is_bootrom(uint64_t addr) -{ return (addr >= 0x02008000ull) && (addr < 0x0200A000ull); } +{ return (addr >= ERBIUM_TOP_BOOTROM_BASE) && (addr < ERBIUM_TOP_BOOTROM_END); } +// SRAM is 4KB inside the ROMRAM region. static inline bool paddr_is_sram(uint64_t addr) -{ return (addr >= 0x0200C000ull) && (addr < 0x0200D000ull); } +{ return (addr >= ERBIUM_TOP_SRAM_BASE) && (addr < ERBIUM_TOP_SRAM_END); } +// OTP is the top 12KB of MRAM space, just below the ESR base. static inline bool paddr_is_otp(uint64_t addr) -{ return (addr >= 0x7FFFD000ull) && (addr < 0x80000000ull); } +{ return (addr >= ERBIUM_TOP_CPU_REGISTERS_BASE - 0x3000ull) && (addr < ERBIUM_TOP_CPU_REGISTERS_BASE); } +// MRAM is the entire 1GB span between MRAM_BASE and the ESR base. static inline bool paddr_is_mram(uint64_t addr) -{ return (addr >= 0x40000000ull) && (addr < 0x80000000ull); } +{ return (addr >= ERBIUM_TOP_MRAM_BASE) && (addr < ERBIUM_TOP_CPU_REGISTERS_BASE); } +// ESR is the entire 0.5GB span between CPU_REGISTERS_BASE and the PLIC base. static inline bool paddr_is_esr(uint64_t addr) -{ return (addr >= 0x80000000ull) && (addr < 0xA0000000ull); } +{ return (addr >= ERBIUM_TOP_CPU_REGISTERS_BASE) && (addr < ERBIUM_TOP_PLIC_BASE); } static inline bool paddr_is_plic(uint64_t addr) -{ return (addr >= 0xA0000000ull) && (addr < 0xA4000000ull); } +{ return (addr >= ERBIUM_TOP_PLIC_BASE) && (addr < ERBIUM_TOP_PLIC_END); } @@ -99,7 +109,6 @@ static bool data_access_is_write(mem_access_type macc) #define MPROT_EN 0x100 #define MPROT_MMODE_SIZE(x) (((x) >> 4) & 0xF) #define MPROT_SMODE_SIZE(x) ((x) & 0xF) -#define MRAM_BASE 0x40000000ull // mmode_end = MRAM_BASE + 4KB * (2^mmode_size), capped at 16MB static inline uint64_t mmode_region_end(uint16_t mprot) @@ -107,7 +116,7 @@ static inline uint64_t mmode_region_end(uint16_t mprot) unsigned mmode_size = MPROT_MMODE_SIZE(mprot); // Cap at 16MB uint64_t size = 0x1000ull << (mmode_size > 12 ? 12 : mmode_size); - return MRAM_BASE + size; + return ERBIUM_TOP_MRAM_BASE + size; } // smode_end = MRAM_BASE + 4KB * (2^smode_size), capped at 16MB @@ -116,7 +125,7 @@ static inline uint64_t smode_region_end(uint16_t mprot) unsigned smode_size = MPROT_SMODE_SIZE(mprot); // Cap at 16MB uint64_t size = 0x1000ull << (smode_size > 12 ? 12 : smode_size); - return MRAM_BASE + size; + return ERBIUM_TOP_MRAM_BASE + size; } static bool check_mram_pmp_access(uint64_t addr, uint16_t mprot, Privilege mode) { diff --git a/sw-sysemu/sys_emu/sys_emu.h b/sw-sysemu/sys_emu/sys_emu.h index d4e7c56d1..eb31f9112 100644 --- a/sw-sysemu/sys_emu/sys_emu.h +++ b/sw-sysemu/sys_emu/sys_emu.h @@ -30,6 +30,10 @@ #endif #include "ISysEmuExport.hpp" +#if EMU_ERBIUM +#include +#endif + //////////////////////////////////////////////////////////////////////////////// // Defines //////////////////////////////////////////////////////////////////////////////// @@ -39,8 +43,8 @@ #define SP_RESET_PC 0x0040000000ULL #define DRAM_SIZE 16ull << 30; #elif EMU_ERBIUM -#define RESET_PC 0x0002008000ULL // Start of bootrom -#define DRAM_SIZE 16ull << 20; +#define RESET_PC ERBIUM_TOP_BOOTROM_BASE +#define DRAM_SIZE ERBIUM_TOP_MRAM_SIZE; #else #error "Unknown platform" #endif @@ -105,7 +109,11 @@ struct sys_emu_cmd_options { bool mins_dis = false; bool sp_dis = false; // SVCPROC uint32_t mem_reset = 0; +#if EMU_ERBIUM + uint64_t dram_size = ERBIUM_TOP_MRAM_SIZE; +#else uint64_t dram_size = 16ull << 30; +#endif uint64_t log_at_pc = ~0ull; uint64_t stop_log_at_pc = ~0ull;