From e575dce16d3e178c4dd66b391657175b1237e3b7 Mon Sep 17 00:00:00 2001 From: Matthias Hertel Date: Wed, 28 Jan 2026 14:00:22 +0100 Subject: [PATCH 01/17] Allow selection of source and library build by build-type --- ai_layer/ai_layer.clayer.yml | 65 ++++++++++++++++++++++++++------ executorch_project.cproject.yml | 31 ++++++++++++--- executorch_project.csolution.yml | 25 ++++++++++-- 3 files changed, 100 insertions(+), 21 deletions(-) diff --git a/ai_layer/ai_layer.clayer.yml b/ai_layer/ai_layer.clayer.yml index c68036e9..a3e3ad2c 100644 --- a/ai_layer/ai_layer.clayer.yml +++ b/ai_layer/ai_layer.clayer.yml @@ -2,6 +2,9 @@ layer: type: AI / Executorch description: AI layer for ExecuTorch ARM runtime + packs: + - pack: ARM::CMSIS-NN@7.0.0 + add-path: # Core ExecuTorch includes - ./engine/include @@ -27,6 +30,7 @@ layer: - ./engine/include/executorch/kernels/portable - ./engine/include/executorch/backends - ./engine/include/executorch/backends/xnnpack + - ./engine/include/executorch/backends/cortex_m/ops # Third party includes - ./engine/include/third-party @@ -35,31 +39,70 @@ layer: # Generated model includes - ./model - + + components: + - component: CMSIS:NN Lib + + groups: + + # Libraries with kernel registrations need whole-archive to preserve constructors - group: ExecuTorch Libraries + not-for-context: .Debug-Source files: - # Core runtime libraries (actually present in ai_layer/engine/lib) - - file: ./engine/lib/libexecutorch.a + # Core runtime libraries - file: ./engine/lib/libexecutorch_core.a - file: ./engine/lib/libportable_kernels.a - - file: ./engine/lib/libportable_ops_lib.a - # ARM Cortex-M optimized libraries + # ARM Cortex-M optimized kernels - file: ./engine/lib/libcortex_m_kernels.a - - file: ./engine/lib/libcortex_m_ops_lib.a - # Quantized operation libraries + # Quantized kernels - file: ./engine/lib/libquantized_kernels.a + + # Libraries requiring whole-archive to preserve constructors/registrations + - file: ./engine/lib/libexecutorch.a + link: whole-archive + - file: ./engine/lib/libportable_ops_lib.a + link: whole-archive + - file: ./engine/lib/libcortex_m_ops_lib.a + link: whole-archive - file: ./engine/lib/libquantized_ops_lib.a - - # Ethos-U backend library + link: whole-archive - file: ./engine/lib/libexecutorch_delegate_ethos_u.a + link: whole-archive - group: Reports files: - file: ./REPORT.md - - group: Model Files + # CLANG-specific: Stubs for missing libc++ features (posix_stub only, cxx_stubs is in board layer) + - group: Clang Platform Stubs + for-context: .Debug-Source + for-compiler: + - CLANG + files: + - file: ./stubs/posix_stub.cpp + - file: ./stubs/random_ops_stubs.cpp + + # GCC Debug-Source: Random op stubs (excluded from source build for consistency with Clang) + - group: GCC Random Op Stubs + for-context: .Debug-Source + for-compiler: + - GCC + files: + - file: ./stubs/random_ops_stubs.cpp + + # AC6 Debug-Source: Stubs for missing runtime features + - group: AC6 Platform Stubs + for-context: .Debug-Source + for-compiler: + - AC6 files: - - file: ../model/aot_model.py \ No newline at end of file + - file: ./stubs/posix_stub.cpp + - file: ./stubs/random_ops_stubs.cpp + + # Note: GCC could include actual random op sources, but we use stubs for consistency + # The random ops (op_rand.cpp, op_randn.cpp, op_native_dropout.cpp) are excluded from + # stage2 generation because they require std::random_device (not available in Clang) + diff --git a/executorch_project.cproject.yml b/executorch_project.cproject.yml index ddcef0d6..9a5bd3c4 100644 --- a/executorch_project.cproject.yml +++ b/executorch_project.cproject.yml @@ -15,6 +15,9 @@ # limitations under the License. # A project translates into one executable or library. +# This project supports both GCC and ARM Clang compilers. +# To switch compilers, edit the "compiler:" setting in executorch_project.csolution.yml +# The for-compiler attributes below automatically select the appropriate libraries. project: # List the packs used in the project. packs: @@ -25,13 +28,23 @@ project: misc: - CPP: - -Wno-deprecated-declarations - - Link: + + # GCC linker settings + - for-compiler: GCC + Link: - -Wl,-u,_printf_float - - -Wl,--whole-archive - - $SolutionDir()$/ai_layer/engine/lib/libexecutorch_delegate_ethos_u.a - - $SolutionDir()$/ai_layer/engine/lib/libquantized_ops_lib.a - - -idirafter $SolutionDir()$/ai_layer/engine/include/executorch/runtime/platform - - -Wl,--no-whole-archive + + # CLANG-specific settings + - for-compiler: CLANG + Link: + - -Wl,-u,_printf_float + - -lstdc++ + + # AC6-specific settings + - for-compiler: AC6 + Link: + - --entry=Reset_Handler + - --diag_suppress=6312,6314,6329,6848 # List of #define statements passed via the command line to the build tool. define: @@ -60,6 +73,8 @@ project: - file: src/executor_runner/arm_perf_monitor.cpp - file: src/app_main.c + + # List components to use for your application. # A software component is a re-usable unit that may be configurable. components: @@ -72,6 +87,10 @@ project: type: Board - layer: $SolutionDir()$/ai_layer/ai_layer.clayer.yml + - layer: $SolutionDir()$/ai_layer/engine/stage1_source.clayer.yml + for-context: .Debug-Source + - layer: $SolutionDir()$/ai_layer/engine/stage2_source.clayer.yml + for-context: .Debug-Source # List executable file formats to be generated. output: diff --git a/executorch_project.csolution.yml b/executorch_project.csolution.yml index 6a910bb6..7fc632e7 100644 --- a/executorch_project.csolution.yml +++ b/executorch_project.csolution.yml @@ -15,11 +15,17 @@ # limitations under the License. # A solution is a collection of related projects that share same base configuration. +# This solution supports both GCC and ARM Clang compilers. +# To switch: change "compiler: CLANG" to "compiler: GCC" (or vice versa) below. +# The for-compiler attributes automatically select board layers and libraries. solution: created-for: CMSIS-Toolbox@2.12.0 cdefault: # use CMSIS-Toolbox default Compiler options - - compiler: GCC + select-compiler: + # list tested compilers that can be selected + - compiler: GCC # GCC is supported + - compiler: CLANG # ATfE is supported + - compiler: AC6 # Arm Compiler 6 is supported # List the packs that define the device and/or board. packs: @@ -33,13 +39,22 @@ solution: - type: Debug debug: on optimize: debug + compiler: GCC - type: Release debug: off optimize: speed + compiler: GCC + + - type: Debug-Source + debug: on + optimize: debug # List different hardware targets that are used to deploy the solution. + # The Board-Layer uses for-compiler conditionals internally to handle + # GCC, CLANG, and AC6 compiler differences (linker scripts, runtime stubs). target-types: + # AVH Corstone-300 with Ethos-U55 (supports GCC, CLANG, AC6) - type: AVH-SSE-300 board: V2M-MPS3-SSE-300-FVP device: SSE-300-MPS3 @@ -47,13 +62,13 @@ solution: - Board-Layer: $SolutionDir()$/board/Corstone-300/Board-U55.clayer.yml target-set: - set: - images: - - project-context: executorch_project.Debug debugger: name: Arm-FVP model: FVP_Corstone_SSE-300_Ethos-U55 config-file: board/Corstone-300/fvp_config.txt args: --simlimit 10 + images: + - project-context: executorch_project.Debug-Source - type: DevKit-E7-HE board: DevKit-E7:Gen 2 @@ -87,3 +102,5 @@ solution: projects: # Simple model example - project: ./executorch_project.cproject.yml + compiler: AC6 + # compiler: Use --toolchain option to select GCC, CLANG, or AC6 From d3d50fa4b7fb011a6587ee3af2a4b9c934f61118 Mon Sep 17 00:00:00 2001 From: Matthias Hertel Date: Wed, 28 Jan 2026 15:55:50 +0100 Subject: [PATCH 02/17] Guard the libraries from incompatible compilers --- ai_layer/ai_layer.clayer.yml | 3 +- scripts/local_workflow.sh | 4 +- src/cxx_stubs.cpp | 74 ++++++++++++++++++++++++++++++++++++ 3 files changed, 78 insertions(+), 3 deletions(-) create mode 100644 src/cxx_stubs.cpp diff --git a/ai_layer/ai_layer.clayer.yml b/ai_layer/ai_layer.clayer.yml index a3e3ad2c..93e9c43d 100644 --- a/ai_layer/ai_layer.clayer.yml +++ b/ai_layer/ai_layer.clayer.yml @@ -47,8 +47,9 @@ layer: groups: # Libraries with kernel registrations need whole-archive to preserve constructors - - group: ExecuTorch Libraries + - group: ExecuTorch Libraries not-for-context: .Debug-Source + for-compiler: GCC files: # Core runtime libraries - file: ./engine/lib/libexecutorch_core.a diff --git a/scripts/local_workflow.sh b/scripts/local_workflow.sh index 31cb8ecd..b1319c7b 100755 --- a/scripts/local_workflow.sh +++ b/scripts/local_workflow.sh @@ -57,7 +57,7 @@ log_and_tee "stage1_build" "/workspace2/scripts/build_stage1.sh /workspace/execu # Registration files (RegisterCodegenUnboxedKernelsEverything.cpp) are NOT included here - they come from stage2 (selective build) # Flags -fPIC and -s are removed for AC6 compatibility (causes compiler crash in AC6 6.24.0) echo -e "\033[1;35m=== Step 2a: Generate source layer ===\033[0m" -log_and_tee "generate_source_layer" "cd /workspace2/out/stage1 && python3 /workspace2/scripts/ccdb2clayer.py -c compile_commands.json -v --copy-sources -A /workspace/executorch -A /workspace2/out/stage1 -L . -o /workspace2/ai_layer/engine/stage1_source.clayer.yml -n 'ExecuTorch Stage1 Sources' -g runtime -g extension -g schema -g 'kernels/quantized' -g backends --exclude '*/posix.cpp' --remove-flags=-fPIC --remove-flags=-s" +log_and_tee "generate_source_layer" "cd /workspace2/out/stage1 && python3 /workspace2/scripts/ccdb2clayer.py -c compile_commands.json -v --copy-sources -A /workspace/executorch -A /workspace2/out/stage1 -L . -o /workspace2/ai_layer/engine/stage1_source.clayer.yml -n 'ExecuTorch Core Sources' -g runtime -g extension -g schema -g 'kernels/quantized' -g backends --exclude '*/posix.cpp' --remove-flags=-fPIC --remove-flags=-s" # Step 2b: Copy NativeFunctions.h to stage1 source directories # Registration files use #include "NativeFunctions.h" expecting the header in the same directory @@ -98,7 +98,7 @@ log_and_tee "stage2_build" "/workspace2/scripts/build_stage2_selective.sh /works # Two strip paths are needed: one for ExecuTorch source, one for generated files in build dir # Flags -fPIC and -s are removed for AC6 compatibility (causes compiler crash in AC6 6.24.0) echo -e "\033[1;35m=== Step 3a: Generate stage2 source layer ===\033[0m" -log_and_tee "generate_source_layer_stage2" "cd /workspace2/out/stage2 && python3 /workspace2/scripts/ccdb2clayer.py -c compile_commands.json -v --copy-sources -A /workspace/executorch -A /workspace2/out/stage2 -L . -o /workspace2/ai_layer/engine/stage2_source.clayer.yml -n 'ExecuTorch Stage2 Selective Ops' -g kernels --exclude '*/op_rand.cpp' --exclude '*/op_randn.cpp' --exclude '*/op_native_dropout.cpp' --exclude 'kernels/quantized/*' --remove-flags=-fPIC --remove-flags=-s" +log_and_tee "generate_source_layer_stage2" "cd /workspace2/out/stage2 && python3 /workspace2/scripts/ccdb2clayer.py -c compile_commands.json -v --copy-sources -A /workspace/executorch -A /workspace2/out/stage2 -L . -o /workspace2/ai_layer/engine/stage2_source.clayer.yml -n 'Executorch Selective Sources' -g kernels --exclude '*/op_rand.cpp' --exclude '*/op_randn.cpp' --exclude '*/op_native_dropout.cpp' --exclude 'kernels/quantized/*' --remove-flags=-fPIC --remove-flags=-s" # Step 3a.1: Fix stage2 layer to use selective kernels (executorch_selected_kernels instead of portable_ops_lib) echo -e "\033[1;35m=== Step 3a.1: Fix stage2 layer for selective kernels ===\033[0m" diff --git a/src/cxx_stubs.cpp b/src/cxx_stubs.cpp new file mode 100644 index 00000000..c075af81 --- /dev/null +++ b/src/cxx_stubs.cpp @@ -0,0 +1,74 @@ +/* + * ARM C++ runtime stubs for bare-metal targets + * + * Provides minimal stub implementations for C++ runtime functions + * required by ARM Clang that are not needed in bare-metal contexts. + * + * Note: std::chrono::steady_clock and std::random_device are not available + * in ARM Clang bare-metal libc++ (_LIBCPP_HAS_MONOTONIC_CLOCK=0, + * _LIBCPP_HAS_RANDOM_DEVICE=0). Files using these features must be excluded + * or use alternative implementations. + */ + +#include +#include + +extern "C" { + +/** + * Stub for C++ atexit handler registration + * In bare-metal systems without dynamic library loading, + * we don't need to track exit handlers + */ +int __aeabi_atexit(void *object, void (*destructor)(void *), void *dso_handle) { + (void)object; + (void)destructor; + (void)dso_handle; + return 0; // Success +} + +/** + * GCC libstdc++ std::random_device stubs + * These are needed when linking against GCC-built libraries that use random_device. + * The mangled names are for GCC's libstdc++ ABI. + */ + +// Mangled: _ZNSt13random_device9_M_getvalEv +unsigned int _ZNSt13random_device9_M_getvalEv() { + static unsigned int seed = 0x12345678; + // Simple LCG for deterministic "random" values + seed = (seed * 1103515245U + 12345U) & 0x7FFFFFFF; + return seed; +} + +// Mangled: _ZNSt13random_device7_M_finiEv +void _ZNSt13random_device7_M_finiEv() { + // No cleanup needed in bare-metal +} + +// Mangled: _ZNSt13random_device7_M_initERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE +void _ZNSt13random_device7_M_initERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE(const void* token) { + (void)token; // Ignore token in bare-metal +} + +/** + * GCC libstdc++ std::__cxx11::basic_string stubs + * These are needed when linking against GCC-built libraries. + */ + +// Mangled: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE13_S_copy_charsEPcPKcS7_ +void _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE13_S_copy_charsEPcPKcS7_( + char* dst, const char* src_begin, const char* src_end) +{ + size_t len = src_end - src_begin; + if (len > 0) { + memcpy(dst, src_begin, len); + } +} + +// Mangled: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_disposeEv +void _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_disposeEv() { + // No-op for bare-metal - no dynamic memory to free +} + +} // extern "C" \ No newline at end of file From b8800b624ffcb0830406385a3ee4fcc40006f746 Mon Sep 17 00:00:00 2001 From: Jen-Tse Huang Date: Wed, 28 Jan 2026 16:19:54 +0100 Subject: [PATCH 03/17] Increase ExecuTorch thread stack size --- src/app_main.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/app_main.c b/src/app_main.c index efaddcf8..999cec5c 100644 --- a/src/app_main.c +++ b/src/app_main.c @@ -17,8 +17,8 @@ extern int executorch_runner_main(int argc, const char* argv[]); #include "cmsis_os2.h" -// Custom stack size for ExecuTorch thread (32KB) -#define EXECUTORCH_THREAD_STACK_SIZE (4 * 1024) +// Custom stack size for ExecuTorch thread (64KB) +#define EXECUTORCH_THREAD_STACK_SIZE (8 * 1024) // Stack memory for the ExecuTorch thread static uint64_t executorch_thread_stack[EXECUTORCH_THREAD_STACK_SIZE / sizeof(uint64_t)] __attribute__((aligned(8))); From 274d3bfe875daf560d510a55464338bdd8777473 Mon Sep 17 00:00:00 2001 From: Matthias Hertel Date: Mon, 2 Feb 2026 15:28:51 +0100 Subject: [PATCH 04/17] Readme updated with build targets --- README.md | 16 ++++++++++++++++ ai_layer/engine/stage1_source.clayer.yml | 2 +- ai_layer/engine/stage2_source.clayer.yml | 2 +- 3 files changed, 18 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 3c507568..7a5c7042 100644 --- a/README.md +++ b/README.md @@ -33,6 +33,22 @@ The following tools are used by this template project. The user should have a ba | [GitHub Actions](https://github.com/features/actions) | Workflow automation for building the AI layer in Cloud. | | [Git](https://git-scm.com/) | Version control and repository management (Optional). | +## Build Configurations + + +Build targets are CMSIS “contexts” formed by combining a build type (Debug, Debug-Source, Release) with a target (AVH-SSE-300, DevKit-E7-HE, DevKit-E7-HP). Each context selects the board layer and device for that target and applies the build-type flags. + +Compiler selection is controlled by the csolution toolchain selection. The solution lists supported compilers and defaults to GCC in executorch_project.csolution.yml. Change the *compiler:* setting in this file to select a different compiler toolchain. + +### Supported combinations of build types and compiler toolchains + +| Build Type | GCC | CLANG | AC6 | Comments +| --- | --- | --- | --- | --- | +| Debug | ✅ | | | Optimization low - pre-build libraries in ai_layer | +| Debug-Source | ✅ | ✅ | ✅ | Optimization settings customizable - ai_layer full source | +| Release | ✅ | | | Optimization size - pre-build libraries in ai_layer | + + ## Repository Content The table below explains the content of this repository. diff --git a/ai_layer/engine/stage1_source.clayer.yml b/ai_layer/engine/stage1_source.clayer.yml index 245aa540..121763b4 100644 --- a/ai_layer/engine/stage1_source.clayer.yml +++ b/ai_layer/engine/stage1_source.clayer.yml @@ -1,5 +1,5 @@ layer: - type: ExecuTorch Stage1 Sources + type: ExecuTorch Core Sources description: Generated from compile_commands.json (327 files) groups: - group: Runtime diff --git a/ai_layer/engine/stage2_source.clayer.yml b/ai_layer/engine/stage2_source.clayer.yml index 85a3afdf..2e711464 100644 --- a/ai_layer/engine/stage2_source.clayer.yml +++ b/ai_layer/engine/stage2_source.clayer.yml @@ -1,5 +1,5 @@ layer: - type: ExecuTorch Stage2 Selective Ops + type: Executorch Selective Sources description: Generated from compile_commands.json (240 files) groups: - group: Kernels From 37cee2fc37cfc3e8701d86b6e1cbc4b56e40ae1b Mon Sep 17 00:00:00 2001 From: Matthias Hertel Date: Mon, 16 Feb 2026 13:19:57 +0100 Subject: [PATCH 05/17] Update to Executorch 1.1.0 --- .docker/Dockerfile | 70 ++++++++++++++++----- scripts/build_stage1.sh | 43 ++++++++++++- scripts/build_stage2_selective.sh | 51 ++++++++++----- scripts/local_workflow.sh | 2 +- src/executor_runner/arm_executor_runner.cpp | 8 +++ 5 files changed, 138 insertions(+), 36 deletions(-) diff --git a/.docker/Dockerfile b/.docker/Dockerfile index 60edbfb4..ba54e42a 100644 --- a/.docker/Dockerfile +++ b/.docker/Dockerfile @@ -3,6 +3,11 @@ FROM ubuntu:24.04 # Prevent interactive prompts during package installation ENV DEBIAN_FRONTEND=noninteractive +# Add deadsnakes PPA for Python 3.13 (not in Ubuntu 24.04 default repos) +RUN apt-get update && apt-get install -y software-properties-common && \ + add-apt-repository -y ppa:deadsnakes/ppa && \ + rm -rf /var/lib/apt/lists/* + # Install system dependencies RUN apt-get update && apt-get install -y \ # Basic build tools @@ -17,9 +22,9 @@ RUN apt-get update && apt-get install -y \ # gcc-arm-none-eabi \ # libnewlib-arm-none-eabi \ # Python and pip - python3.12 \ - python3.12-dev \ - python3.12-venv \ + python3.13 \ + python3.13-dev \ + python3.13-venv \ python3-pip \ # Additional build dependencies for ExecuTorch pkg-config \ @@ -43,16 +48,16 @@ RUN apt-get update && apt-get install -y \ tree \ && rm -rf /var/lib/apt/lists/* -# Install current CMake (3.30.x) from Kitware's official repository +# Install current CMake from Kitware's official repository RUN wget -O - https://apt.kitware.com/keys/kitware-archive-latest.asc 2>/dev/null | gpg --dearmor - | tee /etc/apt/trusted.gpg.d/kitware.gpg >/dev/null && \ echo 'deb https://apt.kitware.com/ubuntu/ noble main' | tee /etc/apt/sources.list.d/kitware.list >/dev/null && \ apt-get update && \ apt-get install -y cmake && \ rm -rf /var/lib/apt/lists/* -# Set Python 3.12 as default python -RUN update-alternatives --install /usr/bin/python python /usr/bin/python3.12 1 && \ - update-alternatives --install /usr/bin/python3 python3 /usr/bin/python3.12 1 +# Set Python 3.13 as default python +RUN update-alternatives --install /usr/bin/python python /usr/bin/python3.13 1 && \ + update-alternatives --install /usr/bin/python3 python3 /usr/bin/python3.13 1 ## Create a non-root user for development RUN useradd -m -s /bin/bash developer && \ @@ -66,28 +71,59 @@ USER developer WORKDIR /workspace RUN git clone https://github.com/pytorch/executorch.git && \ cd executorch && \ - git checkout v1.0.0 && \ + git checkout v1.1.0 && \ git submodule sync && \ git submodule update --init --recursive +# Create CMake module to patch CMSIS-NN for CMake 4.x compatibility +RUN mkdir -p /workspace/executorch/cmake/modules && \ + cat > /workspace/executorch/cmake/modules/PatchCmsisNN.cmake << 'EOF' +# Patch CMSIS-NN after FetchContent populates it for CMake 4.x compatibility +macro(patch_cmsis_nn_if_needed) + if(EXISTS "${cmsis_nn_SOURCE_DIR}/CMakeLists.txt") + file(READ "${cmsis_nn_SOURCE_DIR}/CMakeLists.txt" CMSIS_NN_CONTENT) + string(FIND "${CMSIS_NN_CONTENT}" "target_include_directories(cmsis-nn PUBLIC \"Include\")" HAS_RELATIVE_PATH) + if(NOT HAS_RELATIVE_PATH EQUAL -1) + message(STATUS "Patching CMSIS-NN for CMake 4.x compatibility") + string(REPLACE + "target_include_directories(cmsis-nn PUBLIC \"Include\")" + "target_include_directories(cmsis-nn PUBLIC \"\${CMAKE_CURRENT_SOURCE_DIR}/Include\")" + CMSIS_NN_CONTENT "${CMSIS_NN_CONTENT}") + file(WRITE "${cmsis_nn_SOURCE_DIR}/CMakeLists.txt" "${CMSIS_NN_CONTENT}") + endif() + endif() +endmacro() +EOF + +# Patch ExecuTorch's cortex_m backend to use the patching module +RUN cd /workspace/executorch/backends/cortex_m && \ + sed -i '/FetchContent_MakeAvailable(cmsis_nn)/i\ include(${CMAKE_SOURCE_DIR}/cmake/modules/PatchCmsisNN.cmake)\n FetchContent_Populate(cmsis_nn)\n patch_cmsis_nn_if_needed()' CMakeLists.txt && \ + sed -i 's/FetchContent_MakeAvailable(cmsis_nn)/add_subdirectory(${cmsis_nn_SOURCE_DIR} ${cmsis_nn_BINARY_DIR})/' CMakeLists.txt + RUN python -m venv executorch-venv -ENV PATH="/workspace/executorch/examples/arm/ethos-u-scratch/arm-gnu-toolchain-13.3.rel1-arm-none-eabi/bin:/workspace/executorch-venv/bin:$PATH" +ENV PATH="/workspace/executorch/examples/arm/arm-scratch/arm-gnu-toolchain-13.3.rel1-arm-none-eabi/bin:/workspace/executorch-venv/bin:$PATH" # Use ExecuTorch's official installation script but avoid ATen bridge conflicts RUN pip install --extra-index-url https://download.pytorch.org/whl/test/cpu --break-system-packages \ - executorch==1.0.0 \ - ethos-u-vela==4.4.1 \ - torch==2.9.0 \ - torchvision==0.24.0 \ - torchao==0.14.0+cpu \ - torchaudio==2.9.0 - + executorch==1.1.0 \ + ethos-u-vela==4.5.0 \ + torch==2.10.0+cpu \ + torchvision==0.25.0+cpu \ + torchao==0.15.0+cpu \ + torchaudio==2.10.0+cpu + +# Remove visualization-only model-explorer packages from requirements files +# (not needed for compilation, and they all require Python <3.13) +RUN sed -i '/model-explorer/d' \ + /workspace/executorch/backends/arm/requirements-arm-tosa.txt \ + /workspace/executorch/backends/arm/requirements-arm-ethos-u.txt + # Setup ARM environment using official script WORKDIR /workspace/executorch RUN ./examples/arm/setup.sh --i-agree-to-the-contained-eula # Rename architecture-specific toolchain folder to neutral name for multi-arch host-support -RUN cd examples/arm/ethos-u-scratch && \ +RUN cd examples/arm/arm-scratch && \ TOOLCHAIN_DIR=$(ls -d arm-gnu-toolchain-13.3.rel1-*-arm-none-eabi 2>/dev/null | head -1) && \ if [ -n "$TOOLCHAIN_DIR" ] && [ "$TOOLCHAIN_DIR" != "arm-gnu-toolchain-13.3.rel1-arm-none-eabi" ]; then \ echo "Renaming $TOOLCHAIN_DIR to arm-gnu-toolchain-13.3.rel1-arm-none-eabi" && \ diff --git a/scripts/build_stage1.sh b/scripts/build_stage1.sh index 34fef82e..a9717901 100755 --- a/scripts/build_stage1.sh +++ b/scripts/build_stage1.sh @@ -69,7 +69,6 @@ CMAKE_ARGS=( -DEXECUTORCH_ENABLE_PROGRAM_VERIFICATION=OFF -DEXECUTORCH_OPTIMIZE_SIZE=ON -DBUILD_TESTING=OFF - -DFETCH_ETHOS_U_CONTENT=OFF -DEXECUTORCH_SELECT_OPS_MODEL= # empty => full schema based libs ) @@ -83,6 +82,36 @@ if [[ -n "${EXECUTORCH_EXTRA_CMAKE_ARGS:-}" ]]; then CMAKE_ARGS+=("${EXTRA_SPLIT[@]}") fi +# Run configure once to let FetchContent download CMSIS-NN +echo "[Stage1] Initial configure (downloading dependencies)..." +cmake "${EXECUTORCH_SRC}" "${CMAKE_ARGS[@]}" -B . 2>&1 | tee cmake_initial.log || { + # Expected to fail on first run due to CMSIS-NN include path issue + echo "[Stage1] Initial configure failed (expected). Checking for CMSIS-NN..." +} + +# Patch CMSIS-NN if it was downloaded +CMSIS_NN_CMAKE="${BUILD_DIR}/_deps/cmsis_nn-src/CMakeLists.txt" +if [[ -f "${CMSIS_NN_CMAKE}" ]]; then + # Check if it needs patching (either original or Dockerfile-modified version) + if grep -q 'target_include_directories(cmsis-nn PUBLIC "Include")' "${CMSIS_NN_CMAKE}"; then + echo "[Stage1] Patching CMSIS-NN CMakeLists.txt for CMake 4.x (original version)..." + sed -i.bak 's|target_include_directories(cmsis-nn PUBLIC "Include")|target_include_directories(cmsis-nn PUBLIC "$")|' "${CMSIS_NN_CMAKE}" + echo "[Stage1] CMSIS-NN patched successfully." + elif grep -q 'target_include_directories(cmsis-nn PUBLIC "\${CMAKE_CURRENT_SOURCE_DIR}/Include")' "${CMSIS_NN_CMAKE}"; then + echo "[Stage1] Patching CMSIS-NN CMakeLists.txt for CMake 4.x (Dockerfile-modified version)..." + sed -i.bak 's|target_include_directories(cmsis-nn PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/Include")|target_include_directories(cmsis-nn PUBLIC "$")|' "${CMSIS_NN_CMAKE}" + echo "[Stage1] CMSIS-NN patched successfully." + else + echo "[Stage1] CMSIS-NN already has BUILD_INTERFACE or unknown version." + fi +else + echo "[Stage1] WARNING: CMSIS-NN not found at ${CMSIS_NN_CMAKE}" + echo "[Stage1] Build may fail if CMSIS-NN is required." +fi + +# Clean CMake cache and re-configure with patched CMSIS-NN +echo "[Stage1] Re-configuring with patched dependencies..." +rm -f CMakeCache.txt cmake "${EXECUTORCH_SRC}" "${CMAKE_ARGS[@]}" -B . echo "[Stage1] Building core & kernel libraries (no install step)..." @@ -155,6 +184,18 @@ fi HDR_COUNT=$(find "$INC_DIR" -type f -name '*.h' | wc -l | tr -d ' ' || true) echo "[Stage1] Collected $HDR_COUNT header files." +# Collect FlatBuffers generated headers from extension builds +echo "[Stage1] Collecting FlatBuffers generated headers..." +FLATBUFFER_HEADERS=$(find . -type f -name '*_generated.h' 2>/dev/null | grep -v 'program_generated\|scalar_type_generated' || true) +for FB_HDR in $FLATBUFFER_HEADERS; do + # Extract path relative to build dir + REL_PATH=$(echo "$FB_HDR" | sed 's|^\./||' | sed 's|^extension/||') + TARGET_DIR="$INC_DIR/executorch/extension/$(dirname "$REL_PATH")" + mkdir -p "$TARGET_DIR" + cp "$FB_HDR" "$TARGET_DIR/" + echo "[Stage1] Copied FlatBuffer header: $(basename "$FB_HDR")" +done + # Supplement: explicitly gather codegen headers that might live outside include/ tree echo "[Stage1] Scanning for additional generated headers (Functions.h, NativeFunctions.h, CustomOpsNativeFunctions.h, Register*)." CODEGEN_PATTERNS=('Functions.h' 'NativeFunctions.h' 'CustomOpsNativeFunctions.h' 'RegisterCodegenUnboxedKernelsEverything.cpp' 'RegisterCPUCustomOps.cpp' 'RegisterSchema.cpp') diff --git a/scripts/build_stage2_selective.sh b/scripts/build_stage2_selective.sh index ed76888d..b31e62e8 100755 --- a/scripts/build_stage2_selective.sh +++ b/scripts/build_stage2_selective.sh @@ -108,8 +108,8 @@ CMAKE_ARGS=( -DCMAKE_EXPORT_COMPILE_COMMANDS=ON -DEXECUTORCH_BUILD_ARM_BAREMETAL=ON -DEXECUTORCH_BUILD_PORTABLE_OPS=ON # Build portable ops with selection - -DEXECUTORCH_BUILD_KERNELS_QUANTIZED=OFF # Disable quantized ops - -DEXECUTORCH_BUILD_CORTEX_M=OFF # Disable cortex-m ops + -DEXECUTORCH_BUILD_KERNELS_QUANTIZED=ON # Enable quantized ops (needed for header generation) + -DEXECUTORCH_BUILD_CORTEX_M=ON # Enable cortex-m ops (needed for header generation) -DEXECUTORCH_BUILD_EXECUTOR_RUNNER=OFF -DEXECUTORCH_BUILD_DEVTOOLS=OFF -DEXECUTORCH_BUILD_EXTENSION_RUNNER_UTIL=OFF @@ -119,27 +119,14 @@ CMAKE_ARGS=( -DEXECUTORCH_ENABLE_PROGRAM_VERIFICATION=OFF -DEXECUTORCH_OPTIMIZE_SIZE=ON -DBUILD_TESTING=OFF - -DFETCH_ETHOS_U_CONTENT=OFF -DEXECUTORCH_ENABLE_DTYPE_SELECTIVE_BUILD=OFF # Only build support for dtypes in model ) # Detect if quantized operators are needed NEEDS_QUANTIZED=false if [[ "${SELECTION_STRATEGY}" == "model" ]]; then - # Check if model contains quantized_decomposed operators - if python3 -c " -import sys -sys.path.insert(0, '${EXECUTORCH_SRC}') -from executorch.exir._serialize._program import deserialize_pte_binary -with open('${SELECTION_VALUE}', 'rb') as f: - program = deserialize_pte_binary(f.read()) -for plan in program.execution_plan: - for op in plan.operators: - if hasattr(op, 'name') and 'quantized' in op.name: - print('found') - exit(0) -exit(1) -" 2>/dev/null; then + # Check if the PTE binary contains quantized operator references + if strings "${SELECTION_VALUE}" 2>/dev/null | grep -qi "quantize\|dequantize"; then NEEDS_QUANTIZED=true echo "[Stage2] Detected quantized operators in model, enabling quantized kernels" fi @@ -176,6 +163,36 @@ if [[ -n "${EXECUTORCH_EXTRA_CMAKE_ARGS:-}" ]]; then CMAKE_ARGS+=("${EXTRA_SPLIT[@]}") fi +# Run configure once to let FetchContent download CMSIS-NN +echo "[Stage2] Initial configure (downloading dependencies)..." +cmake "${EXECUTORCH_SRC}" "${CMAKE_ARGS[@]}" -B . 2>&1 | tee cmake_initial.log || { + # Expected to fail on first run due to CMSIS-NN include path issue + echo "[Stage2] Initial configure failed (expected). Checking for CMSIS-NN..." +} + +# Patch CMSIS-NN if it was downloaded +CMSIS_NN_CMAKE="${BUILD_DIR}/_deps/cmsis_nn-src/CMakeLists.txt" +if [[ -f "${CMSIS_NN_CMAKE}" ]]; then + # Check if it needs patching (either original or Dockerfile-modified version) + if grep -q 'target_include_directories(cmsis-nn PUBLIC "Include")' "${CMSIS_NN_CMAKE}"; then + echo "[Stage2] Patching CMSIS-NN CMakeLists.txt for CMake 4.x (original version)..." + sed -i.bak 's|target_include_directories(cmsis-nn PUBLIC "Include")|target_include_directories(cmsis-nn PUBLIC "$")|' "${CMSIS_NN_CMAKE}" + echo "[Stage2] CMSIS-NN patched successfully." + elif grep -q 'target_include_directories(cmsis-nn PUBLIC "\${CMAKE_CURRENT_SOURCE_DIR}/Include")' "${CMSIS_NN_CMAKE}"; then + echo "[Stage2] Patching CMSIS-NN CMakeLists.txt for CMake 4.x (Dockerfile-modified version)..." + sed -i.bak 's|target_include_directories(cmsis-nn PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/Include")|target_include_directories(cmsis-nn PUBLIC "$")|' "${CMSIS_NN_CMAKE}" + echo "[Stage2] CMSIS-NN patched successfully." + else + echo "[Stage2] CMSIS-NN already has BUILD_INTERFACE or unknown version." + fi +else + echo "[Stage2] WARNING: CMSIS-NN not found at ${CMSIS_NN_CMAKE}" + echo "[Stage2] Build may fail if CMSIS-NN is required." +fi + +# Clean CMake cache and re-configure with patched CMSIS-NN +echo "[Stage2] Re-configuring with patched dependencies..." +rm -f CMakeCache.txt cmake "${EXECUTORCH_SRC}" "${CMAKE_ARGS[@]}" -B . echo "[Stage2] Building selective operator library..." diff --git a/scripts/local_workflow.sh b/scripts/local_workflow.sh index b1319c7b..e9865366 100755 --- a/scripts/local_workflow.sh +++ b/scripts/local_workflow.sh @@ -57,7 +57,7 @@ log_and_tee "stage1_build" "/workspace2/scripts/build_stage1.sh /workspace/execu # Registration files (RegisterCodegenUnboxedKernelsEverything.cpp) are NOT included here - they come from stage2 (selective build) # Flags -fPIC and -s are removed for AC6 compatibility (causes compiler crash in AC6 6.24.0) echo -e "\033[1;35m=== Step 2a: Generate source layer ===\033[0m" -log_and_tee "generate_source_layer" "cd /workspace2/out/stage1 && python3 /workspace2/scripts/ccdb2clayer.py -c compile_commands.json -v --copy-sources -A /workspace/executorch -A /workspace2/out/stage1 -L . -o /workspace2/ai_layer/engine/stage1_source.clayer.yml -n 'ExecuTorch Core Sources' -g runtime -g extension -g schema -g 'kernels/quantized' -g backends --exclude '*/posix.cpp' --remove-flags=-fPIC --remove-flags=-s" +log_and_tee "generate_source_layer" "cd /workspace2/out/stage1 && python3 /workspace2/scripts/ccdb2clayer.py -c compile_commands.json -v --copy-sources -A /workspace/executorch -A /workspace2/out/stage1 -L . -o /workspace2/ai_layer/engine/stage1_source.clayer.yml -n 'ExecuTorch Core Sources' -g runtime -g extension -g schema -g 'kernels/quantized' -g backends --exclude '*/posix.cpp' --exclude 'extension/flat_tensor/*' --remove-flags=-fPIC --remove-flags=-s" # Step 2b: Copy NativeFunctions.h to stage1 source directories # Registration files use #include "NativeFunctions.h" expecting the header in the same directory diff --git a/src/executor_runner/arm_executor_runner.cpp b/src/executor_runner/arm_executor_runner.cpp index 6b965d03..a4c9f3d0 100644 --- a/src/executor_runner/arm_executor_runner.cpp +++ b/src/executor_runner/arm_executor_runner.cpp @@ -92,6 +92,7 @@ #include #include #include +#include #include #include // For exit() @@ -623,6 +624,13 @@ void runner_init( program.error()); } + // Get program version from the FlatBuffer schema + const auto* program_ptr = executorch_flatbuffer::GetProgram(program_data); + if (program_ptr != nullptr) { + uint32_t pte_version = program_ptr->version(); + ET_LOG(Info, "ExecuTorch Program Schema Version: %u", pte_version); + } + ET_LOG(Info, "Model buffer loaded, has %u methods", program->num_methods()); { From b3ddf6c2baf1d1fe5cbe351869a69fe13cd9e370 Mon Sep 17 00:00:00 2001 From: Matthias Hertel Date: Sun, 22 Feb 2026 12:28:23 +0100 Subject: [PATCH 06/17] Fix pybind dependency --- .docker/Dockerfile | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/.docker/Dockerfile b/.docker/Dockerfile index ba54e42a..ad2bde9b 100644 --- a/.docker/Dockerfile +++ b/.docker/Dockerfile @@ -118,6 +118,10 @@ RUN sed -i '/model-explorer/d' \ /workspace/executorch/backends/arm/requirements-arm-tosa.txt \ /workspace/executorch/backends/arm/requirements-arm-ethos-u.txt +# Pin pybind11 to version compatible with TOSA serialization library +# (pybind11 v2.13+ has breaking changes that break def_property_readonly with keep_alive) +RUN pip install --break-system-packages "pybind11<2.13" + # Setup ARM environment using official script WORKDIR /workspace/executorch RUN ./examples/arm/setup.sh --i-agree-to-the-contained-eula From 81c34eb24d127ae6b43bfcede853ad8d122a3220 Mon Sep 17 00:00:00 2001 From: Matthias Hertel Date: Tue, 24 Feb 2026 13:41:12 +0100 Subject: [PATCH 07/17] Use tosa-tools binary wheels --- .docker/Dockerfile | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/.docker/Dockerfile b/.docker/Dockerfile index ad2bde9b..b3b2e85e 100644 --- a/.docker/Dockerfile +++ b/.docker/Dockerfile @@ -122,6 +122,18 @@ RUN sed -i '/model-explorer/d' \ # (pybind11 v2.13+ has breaking changes that break def_property_readonly with keep_alive) RUN pip install --break-system-packages "pybind11<2.13" +# Pre-install tosa-tools from PyPI (avoids ~3min C++ source build in setup.sh) +# tosa-tools 0.4.0 bundles both the reference model and tosa_serialization_lib +RUN pip install --break-system-packages tosa-tools==0.4.0 + +# Neutralize the tosa-tools source-build pip-install lines in setup.sh +# (the env-var prefixes become harmless assignments passed to `true`; +# the git clone still runs so the directory-existence checks pass) +RUN sed -i \ + -e 's|pip install --no-dependencies ./reference_model|true # tosa-tools pre-installed from PyPI|' \ + -e 's|pip install --no-dependencies ./serialization|true # tosa-serialization-lib pre-installed from PyPI|' \ + /workspace/executorch/examples/arm/setup.sh + # Setup ARM environment using official script WORKDIR /workspace/executorch RUN ./examples/arm/setup.sh --i-agree-to-the-contained-eula From 225f59e53810abff8a62ba3fb39eecbb74969342 Mon Sep 17 00:00:00 2001 From: Matthias Hertel Date: Tue, 24 Feb 2026 13:51:51 +0100 Subject: [PATCH 08/17] Revert "Use tosa-tools binary wheels" This reverts commit 81c34eb24d127ae6b43bfcede853ad8d122a3220. --- .docker/Dockerfile | 12 ------------ 1 file changed, 12 deletions(-) diff --git a/.docker/Dockerfile b/.docker/Dockerfile index b3b2e85e..ad2bde9b 100644 --- a/.docker/Dockerfile +++ b/.docker/Dockerfile @@ -122,18 +122,6 @@ RUN sed -i '/model-explorer/d' \ # (pybind11 v2.13+ has breaking changes that break def_property_readonly with keep_alive) RUN pip install --break-system-packages "pybind11<2.13" -# Pre-install tosa-tools from PyPI (avoids ~3min C++ source build in setup.sh) -# tosa-tools 0.4.0 bundles both the reference model and tosa_serialization_lib -RUN pip install --break-system-packages tosa-tools==0.4.0 - -# Neutralize the tosa-tools source-build pip-install lines in setup.sh -# (the env-var prefixes become harmless assignments passed to `true`; -# the git clone still runs so the directory-existence checks pass) -RUN sed -i \ - -e 's|pip install --no-dependencies ./reference_model|true # tosa-tools pre-installed from PyPI|' \ - -e 's|pip install --no-dependencies ./serialization|true # tosa-serialization-lib pre-installed from PyPI|' \ - /workspace/executorch/examples/arm/setup.sh - # Setup ARM environment using official script WORKDIR /workspace/executorch RUN ./examples/arm/setup.sh --i-agree-to-the-contained-eula From 713a68ae66086296599b433a39c2455123f5f047 Mon Sep 17 00:00:00 2001 From: Matthias Hertel Date: Wed, 25 Feb 2026 10:01:46 +0100 Subject: [PATCH 09/17] perf: Optimize Docker build by pre-installing tosa-tools from Test PyPI - Install tosa-tools==0.0.4 from Test PyPI using --extra-index-url (pre-built wheel) - Avoids ~3 minute C++ source compilation of reference_model and serialization libs - Patch setup.sh to skip tosa-tools source builds via sed (git clone still runs) - Reduces total Docker build time by ~3 minutes (from ~32min to ~29min) - Uses --extra-index-url to resolve numpy from main PyPI while fetching tosa-tools from Test PyPI --- .docker/Dockerfile | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/.docker/Dockerfile b/.docker/Dockerfile index ad2bde9b..64776977 100644 --- a/.docker/Dockerfile +++ b/.docker/Dockerfile @@ -122,6 +122,17 @@ RUN sed -i '/model-explorer/d' \ # (pybind11 v2.13+ has breaking changes that break def_property_readonly with keep_alive) RUN pip install --break-system-packages "pybind11<2.13" +# Pre-install tosa-tools from Test PyPI (avoids ~3min C++ source build in setup.sh) +# Use --extra-index-url so dependencies like numpy fall back to main PyPI +RUN pip install --break-system-packages --extra-index-url https://test.pypi.org/simple/ tosa-tools==0.0.4 + +# Neutralize the tosa-tools source-build pip-install lines in setup.sh +# (the git clone still runs so the directory-existence checks pass) +RUN sed -i \ + -e 's|pip install --no-dependencies ./reference_model|true # tosa-tools pre-installed from Test PyPI|' \ + -e 's|pip install --no-dependencies ./serialization|true # tosa-serialization-lib pre-installed from Test PyPI|' \ + /workspace/executorch/examples/arm/setup.sh + # Setup ARM environment using official script WORKDIR /workspace/executorch RUN ./examples/arm/setup.sh --i-agree-to-the-contained-eula From 7be98f5bbcff0feb5582165cb5ebe05726640a0d Mon Sep 17 00:00:00 2001 From: Matthias Hertel Date: Fri, 27 Feb 2026 08:42:24 +0100 Subject: [PATCH 10/17] chore: Update tosa-tools to official PyPI release - Replace tosa-tools==0.0.4 from Test PyPI with tosa-tools==2026.2.0 from official PyPI - Remove --extra-index-url workaround (no longer needed) - Simplify installation to use main PyPI directly --- .docker/Dockerfile | 46 ++++++++++++++++++++++++---------------------- 1 file changed, 24 insertions(+), 22 deletions(-) diff --git a/.docker/Dockerfile b/.docker/Dockerfile index 64776977..d93d718c 100644 --- a/.docker/Dockerfile +++ b/.docker/Dockerfile @@ -1,3 +1,4 @@ +# syntax=docker/dockerfile:1 FROM ubuntu:24.04 # Prevent interactive prompts during package installation @@ -76,24 +77,26 @@ RUN git clone https://github.com/pytorch/executorch.git && \ git submodule update --init --recursive # Create CMake module to patch CMSIS-NN for CMake 4.x compatibility +# (printf-based to avoid heredoc syntax that requires BuildKit in older Docker configurations; +# use 'DOCKER_BUILDKIT=1 docker build .' or 'docker buildx build .' to enable BuildKit explicitly) RUN mkdir -p /workspace/executorch/cmake/modules && \ - cat > /workspace/executorch/cmake/modules/PatchCmsisNN.cmake << 'EOF' -# Patch CMSIS-NN after FetchContent populates it for CMake 4.x compatibility -macro(patch_cmsis_nn_if_needed) - if(EXISTS "${cmsis_nn_SOURCE_DIR}/CMakeLists.txt") - file(READ "${cmsis_nn_SOURCE_DIR}/CMakeLists.txt" CMSIS_NN_CONTENT) - string(FIND "${CMSIS_NN_CONTENT}" "target_include_directories(cmsis-nn PUBLIC \"Include\")" HAS_RELATIVE_PATH) - if(NOT HAS_RELATIVE_PATH EQUAL -1) - message(STATUS "Patching CMSIS-NN for CMake 4.x compatibility") - string(REPLACE - "target_include_directories(cmsis-nn PUBLIC \"Include\")" - "target_include_directories(cmsis-nn PUBLIC \"\${CMAKE_CURRENT_SOURCE_DIR}/Include\")" - CMSIS_NN_CONTENT "${CMSIS_NN_CONTENT}") - file(WRITE "${cmsis_nn_SOURCE_DIR}/CMakeLists.txt" "${CMSIS_NN_CONTENT}") - endif() - endif() -endmacro() -EOF + printf '%s\n' \ + '# Patch CMSIS-NN after FetchContent populates it for CMake 4.x compatibility' \ + 'macro(patch_cmsis_nn_if_needed)' \ + ' if(EXISTS "${cmsis_nn_SOURCE_DIR}/CMakeLists.txt")' \ + ' file(READ "${cmsis_nn_SOURCE_DIR}/CMakeLists.txt" CMSIS_NN_CONTENT)' \ + ' string(FIND "${CMSIS_NN_CONTENT}" "target_include_directories(cmsis-nn PUBLIC \"Include\")" HAS_RELATIVE_PATH)' \ + ' if(NOT HAS_RELATIVE_PATH EQUAL -1)' \ + ' message(STATUS "Patching CMSIS-NN for CMake 4.x compatibility")' \ + ' string(REPLACE' \ + ' "target_include_directories(cmsis-nn PUBLIC \"Include\")"' \ + ' "target_include_directories(cmsis-nn PUBLIC \"\${CMAKE_CURRENT_SOURCE_DIR}/Include\")"' \ + ' CMSIS_NN_CONTENT "${CMSIS_NN_CONTENT}")' \ + ' file(WRITE "${cmsis_nn_SOURCE_DIR}/CMakeLists.txt" "${CMSIS_NN_CONTENT}")' \ + ' endif()' \ + ' endif()' \ + 'endmacro()' \ + > /workspace/executorch/cmake/modules/PatchCmsisNN.cmake # Patch ExecuTorch's cortex_m backend to use the patching module RUN cd /workspace/executorch/backends/cortex_m && \ @@ -122,15 +125,14 @@ RUN sed -i '/model-explorer/d' \ # (pybind11 v2.13+ has breaking changes that break def_property_readonly with keep_alive) RUN pip install --break-system-packages "pybind11<2.13" -# Pre-install tosa-tools from Test PyPI (avoids ~3min C++ source build in setup.sh) -# Use --extra-index-url so dependencies like numpy fall back to main PyPI -RUN pip install --break-system-packages --extra-index-url https://test.pypi.org/simple/ tosa-tools==0.0.4 +# Pre-install tosa-tools from PyPI (avoids ~3min C++ source build in setup.sh) +RUN pip install --break-system-packages tosa-tools==2026.2.0 # Neutralize the tosa-tools source-build pip-install lines in setup.sh # (the git clone still runs so the directory-existence checks pass) RUN sed -i \ - -e 's|pip install --no-dependencies ./reference_model|true # tosa-tools pre-installed from Test PyPI|' \ - -e 's|pip install --no-dependencies ./serialization|true # tosa-serialization-lib pre-installed from Test PyPI|' \ + -e 's|pip install --no-dependencies ./reference_model|true # tosa-tools pre-installed from PyPI|' \ + -e 's|pip install --no-dependencies ./serialization|true # tosa-serialization-lib pre-installed from PyPI|' \ /workspace/executorch/examples/arm/setup.sh # Setup ARM environment using official script From 28112caf7fcda634763ddffb34d40bb9ad39310f Mon Sep 17 00:00:00 2001 From: Matthias Hertel Date: Fri, 6 Mar 2026 11:59:55 +0100 Subject: [PATCH 11/17] feat: add pack-based AI layer generation from operator metadata Add scripts to translate ExecuTorch operator names (aten::, quantized_decomposed::) into PyTorch::ExecuTorch CMSIS-Pack component references, enabling AI layer generation without Docker builds. New files: - scripts/generate_pack_clayer.py: Python script with operator-to-component mapping for 143 portable + 9 quantized operators. Supports input from .pte model files, operators list files, selected_operators.yaml, or command-line lists. - scripts/generate_pack_layer.sh: Shell wrapper combining model conversion and pack-based layer generation. - documentation/PACK_BASED_LAYER.md: Comprehensive documentation including mapping tables, usage examples, and comparison with the Docker-based workflow. Modified: - .vscode/tasks.json: Added 'Pack: Generate AI Layer from Model' and 'Pack: Generate AI Layer from Operators File' VS Code tasks. --- .vscode/tasks.json | 339 ++++++++++++++++- documentation/PACK_BASED_LAYER.md | 219 +++++++++++ scripts/generate_pack_clayer.py | 588 ++++++++++++++++++++++++++++++ scripts/generate_pack_layer.sh | 213 +++++++++++ 4 files changed, 1358 insertions(+), 1 deletion(-) create mode 100644 documentation/PACK_BASED_LAYER.md create mode 100644 scripts/generate_pack_clayer.py create mode 100755 scripts/generate_pack_layer.sh diff --git a/.vscode/tasks.json b/.vscode/tasks.json index 870f6521..37fc0ff0 100644 --- a/.vscode/tasks.json +++ b/.vscode/tasks.json @@ -50,7 +50,7 @@ } }, { - "label": "Docker: Run ExecuTorch Build", + "label": "Docker: Run ExecuTorch Build - AI Layer Generation", "type": "shell", "command": "docker", "args": [ @@ -166,6 +166,343 @@ } }, "problemMatcher": [] + }, + { + "label": "CMSIS Load+Run", + "problemMatcher": [], + "type": "shell", + "command": "FVP_Corstone_SSE-300_Ethos-U55", + "options": { + "cwd": "${workspaceFolder}/", + "shell": { + "executable": "/bin/bash", + "args": [ + "-c" + ] + } + }, + "args": [ + "-f", + "board/Corstone-300/fvp_config.txt", + "--simlimit", + "10", + "-a", + "out/executorch_project/AVH-SSE-300/Debug-Source/executorch_project.axf", + "" + ] + }, + { + "label": "FVP: Run Debug (GCC, Libraries)", + "problemMatcher": [], + "type": "shell", + "command": "docker", + "args": [ + "run", + "--rm", + "-v", + "${workspaceFolder}:/workspaceFolder", + "avh-mlops-licensed:latest", + "runops", + "FVP_Corstone_SSE-300_Ethos-U55", + "-f", + "/workspaceFolder/board/Corstone-300/fvp_config.txt", + "-a", + "/workspaceFolder/out/executorch_project/AVH-SSE-300/Debug/executorch_project.elf" + ], + "detail": "Run Debug build on FVP (GCC with pre-built libraries)" + }, + { + "label": "FVP: Run Debug-Source (GCC / Clang)", + "problemMatcher": [], + "type": "shell", + "command": "docker", + "args": [ + "run", + "--rm", + "-v", + "${workspaceFolder}:/workspaceFolder", + "avh-mlops-licensed:latest", + "runops", + "FVP_Corstone_SSE-300_Ethos-U55", + "-f", + "/workspaceFolder/board/Corstone-300/fvp_config.txt", + "-a", + "/workspaceFolder/out/executorch_project/AVH-SSE-300/Debug-Source/executorch_project.elf" + ], + "detail": "Run Debug-Source build on FVP (GCC from source)" + }, + { + "label": "FVP: Run Release (GCC, Libraries)", + "problemMatcher": [], + "type": "shell", + "command": "docker", + "args": [ + "run", + "--rm", + "-v", + "${workspaceFolder}:/workspaceFolder", + "avh-mlops-licensed:latest", + "runops", + "FVP_Corstone_SSE-300_Ethos-U55", + "-f", + "/workspaceFolder/board/Corstone-300/fvp_config.txt", + "-a", + "/workspaceFolder/out/executorch_project/AVH-SSE-300/Release/executorch_project.elf" + ], + "detail": "Run Release build on FVP (GCC with pre-built libraries)" + }, + { + "label": "FVP: Run Debug-Source (AC6)", + "problemMatcher": [], + "type": "shell", + "command": "docker", + "args": [ + "run", + "--rm", + "-v", + "${workspaceFolder}:/workspaceFolder", + "avh-mlops-licensed:latest", + "runops", + "FVP_Corstone_SSE-300_Ethos-U55", + "-f", + "/workspaceFolder/board/Corstone-300/fvp_config.txt", + "-a", + "/workspaceFolder/out/executorch_project/AVH-SSE-300/Debug-Source/executorch_project.axf" + ], + "detail": "Run Debug-Source build on FVP (AC6 compiler)" + }, + { + "label": "cbuild: Build All", + "type": "shell", + "command": "cbuild", + "args": [ + "executorch_project.csolution.yml", + "--packs" + ], + "group": "build", + "problemMatcher": [], + "detail": "Build all contexts in the solution" + }, + { + "label": "cbuild: AVH-SSE-300 Debug (GCC)", + "type": "shell", + "command": "cbuild", + "args": [ + "executorch_project.csolution.yml", + "--packs", + "--context", + "executorch_project.Debug+AVH-SSE-300", + "--toolchain", + "GCC" + ], + "group": "build", + "problemMatcher": [], + "detail": "Build Debug configuration for AVH-SSE-300 with GCC" + }, + { + "label": "cbuild: AVH-SSE-300 Debug (CLANG)", + "type": "shell", + "command": "cbuild", + "args": [ + "executorch_project.csolution.yml", + "--packs", + "--context", + "executorch_project.Debug+AVH-SSE-300", + "--toolchain", + "CLANG" + ], + "group": "build", + "problemMatcher": [], + "detail": "Build Debug configuration for AVH-SSE-300 with CLANG" + }, + { + "label": "cbuild: AVH-SSE-300 Debug (AC6)", + "type": "shell", + "command": "cbuild", + "args": [ + "executorch_project.csolution.yml", + "--packs", + "--context", + "executorch_project.Debug+AVH-SSE-300", + "--toolchain", + "AC6" + ], + "group": "build", + "problemMatcher": [], + "detail": "Build Debug configuration for AVH-SSE-300 with AC6" + }, + { + "label": "cbuild: AVH-SSE-300 Release (GCC)", + "type": "shell", + "command": "cbuild", + "args": [ + "executorch_project.csolution.yml", + "--packs", + "--context", + "executorch_project.Release+AVH-SSE-300", + "--toolchain", + "GCC" + ], + "group": "build", + "problemMatcher": [], + "detail": "Build Release configuration for AVH-SSE-300 with GCC" + }, + { + "label": "cbuild: AVH-SSE-300 Release (CLANG)", + "type": "shell", + "command": "cbuild", + "args": [ + "executorch_project.csolution.yml", + "--packs", + "--context", + "executorch_project.Release+AVH-SSE-300", + "--toolchain", + "CLANG" + ], + "group": "build", + "problemMatcher": [], + "detail": "Build Release configuration for AVH-SSE-300 with CLANG" + }, + { + "label": "cbuild: AVH-SSE-300 Release (AC6)", + "type": "shell", + "command": "cbuild", + "args": [ + "executorch_project.csolution.yml", + "--packs", + "--context", + "executorch_project.Release+AVH-SSE-300", + "--toolchain", + "AC6" + ], + "group": "build", + "problemMatcher": [], + "detail": "Build Release configuration for AVH-SSE-300 with AC6" + }, + { + "label": "cbuild: AVH-SSE-300 Debug-Source (GCC)", + "type": "shell", + "command": "cbuild", + "args": [ + "executorch_project.csolution.yml", + "--packs", + "--context", + "executorch_project.Debug-Source+AVH-SSE-300", + "--toolchain", + "GCC" + ], + "group": "build", + "problemMatcher": [], + "detail": "Build Debug-Source configuration for AVH-SSE-300 with GCC" + }, + { + "label": "cbuild: AVH-SSE-300 Debug-Source (CLANG)", + "type": "shell", + "command": "cbuild", + "args": [ + "executorch_project.csolution.yml", + "--packs", + "--context", + "executorch_project.Debug-Source+AVH-SSE-300", + "--toolchain", + "CLANG" + ], + "group": "build", + "problemMatcher": [], + "detail": "Build Debug-Source configuration for AVH-SSE-300 with CLANG" + }, + { + "label": "cbuild: AVH-SSE-300 Debug-Source (AC6)", + "type": "shell", + "command": "cbuild", + "args": [ + "executorch_project.csolution.yml", + "--packs", + "--context", + "executorch_project.Debug-Source+AVH-SSE-300", + "--toolchain", + "AC6" + ], + "group": "build", + "problemMatcher": [], + "detail": "Build Debug-Source configuration for AVH-SSE-300 with AC6" + }, + { + "label": "cbuild: Clean All", + "type": "shell", + "command": "cbuild", + "args": [ + "executorch_project.csolution.yml", + "--clean" + ], + "group": "build", + "problemMatcher": [], + "detail": "Clean all build outputs" + }, + { + "label": "cbuild: Rebuild All", + "type": "shell", + "command": "cbuild", + "args": [ + "executorch_project.csolution.yml", + "--packs", + "--rebuild" + ], + "group": "build", + "problemMatcher": [], + "detail": "Clean and rebuild all contexts" + }, + { + "label": "Pack: Generate AI Layer from Model", + "type": "shell", + "command": "bash", + "args": [ + "scripts/generate_pack_layer.sh", + "--convert-model", + "--model-header", "./model/model_pte.h", + "--report", "./model/REPORT.md", + "--verbose", + "model/ethos_u_minimal_example.pte" + ], + "options": { + "cwd": "${workspaceFolder}" + }, + "group": "build", + "problemMatcher": [], + "detail": "Generate a pack-based ai_layer.clayer.yml from model operators (no Docker needed)" + }, + { + "label": "Pack: Generate AI Layer from Operators File", + "type": "shell", + "command": "python3", + "args": [ + "scripts/generate_pack_clayer.py", + "--ops-file", "model/operators_minimal.txt", + "--model-header", "./model/model_pte.h", + "--report", "./model/REPORT.md", + "--verbose", + "-o", "ai_layer/ai_layer.clayer.yml" + ], + "options": { + "cwd": "${workspaceFolder}" + }, + "group": "build", + "problemMatcher": [], + "detail": "Generate a pack-based ai_layer.clayer.yml from an operators list file" + }, + { + "label": "Test: Full Build Matrix", + "type": "shell", + "command": "bash", + "args": [ + "scripts/run_full_matrix.sh" + ], + "options": { + "cwd": "${workspaceFolder}" + }, + "group": "test", + "problemMatcher": [], + "detail": "Run the full build-matrix test script" } ] } \ No newline at end of file diff --git a/documentation/PACK_BASED_LAYER.md b/documentation/PACK_BASED_LAYER.md new file mode 100644 index 00000000..9a19c614 --- /dev/null +++ b/documentation/PACK_BASED_LAYER.md @@ -0,0 +1,219 @@ +# Pack-Based AI Layer Generation + +This document describes how to generate a **pack-based** `ai_layer.clayer.yml` using the +`PyTorch::ExecuTorch` CMSIS-Pack, replacing the Docker-based source compilation workflow. + +## Overview + +The traditional workflow requires a Docker container to compile ExecuTorch from source, +producing static libraries and source layers (stage1/stage2). The **pack-based** approach +instead references pre-built operator components from the `PyTorch::ExecuTorch` pack, +eliminating the need for Docker entirely. + +### Comparison + +| Aspect | Source-Based (Docker) | Pack-Based | +|--------|----------------------|------------| +| Build time | ~30 minutes | Seconds | +| Requires Docker | Yes | No | +| ExecuTorch source | Required | Not needed | +| Operator selection | CMake selective build | Pack component references | +| Output | Static libraries + source layers | Single `ai_layer.clayer.yml` | +| Toolchain support | GCC, CLANG, AC6 | GCC, CLANG, AC6 (via pack) | + +## Quick Start + +### From a `.pte` Model File + +```bash +# Extract operators from model, convert to header, generate layer: +./scripts/generate_pack_layer.sh \ + --convert-model \ + --model-header ./model/model_pte.h \ + model/ethos_u_minimal_example.pte +``` + +### From an Operators List File + +```bash +# Use a manually curated operator list: +python3 scripts/generate_pack_clayer.py \ + --ops-file model/operators_minimal.txt \ + --model-header ./model/model_pte.h \ + -o ai_layer/ai_layer.clayer.yml +``` + +### From `selected_operators.yaml` + +```bash +# Use the YAML generated by an ExecuTorch build: +python3 scripts/generate_pack_clayer.py \ + --selected-yaml out/stage2/assets/meta/selected_operators.yaml \ + -o ai_layer/ai_layer.clayer.yml +``` + +## Operator-to-Component Mapping + +The script translates ExecuTorch operator names to pack component references: + +### Portable Operators + +| aten:: Operator | Pack Component | +|----------------|----------------| +| `aten::add.out` | `Operators Portable add` | +| `aten::relu.out` | `Operators Portable relu` | +| `aten::conv2d.out` | `Operators Portable convolution` | +| `aten::linear.out` | `Operators Portable addmm` | +| `aten::softmax.int_out` | `Operators Portable softmax` | +| `aten::view_copy.out` | `Operators Portable view_copy` | +| `aten::_softmax.out` | `Operators Portable softmax` | +| `aten::_native_batch_norm_legit.out` | `Operators Portable native_batch_norm` | + +**Pattern:** `aten::.out` → `Machine Learning:ExecuTorch:Operators Portable ` + +Special cases: +- Leading underscores are stripped (`_softmax` → `softmax`) +- Aliases are resolved (`conv2d` → `convolution`, `linear` → `addmm`) +- Suffixes like `.int_out`, `.Tensor_out`, `.dim_out` are stripped + +### Quantized Operators + +| quantized_decomposed:: Operator | Pack Component | +|--------------------------------|----------------| +| `quantized_decomposed::quantize_per_tensor.out` | `Operators Quantized quantize` | +| `quantized_decomposed::dequantize_per_channel.out` | `Operators Quantized dequantize` | +| `quantized_decomposed::embedding_byte.out` | `Operators Quantized embedding` | +| `quantized_decomposed::embedding_4bit.out` | `Operators Quantized embedding4b` | + +**Pattern:** Variants (per_tensor, per_channel, per_token) are grouped under a single component. + +## Core Components (Always Included) + +These components are always added to the generated layer: + +| Component | Purpose | +|-----------|---------| +| `Machine Learning:ExecuTorch:Runtime` | Core ExecuTorch runtime | +| `Machine Learning:ExecuTorch:Kernel Utils` | Kernel utilities (broadcast, reduce, etc.) | +| `Machine Learning:ExecuTorch:Kernel Registration` | Unified operator registration | +| `Machine Learning:ExecuTorch:Backend EthosU` | Ethos-U NPU backend (optional, `--no-ethos-u`) | +| `Machine Learning:ExecuTorch:Platform Bare-Metal` | Bare-metal PAL stubs | +| `Machine Learning:ExecuTorch:Stubs RandomOps` | Random op stubs for bare-metal | + +## Script Reference + +### `scripts/generate_pack_clayer.py` + +Python script that performs the operator-to-component translation. + +``` +Usage: generate_pack_clayer.py [OPTIONS] + +Options: + --model, -m FILE Extract operators from .pte model file + --ops-file, -f FILE Operators list file (one per line, # comments) + --selected-yaml, -y FILE selected_operators.yaml from ExecuTorch build + --ops, -O LIST Comma-separated operator list + --pack-name NAME CMSIS pack name (default: PyTorch::ExecuTorch) + --pack-path PATH Relative path to local pack directory + --ethos-u / --no-ethos-u Include/exclude Ethos-U backend + --cortex-m Include CMSIS-NN Cortex-M backend + --model-header PATH Path to model_pte.h in the layer + --report PATH Path to REPORT.md in the layer + --output, -o FILE Output clayer.yml path (required) + --dry-run Print YAML to stdout without writing + --verbose, -v Enable verbose output +``` + +### `scripts/generate_pack_layer.sh` + +Shell wrapper that combines model conversion and layer generation. + +``` +Usage: generate_pack_layer.sh [OPTIONS] [model.pte] + +Options: + --ops-file FILE Operators list file + --pack-path PATH Path to ExecuTorch pack + --convert-model Also convert .pte to model_pte.h header + --model-header PATH Path to model_pte.h in the layer + --cortex-m Include CMSIS-NN backend + --verbose, -v Verbose output +``` + +## Example Output + +For the Ethos-U minimal example model (`ethos_u_minimal_example.pte`): + +```yaml +layer: + type: AI + description: AI layer using PyTorch ExecuTorch pack + + packs: + - pack: PyTorch::ExecuTorch + + define: + - ET_LOG_ENABLED : 0 + + components: + # ExecuTorch core runtime + - component: Machine Learning:ExecuTorch:Runtime + - component: Machine Learning:ExecuTorch:Kernel Utils + - component: Machine Learning:ExecuTorch:Kernel Registration + # Ethos-U NPU backend + - component: Machine Learning:ExecuTorch:Backend EthosU + # Bare-metal PAL stubs + - component: Machine Learning:ExecuTorch:Platform Bare-Metal + # Random op stubs + - component: Machine Learning:ExecuTorch:Stubs RandomOps + # Quantized operators used by the model + - component: Machine Learning:ExecuTorch:Operators Quantized dequantize + - component: Machine Learning:ExecuTorch:Operators Quantized quantize + + groups: + - group: Executorch Model + files: + - file: ./model/model_pte.h + - file: ./model/REPORT.md +``` + +## Operators List File Format + +Create a text file with one operator per line. Lines starting with `#` are comments: + +```text +# Operators for my CNN model +aten::add.out +aten::conv2d.out +aten::relu.out +aten::softmax.out +aten::view_copy.out +quantized_decomposed::quantize_per_tensor.out +quantized_decomposed::dequantize_per_tensor.out +``` + +## Using a Local Pack + +If the pack is not registered with `cpackget`, provide a relative path: + +```bash +python3 scripts/generate_pack_clayer.py \ + --ops-file model/operators_minimal.txt \ + --pack-path ../packs/PyTorch.ExecuTorch.1.1.0-rc1-build.12 \ + -o ai_layer/ai_layer.clayer.yml +``` + +This generates: +```yaml + packs: + - pack: PyTorch::ExecuTorch + path: ../packs/PyTorch.ExecuTorch.1.1.0-rc1-build.12 +``` + +## VS Code Tasks + +Two tasks are available in the VS Code task runner: + +- **Pack: Generate AI Layer from Model** — Extracts operators from the `.pte` model, converts it to a header, and generates the pack-based layer +- **Pack: Generate AI Layer from Operators File** — Generates the pack-based layer from `model/operators_minimal.txt` diff --git a/scripts/generate_pack_clayer.py b/scripts/generate_pack_clayer.py new file mode 100644 index 00000000..889fab2b --- /dev/null +++ b/scripts/generate_pack_clayer.py @@ -0,0 +1,588 @@ +#!/usr/bin/env python3 +""" +Generate a pack-based ai_layer.clayer.yml from model operator metadata. + +This script translates ExecuTorch operator names (aten::, quantized_decomposed::) +into PyTorch::ExecuTorch CMSIS-Pack component references, producing a self-contained +clayer.yml that replaces the source-based stage1/stage2 layers. + +Usage: + # From a .pte model file (extracts operators via strings): + python3 generate_pack_clayer.py --model model/ethos_u_minimal_example.pte -o ai_layer/ai_layer.clayer.yml + + # From an operators list file: + python3 generate_pack_clayer.py --ops-file model/operators_minimal.txt -o ai_layer/ai_layer.clayer.yml + + # From a selected_operators.yaml (generated by ExecuTorch build): + python3 generate_pack_clayer.py --selected-yaml out/stage2/assets/meta/selected_operators.yaml -o ai_layer/ai_layer.clayer.yml + + # With explicit pack path and model header: + python3 generate_pack_clayer.py --ops-file model/operators_cnn.txt \ + --pack-path ../packs/PyTorch.ExecuTorch.1.1.0-rc1-build.12 \ + --model-header ai_layer/model/model_pte.h \ + --ethos-u --cortex-m \ + -o ai_layer/ai_layer.clayer.yml +""" + +import argparse +import re +import subprocess +import sys +from pathlib import Path +from typing import Optional + + +# ────────────────────────────────────────────────────────────────────────────── +# Operator → Pack Component Mapping +# ────────────────────────────────────────────────────────────────────────────── + +# All portable operator component names available in the pack (Csub values) +PORTABLE_COMPONENTS = { + "abs", "acos", "acosh", "add", "addmm", "alias_copy", "allclose", + "amax", "amin", "any", "arange", "argmax", "argmin", "as_strided_copy", + "asin", "asinh", "atan", "atan2", "atanh", "avg_pool2d", + "bitwise_and", "bitwise_left_shift", "bitwise_not", "bitwise_or", + "bitwise_right_shift", "bitwise_xor", "bmm", + "cat", "cdist_forward", "ceil", "clamp", "clone", "clone_dim_order", + "constant_pad_nd", "convolution", "convolution_backward", "copy", + "cos", "cosh", "cumsum", + "detach_copy", "diagonal_copy", "div", + "elu", "embedding", "empty", "empty_dim_order", "eq", "erf", "exp", + "expand_copy", "expm1", + "fill", "flip", "floor", "floor_divide", "fmod", "full", "full_like", + "gather", "ge", "gelu", "glu", "grid_sampler_2d", "gt", + "hardtanh", + "index", "index_put", "index_select", "isinf", "isnan", + "le", "leaky_relu", "lift_fresh_copy", "log", "log10", "log1p", "log2", + "log_softmax", "logical_and", "logical_not", "logical_or", "logical_xor", + "logit", "lt", + "masked_fill", "masked_scatter", "masked_select", "max", + "max_pool2d_with_indices", "max_pool2d_with_indices_backward", + "maximum", "mean", "min", "minimum", "mm", "mul", + "narrow_copy", "native_batch_norm", "native_dropout", + "native_group_norm", "native_layer_norm", "ne", "neg", "nonzero", + "ones", + "pdist_forward", "permute_copy", "pixel_shuffle", "pixel_unshuffle", + "pow", "prod", + "rand", "randn", "reciprocal", + "reflection_pad1d", "reflection_pad2d", "reflection_pad3d", + "relu", "remainder", "repeat", "repeat_interleave", + "replication_pad1d", "replication_pad2d", "replication_pad3d", + "roll", "round", "rsqrt", "rsub", + "scalar_tensor", "scatter", "scatter_add", "select_copy", + "select_scatter", "sigmoid", "sign", "sin", "sinh", + "slice_copy", "slice_scatter", "softmax", + "split_copy", "split_with_sizes_copy", "sqrt", "squeeze_copy", + "stack", "sub", "sum", + "t_copy", "tan", "tanh", "to_copy", "to_dim_order_copy", "topk", + "transpose_copy", "tril", "trunc", + "unbind_copy", "unfold_copy", "unsqueeze_copy", + "upsample_bilinear2d", "upsample_bilinear2d_aa", "upsample_nearest2d", + "var", "view_as_real_copy", "view_copy", "where", "zeros", +} + +# Quantized operator component names available in the pack +QUANTIZED_COMPONENTS = { + "add", "choose_qparams", "dequantize", "embedding", + "embedding2b", "embedding4b", "mixed_linear", "mixed_mm", "quantize", +} + +# Special aten:: operator name → portable component name mappings +# Most aten ops map directly: aten::relu.out → relu +# These handle cases where the aten name differs from the component name +ATEN_TO_PORTABLE = { + # Operators with leading underscores in aten:: names + "_softmax": "softmax", + "_log_softmax": "log_softmax", + "_cdist_forward": "cdist_forward", + "_pdist_forward": "pdist_forward", + "_to_copy": "to_copy", + "_native_batch_norm_legit": "native_batch_norm", + "_native_batch_norm_legit_no_training": "native_batch_norm", + # Alias mappings for common operator name variants + "conv2d": "convolution", # aten::conv2d.out → convolution component + "linear": "addmm", # aten::linear.out → addmm (linear decomposed) + "batch_norm": "native_batch_norm", + "layer_norm": "native_layer_norm", + "group_norm": "native_group_norm", + "dropout": "native_dropout", + "adaptive_avg_pool2d": "avg_pool2d", # fallback to avg_pool2d +} + +# quantized_decomposed:: operator → quantized component mappings +# Many variants map to the same component +QUANTIZED_DECOMPOSED_TO_COMPONENT = { + "quantize_per_tensor": "quantize", + "quantize_per_channel": "quantize", + "quantize_per_token": "quantize", + "dequantize_per_tensor": "dequantize", + "dequantize_per_channel": "dequantize", + "dequantize_per_token": "dequantize", + "add": "add", + "choose_qparams": "choose_qparams", + "embedding_byte": "embedding", + "embedding_2bit": "embedding2b", + "embedding_4bit": "embedding4b", + "mixed_linear": "mixed_linear", + "mixed_mm": "mixed_mm", +} + + +def resolve_portable_component(op_name: str) -> Optional[str]: + """ + Resolve an aten:: operator name to a portable component name. + + Examples: + "add" → "add" + "relu" → "relu" + "_softmax" → "softmax" + "conv2d" → "convolution" + "softmax.int" → "softmax" + """ + # Strip trailing .out, .Tensor_out, .int_out, .dim_out, etc. + base = op_name.split(".")[0] + + # Check explicit mapping first + if base in ATEN_TO_PORTABLE: + component = ATEN_TO_PORTABLE[base] + if component in PORTABLE_COMPONENTS: + return component + + # Direct match + if base in PORTABLE_COMPONENTS: + return base + + # Try stripping leading underscore + if base.startswith("_") and base[1:] in PORTABLE_COMPONENTS: + return base[1:] + + # Try stripping _copy suffix and matching + if base.endswith("_copy"): + without_copy = base[:-5] + if without_copy in PORTABLE_COMPONENTS: + return without_copy + + return None + + +def resolve_quantized_component(op_name: str) -> Optional[str]: + """ + Resolve a quantized_decomposed:: operator name to a quantized component name. + + Examples: + "quantize_per_tensor" → "quantize" + "dequantize_per_channel" → "dequantize" + "embedding_byte" → "embedding" + """ + # Strip trailing .out, .Tensor_out, etc. + base = op_name.split(".")[0] + + # Check explicit mapping + if base in QUANTIZED_DECOMPOSED_TO_COMPONENT: + component = QUANTIZED_DECOMPOSED_TO_COMPONENT[base] + if component in QUANTIZED_COMPONENTS: + return component + + # Direct match + if base in QUANTIZED_COMPONENTS: + return base + + return None + + +def parse_operators_file(path: Path) -> list[str]: + """ + Parse an operators list file (one operator per line, # comments). + Returns raw operator strings like "aten::add.out". + """ + ops = [] + with open(path) as f: + for line in f: + line = line.strip() + if not line or line.startswith("#"): + continue + ops.append(line) + return ops + + +def parse_selected_operators_yaml(path: Path) -> list[str]: + """ + Parse ExecuTorch's selected_operators.yaml to extract operator names. + Format is typically: + operators: + aten::add.out: + ... + quantized_decomposed::quantize_per_tensor.out: + ... + """ + ops = [] + with open(path) as f: + for line in f: + line = line.strip() + # Match lines like "aten::add.out:" or "quantized_decomposed::dequantize_per_tensor.out:" + if (line.startswith("aten::") or line.startswith("quantized_decomposed::")) and line.endswith(":"): + ops.append(line.rstrip(":").strip()) + return ops + + +def extract_operators_from_pte(pte_path: Path) -> list[str]: + """ + Extract operator names from a .pte model file using strings. + Looks for aten:: and quantized_decomposed:: patterns. + """ + try: + result = subprocess.run( + ["strings", str(pte_path)], + capture_output=True, text=True, timeout=30 + ) + if result.returncode != 0: + print(f"[WARN] strings command failed on {pte_path}", file=sys.stderr) + return [] + except Exception as e: + print(f"[WARN] Failed to run strings on {pte_path}: {e}", file=sys.stderr) + return [] + + ops = set() + for line in result.stdout.splitlines(): + line = line.strip() + # Match full operator references + for match in re.finditer(r'(aten::\w+(?:\.\w+)*)', line): + ops.add(match.group(1)) + for match in re.finditer(r'(quantized_decomposed::\w+(?:\.\w+)*)', line): + ops.add(match.group(1)) + + return sorted(ops) + + +def translate_operators(raw_ops: list[str], verbose: bool = False) -> tuple[list[str], list[str], list[str]]: + """ + Translate raw operator strings to pack component names. + + Returns: + (portable_components, quantized_components, unmapped_operators) + """ + portable = set() + quantized = set() + unmapped = [] + + for op in raw_ops: + if op.startswith("aten::"): + op_name = op[len("aten::"):] + component = resolve_portable_component(op_name) + if component: + portable.add(component) + if verbose: + print(f" {op} → Operators Portable {component}") + else: + unmapped.append(op) + if verbose: + print(f" {op} → [UNMAPPED]") + + elif op.startswith("quantized_decomposed::"): + op_name = op[len("quantized_decomposed::"):] + component = resolve_quantized_component(op_name) + if component: + quantized.add(component) + if verbose: + print(f" {op} → Operators Quantized {component}") + else: + unmapped.append(op) + if verbose: + print(f" {op} → [UNMAPPED]") + + else: + # Unknown namespace — try as portable + component = resolve_portable_component(op) + if component: + portable.add(component) + if verbose: + print(f" {op} → Operators Portable {component} (inferred)") + else: + unmapped.append(op) + if verbose: + print(f" {op} → [UNMAPPED]") + + return sorted(portable), sorted(quantized), unmapped + + +def generate_clayer_yml( + portable_components: list[str], + quantized_components: list[str], + pack_name: str = "PyTorch::ExecuTorch", + pack_path: Optional[str] = None, + description: str = "AI layer using PyTorch ExecuTorch pack", + model_header: Optional[str] = None, + report_file: Optional[str] = None, + ethos_u: bool = True, + cortex_m: bool = False, + bare_metal: bool = True, + random_stubs: bool = True, + log_enabled: int = 0, +) -> str: + """Generate the YAML content for a pack-based ai_layer.clayer.yml.""" + + lines = [] + lines.append("layer:") + lines.append(" type: AI") + lines.append(f" description: {description}") + lines.append("") + lines.append(" packs:") + + if pack_path: + lines.append(f" - pack: {pack_name}") + lines.append(f" path: {pack_path}") + else: + lines.append(f" - pack: {pack_name}") + + lines.append("") + + # Defines + lines.append(" define:") + lines.append(f" - ET_LOG_ENABLED : {log_enabled}") + lines.append("") + + # Components + lines.append(" components:") + lines.append(" # ExecuTorch core runtime") + lines.append(" - component: Machine Learning:ExecuTorch:Runtime") + lines.append(" - component: Machine Learning:ExecuTorch:Kernel Utils") + lines.append(" - component: Machine Learning:ExecuTorch:Kernel Registration") + + # Backends + if ethos_u: + lines.append(" # Ethos-U NPU backend") + lines.append(" - component: Machine Learning:ExecuTorch:Backend EthosU") + if cortex_m: + lines.append(" # CMSIS-NN Cortex-M backend") + lines.append(" - component: Machine Learning:ExecuTorch:Backend CortexM") + + # Platform stubs + if bare_metal: + lines.append(" # Bare-metal PAL stubs (replaces posix.cpp)") + lines.append(" - component: Machine Learning:ExecuTorch:Platform Bare-Metal") + if random_stubs: + lines.append(" # Random op stubs (no std::random_device on bare-metal)") + lines.append(" - component: Machine Learning:ExecuTorch:Stubs RandomOps") + + # Operator components + if portable_components: + lines.append(" # Portable operators used by the model") + for comp in portable_components: + lines.append(f" - component: Machine Learning:ExecuTorch:Operators Portable {comp}") + + if quantized_components: + lines.append(" # Quantized operators used by the model") + for comp in quantized_components: + lines.append(f" - component: Machine Learning:ExecuTorch:Operators Quantized {comp}") + + # Model files group + model_files = [] + if model_header: + model_files.append(model_header) + if report_file: + model_files.append(report_file) + + if model_files: + lines.append("") + lines.append(" groups:") + lines.append(" # AI Model") + lines.append(" - group: Executorch Model") + lines.append(" files:") + for f in model_files: + lines.append(f" - file: {f}") + + lines.append("") + return "\n".join(lines) + + +def main(): + parser = argparse.ArgumentParser( + description="Generate a pack-based ai_layer.clayer.yml from model operators", + formatter_class=argparse.RawDescriptionHelpFormatter, + epilog=__doc__, + ) + + # Input sources (at least one required) + input_group = parser.add_argument_group("Operator input (at least one required)") + input_group.add_argument( + "--model", "-m", + help="Path to .pte model file (extracts operators via strings)", + ) + input_group.add_argument( + "--ops-file", "-f", + help="Path to operators list file (one per line, # comments)", + ) + input_group.add_argument( + "--selected-yaml", "-y", + help="Path to selected_operators.yaml from ExecuTorch build", + ) + input_group.add_argument( + "--ops", "-O", + help="Comma-separated operator list (e.g. 'aten::add.out,aten::relu.out')", + ) + + # Pack configuration + pack_group = parser.add_argument_group("Pack configuration") + pack_group.add_argument( + "--pack-name", + default="PyTorch::ExecuTorch", + help="CMSIS pack name (default: PyTorch::ExecuTorch)", + ) + pack_group.add_argument( + "--pack-path", + help="Relative path to the pack directory (optional, for local packs)", + ) + + # Backend options + backend_group = parser.add_argument_group("Backend options") + backend_group.add_argument( + "--ethos-u", action="store_true", default=True, + help="Include Ethos-U NPU backend (default: true)", + ) + backend_group.add_argument( + "--no-ethos-u", action="store_true", + help="Exclude Ethos-U NPU backend", + ) + backend_group.add_argument( + "--cortex-m", action="store_true", + help="Include CMSIS-NN Cortex-M backend", + ) + backend_group.add_argument( + "--no-bare-metal", action="store_true", + help="Exclude bare-metal platform stubs", + ) + backend_group.add_argument( + "--no-random-stubs", action="store_true", + help="Exclude random ops stubs", + ) + + # Model files + model_group = parser.add_argument_group("Model files") + model_group.add_argument( + "--model-header", + help="Path to model_pte.h (relative to layer, e.g. ./model/model_pte.h)", + ) + model_group.add_argument( + "--report", + help="Path to REPORT.md (relative to layer, e.g. ./model/REPORT.md)", + ) + + # Output + parser.add_argument( + "--output", "-o", + required=True, + help="Output path for the generated clayer.yml", + ) + parser.add_argument( + "--description", "-d", + default="AI layer using PyTorch ExecuTorch pack", + help="Layer description", + ) + parser.add_argument( + "--log-enabled", type=int, default=0, + help="Value for ET_LOG_ENABLED define (default: 0)", + ) + parser.add_argument("--verbose", "-v", action="store_true") + parser.add_argument("--dry-run", action="store_true", help="Print YAML to stdout without writing file") + + args = parser.parse_args() + + # Collect operators from all sources + raw_ops = [] + + if args.ops: + raw_ops.extend(args.ops.split(",")) + if args.verbose: + print(f"[INFO] Loaded {len(args.ops.split(','))} operators from command line") + + if args.ops_file: + path = Path(args.ops_file) + if not path.exists(): + print(f"[ERROR] Operators file not found: {path}", file=sys.stderr) + sys.exit(1) + file_ops = parse_operators_file(path) + raw_ops.extend(file_ops) + if args.verbose: + print(f"[INFO] Loaded {len(file_ops)} operators from {path}") + + if args.selected_yaml: + path = Path(args.selected_yaml) + if not path.exists(): + print(f"[ERROR] Selected operators YAML not found: {path}", file=sys.stderr) + sys.exit(1) + yaml_ops = parse_selected_operators_yaml(path) + raw_ops.extend(yaml_ops) + if args.verbose: + print(f"[INFO] Loaded {len(yaml_ops)} operators from {path}") + + if args.model: + path = Path(args.model) + if not path.exists(): + print(f"[ERROR] Model file not found: {path}", file=sys.stderr) + sys.exit(1) + pte_ops = extract_operators_from_pte(path) + raw_ops.extend(pte_ops) + if args.verbose: + print(f"[INFO] Extracted {len(pte_ops)} operators from {path}") + + if not raw_ops: + print("[ERROR] No operators provided. Use --model, --ops-file, --selected-yaml, or --ops", file=sys.stderr) + sys.exit(1) + + # Deduplicate + raw_ops = sorted(set(raw_ops)) + + if args.verbose: + print(f"\n[INFO] Total unique operators: {len(raw_ops)}") + print("[INFO] Translating operators to pack components...") + + # Translate to pack components + portable, quantized, unmapped = translate_operators(raw_ops, verbose=args.verbose) + + if args.verbose: + print(f"\n[INFO] Portable components: {len(portable)}") + print(f"[INFO] Quantized components: {len(quantized)}") + if unmapped: + print(f"[WARN] Unmapped operators ({len(unmapped)}):") + for op in unmapped: + print(f" - {op}") + + if unmapped: + print(f"[WARN] {len(unmapped)} operator(s) could not be mapped to pack components:", file=sys.stderr) + for op in unmapped: + print(f" {op}", file=sys.stderr) + + # Generate YAML + ethos_u = args.ethos_u and not args.no_ethos_u + bare_metal = not args.no_bare_metal + random_stubs = not args.no_random_stubs + + yaml_content = generate_clayer_yml( + portable_components=portable, + quantized_components=quantized, + pack_name=args.pack_name, + pack_path=args.pack_path, + description=args.description, + model_header=args.model_header, + report_file=args.report, + ethos_u=ethos_u, + cortex_m=args.cortex_m, + bare_metal=bare_metal, + random_stubs=random_stubs, + log_enabled=args.log_enabled, + ) + + if args.dry_run: + print(yaml_content) + else: + output_path = Path(args.output) + output_path.parent.mkdir(parents=True, exist_ok=True) + output_path.write_text(yaml_content) + print(f"[OK] Generated {output_path}") + print(f" {len(portable)} portable + {len(quantized)} quantized operator components") + if unmapped: + print(f" {len(unmapped)} operators could not be mapped (see warnings above)") + + +if __name__ == "__main__": + main() diff --git a/scripts/generate_pack_layer.sh b/scripts/generate_pack_layer.sh new file mode 100755 index 00000000..a2722d1a --- /dev/null +++ b/scripts/generate_pack_layer.sh @@ -0,0 +1,213 @@ +#!/usr/bin/env bash +set -euo pipefail + +# ────────────────────────────────────────────────────────────────────────────── +# generate_pack_layer.sh — Generate a pack-based AI layer from model metadata +# ────────────────────────────────────────────────────────────────────────────── +# +# This script replaces the Docker-based stage1/stage2 build workflow with a +# simple operator-to-pack-component translation. Instead of compiling ExecuTorch +# from source, it references pre-built components from the PyTorch::ExecuTorch +# CMSIS-Pack. +# +# Prerequisites: +# - Python 3.8+ +# - The PyTorch::ExecuTorch pack (either local path or registered in cpackget) +# - A .pte model file OR an operators list file +# +# Usage: +# # From a .pte model (auto-extracts operators): +# ./scripts/generate_pack_layer.sh model/ethos_u_minimal_example.pte +# +# # From an operators file: +# ./scripts/generate_pack_layer.sh --ops-file model/operators_minimal.txt +# +# # With explicit pack path: +# ./scripts/generate_pack_layer.sh --pack-path ../packs/PyTorch.ExecuTorch.1.1.0-rc1-build.12 model/my_model.pte +# +# # Full options: +# ./scripts/generate_pack_layer.sh \ +# --pack-path ../packs/PyTorch.ExecuTorch.1.1.0-rc1-build.12 \ +# --ops-file model/operators_cnn.txt \ +# --model-header ./model/model_pte.h \ +# --cortex-m \ +# --output ai_layer/ai_layer.clayer.yml +# +# ────────────────────────────────────────────────────────────────────────────── + +ROOT_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd) +SCRIPT_DIR="$ROOT_DIR/scripts" + +# ── Defaults ────────────────────────────────────────────────────────────────── +OUTPUT="${OUTPUT:-$ROOT_DIR/ai_layer/ai_layer.clayer.yml}" +PACK_PATH="${PACK_PATH:-}" +PACK_NAME="${PACK_NAME:-PyTorch::ExecuTorch}" +MODEL_PTE="" +OPS_FILE="" +MODEL_HEADER="" +REPORT_FILE="" +DESCRIPTION="AI layer using PyTorch ExecuTorch pack" +CORTEX_M=false +NO_ETHOS_U=false +CONVERT_MODEL=false +VERBOSE=false + +# ── Usage ───────────────────────────────────────────────────────────────────── +usage() { + cat <&2; usage; exit 1 ;; + *) MODEL_PTE="$1"; shift ;; + esac +done + +# ── Validate inputs ────────────────────────────────────────────────────────── +if [[ -z "$MODEL_PTE" && -z "$OPS_FILE" && -z "${SELECTED_YAML:-}" ]]; then + echo "[ERROR] Must provide a .pte model, --ops-file, or --selected-yaml" >&2 + usage + exit 1 +fi + +if [[ -n "$MODEL_PTE" && ! -f "$MODEL_PTE" ]]; then + echo "[ERROR] Model file not found: $MODEL_PTE" >&2 + exit 1 +fi + +if [[ -n "$OPS_FILE" && ! -f "$OPS_FILE" ]]; then + echo "[ERROR] Operators file not found: $OPS_FILE" >&2 + exit 1 +fi + +if [[ -n "${SELECTED_YAML:-}" && ! -f "${SELECTED_YAML}" ]]; then + echo "[ERROR] Selected operators YAML not found: ${SELECTED_YAML}" >&2 + exit 1 +fi + +# ── Step 1: Convert model to header if requested ───────────────────────────── +if [[ "$CONVERT_MODEL" == "true" && -n "$MODEL_PTE" ]]; then + echo "=== Step 1: Convert model to header ===" + MODEL_DIR="$ROOT_DIR/ai_layer/model" + mkdir -p "$MODEL_DIR" + python3 "$SCRIPT_DIR/pte_to_header.py" \ + -p "$MODEL_PTE" \ + -d "$MODEL_DIR" \ + -o model_pte.h + + # Auto-set model header if not explicitly provided + if [[ -z "$MODEL_HEADER" ]]; then + MODEL_HEADER="./model/model_pte.h" + fi + echo "" +fi + +# ── Step 2: Generate pack-based clayer.yml ──────────────────────────────────── +echo "=== Step 2: Generate pack-based ai_layer.clayer.yml ===" + +GENERATE_ARGS=( + "--output" "$OUTPUT" + "--pack-name" "$PACK_NAME" + "--description" "$DESCRIPTION" +) + +# Add pack path if provided +if [[ -n "$PACK_PATH" ]]; then + GENERATE_ARGS+=("--pack-path" "$PACK_PATH") +fi + +# Add model file for operator extraction +if [[ -n "$MODEL_PTE" ]]; then + GENERATE_ARGS+=("--model" "$MODEL_PTE") +fi + +# Add operators file +if [[ -n "$OPS_FILE" ]]; then + GENERATE_ARGS+=("--ops-file" "$OPS_FILE") +fi + +# Add selected operators YAML +if [[ -n "${SELECTED_YAML:-}" ]]; then + GENERATE_ARGS+=("--selected-yaml" "${SELECTED_YAML}") +fi + +# Add model files +if [[ -n "$MODEL_HEADER" ]]; then + GENERATE_ARGS+=("--model-header" "$MODEL_HEADER") +fi +if [[ -n "$REPORT_FILE" ]]; then + GENERATE_ARGS+=("--report" "$REPORT_FILE") +fi + +# Backend options +if [[ "$CORTEX_M" == "true" ]]; then + GENERATE_ARGS+=("--cortex-m") +fi +if [[ "$NO_ETHOS_U" == "true" ]]; then + GENERATE_ARGS+=("--no-ethos-u") +fi + +# Verbose +if [[ "$VERBOSE" == "true" ]]; then + GENERATE_ARGS+=("--verbose") +fi + +python3 "$SCRIPT_DIR/generate_pack_clayer.py" "${GENERATE_ARGS[@]}" + +echo "" +echo "=== Done ===" +echo "Generated: $OUTPUT" +echo "" +echo "Next steps:" +echo " 1. Ensure the PyTorch::ExecuTorch pack is available" +echo " (either via --pack-path or registered with cpackget)" +echo " 2. Build the project:" +echo " cbuild executorch_project.csolution.yml --packs" +echo "" From 715d5f7a6af9e8e90555d0839aec0376a48acbf0 Mon Sep 17 00:00:00 2001 From: Matthias Hertel Date: Fri, 6 Mar 2026 12:23:48 +0100 Subject: [PATCH 12/17] refactor: simplify local_workflow.sh to use pack-based layer generation Replace the 7-step source-compilation workflow (stage1/stage2 CMake builds, source layer generation, header patching, artifact packaging) with a 3-step pack-based workflow: 1. Convert PyTorch model to .pte (aot_model.py) 2. Convert .pte to C header (pte_to_header.py) 3. Generate pack-based ai_layer.clayer.yml (generate_pack_clayer.py) The generated layer references PyTorch::ExecuTorch pack components instead of compiled source files, eliminating the need for ExecuTorch source compilation. --- scripts/local_workflow.sh | 208 ++++++++------------------------------ 1 file changed, 40 insertions(+), 168 deletions(-) diff --git a/scripts/local_workflow.sh b/scripts/local_workflow.sh index e9865366..1a71cf77 100755 --- a/scripts/local_workflow.sh +++ b/scripts/local_workflow.sh @@ -1,6 +1,17 @@ #!/bin/bash -# Simple build script that executes the same commands as GitHub Actions workflow +# Pack-based build script: converts model and generates a pack-based AI layer. +# +# This replaces the source-compilation workflow (stage1/stage2) with a simple +# operator-to-pack-component translation using the PyTorch::ExecuTorch CMSIS-Pack. +# +# Steps: +# 1. Convert PyTorch model to .pte (requires ExecuTorch Python environment) +# 2. Convert .pte model to C header (model_pte.h) +# 3. Generate pack-based ai_layer.clayer.yml from model operators +# +# The generated layer references pre-built components from the pack instead of +# compiling ExecuTorch from source, eliminating steps 2-4 of the old workflow. set -e @@ -32,12 +43,12 @@ log_and_tee() { # Log build start echo "$(date '+%Y-%m-%d %H:%M:%S') [INFO] ==================================" | tee "$MAIN_LOG" -echo "$(date '+%Y-%m-%d %H:%M:%S') [INFO] ExecuTorch AI Layer Build Started" | tee -a "$MAIN_LOG" +echo "$(date '+%Y-%m-%d %H:%M:%S') [INFO] ExecuTorch Pack-Based AI Layer Build" | tee -a "$MAIN_LOG" echo "$(date '+%Y-%m-%d %H:%M:%S') [INFO] Timestamp: $TIMESTAMP" | tee -a "$MAIN_LOG" echo "$(date '+%Y-%m-%d %H:%M:%S') [INFO] Log Directory: $LOG_DIR" | tee -a "$MAIN_LOG" echo "$(date '+%Y-%m-%d %H:%M:%S') [INFO] ==================================" | tee -a "$MAIN_LOG" -# Step 1: Convert and build model +# Step 1: Convert and build model (.py → .pte) echo -e "\033[1;36m=== Step 1: Convert and build model ===\033[0m" # Install model-specific requirements if requirements.txt exists @@ -47,197 +58,58 @@ fi log_and_tee "model_conversion" "cd /workspace2/model && python3 aot_model.py" -# Step 2: Build ExecuTorch Core Libraries -echo -e "\033[1;33m=== Step 2: Build ExecuTorch Core Libraries ===\033[0m" -log_and_tee "stage1_build" "/workspace2/scripts/build_stage1.sh /workspace/executorch /workspace2/out/stage1 /workspace2/model/arm-none-eabi-gcc.cmake" - -# Step 2a: Generate source layer from stage1 compile_commands.json -# Note: posix.cpp is excluded because it uses std::chrono::steady_clock which is not available in ARM Clang bare-metal libc++ -# Two strip paths are needed: one for ExecuTorch source, one for generated files in build dir -# Registration files (RegisterCodegenUnboxedKernelsEverything.cpp) are NOT included here - they come from stage2 (selective build) -# Flags -fPIC and -s are removed for AC6 compatibility (causes compiler crash in AC6 6.24.0) -echo -e "\033[1;35m=== Step 2a: Generate source layer ===\033[0m" -log_and_tee "generate_source_layer" "cd /workspace2/out/stage1 && python3 /workspace2/scripts/ccdb2clayer.py -c compile_commands.json -v --copy-sources -A /workspace/executorch -A /workspace2/out/stage1 -L . -o /workspace2/ai_layer/engine/stage1_source.clayer.yml -n 'ExecuTorch Core Sources' -g runtime -g extension -g schema -g 'kernels/quantized' -g backends --exclude '*/posix.cpp' --exclude 'extension/flat_tensor/*' --remove-flags=-fPIC --remove-flags=-s" - -# Step 2b: Copy NativeFunctions.h to stage1 source directories -# Registration files use #include "NativeFunctions.h" expecting the header in the same directory -echo -e "\033[1;35m=== Step 2b: Copy NativeFunctions.h to stage1 directories ===\033[0m" -log_and_tee "copy_native_functions_stage1" " -# Copy NativeFunctions.h for backends/cortex_m/cortex_m_ops_lib -ops_dir=/workspace2/out/stage1/backends/cortex_m/cortex_m_ops_lib -dst_dir=\"/workspace2/ai_layer/engine/backends/cortex_m/cortex_m_ops_lib\" -if [ -f \"\${ops_dir}/NativeFunctions.h\" ]; then - if [ -d \"\${dst_dir}\" ]; then - cp \"\${ops_dir}/NativeFunctions.h\" \"\${dst_dir}/\" - cp \"\${ops_dir}/Functions.h\" \"\${dst_dir}\" 2>/dev/null || true - cp \"\${ops_dir}/CustomOpsNativeFunctions.h\" \"\${dst_dir}\" 2>/dev/null || true - echo \"[Copy] NativeFunctions.h -> \${dst_dir}\" - fi -fi -# Copy NativeFunctions.h for kernels/quantized/quantized_ops_lib -ops_dir=/workspace2/out/stage1/kernels/quantized/quantized_ops_lib -dst_dir=\"/workspace2/ai_layer/engine/kernels/quantized/quantized_ops_lib\" -if [ -f \"\${ops_dir}/NativeFunctions.h\" ]; then - if [ -d \"\${dst_dir}\" ]; then - cp \"\${ops_dir}/NativeFunctions.h\" \"\${dst_dir}/\" - cp \"\${ops_dir}/Functions.h\" \"\${dst_dir}\" 2>/dev/null || true - cp \"\${ops_dir}/CustomOpsNativeFunctions.h\" \"\${dst_dir}\" 2>/dev/null || true - echo \"[Copy] NativeFunctions.h -> \${dst_dir}\" - fi -fi -" - -# Step 3: Build ExecuTorch Selective Kernel Libraries -# Using model PTE for automatic operator analysis (instead of manual operators list) -echo -e "\033[1;34m=== Step 3: Build ExecuTorch Selective Kernel Libraries ===\033[0m" -log_and_tee "stage2_build" "/workspace2/scripts/build_stage2_selective.sh /workspace/executorch /workspace2/model/ethos_u_minimal_example.pte /workspace2/out/stage2 /workspace2/model/arm-none-eabi-gcc.cmake" - -# Step 3a: Generate source layer from stage2 compile_commands.json -# Note: Files using std::random_device are excluded (not available in ARM Clang bare-metal libc++) -# Note: Quantized kernels are excluded because they're already in stage1_source.clayer.yml -# Two strip paths are needed: one for ExecuTorch source, one for generated files in build dir -# Flags -fPIC and -s are removed for AC6 compatibility (causes compiler crash in AC6 6.24.0) -echo -e "\033[1;35m=== Step 3a: Generate stage2 source layer ===\033[0m" -log_and_tee "generate_source_layer_stage2" "cd /workspace2/out/stage2 && python3 /workspace2/scripts/ccdb2clayer.py -c compile_commands.json -v --copy-sources -A /workspace/executorch -A /workspace2/out/stage2 -L . -o /workspace2/ai_layer/engine/stage2_source.clayer.yml -n 'Executorch Selective Sources' -g kernels --exclude '*/op_rand.cpp' --exclude '*/op_randn.cpp' --exclude '*/op_native_dropout.cpp' --exclude 'kernels/quantized/*' --remove-flags=-fPIC --remove-flags=-s" - -# Step 3a.1: Fix stage2 layer to use selective kernels (executorch_selected_kernels instead of portable_ops_lib) -echo -e "\033[1;35m=== Step 3a.1: Fix stage2 layer for selective kernels ===\033[0m" -log_and_tee "fix_stage2_layer" "sed -i 's|kernels/portable/portable_ops_lib/RegisterCodegenUnboxedKernelsEverything.cpp|executorch_selected_kernels/RegisterCodegenUnboxedKernelsEverything.cpp|g' /workspace2/ai_layer/engine/stage2_source.clayer.yml && echo '[Fix] Updated stage2_source.clayer.yml to use executorch_selected_kernels'" - -# Step 3b: Copy NativeFunctions.h to registration source directories (stage2 only) -# Registration files use #include "NativeFunctions.h" expecting the header in the same directory -echo -e "\033[1;35m=== Step 3b: Copy NativeFunctions.h to registration directories ===\033[0m" -log_and_tee "copy_native_functions" " -# First try executorch_selected_kernels (selective build target) -select_dir=/workspace2/out/stage2/executorch_selected_kernels -if [ -f \"\${select_dir}/NativeFunctions.h\" ]; then - dst_dir=\"/workspace2/ai_layer/engine/executorch_selected_kernels\" - mkdir -p \"\${dst_dir}\" - cp \"\${select_dir}/NativeFunctions.h\" \"\${dst_dir}/\" - if [ -f \"\${select_dir}/RegisterCodegenUnboxedKernelsEverything.cpp\" ]; then - cp \"\${select_dir}/RegisterCodegenUnboxedKernelsEverything.cpp\" \"\${dst_dir}/\" - fi - echo \"[Copy] NativeFunctions.h + registration -> \${dst_dir}\" -fi -# Fallback to portable_ops_lib if executorch_selected_kernels doesn't exist -ops_dir=/workspace2/out/stage2/kernels/portable/portable_ops_lib -if [ -f \"\${ops_dir}/NativeFunctions.h\" ]; then - dst_dir=\"/workspace2/ai_layer/engine/kernels/portable/portable_ops_lib\" - if [ -d \"\${dst_dir}\" ]; then - cp \"\${ops_dir}/NativeFunctions.h\" \"\${dst_dir}/\" - echo \"[Copy] NativeFunctions.h -> \${dst_dir}\" - fi -fi -" - -# Step 3c: Copy Clang platform stubs to ai_layer for self-contained layer -# These stubs are needed for ARM Clang builds (std::chrono and std::random_device not available) -echo -e "\033[1;35m=== Step 3c: Copy Clang platform stubs to ai_layer ===\033[0m" -log_and_tee "copy_clang_stubs" " -mkdir -p /workspace2/ai_layer/stubs -cp /workspace2/src/posix_stub.cpp /workspace2/ai_layer/stubs/ -cp /workspace2/src/random_ops_stubs.cpp /workspace2/ai_layer/stubs/ -echo '[Copy] Clang stubs -> ai_layer/stubs/' -" - -# Step 3d: Fix empty #include "" in RegisterCodegenUnboxedKernelsEverything.cpp -# ExecuTorch generates this file with #include "" which needs to be NativeFunctions.h -echo -e "\033[1;35m=== Step 3d: Fix empty include in registration files ===\033[0m" -log_and_tee "fix_empty_include" " -find /workspace2/ai_layer/engine -name 'RegisterCodegenUnboxedKernelsEverything.cpp' | while read f; do - if grep -q '#include \"\"' \"\$f\"; then - sed -i 's|#include \"\"|#include \"NativeFunctions.h\"|g' \"\$f\" - echo \"[Fix] #include \\\"\\\" -> #include \\\"NativeFunctions.h\\\" in \$(basename \$f)\" - fi -done -" - -# Step 3e: Fix assert(False) -> assert(false) in synced source files -# ExecuTorch uses Python-style assert(False) which doesn't work in C++ -echo -e "\033[1;35m=== Step 3e: Fix assert(False) bugs in synced sources ===\033[0m" -log_and_tee "fix_assert_false" " -find /workspace2/ai_layer/engine -name '*.cpp' -o -name '*.h' | xargs grep -l 'assert(False)' 2>/dev/null | while read f; do - sed -i 's/assert(False)/assert(false)/g' \"\$f\" - echo \"[Fix] assert(False) -> assert(false) in \$(basename \$f)\" -done -" - -# Step 4: Collect artifacts -echo -e "\033[1;32m=== Step 4: Collect artifacts ===\033[0m" -# Pass the ExecuTorch source path so package_sdk can copy extended_header.h. -log_and_tee "package_artifacts" "cd /workspace2 && EXECUTORCH_SRC=/workspace/executorch ./scripts/package_sdk.sh \"/workspace2/out/stage1/assets\" \"/workspace2/out/stage2/assets\" \"/workspace2/model/ethos_u_minimal_example.pte\" \"/workspace2/ai_layer/engine\"" - -# Step 4a: Fix compiler.h for AC6 (ARM Compiler 6) compatibility -# Must run AFTER package_artifacts which copies fresh headers from ExecuTorch -# AC6 uses armclang which doesn't have in bare-metal mode -echo -e "\033[1;35m=== Step 4a: Fix compiler.h for AC6 compatibility ===\033[0m" -log_and_tee "fix_ac6_compiler_h" " -COMPILER_H=/workspace2/ai_layer/engine/include/executorch/runtime/platform/compiler.h -if [ -f \"\$COMPILER_H\" ]; then - # Replace the sys/types.h include block to also handle AC6 (__ARMCC_VERSION) - # Original: #ifndef _MSC_VER / #include / #else / #include - # New: Also check for __ARMCC_VERSION (AC6) - if grep -q '#include ' \"\$COMPILER_H\"; then - sed -i 's|#ifndef _MSC_VER|#if !defined(_MSC_VER) \\&\\& !defined(__ARMCC_VERSION)|g' \"\$COMPILER_H\" - echo \"[Fix] compiler.h: Added AC6 (__ARMCC_VERSION) detection for sys/types.h workaround\" - else - echo \"[Skip] compiler.h: sys/types.h include not found (already fixed or different version)\" - fi -else - echo \"[Skip] compiler.h not found\" -fi -" - -# Step 5: Convert model to header file -echo -e "\033[1;31m=== Step 5: Convert model to header file ===\033[0m" +# Step 2: Convert model to header file (.pte → model_pte.h) +echo -e "\033[1;31m=== Step 2: Convert model to header file ===\033[0m" log_and_tee "model_to_header" "cd /workspace2 && python3 scripts/pte_to_header.py -p model/ethos_u_minimal_example.pte -d ai_layer/model -o model_pte.h" -# Step 6: Generate comprehensive AI layer report -echo -e "\033[1;93m=== Step 6: Generate AI layer report ===\033[0m" -log_and_tee "generate_report" "cd /workspace2 && python3 scripts/generate_ai_layer_report.py" - -# Step 7: Build Report Summary -echo -e "\033[1;92m=== Step 7: Build Report Summary ===\033[0m" | tee -a "$MAIN_LOG" +# Step 3: Generate pack-based ai_layer.clayer.yml +# Extracts operators from the .pte model and translates them to +# PyTorch::ExecuTorch CMSIS-Pack component references. +echo -e "\033[1;34m=== Step 3: Generate pack-based AI layer ===\033[0m" +log_and_tee "generate_pack_layer" "cd /workspace2 && python3 scripts/generate_pack_clayer.py \ + --model model/ethos_u_minimal_example.pte \ + --model-header ./model/model_pte.h \ + --report ./model/REPORT.md \ + --verbose \ + -o ai_layer/ai_layer.clayer.yml" + +# Step 4: Build Report Summary +echo -e "\033[1;92m=== Step 4: Build Report Summary ===\033[0m" | tee -a "$MAIN_LOG" echo "" | tee -a "$MAIN_LOG" -echo "📊 Build Summary:" | tee -a "$MAIN_LOG" -head -n 20 /workspace2/ai_layer/REPORT.md 2>/dev/null | tee -a "$MAIN_LOG" || echo "Report could not be displayed" | tee -a "$MAIN_LOG"/9 +echo "Generated ai_layer.clayer.yml:" | tee -a "$MAIN_LOG" +cat /workspace2/ai_layer/ai_layer.clayer.yml 2>/dev/null | tee -a "$MAIN_LOG" || echo "Layer file could not be displayed" | tee -a "$MAIN_LOG" # Log build completion echo "" | tee -a "$MAIN_LOG" echo "$(date '+%Y-%m-%d %H:%M:%S') [SUCCESS] ==================================" | tee -a "$MAIN_LOG" -echo "$(date '+%Y-%m-%d %H:%M:%S') [SUCCESS] ExecuTorch AI Layer Build Completed" | tee -a "$MAIN_LOG" +echo "$(date '+%Y-%m-%d %H:%M:%S') [SUCCESS] Pack-Based AI Layer Build Completed" | tee -a "$MAIN_LOG" echo "$(date '+%Y-%m-%d %H:%M:%S') [SUCCESS] ==================================" | tee -a "$MAIN_LOG" echo "" | tee -a "$MAIN_LOG" echo "📋 Build logs available at: $LOG_DIR" | tee -a "$MAIN_LOG" echo "📋 Main build log: $MAIN_LOG" | tee -a "$MAIN_LOG" -echo "📋 Full report available at: ai_layer/REPORT.md" | tee -a "$MAIN_LOG" +echo "📋 Generated layer: ai_layer/ai_layer.clayer.yml" | tee -a "$MAIN_LOG" # Create a build summary file cat > "$LOG_DIR/build_summary_${TIMESTAMP}.txt" << EOF -ExecuTorch AI Layer Build Summary -================================= +ExecuTorch Pack-Based AI Layer Build Summary +============================================= Build Timestamp: $TIMESTAMP Build Status: SUCCESS -Build Duration: Started at $(head -n 1 "$MAIN_LOG" | cut -d' ' -f1-2) +Build Mode: Pack-based (PyTorch::ExecuTorch CMSIS-Pack) Log Files Generated: - Main build log: $MAIN_LOG - Model conversion: $LOG_DIR/model_conversion_${TIMESTAMP}.log -- Stage1 build: $LOG_DIR/stage1_build_${TIMESTAMP}.log -- Generate source layer: $LOG_DIR/generate_source_layer_${TIMESTAMP}.log -- Stage2 build: $LOG_DIR/stage2_build_${TIMESTAMP}.log -- Package artifacts: $LOG_DIR/package_artifacts_${TIMESTAMP}.log - Model to header: $LOG_DIR/model_to_header_${TIMESTAMP}.log -- Generate report: $LOG_DIR/generate_report_${TIMESTAMP}.log +- Pack layer generation: $LOG_DIR/generate_pack_layer_${TIMESTAMP}.log Outputs Generated: -- AI Layer libraries: ai_layer/engine/lib/ -- AI Layer headers: ai_layer/engine/include/ +- AI Layer definition: ai_layer/ai_layer.clayer.yml - Model header: ai_layer/model/model_pte.h -- Build report: ai_layer/REPORT.md -For detailed information, see the individual log files above. +Next steps: + Build the project with: cbuild executorch_project.csolution.yml --packs EOF echo "" From f4db3ab6dabba9255daebdfff76bc3d6dd780d27 Mon Sep 17 00:00:00 2001 From: Matthias Hertel Date: Fri, 6 Mar 2026 12:49:31 +0100 Subject: [PATCH 13/17] feat: add portable ops to model for pack integration testing Extend the model from a simple Add (fully delegated to Ethos-U) to AddWithPostProcessing which includes CPU-side portable operators: - view_copy, mul, add, sigmoid, unsqueeze_copy, softmax These ops stay on the CPU (not delegated to NPU) so they exercise the pack-based operator component selection in the generated clayer.yml. --- model/aot_model.py | 33 ++++++++++++++++++++++++++++++--- 1 file changed, 30 insertions(+), 3 deletions(-) diff --git a/model/aot_model.py b/model/aot_model.py index aa398c43..d10dd282 100644 --- a/model/aot_model.py +++ b/model/aot_model.py @@ -1,12 +1,39 @@ import torch -class Add(torch.nn.Module): +class AddWithPostProcessing(torch.nn.Module): + """ + Model that combines an Ethos-U-delegated add with CPU-side portable ops + for testing pack-based operator component integration. + + The add operation gets quantized and delegated to Ethos-U NPU. + The post-processing ops run on the CPU as portable operators: + - view_copy (reshape the output) + - mul (scale the values) + - add (apply bias) + - sigmoid (squash to [0, 1]) + - softmax (normalize to probability distribution) + """ + def __init__(self): + super().__init__() + # Learnable scale and bias for post-processing (not quantized) + self.register_buffer('scale', torch.tensor([2.0])) + self.register_buffer('bias', torch.tensor([0.5])) + def forward(self, x: torch.Tensor, y: torch.Tensor) -> torch.Tensor: - return x + y + # This add will be delegated to Ethos-U via quantization + z = x + y + # --- CPU portable ops (not delegated) --- + z = z.view(1) # aten::view_copy.out + z = z * self.scale # aten::mul.out + z = z + self.bias # aten::add.out + z = torch.sigmoid(z) # aten::sigmoid.out + z = z.unsqueeze(0) # aten::unsqueeze_copy.out + z = torch.softmax(z, dim=-1) # aten::_softmax.out + return z example_inputs = (torch.ones(1,1,1,1),torch.ones(1,1,1,1)) -model = Add() +model = AddWithPostProcessing() model = model.eval() exported_program = torch.export.export(model, example_inputs) graph_module = exported_program.module() From 7cd6cd5328d0066b1a0116e26379b4ba55a7925f Mon Sep 17 00:00:00 2001 From: Matthias Hertel Date: Fri, 6 Mar 2026 12:57:42 +0100 Subject: [PATCH 14/17] fix: use set_module_name to only quantize inner_add submodule The previous model used set_global() which quantized ALL ops including the post-processing chain (view, mul, sigmoid, softmax). The EthosU partitioner then delegated everything to the NPU, leaving zero CPU ops. Fix: split the add into an InnerAdd submodule and use quantizer.set_module_name('inner_add', config) so only the add gets quantized and delegated. The post-processing ops stay as float and will appear in the .pte as portable CPU operators. --- model/aot_model.py | 37 +++++++++++++++++++++++-------------- 1 file changed, 23 insertions(+), 14 deletions(-) diff --git a/model/aot_model.py b/model/aot_model.py index d10dd282..1e99ff00 100644 --- a/model/aot_model.py +++ b/model/aot_model.py @@ -1,28 +1,37 @@ import torch + +class InnerAdd(torch.nn.Module): + """The add operation — this submodule gets quantized and delegated to Ethos-U.""" + def forward(self, x: torch.Tensor, y: torch.Tensor) -> torch.Tensor: + return x + y + + class AddWithPostProcessing(torch.nn.Module): """ Model that combines an Ethos-U-delegated add with CPU-side portable ops for testing pack-based operator component integration. - - The add operation gets quantized and delegated to Ethos-U NPU. - The post-processing ops run on the CPU as portable operators: - - view_copy (reshape the output) - - mul (scale the values) - - add (apply bias) - - sigmoid (squash to [0, 1]) - - softmax (normalize to probability distribution) + + Only the InnerAdd submodule is quantized (via set_module_name). + The post-processing ops stay as float and run on the CPU as portable operators: + - view_copy (reshape the output) + - mul (scale the values) + - add (apply bias) + - sigmoid (squash to [0, 1]) + - unsqueeze_copy (add batch dimension) + - softmax (normalize to probability distribution) """ def __init__(self): super().__init__() - # Learnable scale and bias for post-processing (not quantized) + self.inner_add = InnerAdd() + # Float scale and bias for post-processing (not quantized) self.register_buffer('scale', torch.tensor([2.0])) self.register_buffer('bias', torch.tensor([0.5])) def forward(self, x: torch.Tensor, y: torch.Tensor) -> torch.Tensor: - # This add will be delegated to Ethos-U via quantization - z = x + y - # --- CPU portable ops (not delegated) --- + # This add is quantized and delegated to Ethos-U NPU + z = self.inner_add(x, y) + # --- CPU portable ops (float, not delegated) --- z = z.view(1) # aten::view_copy.out z = z * self.scale # aten::mul.out z = z + self.bias # aten::add.out @@ -57,10 +66,10 @@ def forward(self, x: torch.Tensor, y: torch.Tensor) -> torch.Tensor: extra_flags=["--output-format=raw", "--debug-force-regor", "--verbose-all"], ) -# Create and configure quantizer to use a symmetric quantization config globally on all nodes +# Only quantize the inner_add submodule — post-processing stays as float CPU ops quantizer = EthosUQuantizer(compile_spec) operator_config = get_symmetric_quantization_config() -quantizer.set_global(operator_config) +quantizer.set_module_name("inner_add", operator_config) # Post training quantization quantized_graph_module = prepare_pt2e(graph_module, quantizer) From 6889282ecabfdfcaba02697d489efb2eb24ccb61 Mon Sep 17 00:00:00 2001 From: Matthias Hertel Date: Fri, 6 Mar 2026 13:11:00 +0100 Subject: [PATCH 15/17] feat: add generate_report.py to auto-create REPORT.md from build logs Parses model_conversion (Vela) and generate_pack_layer logs to produce a structured report with selected operators table, TOSA graphs, NPU performance summary, network summary, and final exported program graph. Integrated as Step 4 in local_workflow.sh (runs after pack layer gen). --- ai_layer/REPORT.md | 317 ++++++++++++++++------------ scripts/generate_report.py | 416 +++++++++++++++++++++++++++++++++++++ scripts/local_workflow.sh | 12 +- 3 files changed, 612 insertions(+), 133 deletions(-) create mode 100644 scripts/generate_report.py diff --git a/ai_layer/REPORT.md b/ai_layer/REPORT.md index 47eb8112..d4367413 100644 --- a/ai_layer/REPORT.md +++ b/ai_layer/REPORT.md @@ -1,152 +1,207 @@ -# ExecuTorch AI Layer Build Report +# AI Layer Report -**Generated:** 2026-01-27T15:55:53Z -**Git Commit:** f58e85dc74eb on main -**Repository Status:** 🔄 Modified -**Last Commit:** 2026-01-27 16:47:30 +0100 +## Selected Operators -## 📊 Build Summary +### Portable Operators (CPU) -- **Libraries:** 9 static libraries -- **Models:** 1 model assets -- **Operators:** 2 selected operators -- **Build Type:** Release +| Operator | Pack Component | +|----------|---------------| +| `aten::add` | `Machine Learning:ExecuTorch:Operators Portable add` | +| `aten::exp` | `Machine Learning:ExecuTorch:Operators Portable exp` | +| `aten::mul` | `Machine Learning:ExecuTorch:Operators Portable mul` | +| `aten::reciprocal` | `Machine Learning:ExecuTorch:Operators Portable reciprocal` | +| `aten::sigmoid` | `Machine Learning:ExecuTorch:Operators Portable sigmoid` | +| `aten::sum` | `Machine Learning:ExecuTorch:Operators Portable sum` | +| `aten::unsqueeze_copy` | `Machine Learning:ExecuTorch:Operators Portable unsqueeze_copy` | -## 📚 Library Assets +### Quantized Operators (NPU wrapper) -**Total Size:** 9.9 MiB +| Operator | Pack Component | +|----------|---------------| +| `quantized_decomposed::dequantize_per_tensor` | `Machine Learning:ExecuTorch:Operators Quantized dequantize` | +| `quantized_decomposed::quantize_per_tensor` | `Machine Learning:ExecuTorch:Operators Quantized quantize` | -| Library | Size | Percentage | Modified | Hash | -|---------|------|------------|----------|------| -| libcortex_m_kernels.a | 20.0 KiB | 0.2% | 2026-01-27 15:55:25 | `86ef9627fa72a103` | -| libcortex_m_ops_lib.a | 12.6 KiB | 0.1% | 2026-01-27 15:55:26 | `f4a47ddf1b21f081` | -| libexecutorch.a | 51.9 KiB | 0.5% | 2026-01-27 15:55:25 | `4f930898f0b42cb2` | -| libexecutorch_core.a | 216.5 KiB | 2.1% | 2026-01-27 15:55:25 | `236f25130fc02703` | -| libexecutorch_delegate_ethos_u.a | 18.6 KiB | 0.2% | 2026-01-27 15:55:26 | `7018288463b78ba6` | -| libportable_kernels.a | 9.1 MiB | 92.3% | 2026-01-27 15:55:25 | `7e65742bade39aa2` | -| libportable_ops_lib.a | 199.1 KiB | 2.0% | 2026-01-27 15:55:25 | `c4073b752a26f3fe` | -| libquantized_kernels.a | 238.6 KiB | 2.4% | 2026-01-27 15:55:26 | `95ab0f70d52a7c81` | -| libquantized_ops_lib.a | 28.7 KiB | 0.3% | 2026-01-27 15:55:26 | `6a439a0e67d94665` | +**Total:** 7 portable + 2 quantized = 9 operator components -## 🤖 Model Assets +--- -| Asset | Type | Size | Modified | Hash | -|-------|------|------|----------|------| -| ethos_u_minimal_example.pte | Model | 3.8 KiB | 2026-01-27 15:55:53 | `bd7a211160a18572` | +## Vela Conversion Log -## ⚙️ Build Configuration +### TOSA Graph — Before Optimisation -### CMake Configuration -- **Build Type:** `Release` -- **Toolchain File:** `/workspace2/model/arm-none-eabi-gcc.cmake` -- **ARM Baremetal:** `ON` -- **Cortex-M Support:** `ON` -- **Portable Ops:** `ON` -- **Quantized Kernels:** `ON` +``` +0 Const tosa_rescale_default_2_output_zp +1 Const tosa_rescale_default_2_input_zp +2 Const tosa_rescale_default_2_shifts +3 Const tosa_rescale_default_2_multipliers +4 Const tosa_rescale_default_1_output_zp +5 Const tosa_rescale_default_1_input_zp +6 Const tosa_rescale_default_1_shifts +7 Const tosa_rescale_default_1_multipliers +8 Transpose tosa_transpose_default_1 +9 Rescale tosa_rescale_default_1 +10 Const tosa_rescale_default_output_zp +11 Const tosa_rescale_default_input_zp +12 Const tosa_rescale_default_shifts +13 Const tosa_rescale_default_multipliers +14 Transpose tosa_transpose_default +15 Rescale tosa_rescale_default +16 Add aten_add_tensor +17 Rescale tosa_rescale_default_2 +18 Transpose tosa_transpose_default_2 +``` -### Selected Operators +### TOSA Graph — After Optimisation -**Source:** Model file: ethos_u_minimal_example.pte (inferred) +``` +0 Transpose tosa_transpose_default_1 +1 Add tosa_transpose_default_1_int32 +2 Mul tosa_rescale_default_1 +3 Transpose tosa_transpose_default +4 Add tosa_transpose_default_int32 +5 Mul tosa_rescale_default +6 Add tosa_rescale_default_2 +7 Transpose tosa_transpose_default_2 +``` -**Count:** 2 operators +### NPU Performance Summary ``` -quantized_decomposed::dequantize_per_tensor.out -quantized_decomposed::quantize_per_tensor.out +Original Operator NNG Operator Target Staging Usage Peak% (Staging) Op Cycles Network% (cycles) NPU SRAM AC DRAM AC OnFlash AC OffFlash AC MAC Count Network% (MAC) Util% (MAC) Name +-------------------- -------------------- ------ ------------- ---------------- ---------- ----------------- ---------- ---------- ---------- ---------- ----------- ---------- -------------- ------------ -------------------- +Transpose Transpose NPU 48 33.33 32 9.76 32 1 0 0 0 0 100.00 0.00 #70 +Transpose Transpose NPU 48 33.33 32 9.76 32 1 0 0 0 0 100.00 0.00 tosa_transpose_default_1 +Rescale Add NPU 96 66.67 34 10.37 34 2 0 0 16 0 100.00 0.00 tosa_transpose_default_1_int32 +Rescale Mul NPU 80 55.56 33 10.06 33 4 0 0 0 0 100.00 0.00 tosa_rescale_default_1 +Transpose Transpose NPU 96 66.67 32 9.76 32 1 0 0 0 0 100.00 0.00 #85 +Transpose Transpose NPU 96 66.67 32 9.76 32 1 0 0 0 0 100.00 0.00 tosa_transpose_default +Rescale Add NPU 144 100.00 34 10.37 34 2 0 0 16 0 100.00 0.00 tosa_transpose_default_int32 +Rescale Mul NPU 128 88.89 33 10.06 33 4 0 0 0 0 100.00 0.00 tosa_rescale_default +Add Add NPU 144 100.00 2 0.61 1 2 0 0 0 0 100.00 0.00 tosa_rescale_default_2 +Transpose Transpose NPU 32 22.22 32 9.76 32 1 0 0 0 0 100.00 0.00 #101 +Transpose Transpose NPU 32 22.22 32 9.76 32 1 0 0 0 0 100.00 0.00 tosa_transpose_default_2 ``` -## 🔄 Model Conversion Details - -**Ethos-U Compile Specification:** - - target: ethos-u55-128 - - system_config: Ethos_U55_High_End_Embedded - - memory_mode: Shared_Sram - - extra_flags: --output-format=raw, --debug-force-regor, --verbose-all - -**Quantization Configuration:** - - Using EthosUQuantizer with symmetric quantization - - Post-training quantization enabled - -**Model Architecture:** - - Model class: Add - -**Vela Compilation Summary:** - - Accelerator configuration Ethos_U55_128 - - System configuration Ethos_U55_High_End_Embedded - - Memory mode Shared_Sram - - Accelerator clock 500 MHz - - Design peak SRAM bandwidth 3.73 GB/s - - Design peak Off-chip Flash bandwidth 0.47 GB/s - - Total SRAM used 0.14 KiB - - Total Off-chip Flash used 0.03 KiB - - CPU operators = 0 (0.0%) - - NPU operators = 12 (100.0%) - - Average SRAM bandwidth 0.27 GB/s - - Input SRAM bandwidth 0.00 MB/batch - - Weight SRAM bandwidth 0.00 MB/batch - - Output SRAM bandwidth 0.00 MB/batch - - Total SRAM bandwidth 0.00 MB/batch - - Total SRAM bandwidth per input 0.00 MB/inference (batch size 1) - - Average Off-chip Flash bandwidth 0.04 GB/s - - Input Off-chip Flash bandwidth 0.00 MB/batch - - Weight Off-chip Flash bandwidth 0.00 MB/batch - - Output Off-chip Flash bandwidth 0.00 MB/batch - - Total Off-chip Flash bandwidth 0.00 MB/batch - - Total Off-chip Flash bandwidth per input 0.00 MB/inference (batch size 1) - - Original Weights Size 0.00 KiB - - NPU Encoded Weights Size 0.00 KiB - - Neural network macs 0 MACs/batch - - Info: The numbers below are internal compiler estimates. - - For performance numbers the compiled network should be run on an FVP Model or FPGA. - - Network Tops/s 0.00 Tops/s - - NPU cycles 349 cycles/batch - - SRAM Access cycles 24 cycles/batch - - DRAM Access cycles 0 cycles/batch - - On-chip Flash Access cycles 0 cycles/batch - - Off-chip Flash Access cycles 32 cycles/batch - - Total cycles 349 cycles/batch - - Batch Inference time 0.00 ms, 1432664.76 inferences/s (batch size 1) - -## 📦 Source Layer Export - -**Total Source Files:** 226 files across 2 layers - -| Layer | Description | Groups | Files | -|-------|-------------|--------|-------| -| stage1 | Generated from compile_commands.json (327 files) | 4 | 37 | -| stage2 | Generated from compile_commands.json (240 files) | 1 | 189 | - -### Group Details - -**STAGE1:** - -- `Runtime`: 19 files -- `Schema`: 1 files -- `Kernels/quantized`: 11 files -- `Backends`: 6 files - -**STAGE2:** - -- `Kernels`: 189 files - - -## 🛠️ Build Environment - -- **Platform:** `Linux f16f207ed567 6.12.54-linuxkit #1 SMP Fri Nov 21 10:33:45 UTC 2025 aarch64 aarch64 aarch64 GNU/Linux` -- **Python:** `Python 3.12.3` -- **CMake:** `cmake version 4.2.0` -- **ARM GCC:** `arm-none-eabi-gcc (Arm GNU Toolchain 13.3.Rel1 (Build arm-13.24)) 13.3.1 20240614` - -## 📁 Asset Locations +### Network Summary ``` -ai_layer/ -├── engine/ -│ ├── lib/ # Static libraries -│ ├── include/ # Header files -│ └── model/ # Model assets -└── REPORT.md # This report +Accelerator configuration Ethos_U55_128 +System configuration Ethos_U55_High_End_Embedded +Memory mode Shared_Sram +Accelerator clock 500 MHz +Design peak SRAM bandwidth 3.73 GB/s +Design peak Off-chip Flash bandwidth 0.47 GB/s + +Total SRAM used 0.14 KiB +Total Off-chip Flash used 0.03 KiB + +CPU operators = 0 (0.0%) +NPU operators = 11 (100.0%) + +Average SRAM bandwidth 0.24 GB/s +Input SRAM bandwidth 0.00 MB/batch +Weight SRAM bandwidth 0.00 MB/batch +Output SRAM bandwidth 0.00 MB/batch +Total SRAM bandwidth 0.00 MB/batch +Total SRAM bandwidth per input 0.00 MB/inference (batch size 1) + +Average Off-chip Flash bandwidth 0.05 GB/s +Input Off-chip Flash bandwidth 0.00 MB/batch +Weight Off-chip Flash bandwidth 0.00 MB/batch +Output Off-chip Flash bandwidth 0.00 MB/batch +Total Off-chip Flash bandwidth 0.00 MB/batch +Total Off-chip Flash bandwidth per input 0.00 MB/inference (batch size 1) + +Original Weights Size 0.00 KiB +NPU Encoded Weights Size 0.00 KiB + +Neural network macs 0 MACs/batch + +Info: The numbers below are internal compiler estimates. +For performance numbers the compiled network should be run on an FVP Model or FPGA. + +Network Tops/s 0.00 Tops/s + +NPU cycles 327 cycles/batch +SRAM Access cycles 20 cycles/batch +DRAM Access cycles 0 cycles/batch +On-chip Flash Access cycles 0 cycles/batch +Off-chip Flash Access cycles 32 cycles/batch +Total cycles 328 cycles/batch + +Batch Inference time 0.00 ms, 1524390.24 inferences/s (batch size 1) ``` ---- -*Report generated by ExecuTorch AI Layer build system at 2026-01-27T15:55:53Z* \ No newline at end of file +### Final Exported Program Graph + +```python +class GraphModule(torch.nn.Module): + def forward(self, x, y): + x: "f32[1, 1, 1, 1]"; y: "f32[1, 1, 1, 1]"; + + x, y, = fx_pytree.tree_flatten_spec(([x, y], {}), self._in_spec) + # No stacktrace found for following nodes + _tensor_constant0: "f32[1]" = self._tensor_constant0 + _tensor_constant1: "f32[1]" = self._tensor_constant1 + alloc: "i8[1, 1, 1, 1]" = executorch_exir_memory_alloc(((1, 1, 1, 1), torch.int8)) + quantized_decomposed_quantize_per_tensor_default: "i8[1, 1, 1, 1]" = torch.ops.quantized_decomposed.quantize_per_tensor.out(x, 0.003921568859368563, -128, -128, 127, torch.int8, out = alloc); x = alloc = None + alloc_1: "i8[1, 1, 1, 1]" = executorch_exir_memory_alloc(((1, 1, 1, 1), torch.int8)) + quantized_decomposed_quantize_per_tensor_default_1: "i8[1, 1, 1, 1]" = torch.ops.quantized_decomposed.quantize_per_tensor.out(y, 0.003921568859368563, -128, -128, 127, torch.int8, out = alloc_1); y = alloc_1 = None + lowered_module_0 = self.lowered_module_0 + executorch_call_delegate = torch.ops.higher_order.executorch_call_delegate(lowered_module_0, quantized_decomposed_quantize_per_tensor_default, quantized_decomposed_quantize_per_tensor_default_1); lowered_module_0 = quantized_decomposed_quantize_per_tensor_default = quantized_decomposed_quantize_per_tensor_default_1 = None + getitem: "i8[1, 1, 1, 1]" = executorch_call_delegate[0]; executorch_call_delegate = None + alloc_2: "f32[1, 1, 1, 1]" = executorch_exir_memory_alloc(((1, 1, 1, 1), torch.float32)) + quantized_decomposed_dequantize_per_tensor_default: "f32[1, 1, 1, 1]" = torch.ops.quantized_decomposed.dequantize_per_tensor.out(getitem, 0.007843137718737125, -128, -128, 127, torch.int8, out = alloc_2); getitem = alloc_2 = None + + # File: /workspace2/model/aot_model.py:35 in forward, code: z = z.view(1) # aten::view_copy.out + aten_view_copy_default: "f32[1]" = executorch_exir_memory_view(quantized_decomposed_dequantize_per_tensor_default, [1]); quantized_decomposed_dequantize_per_tensor_default = None + + # No stacktrace found for following nodes + alloc_3: "f32[1]" = executorch_exir_memory_alloc(((1,), torch.float32)) + + # File: /workspace2/model/aot_model.py:36 in forward, code: z = z * self.scale # aten::mul.out + aten_mul_tensor: "f32[1]" = torch.ops.aten.mul.out(aten_view_copy_default, _tensor_constant0, out = alloc_3); aten_view_copy_default = _tensor_constant0 = alloc_3 = None + + # No stacktrace found for following nodes + alloc_4: "f32[1]" = executorch_exir_memory_alloc(((1,), torch.float32)) + + # File: /workspace2/model/aot_model.py:37 in forward, code: z = z + self.bias # aten::add.out + aten_add_tensor: "f32[1]" = torch.ops.aten.add.out(aten_mul_tensor, _tensor_constant1, out = alloc_4); aten_mul_tensor = _tensor_constant1 = alloc_4 = None + + # No stacktrace found for following nodes + alloc_5: "f32[1]" = executorch_exir_memory_alloc(((1,), torch.float32)) + + # File: /workspace2/model/aot_model.py:38 in forward, code: z = torch.sigmoid(z) # aten::sigmoid.out + aten_sigmoid_default: "f32[1]" = torch.ops.aten.sigmoid.out(aten_add_tensor, out = alloc_5); aten_add_tensor = alloc_5 = None + + # No stacktrace found for following nodes + alloc_6: "f32[1, 1]" = executorch_exir_memory_alloc(((1, 1), torch.float32)) + + # File: /workspace2/model/aot_model.py:39 in forward, code: z = z.unsqueeze(0) # aten::unsqueeze_copy.out + aten_unsqueeze_copy_default: "f32[1, 1]" = torch.ops.aten.unsqueeze_copy.out(aten_sigmoid_default, 0, out = alloc_6); aten_sigmoid_default = alloc_6 = None + + # No stacktrace found for following nodes + alloc_7: "f32[1, 1]" = executorch_exir_memory_alloc(((1, 1), torch.float32)) + + # File: /workspace/executorch-venv/lib/python3.13/site-packages/executorch/backends/arm/_passes/decompose_softmax_unstable_pass.py:80 in call_operator, code: op1 = super().call_operator(exp_op, (_input,), {}, meta, True) + aten_exp_default: "f32[1, 1]" = torch.ops.aten.exp.out(aten_unsqueeze_copy_default, out = alloc_7); aten_unsqueeze_copy_default = alloc_7 = None + + # No stacktrace found for following nodes + alloc_8: "f32[1, 1]" = executorch_exir_memory_alloc(((1, 1), torch.float32)) + + # File: /workspace/executorch-venv/lib/python3.13/site-packages/executorch/backends/arm/_passes/decompose_softmax_unstable_pass.py:81 in call_operator, code: op2 = super().call_operator(sum_op, (op1, dim, True), {}, meta, True) + aten_sum_dim_int_list: "f32[1, 1]" = torch.ops.aten.sum.IntList_out(aten_exp_default, [-1], True, out = alloc_8); alloc_8 = None + + # No stacktrace found for following nodes + alloc_9: "f32[1, 1]" = executorch_exir_memory_alloc(((1, 1), torch.float32)) + + # File: /workspace/executorch-venv/lib/python3.13/site-packages/executorch/backends/arm/_passes/decompose_softmax_unstable_pass.py:82 in call_operator, code: op3 = super().call_operator(reciprocal_op, (op2,), {}, meta, True) + aten_reciprocal_default: "f32[1, 1]" = torch.ops.aten.reciprocal.out(aten_sum_dim_int_list, out = alloc_9); aten_sum_dim_int_list = alloc_9 = None + + # No stacktrace found for following nodes + alloc_10: "f32[1, 1]" = executorch_exir_memory_alloc(((1, 1), torch.float32)) + + # File: /workspace/executorch-venv/lib/python3.13/site-packages/executorch/backends/arm/_passes/decompose_softmax_unstable_pass.py:83 in call_operator, code: op4 = super().call_operator(mul_op, (op1, op3), {}, meta, True) + aten_mul_tensor_1: "f32[1, 1]" = torch.ops.aten.mul.out(aten_exp_default, aten_reciprocal_default, out = alloc_10); aten_exp_default = aten_reciprocal_default = alloc_10 = None + return pytree.tree_unflatten((aten_mul_tensor_1,), self._out_spec) +``` diff --git a/scripts/generate_report.py b/scripts/generate_report.py new file mode 100644 index 00000000..bc9577e2 --- /dev/null +++ b/scripts/generate_report.py @@ -0,0 +1,416 @@ +#!/usr/bin/env python3 +""" +Generate ai_layer/REPORT.md from build logs. + +Parses the model conversion log (Vela output) and pack layer generation log +to produce a structured Markdown report with: + - Selected operators table (portable + quantized) + - Vela conversion log (TOSA graphs, NPU perf, network summary) + - Final exported program graph + +Usage: + python3 scripts/generate_report.py \ + --conversion-log ai_layer/logs/model_conversion_TIMESTAMP.log \ + --pack-log ai_layer/logs/generate_pack_layer_TIMESTAMP.log \ + -o ai_layer/REPORT.md + + # Auto-detect latest logs in a directory: + python3 scripts/generate_report.py \ + --log-dir ai_layer/logs \ + -o ai_layer/REPORT.md +""" + +import argparse +import re +import sys +from pathlib import Path +from typing import Optional + + +# ────────────────────────────────────────────────────────────────────────────── +# Log Parsing +# ────────────────────────────────────────────────────────────────────────────── + +def find_latest_log(log_dir: Path, prefix: str) -> Optional[Path]: + """Find the most recent log file matching a prefix, sorted by timestamp.""" + candidates = sorted(log_dir.glob(f"{prefix}_*.log"), reverse=True) + return candidates[0] if candidates else None + + +def parse_pack_log(log_path: Path) -> dict: + """ + Parse the pack layer generation log for operator→component mappings. + + Returns dict with: + portable: list of (operator, component) tuples + quantized: list of (operator, component) tuples + total_ops: int + n_portable: int + n_quantized: int + """ + portable = [] + quantized = [] + total_ops = 0 + + with open(log_path) as f: + for line in f: + line = line.rstrip("\n") + + # Total unique operators + m = re.search(r"Total unique operators:\s*(\d+)", line) + if m: + total_ops = int(m.group(1)) + + # Mapping lines: " aten::add → Operators Portable add" + m = re.match(r"\s+(\S+)\s+→\s+Operators (Portable|Quantized)\s+(.+)", line) + if m: + op_name = m.group(1) + kind = m.group(2) + component = m.group(3).strip() + if kind == "Portable": + portable.append((op_name, component)) + else: + quantized.append((op_name, component)) + + return { + "portable": portable, + "quantized": quantized, + "total_ops": total_ops, + "n_portable": len(portable), + "n_quantized": len(quantized), + } + + +def parse_conversion_log(log_path: Path) -> dict: + """ + Parse the model conversion log for Vela sections. + + Returns dict with: + before_opt: str — "Before Graph Optimisation" block + after_opt: str — "After Graph Optimization" block + perf_table: str — NPU performance table + network_summary: str — Network summary block + final_graph: str — Final exported program graph + system_config: str — System/memory/architecture config + """ + text = log_path.read_text() + lines = text.splitlines() + + sections = { + "before_opt": "", + "after_opt": "", + "perf_table": "", + "network_summary": "", + "final_graph": "", + "system_config": "", + } + + def extract_block(start_marker: str, end_markers: list[str], + include_start: bool = False) -> str: + """Extract text between start_marker and the first end_marker found.""" + capturing = False + result = [] + for line in lines: + if start_marker in line: + capturing = True + if include_start: + result.append(line) + continue + if capturing: + for em in end_markers: + if em in line: + return "\n".join(result).strip() + result.append(line) + if capturing: + return "\n".join(result).strip() + return "" + + # ── Before Graph Optimisation ── + # There are multiple occurrences; we want the FIRST one + first_before = extract_block( + "[ Before Graph Optimisation ]", + ["[ After Graph Optim", "[ Graph With Tensor"], + ) + sections["before_opt"] = first_before + + # ── After Graph Optimization ── + # Also multiple occurrences; we want the SECOND one (the optimised version) + after_blocks = [] + capturing = False + buf = [] + for line in lines: + if "[ After Graph Optimization ]" in line: + if buf and capturing: + after_blocks.append("\n".join(buf).strip()) + capturing = True + buf = [] + continue + if capturing: + if "[ Graph With Tensor" in line or "Schedule:" in line: + after_blocks.append("\n".join(buf).strip()) + capturing = False + buf = [] + continue + buf.append(line) + if capturing and buf: + after_blocks.append("\n".join(buf).strip()) + # Use the second block if available (post-constant-fold), else first + sections["after_opt"] = after_blocks[-1] if after_blocks else "" + + # ── NPU Performance Table ── + # Starts with "Original Operator" header row, ends with blank line + perf_lines = [] + capturing = False + for line in lines: + if line.strip().startswith("Original Operator") and "NNG Operator" in line: + capturing = True + perf_lines.append(line) + continue + if capturing: + if line.strip() == "": + break + perf_lines.append(line) + sections["perf_table"] = "\n".join(perf_lines).strip() + + # ── Network Summary ── + # Starts with "Network summary for ..." and ends before "class GraphModule" + summary_lines = [] + capturing = False + for line in lines: + if line.strip().startswith("Network summary for"): + capturing = True + continue + if capturing: + if "class GraphModule" in line: + break + summary_lines.append(line) + sections["network_summary"] = "\n".join(summary_lines).strip() + + # ── Final Exported Program Graph ── + # The LAST "class GraphModule" block in the file (after Vela output) + graph_blocks = [] + capturing = False + buf = [] + for line in lines: + if "class GraphModule" in line: + if buf and capturing: + graph_blocks.append("\n".join(buf).strip()) + capturing = True + buf = [line] + continue + if capturing: + buf.append(line) + if capturing and buf: + graph_blocks.append("\n".join(buf).strip()) + sections["final_graph"] = graph_blocks[-1].strip() if graph_blocks else "" + + # ── System Configuration ── + config_lines = [] + capturing = False + for line in lines: + if line.strip().startswith("Configuration files:"): + capturing = True + config_lines.append(line) + continue + if capturing: + if line.strip().startswith("Original Operator") or line.strip() == "": + if any("Architecture Settings:" in l for l in config_lines): + break + config_lines.append(line) + if "fast_storage_mem_area" in line: + break + sections["system_config"] = "\n".join(config_lines).strip() + + return sections + + +# ────────────────────────────────────────────────────────────────────────────── +# Report Generation +# ────────────────────────────────────────────────────────────────────────────── + +def generate_report(pack_info: dict, vela_info: dict) -> str: + """Generate the REPORT.md content from parsed log data.""" + lines = [] + + lines.append("# AI Layer Report") + lines.append("") + + # ── Selected Operators ── + lines.append("## Selected Operators") + lines.append("") + + if pack_info["portable"]: + lines.append("### Portable Operators (CPU)") + lines.append("") + lines.append("| Operator | Pack Component |") + lines.append("|----------|---------------|") + for op, comp in pack_info["portable"]: + lines.append( + f"| `{op}` | `Machine Learning:ExecuTorch:Operators Portable {comp}` |" + ) + lines.append("") + + if pack_info["quantized"]: + lines.append("### Quantized Operators (NPU wrapper)") + lines.append("") + lines.append("| Operator | Pack Component |") + lines.append("|----------|---------------|") + for op, comp in pack_info["quantized"]: + lines.append( + f"| `{op}` | `Machine Learning:ExecuTorch:Operators Quantized {comp}` |" + ) + lines.append("") + + total = pack_info["n_portable"] + pack_info["n_quantized"] + lines.append( + f"**Total:** {pack_info['n_portable']} portable" + f" + {pack_info['n_quantized']} quantized" + f" = {total} operator components" + ) + lines.append("") + lines.append("---") + lines.append("") + + # ── Vela Conversion Log ── + lines.append("## Vela Conversion Log") + lines.append("") + + if vela_info["before_opt"]: + lines.append("### TOSA Graph — Before Optimisation") + lines.append("") + lines.append("```") + lines.append(vela_info["before_opt"]) + lines.append("```") + lines.append("") + + if vela_info["after_opt"]: + lines.append("### TOSA Graph — After Optimisation") + lines.append("") + lines.append("```") + lines.append(vela_info["after_opt"]) + lines.append("```") + lines.append("") + + if vela_info["perf_table"]: + lines.append("### NPU Performance Summary") + lines.append("") + lines.append("```") + lines.append(vela_info["perf_table"]) + lines.append("```") + lines.append("") + + if vela_info["network_summary"]: + lines.append("### Network Summary") + lines.append("") + lines.append("```") + lines.append(vela_info["network_summary"]) + lines.append("```") + lines.append("") + + if vela_info["final_graph"]: + lines.append("### Final Exported Program Graph") + lines.append("") + lines.append("```python") + lines.append(vela_info["final_graph"]) + lines.append("```") + lines.append("") + + return "\n".join(lines) + + +# ────────────────────────────────────────────────────────────────────────────── +# CLI +# ────────────────────────────────────────────────────────────────────────────── + +def main(): + parser = argparse.ArgumentParser( + description="Generate ai_layer/REPORT.md from build logs", + formatter_class=argparse.RawDescriptionHelpFormatter, + epilog=__doc__, + ) + + parser.add_argument( + "--conversion-log", "-c", + help="Path to model_conversion_*.log (Vela output)", + ) + parser.add_argument( + "--pack-log", "-p", + help="Path to generate_pack_layer_*.log (operator mapping)", + ) + parser.add_argument( + "--log-dir", "-L", + help="Auto-detect latest logs in this directory", + ) + parser.add_argument( + "--output", "-o", + default="ai_layer/REPORT.md", + help="Output path for REPORT.md (default: ai_layer/REPORT.md)", + ) + parser.add_argument( + "--dry-run", action="store_true", + help="Print report to stdout without writing file", + ) + parser.add_argument("--verbose", "-v", action="store_true") + + args = parser.parse_args() + + # Resolve log paths + conversion_log = None + pack_log = None + + if args.log_dir: + log_dir = Path(args.log_dir) + if not log_dir.is_dir(): + print(f"[ERROR] Log directory not found: {log_dir}", file=sys.stderr) + sys.exit(1) + conversion_log = find_latest_log(log_dir, "model_conversion") + pack_log = find_latest_log(log_dir, "generate_pack_layer") + if args.verbose: + print(f"[INFO] Auto-detected conversion log: {conversion_log}") + print(f"[INFO] Auto-detected pack log: {pack_log}") + + if args.conversion_log: + conversion_log = Path(args.conversion_log) + if args.pack_log: + pack_log = Path(args.pack_log) + + if not conversion_log or not conversion_log.exists(): + print(f"[ERROR] Model conversion log not found: {conversion_log}", file=sys.stderr) + print(" Use --conversion-log or --log-dir to specify.", file=sys.stderr) + sys.exit(1) + + if not pack_log or not pack_log.exists(): + print(f"[ERROR] Pack layer generation log not found: {pack_log}", file=sys.stderr) + print(" Use --pack-log or --log-dir to specify.", file=sys.stderr) + sys.exit(1) + + # Parse logs + if args.verbose: + print(f"[INFO] Parsing pack log: {pack_log}") + pack_info = parse_pack_log(pack_log) + if args.verbose: + print(f" Found {pack_info['n_portable']} portable, {pack_info['n_quantized']} quantized operators") + + if args.verbose: + print(f"[INFO] Parsing conversion log: {conversion_log}") + vela_info = parse_conversion_log(conversion_log) + if args.verbose: + for key, val in vela_info.items(): + status = "found" if val else "not found" + print(f" {key}: {status}") + + # Generate report + report = generate_report(pack_info, vela_info) + + if args.dry_run: + print(report) + else: + output_path = Path(args.output) + output_path.parent.mkdir(parents=True, exist_ok=True) + output_path.write_text(report) + print(f"[OK] Generated {output_path}") + print(f" {pack_info['n_portable']} portable + {pack_info['n_quantized']} quantized operators") + + +if __name__ == "__main__": + main() diff --git a/scripts/local_workflow.sh b/scripts/local_workflow.sh index 1a71cf77..f0eaa4a9 100755 --- a/scripts/local_workflow.sh +++ b/scripts/local_workflow.sh @@ -73,8 +73,16 @@ log_and_tee "generate_pack_layer" "cd /workspace2 && python3 scripts/generate_pa --verbose \ -o ai_layer/ai_layer.clayer.yml" -# Step 4: Build Report Summary -echo -e "\033[1;92m=== Step 4: Build Report Summary ===\033[0m" | tee -a "$MAIN_LOG" +# Step 4: Generate AI Layer Report (REPORT.md) +echo -e "\033[1;92m=== Step 4: Generate AI Layer Report ===\033[0m" +log_and_tee "generate_report" "cd /workspace2 && python3 scripts/generate_report.py \ + --conversion-log $LOG_DIR/model_conversion_${TIMESTAMP}.log \ + --pack-log $LOG_DIR/generate_pack_layer_${TIMESTAMP}.log \ + --verbose \ + -o ai_layer/REPORT.md" + +# Step 5: Build Report Summary +echo -e "\033[1;92m=== Step 5: Build Report Summary ===\033[0m" | tee -a "$MAIN_LOG" echo "" | tee -a "$MAIN_LOG" echo "Generated ai_layer.clayer.yml:" | tee -a "$MAIN_LOG" cat /workspace2/ai_layer/ai_layer.clayer.yml 2>/dev/null | tee -a "$MAIN_LOG" || echo "Layer file could not be displayed" | tee -a "$MAIN_LOG" From 63c4c079f700d56113d5762c6d53d8718ef3cf96 Mon Sep 17 00:00:00 2001 From: Matthias Hertel Date: Fri, 6 Mar 2026 13:56:08 +0100 Subject: [PATCH 16/17] fix: write REPORT.md to ai_layer/model/ to match clayer path --- scripts/generate_report.py | 4 ++-- scripts/local_workflow.sh | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/scripts/generate_report.py b/scripts/generate_report.py index bc9577e2..ca81c917 100644 --- a/scripts/generate_report.py +++ b/scripts/generate_report.py @@ -343,8 +343,8 @@ def main(): ) parser.add_argument( "--output", "-o", - default="ai_layer/REPORT.md", - help="Output path for REPORT.md (default: ai_layer/REPORT.md)", + default="ai_layer/model/REPORT.md", + help="Output path for REPORT.md (default: ai_layer/model/REPORT.md)", ) parser.add_argument( "--dry-run", action="store_true", diff --git a/scripts/local_workflow.sh b/scripts/local_workflow.sh index f0eaa4a9..80262cc9 100755 --- a/scripts/local_workflow.sh +++ b/scripts/local_workflow.sh @@ -79,7 +79,7 @@ log_and_tee "generate_report" "cd /workspace2 && python3 scripts/generate_report --conversion-log $LOG_DIR/model_conversion_${TIMESTAMP}.log \ --pack-log $LOG_DIR/generate_pack_layer_${TIMESTAMP}.log \ --verbose \ - -o ai_layer/REPORT.md" + -o ai_layer/model/REPORT.md" # Step 5: Build Report Summary echo -e "\033[1;92m=== Step 5: Build Report Summary ===\033[0m" | tee -a "$MAIN_LOG" From 8879193a4e0fb2449a899407fc65ac7fdff8ce9f Mon Sep 17 00:00:00 2001 From: Matthias Hertel Date: Fri, 6 Mar 2026 13:59:34 +0100 Subject: [PATCH 17/17] Generate new pack-based CLayer --- ai_layer/ai_layer.clayer.yml | 132 +- .../backends/arm/runtime/EthosUBackend.cpp | 392 - .../backends/arm/runtime/VelaBinStream.cpp | 104 - .../CustomOpsNativeFunctions.h | 26 - .../cortex_m/cortex_m_ops_lib/Functions.h | 54 - .../cortex_m_ops_lib/NativeFunctions.h | 31 - ...egisterCodegenUnboxedKernelsEverything.cpp | 186 - .../cortex_m/ops/op_dequantize_per_tensor.cpp | 196 - .../cortex_m/ops/op_quantize_per_tensor.cpp | 235 - .../cortex_m/ops/op_quantized_add.cpp | 150 - .../executorch_selected_kernels/Functions.h | 66 - .../NativeFunctions.h | 20 - ...egisterCodegenUnboxedKernelsEverything.cpp | 49 - .../RegisterCodegenUnboxedKernels_0.cpp | 182 - .../RegisterKernels.h | 22 - .../selected_operators.yaml | 79 - .../backends/arm/runtime/VGFSetup.h | 121 - .../backends/arm/runtime/VelaBinStream.h | 79 - .../include/ethosu_driver.h | 399 - .../include/ethosu_types.h | 84 - .../ethos-u-core-driver/include/pmu_ethosu.h | 515 - .../src/ethosu55_interface.h | 26197 --- .../src/ethosu65_interface.h | 26060 --- .../src/ethosu85_interface.h | 24620 --- .../src/ethosu_config_u55.h | 124 - .../src/ethosu_config_u65.h | 124 - .../src/ethosu_config_u85.h | 112 - .../ethos-u-core-driver/src/ethosu_device.h | 115 - .../src/ethosu_interface.h | 32 - .../ethos-u-core-driver/src/ethosu_log.h | 82 - .../cortex_m/ops/cortex_m_ops_common.h | 152 - .../extension/android/jni/jni_helper.h | 33 - .../android/jni/jni_layer_constants.h | 96 - .../executorch/extension/android/jni/log.h | 43 - .../apple/ExecuTorch/Exported/ExecuTorch.h | 13 - .../ExecuTorch/Exported/ExecuTorchError.h | 86 - .../apple/ExecuTorch/Exported/ExecuTorchLog.h | 77 - .../ExecuTorch/Exported/ExecuTorchModule.h | 537 - .../ExecuTorch/Exported/ExecuTorchTensor.h | 1308 - .../ExecuTorch/Exported/ExecuTorchValue.h | 256 - .../ExecuTorch/Internal/ExecuTorchUtils.h | 124 - .../extension/aten_util/aten_bridge.h | 86 - .../make_aten_functor_from_et_functor.h | 308 - .../Benchmark/TestUtils/DynamicTestCase.h | 24 - .../Benchmark/TestUtils/ResourceTestCase.h | 50 - .../data_loader/buffer_data_loader.h | 86 - .../extension/data_loader/file_data_loader.h | 114 - .../data_loader/file_descriptor_data_loader.h | 112 - .../executorch/extension/data_loader/mman.h | 43 - .../extension/data_loader/mman_windows.h | 68 - .../extension/data_loader/mmap_data_loader.h | 145 - .../data_loader/shared_ptr_data_loader.h | 67 - .../extension/evalue_util/print_evalue.h | 83 - .../flat_tensor/flat_tensor_data_map.h | 131 - .../serialize/flat_tensor_header.h | 90 - .../flat_tensor/serialize/serialize.h | 53 - .../make_boxed_from_unboxed_functor.h | 263 - .../extension/kernel_util/meta_programming.h | 122 - .../extension/kernel_util/type_list.h | 148 - .../ExecuTorchLLM/Exported/ExecuTorchLLM.h | 12 - .../Exported/ExecuTorchLLMConfig.h | 56 - .../Exported/ExecuTorchLLMError.h | 15 - .../Exported/ExecuTorchLLMMultimodalRunner.h | 234 - .../Exported/ExecuTorchLLMTextRunner.h | 96 - .../extension/llm/custom_ops/op_fallback.h | 20 - .../custom_ops/op_fast_hadamard_transform.h | 25 - .../extension/llm/custom_ops/op_sdpa.h | 80 - .../extension/llm/custom_ops/op_sdpa_impl.h | 1079 - .../extension/llm/custom_ops/op_tile_crop.h | 26 - .../llm/custom_ops/op_update_cache.h | 36 - .../spinquant/fast_hadamard_transform.h | 144 - .../fast_hadamard_transform_special.h | 241 - ...hadamard_transform_special_unstrided_cpu.h | 137 - .../test/fast_hadamard_transform_test_impl.h | 47 - .../spinquant/third-party/FFHT/dumb_fht.h | 14 - .../spinquant/third-party/FFHT/fast_copy.h | 21 - .../spinquant/third-party/FFHT/fht.h | 45 - .../spinquant/third-party/FFHT/fht_impl.h | 39 - .../executorch/extension/llm/runner/audio.h | 167 - .../extension/llm/runner/constants.h | 28 - .../executorch/extension/llm/runner/image.h | 131 - .../extension/llm/runner/image_prefiller.h | 57 - .../llm/runner/io_manager/io_manager.h | 248 - .../executorch/extension/llm/runner/irunner.h | 144 - .../extension/llm/runner/llm_runner_helper.h | 145 - .../llm/runner/multimodal_decoder_runner.h | 106 - .../extension/llm/runner/multimodal_input.h | 327 - .../llm/runner/multimodal_prefiller.h | 61 - .../extension/llm/runner/multimodal_runner.h | 159 - .../executorch/extension/llm/runner/stats.h | 172 - .../llm/runner/text_decoder_runner.h | 125 - .../extension/llm/runner/text_llm_runner.h | 162 - .../extension/llm/runner/text_prefiller.h | 92 - .../llm/runner/text_token_generator.h | 183 - .../executorch/extension/llm/runner/util.h | 157 - .../extension/llm/sampler/sampler.h | 83 - .../include/pytorch/tokenizers/base64.h | 199 - .../pytorch/tokenizers/bpe_tokenizer_base.h | 183 - .../include/pytorch/tokenizers/compiler.h | 22 - .../include/pytorch/tokenizers/error.h | 164 - .../include/pytorch/tokenizers/hf_tokenizer.h | 214 - .../pytorch/tokenizers/llama2c_tokenizer.h | 47 - .../include/pytorch/tokenizers/log.h | 303 - .../include/pytorch/tokenizers/normalizer.h | 189 - .../include/pytorch/tokenizers/pcre2_regex.h | 54 - .../pytorch/tokenizers/pre_tokenizer.h | 268 - .../include/pytorch/tokenizers/re2_regex.h | 46 - .../include/pytorch/tokenizers/regex.h | 72 - .../include/pytorch/tokenizers/result.h | 256 - .../pytorch/tokenizers/sentencepiece.h | 36 - .../include/pytorch/tokenizers/std_regex.h | 44 - .../pytorch/tokenizers/string_integer_map.h | 625 - .../include/pytorch/tokenizers/tekken.h | 102 - .../include/pytorch/tokenizers/tiktoken.h | 137 - .../pytorch/tokenizers/token_decoder.h | 151 - .../include/pytorch/tokenizers/tokenizer.h | 75 - .../abseil-cpp/absl/algorithm/algorithm.h | 64 - .../abseil-cpp/absl/algorithm/container.h | 1830 - .../abseil-cpp/absl/base/attributes.h | 997 - .../abseil-cpp/absl/base/call_once.h | 225 - .../third-party/abseil-cpp/absl/base/casts.h | 180 - .../third-party/abseil-cpp/absl/base/config.h | 985 - .../abseil-cpp/absl/base/const_init.h | 76 - .../absl/base/dynamic_annotations.h | 480 - .../absl/base/internal/atomic_hook.h | 200 - .../base/internal/atomic_hook_test_helper.h | 34 - .../absl/base/internal/cycleclock.h | 144 - .../absl/base/internal/cycleclock_config.h | 55 - .../absl/base/internal/direct_mmap.h | 170 - .../absl/base/internal/dynamic_annotations.h | 398 - .../abseil-cpp/absl/base/internal/endian.h | 283 - .../absl/base/internal/errno_saver.h | 43 - .../base/internal/exception_safety_testing.h | 1109 - .../absl/base/internal/exception_testing.h | 42 - .../absl/base/internal/fast_type_id.h | 50 - .../abseil-cpp/absl/base/internal/hide_ptr.h | 51 - .../abseil-cpp/absl/base/internal/identity.h | 39 - .../absl/base/internal/inline_variable.h | 108 - .../base/internal/inline_variable_testing.h | 46 - .../abseil-cpp/absl/base/internal/invoke.h | 241 - .../absl/base/internal/low_level_alloc.h | 127 - .../absl/base/internal/low_level_scheduling.h | 134 - .../absl/base/internal/nullability_impl.h | 69 - .../absl/base/internal/per_thread_tls.h | 52 - .../abseil-cpp/absl/base/internal/poison.h | 59 - .../absl/base/internal/pretty_function.h | 33 - .../absl/base/internal/raw_logging.h | 217 - .../absl/base/internal/scheduling_mode.h | 58 - .../absl/base/internal/scoped_set_env.h | 45 - .../abseil-cpp/absl/base/internal/spinlock.h | 275 - .../absl/base/internal/spinlock_wait.h | 95 - .../abseil-cpp/absl/base/internal/strerror.h | 39 - .../abseil-cpp/absl/base/internal/sysinfo.h | 74 - .../absl/base/internal/thread_identity.h | 273 - .../absl/base/internal/throw_delegate.h | 75 - .../abseil-cpp/absl/base/internal/tracing.h | 81 - .../absl/base/internal/tsan_mutex_interface.h | 68 - .../absl/base/internal/unaligned_access.h | 89 - .../absl/base/internal/unscaledcycleclock.h | 96 - .../base/internal/unscaledcycleclock_config.h | 62 - .../abseil-cpp/absl/base/log_severity.h | 185 - .../third-party/abseil-cpp/absl/base/macros.h | 220 - .../abseil-cpp/absl/base/no_destructor.h | 212 - .../abseil-cpp/absl/base/nullability.h | 284 - .../abseil-cpp/absl/base/optimization.h | 316 - .../abseil-cpp/absl/base/options.h | 261 - .../abseil-cpp/absl/base/policy_checks.h | 115 - .../third-party/abseil-cpp/absl/base/port.h | 25 - .../abseil-cpp/absl/base/prefetch.h | 209 - .../abseil-cpp/absl/base/thread_annotations.h | 333 - .../abseil-cpp/absl/cleanup/cleanup.h | 140 - .../absl/cleanup/internal/cleanup.h | 100 - .../abseil-cpp/absl/container/btree_map.h | 889 - .../abseil-cpp/absl/container/btree_set.h | 824 - .../abseil-cpp/absl/container/btree_test.h | 166 - .../abseil-cpp/absl/container/fixed_array.h | 556 - .../abseil-cpp/absl/container/flat_hash_map.h | 687 - .../abseil-cpp/absl/container/flat_hash_set.h | 575 - .../absl/container/hash_container_defaults.h | 45 - .../absl/container/inlined_vector.h | 1016 - .../absl/container/internal/btree.h | 3046 - .../absl/container/internal/btree_container.h | 763 - .../absl/container/internal/common.h | 207 - .../container/internal/common_policy_traits.h | 143 - .../container/internal/compressed_tuple.h | 271 - .../container/internal/container_memory.h | 492 - .../internal/hash_function_defaults.h | 276 - .../internal/hash_generator_testing.h | 182 - .../container/internal/hash_policy_testing.h | 183 - .../container/internal/hash_policy_traits.h | 207 - .../absl/container/internal/hashtable_debug.h | 102 - .../internal/hashtable_debug_hooks.h | 85 - .../container/internal/hashtablez_sampler.h | 275 - .../absl/container/internal/inlined_vector.h | 1105 - .../absl/container/internal/layout.h | 844 - .../container/internal/node_slot_policy.h | 95 - .../absl/container/internal/raw_hash_map.h | 226 - .../absl/container/internal/raw_hash_set.h | 4279 - .../absl/container/internal/test_allocator.h | 387 - .../internal/test_instance_tracker.h | 274 - .../absl/container/internal/tracked.h | 83 - .../internal/unordered_map_constructor_test.h | 494 - .../internal/unordered_map_lookup_test.h | 117 - .../internal/unordered_map_members_test.h | 87 - .../internal/unordered_map_modifiers_test.h | 352 - .../internal/unordered_set_constructor_test.h | 496 - .../internal/unordered_set_lookup_test.h | 91 - .../internal/unordered_set_members_test.h | 86 - .../internal/unordered_set_modifiers_test.h | 221 - .../abseil-cpp/absl/container/node_hash_map.h | 682 - .../abseil-cpp/absl/container/node_hash_set.h | 573 - .../third-party/abseil-cpp/absl/crc/crc32c.h | 190 - .../abseil-cpp/absl/crc/internal/cpu_detect.h | 63 - .../abseil-cpp/absl/crc/internal/crc.h | 83 - .../internal/crc32_x86_arm_combined_simd.h | 300 - .../abseil-cpp/absl/crc/internal/crc32c.h | 39 - .../absl/crc/internal/crc32c_inline.h | 72 - .../absl/crc/internal/crc_cord_state.h | 159 - .../absl/crc/internal/crc_internal.h | 177 - .../abseil-cpp/absl/crc/internal/crc_memcpy.h | 122 - .../internal/non_temporal_arm_intrinsics.h | 79 - .../absl/crc/internal/non_temporal_memcpy.h | 195 - .../absl/debugging/failure_signal_handler.h | 121 - .../debugging/internal/address_is_readable.h | 32 - .../internal/bounded_utf8_length_sequence.h | 126 - .../debugging/internal/decode_rust_punycode.h | 55 - .../absl/debugging/internal/demangle.h | 76 - .../absl/debugging/internal/demangle_rust.h | 42 - .../absl/debugging/internal/elf_mem_image.h | 141 - .../absl/debugging/internal/examine_stack.h | 64 - .../debugging/internal/stack_consumption.h | 50 - .../debugging/internal/stacktrace_config.h | 95 - .../absl/debugging/internal/symbolize.h | 153 - .../debugging/internal/utf8_for_code_point.h | 47 - .../absl/debugging/internal/vdso_support.h | 158 - .../abseil-cpp/absl/debugging/leak_check.h | 150 - .../abseil-cpp/absl/debugging/stacktrace.h | 231 - .../abseil-cpp/absl/debugging/symbolize.h | 99 - .../abseil-cpp/absl/flags/commandlineflag.h | 211 - .../abseil-cpp/absl/flags/config.h | 68 - .../abseil-cpp/absl/flags/declare.h | 68 - .../third-party/abseil-cpp/absl/flags/flag.h | 302 - .../absl/flags/internal/commandlineflag.h | 68 - .../abseil-cpp/absl/flags/internal/flag.h | 962 - .../abseil-cpp/absl/flags/internal/parse.h | 70 - .../absl/flags/internal/path_util.h | 62 - .../flags/internal/private_handle_accessor.h | 61 - .../absl/flags/internal/program_name.h | 50 - .../abseil-cpp/absl/flags/internal/registry.h | 97 - .../absl/flags/internal/sequence_lock.h | 187 - .../abseil-cpp/absl/flags/internal/usage.h | 106 - .../abseil-cpp/absl/flags/marshalling.h | 361 - .../third-party/abseil-cpp/absl/flags/parse.h | 130 - .../abseil-cpp/absl/flags/reflection.h | 90 - .../third-party/abseil-cpp/absl/flags/usage.h | 43 - .../abseil-cpp/absl/flags/usage_config.h | 135 - .../absl/functional/any_invocable.h | 334 - .../abseil-cpp/absl/functional/bind_front.h | 194 - .../abseil-cpp/absl/functional/function_ref.h | 151 - .../absl/functional/internal/any_invocable.h | 891 - .../absl/functional/internal/front_binder.h | 95 - .../absl/functional/internal/function_ref.h | 116 - .../abseil-cpp/absl/functional/overload.h | 92 - .../third-party/abseil-cpp/absl/hash/hash.h | 424 - .../abseil-cpp/absl/hash/hash_testing.h | 378 - .../abseil-cpp/absl/hash/internal/city.h | 78 - .../abseil-cpp/absl/hash/internal/hash.h | 1395 - .../abseil-cpp/absl/hash/internal/hash_test.h | 87 - .../absl/hash/internal/low_level_hash.h | 54 - .../absl/hash/internal/spy_hash_state.h | 266 - .../abseil-cpp/absl/log/absl_check.h | 117 - .../abseil-cpp/absl/log/absl_log.h | 115 - .../abseil-cpp/absl/log/absl_vlog_is_on.h | 95 - .../third-party/abseil-cpp/absl/log/check.h | 209 - .../abseil-cpp/absl/log/die_if_null.h | 76 - .../third-party/abseil-cpp/absl/log/flags.h | 43 - .../third-party/abseil-cpp/absl/log/globals.h | 231 - .../abseil-cpp/absl/log/initialize.h | 45 - .../absl/log/internal/append_truncated.h | 47 - .../abseil-cpp/absl/log/internal/check_impl.h | 150 - .../abseil-cpp/absl/log/internal/check_op.h | 473 - .../abseil-cpp/absl/log/internal/conditions.h | 239 - .../abseil-cpp/absl/log/internal/config.h | 45 - .../abseil-cpp/absl/log/internal/flags.h | 59 - .../abseil-cpp/absl/log/internal/fnmatch.h | 35 - .../abseil-cpp/absl/log/internal/globals.h | 101 - .../abseil-cpp/absl/log/internal/log_format.h | 78 - .../abseil-cpp/absl/log/internal/log_impl.h | 282 - .../absl/log/internal/log_message.h | 412 - .../absl/log/internal/log_sink_set.h | 54 - .../abseil-cpp/absl/log/internal/nullguard.h | 88 - .../abseil-cpp/absl/log/internal/nullstream.h | 127 - .../abseil-cpp/absl/log/internal/proto.h | 298 - .../abseil-cpp/absl/log/internal/strip.h | 108 - .../abseil-cpp/absl/log/internal/structured.h | 61 - .../absl/log/internal/test_actions.h | 90 - .../absl/log/internal/test_helpers.h | 71 - .../absl/log/internal/test_matchers.h | 94 - .../absl/log/internal/vlog_config.h | 163 - .../abseil-cpp/absl/log/internal/voidify.h | 44 - .../third-party/abseil-cpp/absl/log/log.h | 365 - .../abseil-cpp/absl/log/log_entry.h | 221 - .../abseil-cpp/absl/log/log_sink.h | 71 - .../abseil-cpp/absl/log/log_sink_registry.h | 64 - .../abseil-cpp/absl/log/log_streamer.h | 181 - .../abseil-cpp/absl/log/scoped_mock_log.h | 197 - .../abseil-cpp/absl/log/structured.h | 75 - .../abseil-cpp/absl/log/vlog_is_on.h | 74 - .../abseil-cpp/absl/memory/memory.h | 278 - .../abseil-cpp/absl/meta/type_traits.h | 660 - .../abseil-cpp/absl/numeric/bits.h | 196 - .../abseil-cpp/absl/numeric/int128.h | 1204 - .../abseil-cpp/absl/numeric/internal/bits.h | 362 - .../absl/numeric/internal/representation.h | 55 - .../profiling/internal/exponential_biased.h | 130 - .../profiling/internal/periodic_sampler.h | 211 - .../absl/profiling/internal/sample_recorder.h | 253 - .../absl/random/bernoulli_distribution.h | 202 - .../absl/random/beta_distribution.h | 429 - .../abseil-cpp/absl/random/bit_gen_ref.h | 188 - .../absl/random/discrete_distribution.h | 249 - .../abseil-cpp/absl/random/distributions.h | 452 - .../absl/random/exponential_distribution.h | 166 - .../absl/random/gaussian_distribution.h | 276 - .../absl/random/internal/chi_square.h | 89 - .../random/internal/distribution_caller.h | 97 - .../random/internal/distribution_test_util.h | 113 - .../absl/random/internal/explicit_seed_seq.h | 92 - .../absl/random/internal/fast_uniform_bits.h | 271 - .../absl/random/internal/fastmath.h | 57 - .../absl/random/internal/generate_real.h | 144 - .../random/internal/iostream_state_saver.h | 245 - .../absl/random/internal/mock_helpers.h | 161 - .../absl/random/internal/mock_overload_set.h | 122 - .../absl/random/internal/mock_validators.h | 98 - .../absl/random/internal/nanobenchmark.h | 172 - .../absl/random/internal/nonsecure_base.h | 161 - .../absl/random/internal/pcg_engine.h | 287 - .../absl/random/internal/platform.h | 171 - .../absl/random/internal/pool_urbg.h | 131 - .../abseil-cpp/absl/random/internal/randen.h | 96 - .../absl/random/internal/randen_detect.h | 33 - .../absl/random/internal/randen_engine.h | 264 - .../absl/random/internal/randen_hwaes.h | 50 - .../absl/random/internal/randen_slow.h | 40 - .../absl/random/internal/randen_traits.h | 88 - .../absl/random/internal/salted_seed_seq.h | 165 - .../absl/random/internal/seed_material.h | 104 - .../absl/random/internal/sequence_urbg.h | 60 - .../abseil-cpp/absl/random/internal/traits.h | 149 - .../absl/random/internal/uniform_helper.h | 244 - .../absl/random/internal/wide_multiply.h | 95 - .../random/log_uniform_int_distribution.h | 253 - .../absl/random/mock_distributions.h | 269 - .../abseil-cpp/absl/random/mocking_bit_gen.h | 239 - .../absl/random/poisson_distribution.h | 262 - .../abseil-cpp/absl/random/random.h | 189 - .../absl/random/seed_gen_exception.h | 55 - .../abseil-cpp/absl/random/seed_sequences.h | 112 - .../absl/random/uniform_int_distribution.h | 276 - .../absl/random/uniform_real_distribution.h | 204 - .../absl/random/zipf_distribution.h | 273 - .../absl/status/internal/status_internal.h | 132 - .../absl/status/internal/status_matchers.h | 246 - .../absl/status/internal/statusor_internal.h | 494 - .../abseil-cpp/absl/status/status.h | 943 - .../abseil-cpp/absl/status/status_matchers.h | 118 - .../absl/status/status_payload_printer.h | 52 - .../abseil-cpp/absl/status/statusor.h | 796 - .../abseil-cpp/absl/strings/ascii.h | 284 - .../abseil-cpp/absl/strings/charconv.h | 123 - .../abseil-cpp/absl/strings/charset.h | 163 - .../abseil-cpp/absl/strings/cord.h | 1762 - .../abseil-cpp/absl/strings/cord_analysis.h | 63 - .../abseil-cpp/absl/strings/cord_buffer.h | 572 - .../absl/strings/cord_test_helpers.h | 122 - .../absl/strings/cordz_test_helpers.h | 153 - .../abseil-cpp/absl/strings/escaping.h | 186 - .../absl/strings/has_absl_stringify.h | 64 - .../absl/strings/has_ostream_operator.h | 42 - .../absl/strings/internal/charconv_bigint.h | 433 - .../absl/strings/internal/charconv_parse.h | 99 - .../absl/strings/internal/cord_data_edge.h | 63 - .../absl/strings/internal/cord_internal.h | 929 - .../absl/strings/internal/cord_rep_btree.h | 944 - .../internal/cord_rep_btree_navigator.h | 267 - .../strings/internal/cord_rep_btree_reader.h | 212 - .../absl/strings/internal/cord_rep_consume.h | 47 - .../absl/strings/internal/cord_rep_crc.h | 103 - .../absl/strings/internal/cord_rep_flat.h | 195 - .../strings/internal/cord_rep_test_util.h | 205 - .../absl/strings/internal/cordz_functions.h | 87 - .../absl/strings/internal/cordz_handle.h | 98 - .../absl/strings/internal/cordz_info.h | 303 - .../strings/internal/cordz_sample_token.h | 97 - .../absl/strings/internal/cordz_statistics.h | 88 - .../strings/internal/cordz_update_scope.h | 71 - .../strings/internal/cordz_update_tracker.h | 123 - .../internal/damerau_levenshtein_distance.h | 34 - .../absl/strings/internal/escaping.h | 57 - .../strings/internal/escaping_test_common.h | 133 - .../absl/strings/internal/memutil.h | 40 - .../strings/internal/numbers_test_common.h | 184 - .../absl/strings/internal/ostringstream.h | 114 - .../absl/strings/internal/pow10_helper.h | 40 - .../strings/internal/resize_uninitialized.h | 119 - .../absl/strings/internal/stl_type_traits.h | 248 - .../absl/strings/internal/str_format/arg.h | 671 - .../absl/strings/internal/str_format/bind.h | 237 - .../strings/internal/str_format/checker.h | 100 - .../internal/str_format/constexpr_parser.h | 357 - .../strings/internal/str_format/extension.h | 456 - .../internal/str_format/float_conversion.h | 37 - .../absl/strings/internal/str_format/output.h | 97 - .../absl/strings/internal/str_format/parser.h | 269 - .../absl/strings/internal/str_join_internal.h | 338 - .../strings/internal/str_split_internal.h | 520 - .../absl/strings/internal/string_constant.h | 72 - .../absl/strings/internal/stringify_sink.h | 57 - .../abseil-cpp/absl/strings/internal/utf8.h | 50 - .../abseil-cpp/absl/strings/match.h | 129 - .../abseil-cpp/absl/strings/numbers.h | 317 - .../abseil-cpp/absl/strings/str_cat.h | 617 - .../abseil-cpp/absl/strings/str_format.h | 887 - .../abseil-cpp/absl/strings/str_join.h | 301 - .../abseil-cpp/absl/strings/str_replace.h | 222 - .../abseil-cpp/absl/strings/str_split.h | 582 - .../abseil-cpp/absl/strings/string_view.h | 768 - .../abseil-cpp/absl/strings/strip.h | 96 - .../abseil-cpp/absl/strings/substitute.h | 767 - .../abseil-cpp/absl/synchronization/barrier.h | 79 - .../absl/synchronization/blocking_counter.h | 107 - .../internal/create_thread_identity.h | 56 - .../absl/synchronization/internal/futex.h | 177 - .../synchronization/internal/futex_waiter.h | 63 - .../synchronization/internal/graphcycles.h | 146 - .../synchronization/internal/kernel_timeout.h | 178 - .../synchronization/internal/per_thread_sem.h | 119 - .../synchronization/internal/pthread_waiter.h | 60 - .../synchronization/internal/sem_waiter.h | 65 - .../synchronization/internal/stdcpp_waiter.h | 56 - .../synchronization/internal/thread_pool.h | 96 - .../absl/synchronization/internal/waiter.h | 69 - .../synchronization/internal/waiter_base.h | 90 - .../synchronization/internal/win32_waiter.h | 72 - .../abseil-cpp/absl/synchronization/mutex.h | 1219 - .../absl/synchronization/notification.h | 133 - .../abseil-cpp/absl/time/civil_time.h | 589 - .../third-party/abseil-cpp/absl/time/clock.h | 78 - .../internal/cctz/include/cctz/civil_time.h | 332 - .../cctz/include/cctz/civil_time_detail.h | 632 - .../internal/cctz/include/cctz/time_zone.h | 460 - .../cctz/include/cctz/zone_info_source.h | 102 - .../time/internal/cctz/src/time_zone_fixed.h | 52 - .../time/internal/cctz/src/time_zone_if.h | 80 - .../time/internal/cctz/src/time_zone_impl.h | 97 - .../time/internal/cctz/src/time_zone_info.h | 128 - .../time/internal/cctz/src/time_zone_libc.h | 60 - .../time/internal/cctz/src/time_zone_posix.h | 132 - .../absl/time/internal/cctz/src/tzfile.h | 120 - .../abseil-cpp/absl/time/internal/test_util.h | 33 - .../third-party/abseil-cpp/absl/time/time.h | 1870 - .../third-party/abseil-cpp/absl/types/any.h | 519 - .../abseil-cpp/absl/types/bad_any_cast.h | 75 - .../absl/types/bad_optional_access.h | 78 - .../absl/types/bad_variant_access.h | 82 - .../abseil-cpp/absl/types/compare.h | 505 - .../abseil-cpp/absl/types/internal/optional.h | 352 - .../abseil-cpp/absl/types/internal/span.h | 140 - .../abseil-cpp/absl/types/internal/variant.h | 1622 - .../abseil-cpp/absl/types/optional.h | 779 - .../third-party/abseil-cpp/absl/types/span.h | 792 - .../abseil-cpp/absl/types/variant.h | 861 - .../absl/utility/internal/if_constexpr.h | 70 - .../abseil-cpp/absl/utility/utility.h | 230 - .../abseil-cpp/ci/absl_alternate_options.h | 30 - .../tests/thirdparty/Fuzzer/FuzzerCorpus.h | 217 - .../json/tests/thirdparty/Fuzzer/FuzzerDefs.h | 89 - .../thirdparty/Fuzzer/FuzzerDictionary.h | 124 - .../thirdparty/Fuzzer/FuzzerExtFunctions.h | 35 - .../json/tests/thirdparty/Fuzzer/FuzzerIO.h | 64 - .../tests/thirdparty/Fuzzer/FuzzerInterface.h | 67 - .../tests/thirdparty/Fuzzer/FuzzerInternal.h | 182 - .../tests/thirdparty/Fuzzer/FuzzerMerge.h | 70 - .../tests/thirdparty/Fuzzer/FuzzerMutate.h | 145 - .../tests/thirdparty/Fuzzer/FuzzerOptions.h | 68 - .../tests/thirdparty/Fuzzer/FuzzerRandom.h | 36 - .../json/tests/thirdparty/Fuzzer/FuzzerSHA1.h | 33 - .../tests/thirdparty/Fuzzer/FuzzerTracePC.h | 158 - .../json/tests/thirdparty/Fuzzer/FuzzerUtil.h | 72 - .../thirdparty/Fuzzer/FuzzerValueBitMap.h | 87 - .../json/tests/thirdparty/doctest/doctest.h | 7106 - .../doctest/doctest_compatibility.h | 37 - .../llama.cpp-unicode/include/unicode-data.h | 58 - .../llama.cpp-unicode/include/unicode.h | 100 - .../pcre2/deps/sljit/regex_src/regexJIT.h | 106 - .../pcre2/deps/sljit/sljit_src/sljitConfig.h | 142 - .../deps/sljit/sljit_src/sljitConfigCPU.h | 188 - .../sljit/sljit_src/sljitConfigInternal.h | 973 - .../pcre2/deps/sljit/sljit_src/sljitLir.h | 2713 - .../deps/sljit/test_src/sljitConfigPost.h | 33 - .../deps/sljit/test_src/sljitConfigPre.h | 35 - .../deps/sljit/test_src/sljitTestBuffers.h | 511 - .../pcre2/deps/sljit/test_src/sljitTestCall.h | 2095 - .../deps/sljit/test_src/sljitTestFloat.h | 3059 - .../deps/sljit/test_src/sljitTestSerialize.h | 501 - .../pcre2/deps/sljit/test_src/sljitTestSimd.h | 2722 - .../third-party/pcre2/src/pcre2_compile.h | 356 - .../third-party/pcre2/src/pcre2_internal.h | 2397 - .../third-party/pcre2/src/pcre2_intmodedep.h | 1001 - .../pcre2/src/pcre2_jit_char_inc.h | 2282 - .../pcre2/src/pcre2_jit_match_inc.h | 201 - .../pcre2/src/pcre2_jit_misc_inc.h | 234 - .../pcre2/src/pcre2_jit_neon_inc.h | 363 - .../pcre2/src/pcre2_jit_simd_inc.h | 2356 - .../pcre2/src/pcre2_printint_inc.h | 1128 - .../third-party/pcre2/src/pcre2_ucp.h | 408 - .../pcre2/src/pcre2_ucptables_inc.h | 1596 - .../third-party/pcre2/src/pcre2_util.h | 132 - .../third-party/pcre2/src/pcre2posix.h | 187 - .../tokenizers/third-party/pcre2/vms/stdint.h | 9 - .../third-party/re2/re2/bitmap256.h | 88 - .../third-party/re2/re2/filtered_re2.h | 115 - .../third-party/re2/re2/pod_array.h | 55 - .../third-party/re2/re2/prefilter.h | 168 - .../third-party/re2/re2/prefilter_tree.h | 153 - .../llm/tokenizers/third-party/re2/re2/prog.h | 492 - .../llm/tokenizers/third-party/re2/re2/re2.h | 1074 - .../tokenizers/third-party/re2/re2/regexp.h | 693 - .../llm/tokenizers/third-party/re2/re2/set.h | 86 - .../third-party/re2/re2/sparse_array.h | 394 - .../third-party/re2/re2/sparse_set.h | 266 - .../third-party/re2/re2/stringpiece.h | 18 - .../re2/re2/testing/exhaustive_tester.h | 105 - .../re2/re2/testing/regexp_generator.h | 77 - .../re2/re2/testing/string_generator.h | 76 - .../third-party/re2/re2/testing/tester.h | 121 - .../third-party/re2/re2/unicode_casefold.h | 77 - .../third-party/re2/re2/unicode_groups.h | 66 - .../third-party/re2/re2/walker-inl.h | 249 - .../third-party/re2/util/malloc_counter.h | 19 - .../tokenizers/third-party/re2/util/pcre.h | 671 - .../tokenizers/third-party/re2/util/strutil.h | 16 - .../llm/tokenizers/third-party/re2/util/utf.h | 44 - .../third-party/sentencepiece/src/bpe_model.h | 52 - .../sentencepiece/src/bpe_model_trainer.h | 130 - .../third-party/sentencepiece/src/builder.h | 148 - .../src/builtin_pb/sentencepiece.pb.h | 1041 - .../src/builtin_pb/sentencepiece_model.pb.h | 5030 - .../sentencepiece/src/char_model.h | 34 - .../sentencepiece/src/char_model_trainer.h | 37 - .../third-party/sentencepiece/src/common.h | 177 - .../sentencepiece/src/filesystem.h | 59 - .../third-party/sentencepiece/src/freelist.h | 90 - .../third-party/sentencepiece/src/init.h | 62 - .../sentencepiece/src/model_factory.h | 31 - .../sentencepiece/src/model_interface.h | 249 - .../sentencepiece/src/normalization_rule.h | 137363 --------------- .../sentencepiece/src/normalizer.h | 159 - .../src/pretokenizer_for_training.h | 63 - .../src/sentencepiece_processor.h | 752 - .../sentencepiece/src/sentencepiece_trainer.h | 206 - .../sentencepiece/src/spec_parser.h | 284 - .../sentencepiece/src/testharness.h | 227 - .../sentencepiece/src/trainer_factory.h | 33 - .../sentencepiece/src/trainer_interface.h | 183 - .../sentencepiece/src/unicode_script.h | 165 - .../sentencepiece/src/unicode_script_map.h | 1955 - .../sentencepiece/src/unigram_model.h | 217 - .../sentencepiece/src/unigram_model_trainer.h | 115 - .../third-party/sentencepiece/src/util.h | 442 - .../sentencepiece/src/word_model.h | 34 - .../sentencepiece/src/word_model_trainer.h | 41 - .../third_party/absl/container/btree_set.h | 28 - .../absl/container/flat_hash_map.h | 29 - .../absl/container/flat_hash_set.h | 29 - .../third_party/absl/flags/flag.h | 68 - .../third_party/absl/flags/parse.h | 25 - .../third_party/absl/flags/usage.h | 28 - .../third_party/absl/strings/ascii.h | 41 - .../third_party/absl/strings/match.h | 38 - .../third_party/absl/strings/numbers.h | 33 - .../third_party/absl/strings/str_cat.h | 52 - .../third_party/absl/strings/str_format.h | 37 - .../third_party/absl/strings/str_join.h | 95 - .../third_party/absl/strings/str_replace.h | 68 - .../third_party/absl/strings/str_split.h | 86 - .../third_party/absl/strings/string_view.h | 57 - .../third_party/absl/strings/strip.h | 32 - .../third_party/darts_clone/darts.h | 1926 - .../protobuf-lite/google/protobuf/any.h | 150 - .../protobuf-lite/google/protobuf/arena.h | 694 - .../google/protobuf/arena_impl.h | 491 - .../google/protobuf/arenastring.h | 375 - .../google/protobuf/descriptor.h | 2324 - .../google/protobuf/extension_set.h | 1591 - .../google/protobuf/extension_set_inl.h | 276 - .../protobuf/generated_enum_reflection.h | 98 - .../google/protobuf/generated_enum_util.h | 83 - .../protobuf/generated_message_table_driven.h | 336 - .../generated_message_table_driven_lite.h | 802 - .../google/protobuf/generated_message_util.h | 270 - .../protobuf-lite/google/protobuf/has_bits.h | 116 - .../google/protobuf/implicit_weak_message.h | 190 - .../google/protobuf/io/coded_stream.h | 1714 - .../google/protobuf/io/io_win32.h | 139 - .../google/protobuf/io/zero_copy_stream.h | 253 - .../protobuf/io/zero_copy_stream_impl.h | 327 - .../protobuf/io/zero_copy_stream_impl_lite.h | 408 - .../protobuf-lite/google/protobuf/map.h | 1362 - .../google/protobuf/map_entry_lite.h | 653 - .../google/protobuf/map_field_lite.h | 183 - .../google/protobuf/map_type_handler.h | 688 - .../google/protobuf/message_lite.h | 621 - .../google/protobuf/metadata_lite.h | 248 - .../google/protobuf/parse_context.h | 869 - .../protobuf-lite/google/protobuf/port.h | 43 - .../google/protobuf/repeated_field.h | 2847 - .../google/protobuf/stubs/bytestream.h | 351 - .../google/protobuf/stubs/callback.h | 583 - .../google/protobuf/stubs/casts.h | 139 - .../google/protobuf/stubs/common.h | 202 - .../google/protobuf/stubs/hash.h | 114 - .../google/protobuf/stubs/int128.h | 387 - .../google/protobuf/stubs/logging.h | 241 - .../google/protobuf/stubs/macros.h | 120 - .../google/protobuf/stubs/map_util.h | 769 - .../google/protobuf/stubs/mutex.h | 186 - .../google/protobuf/stubs/once.h | 55 - .../google/protobuf/stubs/platform_macros.h | 134 - .../google/protobuf/stubs/port.h | 405 - .../google/protobuf/stubs/status.h | 125 - .../google/protobuf/stubs/statusor.h | 272 - .../google/protobuf/stubs/stl_util.h | 71 - .../google/protobuf/stubs/stringpiece.h | 489 - .../google/protobuf/stubs/stringprintf.h | 85 - .../google/protobuf/stubs/strutil.h | 953 - .../google/protobuf/stubs/time.h | 80 - .../google/protobuf/unknown_field_set.h | 411 - .../google/protobuf/wire_format_lite.h | 1866 - .../malloc_memory_allocator.h | 90 - .../extension/module/bundled_module.h | 134 - .../executorch/extension/module/module.h | 667 - .../named_data_map/merged_data_map.h | 106 - .../extension/parallel/thread_parallel.h | 14 - .../extension/pytree/aten_util/ivalue_util.h | 55 - .../extension/pytree/function_ref.h | 24 - .../executorch/extension/pytree/pytree.h | 791 - .../executorch/extension/runner_util/inputs.h | 118 - .../executorch/extension/tensor/tensor.h | 14 - .../extension/tensor/tensor_accessor.h | 218 - .../executorch/extension/tensor/tensor_ptr.h | 447 - .../extension/tensor/tensor_ptr_maker.h | 687 - .../extension/testing_util/temp_file.h | 105 - .../extension/threadpool/cpuinfo_utils.h | 24 - .../extension/threadpool/threadpool.h | 97 - .../extension/threadpool/threadpool_guard.h | 37 - .../training/module/state_dict_util.h | 35 - .../training/module/training_module.h | 137 - .../extension/training/optimizer/sgd.h | 220 - .../CustomOpsNativeFunctions.h | 26 - .../cortex_m/cortex_m_ops_lib/Functions.h | 54 - .../cortex_m_ops_lib/NativeFunctions.h | 31 - .../portable/portable_ops_lib/Functions.h | 1227 - .../portable_ops_lib/NativeFunctions.h | 423 - .../CustomOpsNativeFunctions.h | 43 - .../quantized/quantized_ops_lib/Functions.h | 144 - .../quantized_ops_lib/NativeFunctions.h | 63 - .../kernels/aten/cpu/util/copy_ops_util.h | 23 - .../kernels/optimized/blas/BlasKernel.h | 304 - .../kernels/optimized/blas/CPUBlas.h | 169 - .../kernels/optimized/cpu/binary_ops.h | 261 - .../kernels/optimized/cpu/fft_utils.h | 100 - .../kernels/optimized/cpu/moments_utils.h | 191 - .../kernels/optimized/cpu/op_add_sub_impl.h | 180 - .../src/AccelerateSupport/AccelerateSupport.h | 423 - .../AccelerateSupport/InternalHeaderCheck.h | 3 - .../Eigen/src/Cholesky/InternalHeaderCheck.h | 3 - .../eigen/Eigen/src/Cholesky/LDLT.h | 649 - .../eigen/Eigen/src/Cholesky/LLT.h | 514 - .../eigen/Eigen/src/Cholesky/LLT_LAPACKE.h | 124 - .../Eigen/src/CholmodSupport/CholmodSupport.h | 738 - .../src/CholmodSupport/InternalHeaderCheck.h | 3 - .../eigen/Eigen/src/Core/ArithmeticSequence.h | 239 - .../third-party/eigen/Eigen/src/Core/Array.h | 376 - .../eigen/Eigen/src/Core/ArrayBase.h | 213 - .../eigen/Eigen/src/Core/ArrayWrapper.h | 165 - .../third-party/eigen/Eigen/src/Core/Assign.h | 80 - .../eigen/Eigen/src/Core/AssignEvaluator.h | 1057 - .../eigen/Eigen/src/Core/Assign_MKL.h | 183 - .../eigen/Eigen/src/Core/BandMatrix.h | 338 - .../third-party/eigen/Eigen/src/Core/Block.h | 429 - .../eigen/Eigen/src/Core/CommaInitializer.h | 149 - .../eigen/Eigen/src/Core/ConditionEstimator.h | 173 - .../eigen/Eigen/src/Core/CoreEvaluators.h | 2049 - .../eigen/Eigen/src/Core/CoreIterators.h | 141 - .../eigen/Eigen/src/Core/CwiseBinaryOp.h | 166 - .../eigen/Eigen/src/Core/CwiseNullaryOp.h | 977 - .../eigen/Eigen/src/Core/CwiseTernaryOp.h | 171 - .../eigen/Eigen/src/Core/CwiseUnaryOp.h | 91 - .../eigen/Eigen/src/Core/CwiseUnaryView.h | 167 - .../eigen/Eigen/src/Core/DenseBase.h | 661 - .../eigen/Eigen/src/Core/DenseCoeffsBase.h | 562 - .../eigen/Eigen/src/Core/DenseStorage.h | 578 - .../eigen/Eigen/src/Core/DeviceWrapper.h | 153 - .../eigen/Eigen/src/Core/Diagonal.h | 219 - .../eigen/Eigen/src/Core/DiagonalMatrix.h | 420 - .../eigen/Eigen/src/Core/DiagonalProduct.h | 30 - .../third-party/eigen/Eigen/src/Core/Dot.h | 268 - .../eigen/Eigen/src/Core/EigenBase.h | 149 - .../third-party/eigen/Eigen/src/Core/Fill.h | 139 - .../eigen/Eigen/src/Core/ForceAlignedAccess.h | 127 - .../third-party/eigen/Eigen/src/Core/Fuzzy.h | 132 - .../eigen/Eigen/src/Core/GeneralProduct.h | 519 - .../eigen/Eigen/src/Core/GenericPacketMath.h | 1662 - .../eigen/Eigen/src/Core/GlobalFunctions.h | 230 - .../third-party/eigen/Eigen/src/Core/IO.h | 233 - .../eigen/Eigen/src/Core/IndexedView.h | 315 - .../eigen/Eigen/src/Core/InnerProduct.h | 254 - .../Eigen/src/Core/InternalHeaderCheck.h | 3 - .../eigen/Eigen/src/Core/Inverse.h | 108 - .../third-party/eigen/Eigen/src/Core/Map.h | 153 - .../eigen/Eigen/src/Core/MapBase.h | 283 - .../eigen/Eigen/src/Core/MathFunctions.h | 2065 - .../eigen/Eigen/src/Core/MathFunctionsImpl.h | 305 - .../third-party/eigen/Eigen/src/Core/Matrix.h | 534 - .../eigen/Eigen/src/Core/MatrixBase.h | 542 - .../eigen/Eigen/src/Core/NestByValue.h | 91 - .../eigen/Eigen/src/Core/NoAlias.h | 102 - .../eigen/Eigen/src/Core/NumTraits.h | 321 - .../Eigen/src/Core/PartialReduxEvaluator.h | 253 - .../eigen/Eigen/src/Core/PermutationMatrix.h | 552 - .../eigen/Eigen/src/Core/PlainObjectBase.h | 1014 - .../eigen/Eigen/src/Core/Product.h | 307 - .../eigen/Eigen/src/Core/ProductEvaluators.h | 1271 - .../third-party/eigen/Eigen/src/Core/Random.h | 207 - .../eigen/Eigen/src/Core/RandomImpl.h | 255 - .../third-party/eigen/Eigen/src/Core/Redux.h | 535 - .../third-party/eigen/Eigen/src/Core/Ref.h | 383 - .../eigen/Eigen/src/Core/Replicate.h | 130 - .../eigen/Eigen/src/Core/Reshaped.h | 398 - .../eigen/Eigen/src/Core/ReturnByValue.h | 111 - .../eigen/Eigen/src/Core/Reverse.h | 202 - .../third-party/eigen/Eigen/src/Core/Select.h | 156 - .../eigen/Eigen/src/Core/SelfAdjointView.h | 329 - .../eigen/Eigen/src/Core/SelfCwiseBinaryOp.h | 36 - .../Eigen/src/Core/SkewSymmetricMatrix3.h | 382 - .../third-party/eigen/Eigen/src/Core/Solve.h | 174 - .../eigen/Eigen/src/Core/SolveTriangular.h | 237 - .../eigen/Eigen/src/Core/SolverBase.h | 159 - .../eigen/Eigen/src/Core/StableNorm.h | 217 - .../eigen/Eigen/src/Core/StlIterators.h | 619 - .../third-party/eigen/Eigen/src/Core/Stride.h | 114 - .../third-party/eigen/Eigen/src/Core/Swap.h | 99 - .../eigen/Eigen/src/Core/Transpose.h | 427 - .../eigen/Eigen/src/Core/Transpositions.h | 323 - .../eigen/Eigen/src/Core/TriangularMatrix.h | 900 - .../eigen/Eigen/src/Core/VectorBlock.h | 83 - .../eigen/Eigen/src/Core/VectorwiseOp.h | 710 - .../eigen/Eigen/src/Core/Visitor.h | 798 - .../eigen/Eigen/src/Core/arch/AVX/Complex.h | 565 - .../Eigen/src/Core/arch/AVX/MathFunctions.h | 130 - .../Eigen/src/Core/arch/AVX/PacketMath.h | 3199 - .../Eigen/src/Core/arch/AVX/TypeCasting.h | 308 - .../Eigen/src/Core/arch/AVX512/Complex.h | 472 - .../Eigen/src/Core/arch/AVX512/GemmKernel.h | 1245 - .../src/Core/arch/AVX512/MathFunctions.h | 141 - .../src/Core/arch/AVX512/MathFunctionsFP16.h | 75 - .../Eigen/src/Core/arch/AVX512/PacketMath.h | 3354 - .../src/Core/arch/AVX512/PacketMathFP16.h | 1413 - .../Eigen/src/Core/arch/AVX512/TrsmKernel.h | 1167 - .../Eigen/src/Core/arch/AVX512/TypeCasting.h | 277 - .../src/Core/arch/AVX512/TypeCastingFP16.h | 130 - .../Eigen/src/Core/arch/AltiVec/Complex.h | 653 - .../src/Core/arch/AltiVec/MathFunctions.h | 81 - .../src/Core/arch/AltiVec/MatrixProduct.h | 3686 - .../Core/arch/AltiVec/MatrixProductCommon.h | 205 - .../src/Core/arch/AltiVec/MatrixProductMMA.h | 901 - .../arch/AltiVec/MatrixProductMMAbfloat16.h | 742 - .../Eigen/src/Core/arch/AltiVec/PacketMath.h | 3726 - .../Eigen/src/Core/arch/AltiVec/TypeCasting.h | 163 - .../Eigen/src/Core/arch/Default/BFloat16.h | 860 - .../Eigen/src/Core/arch/Default/ConjHelper.h | 128 - .../arch/Default/GenericPacketMathFunctions.h | 2629 - .../Default/GenericPacketMathFunctionsFwd.h | 227 - .../eigen/Eigen/src/Core/arch/Default/Half.h | 1041 - .../Eigen/src/Core/arch/Default/Settings.h | 47 - .../eigen/Eigen/src/Core/arch/GPU/Complex.h | 244 - .../Eigen/src/Core/arch/GPU/MathFunctions.h | 104 - .../Eigen/src/Core/arch/GPU/PacketMath.h | 1704 - .../eigen/Eigen/src/Core/arch/GPU/Tuple.h | 268 - .../Eigen/src/Core/arch/GPU/TypeCasting.h | 77 - .../src/Core/arch/HIP/hcc/math_constants.h | 23 - .../Eigen/src/Core/arch/HVX/PacketMath.h | 1071 - .../eigen/Eigen/src/Core/arch/LSX/Complex.h | 520 - .../Core/arch/LSX/GeneralBlockPanelKernel.h | 23 - .../Eigen/src/Core/arch/LSX/MathFunctions.h | 43 - .../Eigen/src/Core/arch/LSX/PacketMath.h | 2866 - .../Eigen/src/Core/arch/LSX/TypeCasting.h | 526 - .../eigen/Eigen/src/Core/arch/MSA/Complex.h | 620 - .../Eigen/src/Core/arch/MSA/MathFunctions.h | 379 - .../Eigen/src/Core/arch/MSA/PacketMath.h | 1237 - .../eigen/Eigen/src/Core/arch/NEON/Complex.h | 752 - .../Core/arch/NEON/GeneralBlockPanelKernel.h | 243 - .../Eigen/src/Core/arch/NEON/MathFunctions.h | 68 - .../Eigen/src/Core/arch/NEON/PacketMath.h | 6214 - .../Eigen/src/Core/arch/NEON/TypeCasting.h | 1642 - .../Eigen/src/Core/arch/NEON/UnaryFunctors.h | 57 - .../eigen/Eigen/src/Core/arch/SSE/Complex.h | 503 - .../Eigen/src/Core/arch/SSE/MathFunctions.h | 88 - .../Eigen/src/Core/arch/SSE/PacketMath.h | 2585 - .../Eigen/src/Core/arch/SSE/TypeCasting.h | 230 - .../Eigen/src/Core/arch/SVE/MathFunctions.h | 48 - .../Eigen/src/Core/arch/SVE/PacketMath.h | 672 - .../Eigen/src/Core/arch/SVE/TypeCasting.h | 52 - .../Eigen/src/Core/arch/SYCL/InteropHeaders.h | 227 - .../Eigen/src/Core/arch/SYCL/MathFunctions.h | 303 - .../Eigen/src/Core/arch/SYCL/PacketMath.h | 576 - .../Eigen/src/Core/arch/SYCL/TypeCasting.h | 83 - .../Eigen/src/Core/arch/ZVector/Complex.h | 561 - .../src/Core/arch/ZVector/MathFunctions.h | 230 - .../Eigen/src/Core/arch/ZVector/PacketMath.h | 1286 - .../src/Core/functors/AssignmentFunctors.h | 174 - .../Eigen/src/Core/functors/BinaryFunctors.h | 762 - .../Eigen/src/Core/functors/NullaryFunctors.h | 274 - .../Eigen/src/Core/functors/StlFunctors.h | 149 - .../Eigen/src/Core/functors/TernaryFunctors.h | 52 - .../Eigen/src/Core/functors/UnaryFunctors.h | 1420 - .../Core/products/GeneralBlockPanelKernel.h | 3153 - .../src/Core/products/GeneralMatrixMatrix.h | 459 - .../products/GeneralMatrixMatrixTriangular.h | 330 - .../GeneralMatrixMatrixTriangular_BLAS.h | 148 - .../Core/products/GeneralMatrixMatrix_BLAS.h | 123 - .../src/Core/products/GeneralMatrixVector.h | 473 - .../Core/products/GeneralMatrixVector_BLAS.h | 139 - .../Eigen/src/Core/products/Parallelizer.h | 282 - .../Core/products/SelfadjointMatrixMatrix.h | 483 - .../products/SelfadjointMatrixMatrix_BLAS.h | 277 - .../Core/products/SelfadjointMatrixVector.h | 248 - .../products/SelfadjointMatrixVector_BLAS.h | 115 - .../src/Core/products/SelfadjointProduct.h | 133 - .../Core/products/SelfadjointRank2Update.h | 95 - .../Core/products/TriangularMatrixMatrix.h | 397 - .../products/TriangularMatrixMatrix_BLAS.h | 325 - .../Core/products/TriangularMatrixVector.h | 347 - .../products/TriangularMatrixVector_BLAS.h | 275 - .../Core/products/TriangularSolverMatrix.h | 388 - .../products/TriangularSolverMatrix_BLAS.h | 166 - .../Core/products/TriangularSolverVector.h | 122 - .../eigen/Eigen/src/Core/util/Assert.h | 158 - .../eigen/Eigen/src/Core/util/BlasUtil.h | 622 - .../src/Core/util/ConfigureVectorization.h | 543 - .../eigen/Eigen/src/Core/util/Constants.h | 598 - .../src/Core/util/DisableStupidWarnings.h | 146 - .../eigen/Eigen/src/Core/util/EmulateArray.h | 270 - .../Eigen/src/Core/util/ForwardDeclarations.h | 524 - .../Eigen/src/Core/util/IndexedViewHelper.h | 487 - .../Eigen/src/Core/util/IntegralConstant.h | 279 - .../eigen/Eigen/src/Core/util/MKL_support.h | 139 - .../eigen/Eigen/src/Core/util/Macros.h | 1317 - .../eigen/Eigen/src/Core/util/MaxSizeVector.h | 139 - .../eigen/Eigen/src/Core/util/Memory.h | 1345 - .../eigen/Eigen/src/Core/util/Meta.h | 760 - .../eigen/Eigen/src/Core/util/MoreMeta.h | 638 - .../src/Core/util/ReenableStupidWarnings.h | 44 - .../Eigen/src/Core/util/ReshapedHelper.h | 51 - .../eigen/Eigen/src/Core/util/Serializer.h | 208 - .../eigen/Eigen/src/Core/util/StaticAssert.h | 105 - .../eigen/Eigen/src/Core/util/SymbolicIndex.h | 445 - .../eigen/Eigen/src/Core/util/XprHelper.h | 1093 - .../src/Eigenvalues/ComplexEigenSolver.h | 315 - .../Eigen/src/Eigenvalues/ComplexSchur.h | 442 - .../src/Eigenvalues/ComplexSchur_LAPACKE.h | 95 - .../eigen/Eigen/src/Eigenvalues/EigenSolver.h | 579 - .../src/Eigenvalues/GeneralizedEigenSolver.h | 402 - .../GeneralizedSelfAdjointEigenSolver.h | 212 - .../src/Eigenvalues/HessenbergDecomposition.h | 356 - .../src/Eigenvalues/InternalHeaderCheck.h | 3 - .../src/Eigenvalues/MatrixBaseEigenvalues.h | 142 - .../eigen/Eigen/src/Eigenvalues/RealQZ.h | 587 - .../eigen/Eigen/src/Eigenvalues/RealSchur.h | 519 - .../Eigen/src/Eigenvalues/RealSchur_LAPACKE.h | 83 - .../src/Eigenvalues/SelfAdjointEigenSolver.h | 850 - .../SelfAdjointEigenSolver_LAPACKE.h | 90 - .../src/Eigenvalues/Tridiagonalization.h | 529 - .../eigen/Eigen/src/Geometry/AlignedBox.h | 485 - .../eigen/Eigen/src/Geometry/AngleAxis.h | 245 - .../eigen/Eigen/src/Geometry/EulerAngles.h | 203 - .../eigen/Eigen/src/Geometry/Homogeneous.h | 455 - .../eigen/Eigen/src/Geometry/Hyperplane.h | 273 - .../Eigen/src/Geometry/InternalHeaderCheck.h | 3 - .../eigen/Eigen/src/Geometry/OrthoMethods.h | 257 - .../Eigen/src/Geometry/ParametrizedLine.h | 232 - .../eigen/Eigen/src/Geometry/Quaternion.h | 855 - .../eigen/Eigen/src/Geometry/Rotation2D.h | 201 - .../eigen/Eigen/src/Geometry/RotationBase.h | 209 - .../eigen/Eigen/src/Geometry/Scaling.h | 195 - .../eigen/Eigen/src/Geometry/Transform.h | 1485 - .../eigen/Eigen/src/Geometry/Translation.h | 204 - .../eigen/Eigen/src/Geometry/Umeyama.h | 161 - .../Eigen/src/Geometry/arch/Geometry_SIMD.h | 154 - .../Eigen/src/Householder/BlockHouseholder.h | 115 - .../eigen/Eigen/src/Householder/Householder.h | 155 - .../src/Householder/HouseholderSequence.h | 504 - .../src/Householder/InternalHeaderCheck.h | 3 - .../BasicPreconditioners.h | 213 - .../src/IterativeLinearSolvers/BiCGSTAB.h | 217 - .../ConjugateGradient.h | 217 - .../IncompleteCholesky.h | 402 - .../IterativeLinearSolvers/IncompleteLUT.h | 449 - .../InternalHeaderCheck.h | 3 - .../IterativeSolverBase.h | 395 - .../LeastSquareConjugateGradient.h | 193 - .../IterativeLinearSolvers/SolveWithGuess.h | 111 - .../Eigen/src/Jacobi/InternalHeaderCheck.h | 3 - .../eigen/Eigen/src/Jacobi/Jacobi.h | 427 - .../src/KLUSupport/InternalHeaderCheck.h | 3 - .../eigen/Eigen/src/KLUSupport/KLUSupport.h | 339 - .../eigen/Eigen/src/LU/Determinant.h | 98 - .../eigen/Eigen/src/LU/FullPivLU.h | 815 - .../eigen/Eigen/src/LU/InternalHeaderCheck.h | 3 - .../eigen/Eigen/src/LU/InverseImpl.h | 353 - .../eigen/Eigen/src/LU/PartialPivLU.h | 575 - .../eigen/Eigen/src/LU/PartialPivLU_LAPACKE.h | 97 - .../eigen/Eigen/src/LU/arch/InverseSize4.h | 353 - .../src/MetisSupport/InternalHeaderCheck.h | 3 - .../Eigen/src/MetisSupport/MetisSupport.h | 125 - .../eigen/Eigen/src/OrderingMethods/Amd.h | 413 - .../Eigen/src/OrderingMethods/Eigen_Colamd.h | 1690 - .../src/OrderingMethods/InternalHeaderCheck.h | 3 - .../Eigen/src/OrderingMethods/Ordering.h | 146 - .../src/PaStiXSupport/InternalHeaderCheck.h | 3 - .../Eigen/src/PaStiXSupport/PaStiXSupport.h | 632 - .../src/PardisoSupport/InternalHeaderCheck.h | 3 - .../Eigen/src/PardisoSupport/PardisoSupport.h | 499 - .../eigen/Eigen/src/QR/ColPivHouseholderQR.h | 674 - .../src/QR/ColPivHouseholderQR_LAPACKE.h | 161 - .../src/QR/CompleteOrthogonalDecomposition.h | 648 - .../eigen/Eigen/src/QR/FullPivHouseholderQR.h | 722 - .../eigen/Eigen/src/QR/HouseholderQR.h | 532 - .../Eigen/src/QR/HouseholderQR_LAPACKE.h | 77 - .../eigen/Eigen/src/QR/InternalHeaderCheck.h | 3 - .../src/SPQRSupport/InternalHeaderCheck.h | 3 - .../src/SPQRSupport/SuiteSparseQRSupport.h | 315 - .../third-party/eigen/Eigen/src/SVD/BDCSVD.h | 1455 - .../eigen/Eigen/src/SVD/BDCSVD_LAPACKE.h | 172 - .../eigen/Eigen/src/SVD/InternalHeaderCheck.h | 3 - .../eigen/Eigen/src/SVD/JacobiSVD.h | 809 - .../eigen/Eigen/src/SVD/JacobiSVD_LAPACKE.h | 127 - .../third-party/eigen/Eigen/src/SVD/SVDBase.h | 436 - .../Eigen/src/SVD/UpperBidiagonalization.h | 379 - .../src/SparseCholesky/InternalHeaderCheck.h | 3 - .../src/SparseCholesky/SimplicialCholesky.h | 863 - .../SparseCholesky/SimplicialCholesky_impl.h | 384 - .../eigen/Eigen/src/SparseCore/AmbiVector.h | 329 - .../Eigen/src/SparseCore/CompressedStorage.h | 206 - .../ConservativeSparseSparseProduct.h | 308 - .../src/SparseCore/InternalHeaderCheck.h | 3 - .../eigen/Eigen/src/SparseCore/SparseAssign.h | 279 - .../eigen/Eigen/src/SparseCore/SparseBlock.h | 534 - .../Eigen/src/SparseCore/SparseColEtree.h | 194 - .../src/SparseCore/SparseCompressedBase.h | 591 - .../src/SparseCore/SparseCwiseBinaryOp.h | 938 - .../Eigen/src/SparseCore/SparseCwiseUnaryOp.h | 142 - .../Eigen/src/SparseCore/SparseDenseProduct.h | 314 - .../src/SparseCore/SparseDiagonalProduct.h | 138 - .../eigen/Eigen/src/SparseCore/SparseDot.h | 100 - .../eigen/Eigen/src/SparseCore/SparseFuzzy.h | 31 - .../eigen/Eigen/src/SparseCore/SparseMap.h | 295 - .../eigen/Eigen/src/SparseCore/SparseMatrix.h | 1872 - .../Eigen/src/SparseCore/SparseMatrixBase.h | 400 - .../Eigen/src/SparseCore/SparsePermutation.h | 249 - .../Eigen/src/SparseCore/SparseProduct.h | 178 - .../eigen/Eigen/src/SparseCore/SparseRedux.h | 47 - .../eigen/Eigen/src/SparseCore/SparseRef.h | 370 - .../src/SparseCore/SparseSelfAdjointView.h | 613 - .../Eigen/src/SparseCore/SparseSolverBase.h | 115 - .../SparseSparseProductWithPruning.h | 184 - .../Eigen/src/SparseCore/SparseTranspose.h | 83 - .../src/SparseCore/SparseTriangularView.h | 177 - .../eigen/Eigen/src/SparseCore/SparseUtil.h | 209 - .../eigen/Eigen/src/SparseCore/SparseVector.h | 532 - .../eigen/Eigen/src/SparseCore/SparseView.h | 225 - .../Eigen/src/SparseCore/TriangularSolver.h | 266 - .../Eigen/src/SparseLU/InternalHeaderCheck.h | 3 - .../eigen/Eigen/src/SparseLU/SparseLU.h | 969 - .../eigen/Eigen/src/SparseLU/SparseLUImpl.h | 79 - .../Eigen/src/SparseLU/SparseLU_Memory.h | 210 - .../Eigen/src/SparseLU/SparseLU_Structs.h | 113 - .../src/SparseLU/SparseLU_SupernodalMatrix.h | 319 - .../eigen/Eigen/src/SparseLU/SparseLU_Utils.h | 75 - .../Eigen/src/SparseLU/SparseLU_column_bmod.h | 177 - .../Eigen/src/SparseLU/SparseLU_column_dfs.h | 168 - .../src/SparseLU/SparseLU_copy_to_ucol.h | 106 - .../src/SparseLU/SparseLU_heap_relax_snode.h | 114 - .../Eigen/src/SparseLU/SparseLU_kernel_bmod.h | 133 - .../Eigen/src/SparseLU/SparseLU_panel_bmod.h | 215 - .../Eigen/src/SparseLU/SparseLU_panel_dfs.h | 235 - .../Eigen/src/SparseLU/SparseLU_pivotL.h | 136 - .../Eigen/src/SparseLU/SparseLU_pruneL.h | 130 - .../Eigen/src/SparseLU/SparseLU_relax_snode.h | 81 - .../Eigen/src/SparseQR/InternalHeaderCheck.h | 3 - .../eigen/Eigen/src/SparseQR/SparseQR.h | 706 - .../eigen/Eigen/src/StlSupport/StdDeque.h | 51 - .../eigen/Eigen/src/StlSupport/StdList.h | 50 - .../eigen/Eigen/src/StlSupport/StdVector.h | 51 - .../eigen/Eigen/src/StlSupport/details.h | 82 - .../src/SuperLUSupport/InternalHeaderCheck.h | 3 - .../Eigen/src/SuperLUSupport/SuperLUSupport.h | 908 - .../eigen/Eigen/src/ThreadPool/Barrier.h | 70 - .../src/ThreadPool/CoreThreadPoolDevice.h | 336 - .../eigen/Eigen/src/ThreadPool/EventCount.h | 241 - .../eigen/Eigen/src/ThreadPool/ForkJoin.h | 140 - .../src/ThreadPool/InternalHeaderCheck.h | 4 - .../src/ThreadPool/NonBlockingThreadPool.h | 587 - .../eigen/Eigen/src/ThreadPool/RunQueue.h | 230 - .../eigen/Eigen/src/ThreadPool/ThreadCancel.h | 21 - .../Eigen/src/ThreadPool/ThreadEnvironment.h | 43 - .../eigen/Eigen/src/ThreadPool/ThreadLocal.h | 289 - .../src/ThreadPool/ThreadPoolInterface.h | 50 - .../eigen/Eigen/src/ThreadPool/ThreadYield.h | 16 - .../src/UmfPackSupport/InternalHeaderCheck.h | 3 - .../Eigen/src/UmfPackSupport/UmfPackSupport.h | 606 - .../third-party/eigen/Eigen/src/misc/Image.h | 80 - .../Eigen/src/misc/InternalHeaderCheck.h | 3 - .../third-party/eigen/Eigen/src/misc/Kernel.h | 77 - .../eigen/Eigen/src/misc/RealSvd2x2.h | 53 - .../third-party/eigen/Eigen/src/misc/blas.h | 97 - .../eigen/Eigen/src/misc/lapacke.h | 10085 -- .../eigen/Eigen/src/misc/lapacke_helpers.h | 163 - .../eigen/Eigen/src/misc/lapacke_mangling.h | 16 - .../third-party/eigen/bench/BenchSparseUtil.h | 129 - .../third-party/eigen/bench/BenchTimer.h | 176 - .../third-party/eigen/bench/BenchUtil.h | 86 - .../third-party/eigen/bench/basicbenchmark.h | 54 - .../bench/btl/generic_bench/utils/utilities.h | 128 - .../eigen/bench/btl/libs/BLAS/blas.h | 545 - .../bench/btl/libs/BLAS/c_interface_base.h | 61 - .../eigen/bench/perf_monitoring/gemm_common.h | 61 - .../eigen/bench/perf_monitoring/gemv_common.h | 63 - .../eigen/bench/spbench/spbenchsolver.h | 565 - .../eigen/bench/spbench/spbenchstyle.h | 93 - .../eigen/bench/tensors/benchmark.h | 45 - .../eigen/bench/tensors/tensor_benchmarks.h | 531 - .../eigen/blas/BandTriangularSolver.h | 84 - .../eigen/blas/GeneralRank1Update.h | 42 - .../eigen/blas/PackedSelfadjointProduct.h | 52 - .../eigen/blas/PackedTriangularMatrixVector.h | 82 - .../eigen/blas/PackedTriangularSolverVector.h | 76 - .../third-party/eigen/blas/Rank2Update.h | 56 - .../optimized/third-party/eigen/blas/blas.h | 471 - .../optimized/third-party/eigen/blas/common.h | 153 - .../third-party/eigen/blas/f2c/datatypes.h | 27 - .../third-party/eigen/blas/level1_cplx_impl.h | 159 - .../third-party/eigen/blas/level1_impl.h | 133 - .../third-party/eigen/blas/level1_real_impl.h | 130 - .../third-party/eigen/blas/level2_cplx_impl.h | 362 - .../third-party/eigen/blas/level2_impl.h | 616 - .../third-party/eigen/blas/level2_real_impl.h | 313 - .../third-party/eigen/blas/level3_impl.h | 878 - .../eigen/demos/mandelbrot/mandelbrot.h | 67 - .../demos/mix_eigen_and_c/binary_library.h | 55 - .../third-party/eigen/demos/opengl/camera.h | 111 - .../eigen/demos/opengl/gpuhelper.h | 187 - .../eigen/demos/opengl/icosphere.h | 30 - .../eigen/demos/opengl/quaternion_demo.h | 100 - .../eigen/demos/opengl/trackball.h | 41 - .../third-party/eigen/lapack/lapack.h | 136 - .../third-party/eigen/lapack/lapack_common.h | 20 - .../third-party/eigen/test/AnnoyingScalar.h | 204 - .../third-party/eigen/test/CustomComplex.h | 132 - .../third-party/eigen/test/MovableScalar.h | 54 - .../third-party/eigen/test/OffByOneScalar.h | 20 - .../third-party/eigen/test/SafeScalar.h | 33 - .../third-party/eigen/test/bug1213.h | 7 - .../third-party/eigen/test/evaluator_common.h | 0 .../third-party/eigen/test/gpu_common.h | 161 - .../third-party/eigen/test/gpu_test_helper.h | 448 - .../optimized/third-party/eigen/test/main.h | 937 - .../eigen/test/packetmath_test_shared.h | 295 - .../third-party/eigen/test/product.h | 317 - .../eigen/test/random_matrix_helper.h | 242 - .../eigen/test/random_without_cast_overflow.h | 191 - .../third-party/eigen/test/solverbase.h | 39 - .../optimized/third-party/eigen/test/sparse.h | 124 - .../third-party/eigen/test/sparse_solver.h | 769 - .../eigen/test/split_test_helper.h | 5993 - .../third-party/eigen/test/svd_common.h | 553 - .../third-party/eigen/test/svd_fill.h | 109 - .../CXX11/src/Tensor/InternalHeaderCheck.h | 3 - .../Eigen/CXX11/src/Tensor/Tensor.h | 382 - .../Eigen/CXX11/src/Tensor/TensorArgMax.h | 282 - .../Eigen/CXX11/src/Tensor/TensorAssign.h | 211 - .../Eigen/CXX11/src/Tensor/TensorBase.h | 1244 - .../Eigen/CXX11/src/Tensor/TensorBlock.h | 1474 - .../CXX11/src/Tensor/TensorBroadcasting.h | 1001 - .../Eigen/CXX11/src/Tensor/TensorChipping.h | 469 - .../CXX11/src/Tensor/TensorConcatenation.h | 352 - .../CXX11/src/Tensor/TensorContraction.h | 958 - .../src/Tensor/TensorContractionBlocking.h | 69 - .../CXX11/src/Tensor/TensorContractionCuda.h | 7 - .../CXX11/src/Tensor/TensorContractionGpu.h | 1387 - .../src/Tensor/TensorContractionMapper.h | 533 - .../CXX11/src/Tensor/TensorContractionSycl.h | 1653 - .../src/Tensor/TensorContractionThreadPool.h | 1552 - .../Eigen/CXX11/src/Tensor/TensorConversion.h | 416 - .../CXX11/src/Tensor/TensorConvolution.h | 1119 - .../CXX11/src/Tensor/TensorConvolutionSycl.h | 538 - .../Eigen/CXX11/src/Tensor/TensorCostModel.h | 189 - .../Eigen/CXX11/src/Tensor/TensorCustomOp.h | 307 - .../Eigen/CXX11/src/Tensor/TensorDevice.h | 138 - .../Eigen/CXX11/src/Tensor/TensorDeviceCuda.h | 7 - .../CXX11/src/Tensor/TensorDeviceDefault.h | 113 - .../Eigen/CXX11/src/Tensor/TensorDeviceGpu.h | 395 - .../Eigen/CXX11/src/Tensor/TensorDeviceSycl.h | 567 - .../CXX11/src/Tensor/TensorDeviceThreadPool.h | 346 - .../CXX11/src/Tensor/TensorDimensionList.h | 117 - .../Eigen/CXX11/src/Tensor/TensorDimensions.h | 334 - .../Eigen/CXX11/src/Tensor/TensorEvalTo.h | 189 - .../Eigen/CXX11/src/Tensor/TensorEvaluator.h | 858 - .../Eigen/CXX11/src/Tensor/TensorExecutor.h | 670 - .../Eigen/CXX11/src/Tensor/TensorExpr.h | 338 - .../Eigen/CXX11/src/Tensor/TensorFFT.h | 666 - .../Eigen/CXX11/src/Tensor/TensorFixedSize.h | 225 - .../Eigen/CXX11/src/Tensor/TensorForcedEval.h | 231 - .../src/Tensor/TensorForwardDeclarations.h | 215 - .../Eigen/CXX11/src/Tensor/TensorFunctors.h | 422 - .../Eigen/CXX11/src/Tensor/TensorGenerator.h | 269 - .../CXX11/src/Tensor/TensorGlobalFunctions.h | 36 - .../src/Tensor/TensorGpuHipCudaDefines.h | 101 - .../src/Tensor/TensorGpuHipCudaUndefines.h | 45 - .../Eigen/CXX11/src/Tensor/TensorIO.h | 413 - .../Eigen/CXX11/src/Tensor/TensorImagePatch.h | 590 - .../Eigen/CXX11/src/Tensor/TensorIndexList.h | 619 - .../Eigen/CXX11/src/Tensor/TensorInflation.h | 224 - .../CXX11/src/Tensor/TensorInitializer.h | 78 - .../Eigen/CXX11/src/Tensor/TensorIntDiv.h | 259 - .../Eigen/CXX11/src/Tensor/TensorLayoutSwap.h | 185 - .../Eigen/CXX11/src/Tensor/TensorMacros.h | 85 - .../Eigen/CXX11/src/Tensor/TensorMap.h | 191 - .../Eigen/CXX11/src/Tensor/TensorMeta.h | 291 - .../Eigen/CXX11/src/Tensor/TensorMorphing.h | 982 - .../Eigen/CXX11/src/Tensor/TensorPadding.h | 620 - .../Eigen/CXX11/src/Tensor/TensorPatch.h | 258 - .../Eigen/CXX11/src/Tensor/TensorRandom.h | 315 - .../Eigen/CXX11/src/Tensor/TensorReduction.h | 1025 - .../CXX11/src/Tensor/TensorReductionGpu.h | 958 - .../CXX11/src/Tensor/TensorReductionSycl.h | 588 - .../Eigen/CXX11/src/Tensor/TensorRef.h | 391 - .../Eigen/CXX11/src/Tensor/TensorReverse.h | 410 - .../Eigen/CXX11/src/Tensor/TensorRoll.h | 361 - .../Eigen/CXX11/src/Tensor/TensorScan.h | 474 - .../Eigen/CXX11/src/Tensor/TensorScanSycl.h | 506 - .../Eigen/CXX11/src/Tensor/TensorShuffling.h | 413 - .../Eigen/CXX11/src/Tensor/TensorStorage.h | 143 - .../Eigen/CXX11/src/Tensor/TensorStriding.h | 314 - .../Eigen/CXX11/src/Tensor/TensorTrace.h | 281 - .../Eigen/CXX11/src/Tensor/TensorTraits.h | 232 - .../Eigen/CXX11/src/Tensor/TensorUInt128.h | 229 - .../CXX11/src/Tensor/TensorVolumePatch.h | 622 - .../src/TensorSymmetry/DynamicSymmetry.h | 296 - .../src/TensorSymmetry/InternalHeaderCheck.h | 4 - .../CXX11/src/TensorSymmetry/StaticSymmetry.h | 223 - .../Eigen/CXX11/src/TensorSymmetry/Symmetry.h | 335 - .../TensorSymmetry/util/TemplateGroupTheory.h | 492 - .../Eigen/CXX11/src/util/CXX11Meta.h | 18 - .../Eigen/CXX11/src/util/CXX11Workarounds.h | 85 - .../Eigen/src/AutoDiff/AutoDiffJacobian.h | 76 - .../Eigen/src/AutoDiff/AutoDiffScalar.h | 639 - .../Eigen/src/AutoDiff/AutoDiffVector.h | 189 - .../Eigen/src/AutoDiff/CoherentPadOp.h | 152 - .../Eigen/src/AutoDiff/InternalHeaderCheck.h | 3 - .../unsupported/Eigen/src/BVH/BVAlgorithms.h | 291 - .../Eigen/src/BVH/InternalHeaderCheck.h | 3 - .../eigen/unsupported/Eigen/src/BVH/KdBVH.h | 223 - .../ArpackSelfAdjointEigenSolver.h | 701 - .../src/Eigenvalues/InternalHeaderCheck.h | 3 - .../Eigen/src/EulerAngles/EulerAngles.h | 350 - .../Eigen/src/EulerAngles/EulerSystem.h | 284 - .../src/EulerAngles/InternalHeaderCheck.h | 3 - .../Eigen/src/FFT/InternalHeaderCheck.h | 3 - .../unsupported/Eigen/src/FFT/ei_fftw_impl.h | 216 - .../Eigen/src/FFT/ei_imklfft_impl.h | 248 - .../Eigen/src/FFT/ei_kissfft_impl.h | 416 - .../Eigen/src/FFT/ei_pocketfft_impl.h | 68 - .../Eigen/src/IterativeSolvers/BiCGSTABL.h | 339 - .../Eigen/src/IterativeSolvers/DGMRES.h | 492 - .../Eigen/src/IterativeSolvers/GMRES.h | 315 - .../Eigen/src/IterativeSolvers/IDRS.h | 395 - .../Eigen/src/IterativeSolvers/IDRSTABL.h | 476 - .../Eigen/src/IterativeSolvers/IncompleteLU.h | 88 - .../IterativeSolvers/InternalHeaderCheck.h | 4 - .../Eigen/src/IterativeSolvers/MINRES.h | 254 - .../Eigen/src/IterativeSolvers/Scaling.h | 172 - .../KroneckerProduct/InternalHeaderCheck.h | 4 - .../KroneckerProduct/KroneckerTensorProduct.h | 284 - .../LevenbergMarquardt/InternalHeaderCheck.h | 4 - .../Eigen/src/LevenbergMarquardt/LMcovar.h | 80 - .../Eigen/src/LevenbergMarquardt/LMonestep.h | 187 - .../Eigen/src/LevenbergMarquardt/LMpar.h | 149 - .../Eigen/src/LevenbergMarquardt/LMqrsolv.h | 178 - .../LevenbergMarquardt/LevenbergMarquardt.h | 362 - .../src/MatrixFunctions/InternalHeaderCheck.h | 4 - .../src/MatrixFunctions/MatrixExponential.h | 456 - .../src/MatrixFunctions/MatrixFunction.h | 543 - .../src/MatrixFunctions/MatrixLogarithm.h | 366 - .../Eigen/src/MatrixFunctions/MatrixPower.h | 694 - .../src/MatrixFunctions/MatrixSquareRoot.h | 346 - .../Eigen/src/MatrixFunctions/StemFunction.h | 115 - .../HybridNonLinearSolver.h | 545 - .../InternalHeaderCheck.h | 4 - .../LevenbergMarquardt.h | 587 - .../Eigen/src/NonLinearOptimization/chkder.h | 57 - .../Eigen/src/NonLinearOptimization/covar.h | 66 - .../Eigen/src/NonLinearOptimization/dogleg.h | 103 - .../Eigen/src/NonLinearOptimization/fdjac1.h | 73 - .../Eigen/src/NonLinearOptimization/lmpar.h | 265 - .../Eigen/src/NonLinearOptimization/qrsolv.h | 89 - .../Eigen/src/NonLinearOptimization/r1mpyq.h | 33 - .../Eigen/src/NonLinearOptimization/r1updt.h | 96 - .../Eigen/src/NonLinearOptimization/rwupdt.h | 47 - .../src/NumericalDiff/InternalHeaderCheck.h | 3 - .../Eigen/src/NumericalDiff/NumericalDiff.h | 127 - .../Eigen/src/Polynomials/Companion.h | 252 - .../src/Polynomials/InternalHeaderCheck.h | 3 - .../Eigen/src/Polynomials/PolynomialSolver.h | 387 - .../Eigen/src/Polynomials/PolynomialUtils.h | 144 - .../Eigen/src/SparseExtra/BlockSparseMatrix.h | 974 - .../src/SparseExtra/InternalHeaderCheck.h | 3 - .../Eigen/src/SparseExtra/MarketIO.h | 366 - .../src/SparseExtra/MatrixMarketIterator.h | 220 - .../Eigen/src/SparseExtra/RandomSetter.h | 303 - .../Eigen/src/SparseExtra/SparseInverse.h | 232 - .../BesselFunctionsArrayAPI.h | 276 - .../BesselFunctionsBFloat16.h | 71 - .../BesselFunctionsFunctors.h | 323 - .../SpecialFunctions/BesselFunctionsHalf.h | 69 - .../SpecialFunctions/BesselFunctionsImpl.h | 1638 - .../BesselFunctionsPacketMath.h | 108 - .../SpecialFunctions/HipVectorCompatibility.h | 71 - .../SpecialFunctions/InternalHeaderCheck.h | 4 - .../SpecialFunctionsArrayAPI.h | 159 - .../SpecialFunctionsBFloat16.h | 73 - .../SpecialFunctionsFunctors.h | 326 - .../SpecialFunctions/SpecialFunctionsHalf.h | 73 - .../SpecialFunctions/SpecialFunctionsImpl.h | 2073 - .../SpecialFunctionsPacketMath.h | 112 - .../arch/AVX/BesselFunctions.h | 46 - .../arch/AVX/SpecialFunctions.h | 16 - .../arch/AVX512/BesselFunctions.h | 46 - .../arch/AVX512/SpecialFunctions.h | 16 - .../arch/GPU/SpecialFunctions.h | 317 - .../arch/NEON/BesselFunctions.h | 54 - .../arch/NEON/SpecialFunctions.h | 34 - .../Eigen/src/Splines/InternalHeaderCheck.h | 3 - .../unsupported/Eigen/src/Splines/Spline.h | 479 - .../Eigen/src/Splines/SplineFitting.h | 393 - .../unsupported/Eigen/src/Splines/SplineFwd.h | 109 - .../eigen/unsupported/test/fft_test_shared.h | 309 - .../eigen/unsupported/test/matrix_functions.h | 56 - .../kernels/optimized/utils/llvmMathExtras.h | 908 - .../kernels/optimized/utils/math_utils.h | 60 - .../kernels/optimized/utils/unroll.h | 40 - .../kernels/optimized/vec/functional.h | 105 - .../kernels/portable/cpu/math_constants.h | 70 - .../kernels/portable/cpu/pattern/bitwise_op.h | 149 - .../portable/cpu/pattern/comparison_op.h | 107 - .../kernels/portable/cpu/pattern/logical_op.h | 56 - .../kernels/portable/cpu/pattern/pattern.h | 114 - .../kernels/portable/cpu/scalar_utils.h | 317 - .../kernels/portable/cpu/selective_build.h | 44 - .../portable/cpu/util/activation_ops_util.h | 38 - .../portable/cpu/util/advanced_index_util.h | 131 - .../kernels/portable/cpu/util/arange_util.h | 41 - .../cpu/util/broadcast_indexes_range.h | 376 - .../portable/cpu/util/broadcast_util.h | 297 - .../kernels/portable/cpu/util/copy_ops_util.h | 286 - .../portable/cpu/util/delinearize_index.h | 43 - .../kernels/portable/cpu/util/distance_util.h | 134 - .../kernels/portable/cpu/util/dtype_util.h | 458 - .../portable/cpu/util/elementwise_util.h | 616 - .../portable/cpu/util/functional_util.h | 96 - .../kernels/portable/cpu/util/index_util.h | 68 - .../portable/cpu/util/kernel_ops_util.h | 490 - .../kernels/portable/cpu/util/math_util.h | 222 - .../portable/cpu/util/matmul_ops_util.h | 80 - .../cpu/util/normalization_ops_util.h | 56 - .../kernels/portable/cpu/util/padding_util.h | 140 - .../kernels/portable/cpu/util/reduce_util.h | 853 - .../kernels/portable/cpu/util/repeat_util.h | 31 - .../portable/cpu/util/select_copy_util.h | 23 - .../kernels/portable/cpu/util/slice_util.h | 66 - .../kernels/portable/cpu/util/stack_util.h | 28 - .../portable/cpu/util/transpose_util.h | 176 - .../kernels/portable/cpu/util/upsample_util.h | 149 - .../portable/cpu/util/vectorized_math.h | 148 - .../executorch/kernels/portable/cpu/vec_ops.h | 251 - .../kernels/prim_ops/et_copy_index.h | 23 - .../executorch/kernels/prim_ops/et_view.h | 23 - .../kernels/quantized/cpu/embeddingxb.h | 72 - .../kernels/test/BinaryLogicalOpTest.h | 72 - .../kernels/test/ScalarOverflowTestMacros.h | 38 - .../executorch/kernels/test/TestUtil.h | 121 - .../UnaryUfuncRealHBBF16ToFloatHBF16Test.h | 187 - .../include/executorch/kernels/test/op_test.h | 14 - .../backend/backend_execution_context.h | 80 - .../runtime/backend/backend_init_context.h | 94 - .../runtime/backend/backend_option_context.h | 34 - .../executorch/runtime/backend/interface.h | 230 - .../executorch/runtime/backend/options.h | 208 - .../executorch/runtime/core/array_ref.h | 262 - .../executorch/runtime/core/data_loader.h | 141 - .../include/executorch/runtime/core/defines.h | 20 - .../include/executorch/runtime/core/error.h | 257 - .../include/executorch/runtime/core/evalue.h | 559 - .../executorch/runtime/core/event_tracer.h | 592 - .../runtime/core/event_tracer_hooks.h | 340 - .../core/event_tracer_hooks_delegate.h | 204 - .../runtime/core/exec_aten/exec_aten.h | 175 - .../exec_aten/testing_util/tensor_factory.h | 1133 - .../core/exec_aten/testing_util/tensor_util.h | 378 - .../core/exec_aten/util/dim_order_util.h | 278 - .../core/exec_aten/util/scalar_type_util.h | 1423 - .../exec_aten/util/tensor_dimension_limit.h | 21 - .../exec_aten/util/tensor_shape_to_c_string.h | 68 - .../runtime/core/exec_aten/util/tensor_util.h | 1409 - .../executorch/runtime/core/freeable_buffer.h | 122 - .../executorch/runtime/core/function_ref.h | 108 - .../runtime/core/hierarchical_allocator.h | 120 - .../runtime/core/memory_allocator.h | 221 - .../executorch/runtime/core/named_data_map.h | 77 - .../runtime/core/portable_type/bfloat16.h | 27 - .../core/portable_type/bfloat16_math.h | 14 - .../runtime/core/portable_type/bits_types.h | 83 - .../portable_type/c10/c10/macros/Export.h | 1 - .../portable_type/c10/c10/macros/Macros.h | 1 - .../portable_type/c10/c10/util/BFloat16-inl.h | 1 - .../c10/c10/util/BFloat16-math.h | 299 - .../portable_type/c10/c10/util/BFloat16.h | 1 - .../portable_type/c10/c10/util/Half-inl.h | 1 - .../core/portable_type/c10/c10/util/Half.h | 8 - .../c10/c10/util/TypeSafeSignMath.h | 1 - .../portable_type/c10/c10/util/bit_cast.h | 1 - .../core/portable_type/c10/c10/util/complex.h | 78 - .../portable_type/c10/c10/util/complex_math.h | 406 - .../c10/c10/util/complex_utils.h | 46 - .../c10/c10/util/floating_point_utils.h | 1 - .../core/portable_type/c10/c10/util/irange.h | 123 - .../c10/c10/util/llvmMathExtras.h | 905 - .../portable_type/c10/c10/util/overflows.h | 100 - .../c10/c10/util/safe_numerics.h | 99 - .../c10/torch/headeronly/macros/Export.h | 153 - .../c10/torch/headeronly/macros/Macros.h | 572 - .../c10/torch/headeronly/util/BFloat16.h | 478 - .../c10/torch/headeronly/util/Half.h | 787 - .../torch/headeronly/util/TypeSafeSignMath.h | 148 - .../c10/torch/headeronly/util/bit_cast.h | 50 - .../c10/torch/headeronly/util/complex.h | 616 - .../headeronly/util/floating_point_utils.h | 38 - .../runtime/core/portable_type/complex.h | 21 - .../runtime/core/portable_type/device.h | 74 - .../runtime/core/portable_type/half.h | 27 - .../runtime/core/portable_type/optional.h | 36 - .../runtime/core/portable_type/qint_types.h | 83 - .../runtime/core/portable_type/scalar.h | 123 - .../runtime/core/portable_type/scalar_type.h | 154 - .../runtime/core/portable_type/string_view.h | 29 - .../runtime/core/portable_type/tensor.h | 175 - .../runtime/core/portable_type/tensor_impl.h | 304 - .../core/portable_type/tensor_options.h | 60 - .../include/executorch/runtime/core/result.h | 268 - .../include/executorch/runtime/core/span.h | 110 - .../include/executorch/runtime/core/tag.h | 90 - .../executorch/runtime/core/tensor_layout.h | 93 - .../runtime/core/tensor_shape_dynamism.h | 39 - .../core/testing_util/error_matchers.h | 303 - .../runtime/executor/memory_manager.h | 123 - .../runtime/executor/merged_data_map.h | 151 - .../executorch/runtime/executor/method.h | 436 - .../executorch/runtime/executor/method_meta.h | 302 - .../executor/platform_memory_allocator.h | 111 - .../executorch/runtime/executor/program.h | 318 - .../runtime/executor/pte_data_map.h | 152 - .../runtime/executor/tensor_parser.h | 163 - .../executor/test/managed_memory_manager.h | 68 - .../runtime/kernel/kernel_includes.h | 23 - .../runtime/kernel/kernel_runtime_context.h | 131 - .../runtime/kernel/operator_registry.h | 298 - .../runtime/kernel/test/test_util.h | 40 - .../kernel/thread_parallel_interface.h | 107 - .../executorch/runtime/platform/abort.h | 36 - .../executorch/runtime/platform/assert.h | 124 - .../executorch/runtime/platform/clock.h | 43 - .../runtime/platform/compat_unistd.h | 75 - .../executorch/runtime/platform/compiler.h | 201 - .../include/executorch/runtime/platform/log.h | 194 - .../executorch/runtime/platform/platform.h | 276 - .../executorch/runtime/platform/profiler.h | 289 - .../executorch/runtime/platform/runtime.h | 35 - .../executorch/runtime/platform/system.h | 49 - .../runtime/platform/test/pal_spy.h | 86 - .../runtime/platform/test/stub_platform.h | 76 - .../executorch/runtime/platform/types.h | 24 - .../executorch/schema/extended_header.h | 85 - .../executorch/schema/program_generated.h | 3211 - .../executorch/schema/scalar_type_generated.h | 118 - .../include/flatbuffers/allocator.h | 68 - .../flatbuffers/include/flatbuffers/array.h | 256 - .../flatbuffers/include/flatbuffers/base.h | 496 - .../flatbuffers/include/flatbuffers/buffer.h | 199 - .../include/flatbuffers/buffer_ref.h | 53 - .../include/flatbuffers/code_generator.h | 97 - .../include/flatbuffers/code_generators.h | 238 - .../include/flatbuffers/default_allocator.h | 64 - .../include/flatbuffers/detached_buffer.h | 114 - .../include/flatbuffers/file_manager.h | 48 - .../include/flatbuffers/flatbuffer_builder.h | 1478 - .../include/flatbuffers/flatbuffers.h | 284 - .../flatbuffers/include/flatbuffers/flatc.h | 131 - .../include/flatbuffers/flex_flat_util.h | 36 - .../include/flatbuffers/flexbuffers.h | 1938 - .../flatbuffers/include/flatbuffers/grpc.h | 299 - .../flatbuffers/include/flatbuffers/hash.h | 127 - .../flatbuffers/include/flatbuffers/idl.h | 1272 - .../include/flatbuffers/minireflect.h | 421 - .../include/flatbuffers/pch/flatc_pch.h | 39 - .../flatbuffers/include/flatbuffers/pch/pch.h | 38 - .../include/flatbuffers/reflection.h | 523 - .../flatbuffers/reflection_generated.h | 1529 - .../include/flatbuffers/registry.h | 130 - .../include/flatbuffers/stl_emulation.h | 514 - .../flatbuffers/include/flatbuffers/string.h | 69 - .../flatbuffers/include/flatbuffers/struct.h | 53 - .../flatbuffers/include/flatbuffers/table.h | 188 - .../flatbuffers/include/flatbuffers/util.h | 737 - .../flatbuffers/include/flatbuffers/vector.h | 397 - .../include/flatbuffers/vector_downward.h | 289 - .../include/flatbuffers/verifier.h | 332 - .../flatcc/include/flatcc/flatcc.h | 268 - .../flatcc/include/flatcc/flatcc_accessors.h | 106 - .../flatcc/include/flatcc/flatcc_alloc.h | 128 - .../flatcc/include/flatcc/flatcc_assert.h | 45 - .../flatcc/include/flatcc/flatcc_builder.h | 1911 - .../flatcc/include/flatcc/flatcc_emitter.h | 215 - .../flatcc/include/flatcc/flatcc_endian.h | 125 - .../flatcc/include/flatcc/flatcc_epilogue.h | 8 - .../include/flatcc/flatcc_flatbuffers.h | 57 - .../flatcc/include/flatcc/flatcc_identifier.h | 148 - .../flatcc/include/flatcc/flatcc_iov.h | 31 - .../include/flatcc/flatcc_json_parser.h | 908 - .../include/flatcc/flatcc_json_printer.h | 788 - .../flatcc/include/flatcc/flatcc_portable.h | 14 - .../flatcc/include/flatcc/flatcc_prologue.h | 8 - .../flatcc/include/flatcc/flatcc_refmap.h | 144 - .../flatcc/include/flatcc/flatcc_rtconfig.h | 162 - .../flatcc/include/flatcc/flatcc_types.h | 97 - .../flatcc/include/flatcc/flatcc_unaligned.h | 16 - .../flatcc/include/flatcc/flatcc_verifier.h | 267 - .../flatcc/include/flatcc/flatcc_version.h | 14 - .../flatcc/include/flatcc/portable/LICENSE | 14 - .../flatcc/include/flatcc/portable/README.md | 57 - .../include/flatcc/portable/grisu3_math.h | 329 - .../include/flatcc/portable/grisu3_parse.h | 582 - .../include/flatcc/portable/grisu3_print.h | 265 - .../include/flatcc/portable/include/README | 4 - .../flatcc/portable/include/linux/endian.h | 1 - .../flatcc/portable/include/std/inttypes.h | 1 - .../flatcc/portable/include/std/stdalign.h | 1 - .../flatcc/portable/include/std/stdbool.h | 1 - .../flatcc/portable/include/std/stdint.h | 1 - .../include/flatcc/portable/paligned_alloc.h | 213 - .../include/flatcc/portable/pattributes.h | 84 - .../flatcc/include/flatcc/portable/pbase64.h | 448 - .../flatcc/include/flatcc/portable/pcrt.h | 48 - .../include/flatcc/portable/pdiagnostic.h | 85 - .../include/flatcc/portable/pdiagnostic_pop.h | 20 - .../flatcc/portable/pdiagnostic_push.h | 51 - .../flatcc/include/flatcc/portable/pendian.h | 206 - .../include/flatcc/portable/pendian_detect.h | 118 - .../flatcc/include/flatcc/portable/pinline.h | 19 - .../include/flatcc/portable/pinttypes.h | 52 - .../include/flatcc/portable/pmemaccess.h | 232 - .../flatcc/include/flatcc/portable/portable.h | 2 - .../include/flatcc/portable/portable_basic.h | 27 - .../flatcc/include/flatcc/portable/pparsefp.h | 226 - .../include/flatcc/portable/pparseint.h | 374 - .../flatcc/include/flatcc/portable/pprintfp.h | 39 - .../include/flatcc/portable/pprintint.h | 628 - .../include/flatcc/portable/prestrict.h | 39 - .../include/flatcc/portable/pstatic_assert.h | 67 - .../flatcc/portable/pstatic_assert_scope.h | 280 - .../include/flatcc/portable/pstdalign.h | 162 - .../flatcc/include/flatcc/portable/pstdbool.h | 46 - .../flatcc/include/flatcc/portable/pstdint.h | 898 - .../include/flatcc/portable/punaligned.h | 190 - .../flatcc/include/flatcc/portable/pversion.h | 6 - .../include/flatcc/portable/pwarnings.h | 52 - .../flatcc/include/flatcc/reflection/README | 19 - .../reflection/flatbuffers_common_builder.h | 685 - .../reflection/flatbuffers_common_reader.h | 578 - .../flatcc/reflection/reflection_builder.h | 457 - .../flatcc/reflection/reflection_reader.h | 411 - .../flatcc/reflection/reflection_verifier.h | 308 - .../flatcc/include/flatcc/support/README | 1 - .../flatcc/include/flatcc/support/cdump.h | 38 - .../flatcc/include/flatcc/support/elapsed.h | 73 - .../flatcc/include/flatcc/support/hexdump.h | 47 - .../flatcc/include/flatcc/support/readfile.h | 66 - .../portable/cpu/op__clone_dim_order.cpp | 80 - .../portable/cpu/op__empty_dim_order.cpp | 83 - .../portable/cpu/op__to_dim_order_copy.cpp | 81 - .../engine/kernels/portable/cpu/op_abs.cpp | 81 - .../engine/kernels/portable/cpu/op_acos.cpp | 21 - .../engine/kernels/portable/cpu/op_acosh.cpp | 21 - .../engine/kernels/portable/cpu/op_add.cpp | 156 - .../engine/kernels/portable/cpu/op_addmm.cpp | 112 - .../kernels/portable/cpu/op_alias_copy.cpp | 46 - .../kernels/portable/cpu/op_allclose.cpp | 191 - .../engine/kernels/portable/cpu/op_amax.cpp | 72 - .../engine/kernels/portable/cpu/op_amin.cpp | 71 - .../engine/kernels/portable/cpu/op_any.cpp | 186 - .../engine/kernels/portable/cpu/op_arange.cpp | 90 - .../engine/kernels/portable/cpu/op_argmax.cpp | 82 - .../engine/kernels/portable/cpu/op_argmin.cpp | 89 - .../portable/cpu/op_as_strided_copy.cpp | 60 - .../engine/kernels/portable/cpu/op_asin.cpp | 21 - .../engine/kernels/portable/cpu/op_asinh.cpp | 21 - .../engine/kernels/portable/cpu/op_atan.cpp | 21 - .../engine/kernels/portable/cpu/op_atan2.cpp | 78 - .../engine/kernels/portable/cpu/op_atanh.cpp | 21 - .../kernels/portable/cpu/op_avg_pool2d.cpp | 126 - .../kernels/portable/cpu/op_bitwise_and.cpp | 39 - .../kernels/portable/cpu/op_bitwise_not.cpp | 71 - .../kernels/portable/cpu/op_bitwise_or.cpp | 39 - .../kernels/portable/cpu/op_bitwise_xor.cpp | 39 - .../engine/kernels/portable/cpu/op_bmm.cpp | 59 - .../engine/kernels/portable/cpu/op_cat.cpp | 120 - .../kernels/portable/cpu/op_cdist_forward.cpp | 175 - .../engine/kernels/portable/cpu/op_ceil.cpp | 23 - .../engine/kernels/portable/cpu/op_clamp.cpp | 249 - .../engine/kernels/portable/cpu/op_clone.cpp | 64 - .../portable/cpu/op_constant_pad_nd.cpp | 203 - .../kernels/portable/cpu/op_convolution.cpp | 438 - .../portable/cpu/op_convolution_backward.cpp | 330 - .../engine/kernels/portable/cpu/op_copy.cpp | 117 - .../engine/kernels/portable/cpu/op_cos.cpp | 21 - .../engine/kernels/portable/cpu/op_cosh.cpp | 21 - .../engine/kernels/portable/cpu/op_cumsum.cpp | 126 - .../kernels/portable/cpu/op_detach_copy.cpp | 55 - .../kernels/portable/cpu/op_diagonal_copy.cpp | 113 - .../engine/kernels/portable/cpu/op_div.cpp | 284 - .../engine/kernels/portable/cpu/op_elu.cpp | 61 - .../kernels/portable/cpu/op_embedding.cpp | 131 - .../engine/kernels/portable/cpu/op_empty.cpp | 46 - .../engine/kernels/portable/cpu/op_eq.cpp | 41 - .../engine/kernels/portable/cpu/op_erf.cpp | 21 - .../engine/kernels/portable/cpu/op_exp.cpp | 21 - .../kernels/portable/cpu/op_expand_copy.cpp | 108 - .../engine/kernels/portable/cpu/op_expm1.cpp | 21 - .../engine/kernels/portable/cpu/op_fill.cpp | 112 - .../engine/kernels/portable/cpu/op_flip.cpp | 85 - .../engine/kernels/portable/cpu/op_floor.cpp | 23 - .../kernels/portable/cpu/op_floor_divide.cpp | 91 - .../engine/kernels/portable/cpu/op_fmod.cpp | 155 - .../engine/kernels/portable/cpu/op_full.cpp | 56 - .../kernels/portable/cpu/op_full_like.cpp | 72 - .../engine/kernels/portable/cpu/op_gather.cpp | 99 - .../engine/kernels/portable/cpu/op_ge.cpp | 41 - .../engine/kernels/portable/cpu/op_gelu.cpp | 88 - .../engine/kernels/portable/cpu/op_glu.cpp | 157 - .../engine/kernels/portable/cpu/op_gt.cpp | 39 - .../kernels/portable/cpu/op_hardtanh.cpp | 73 - .../engine/kernels/portable/cpu/op_index.cpp | 279 - .../kernels/portable/cpu/op_index_put.cpp | 335 - .../kernels/portable/cpu/op_index_select.cpp | 93 - .../engine/kernels/portable/cpu/op_isinf.cpp | 21 - .../engine/kernels/portable/cpu/op_isnan.cpp | 21 - .../engine/kernels/portable/cpu/op_le.cpp | 41 - .../kernels/portable/cpu/op_leaky_relu.cpp | 71 - .../portable/cpu/op_lift_fresh_copy.cpp | 42 - .../cpu/op_linear_scratch_example.cpp | 149 - .../engine/kernels/portable/cpu/op_log.cpp | 21 - .../engine/kernels/portable/cpu/op_log10.cpp | 21 - .../engine/kernels/portable/cpu/op_log1p.cpp | 21 - .../engine/kernels/portable/cpu/op_log2.cpp | 21 - .../kernels/portable/cpu/op_log_softmax.cpp | 94 - .../kernels/portable/cpu/op_logical_and.cpp | 36 - .../kernels/portable/cpu/op_logical_not.cpp | 55 - .../kernels/portable/cpu/op_logical_or.cpp | 36 - .../kernels/portable/cpu/op_logical_xor.cpp | 36 - .../engine/kernels/portable/cpu/op_logit.cpp | 63 - .../engine/kernels/portable/cpu/op_lt.cpp | 39 - .../kernels/portable/cpu/op_masked_fill.cpp | 68 - .../portable/cpu/op_masked_scatter.cpp | 78 - .../kernels/portable/cpu/op_masked_select.cpp | 149 - .../engine/kernels/portable/cpu/op_max.cpp | 152 - .../cpu/op_max_pool2d_with_indices.cpp | 102 - .../op_max_pool2d_with_indices_backward.cpp | 183 - .../kernels/portable/cpu/op_maximum.cpp | 68 - .../engine/kernels/portable/cpu/op_mean.cpp | 88 - .../engine/kernels/portable/cpu/op_min.cpp | 152 - .../kernels/portable/cpu/op_minimum.cpp | 68 - .../engine/kernels/portable/cpu/op_mm.cpp | 60 - .../engine/kernels/portable/cpu/op_mul.cpp | 131 - .../kernels/portable/cpu/op_narrow_copy.cpp | 57 - .../portable/cpu/op_native_batch_norm.cpp | 322 - .../portable/cpu/op_native_group_norm.cpp | 205 - .../portable/cpu/op_native_layer_norm.cpp | 190 - .../engine/kernels/portable/cpu/op_ne.cpp | 41 - .../engine/kernels/portable/cpu/op_neg.cpp | 54 - .../kernels/portable/cpu/op_nonzero.cpp | 102 - .../engine/kernels/portable/cpu/op_ones.cpp | 36 - .../kernels/portable/cpu/op_pdist_forward.cpp | 53 - .../kernels/portable/cpu/op_permute_copy.cpp | 87 - .../kernels/portable/cpu/op_pixel_shuffle.cpp | 104 - .../portable/cpu/op_pixel_unshuffle.cpp | 104 - .../engine/kernels/portable/cpu/op_pow.cpp | 186 - .../engine/kernels/portable/cpu/op_prod.cpp | 108 - .../kernels/portable/cpu/op_reciprocal.cpp | 28 - .../portable/cpu/op_reflection_pad1d.cpp | 58 - .../portable/cpu/op_reflection_pad2d.cpp | 58 - .../portable/cpu/op_reflection_pad3d.cpp | 58 - .../engine/kernels/portable/cpu/op_relu.cpp | 63 - .../kernels/portable/cpu/op_remainder.cpp | 151 - .../engine/kernels/portable/cpu/op_repeat.cpp | 90 - .../portable/cpu/op_repeat_interleave.cpp | 125 - .../portable/cpu/op_replication_pad1d.cpp | 50 - .../portable/cpu/op_replication_pad2d.cpp | 50 - .../portable/cpu/op_replication_pad3d.cpp | 50 - .../engine/kernels/portable/cpu/op_roll.cpp | 99 - .../engine/kernels/portable/cpu/op_round.cpp | 76 - .../engine/kernels/portable/cpu/op_rsqrt.cpp | 28 - .../engine/kernels/portable/cpu/op_rsub.cpp | 73 - .../kernels/portable/cpu/op_scalar_tensor.cpp | 38 - .../kernels/portable/cpu/op_scatter.cpp | 163 - .../kernels/portable/cpu/op_scatter_add.cpp | 106 - .../kernels/portable/cpu/op_select_copy.cpp | 35 - .../portable/cpu/op_select_scatter.cpp | 97 - .../kernels/portable/cpu/op_sigmoid.cpp | 66 - .../engine/kernels/portable/cpu/op_sign.cpp | 63 - .../engine/kernels/portable/cpu/op_sin.cpp | 21 - .../engine/kernels/portable/cpu/op_sinh.cpp | 21 - .../kernels/portable/cpu/op_slice_copy.cpp | 65 - .../kernels/portable/cpu/op_slice_scatter.cpp | 108 - .../kernels/portable/cpu/op_softmax.cpp | 93 - .../kernels/portable/cpu/op_split_copy.cpp | 88 - .../portable/cpu/op_split_with_sizes_copy.cpp | 146 - .../engine/kernels/portable/cpu/op_sqrt.cpp | 21 - .../kernels/portable/cpu/op_squeeze_copy.cpp | 96 - .../engine/kernels/portable/cpu/op_stack.cpp | 26 - .../engine/kernels/portable/cpu/op_sub.cpp | 134 - .../engine/kernels/portable/cpu/op_sum.cpp | 111 - .../engine/kernels/portable/cpu/op_t_copy.cpp | 75 - .../engine/kernels/portable/cpu/op_tan.cpp | 21 - .../engine/kernels/portable/cpu/op_tanh.cpp | 21 - .../kernels/portable/cpu/op_to_copy.cpp | 66 - .../engine/kernels/portable/cpu/op_topk.cpp | 218 - .../portable/cpu/op_transpose_copy.cpp | 72 - .../engine/kernels/portable/cpu/op_tril.cpp | 171 - .../engine/kernels/portable/cpu/op_trunc.cpp | 21 - .../kernels/portable/cpu/op_unbind_copy.cpp | 84 - .../kernels/portable/cpu/op_unfold_copy.cpp | 73 - .../portable/cpu/op_unsqueeze_copy.cpp | 74 - .../portable/cpu/op_upsample_bilinear2d.cpp | 233 - .../cpu/op_upsample_bilinear2d_aa.cpp | 314 - .../portable/cpu/op_upsample_nearest2d.cpp | 141 - .../engine/kernels/portable/cpu/op_var.cpp | 147 - .../portable/cpu/op_view_as_real_copy.cpp | 80 - .../kernels/portable/cpu/op_view_copy.cpp | 63 - .../engine/kernels/portable/cpu/op_where.cpp | 68 - .../engine/kernels/portable/cpu/op_zeros.cpp | 68 - .../unary_ufunc_realhbbf16_to_bool.cpp | 69 - .../unary_ufunc_realhbbf16_to_floathbf16.cpp | 66 - .../cpu/pattern/unary_ufunc_realhbf16.cpp | 62 - .../portable/cpu/util/activation_ops_util.cpp | 118 - .../portable/cpu/util/advanced_index_util.cpp | 493 - .../kernels/portable/cpu/util/arange_util.cpp | 52 - .../portable/cpu/util/broadcast_util.cpp | 311 - .../portable/cpu/util/copy_ops_util.cpp | 1031 - .../portable/cpu/util/delinearize_index.cpp | 33 - .../portable/cpu/util/distance_util.cpp | 56 - .../kernels/portable/cpu/util/dtype_util.cpp | 54 - .../kernels/portable/cpu/util/index_util.cpp | 275 - .../portable/cpu/util/kernel_ops_util.cpp | 645 - .../portable/cpu/util/matmul_ops_util.cpp | 110 - .../cpu/util/normalization_ops_util.cpp | 206 - .../portable/cpu/util/padding_util.cpp | 57 - .../kernels/portable/cpu/util/reduce_util.cpp | 451 - .../kernels/portable/cpu/util/repeat_util.cpp | 291 - .../portable/cpu/util/select_copy_util.cpp | 87 - .../kernels/portable/cpu/util/slice_util.cpp | 184 - .../kernels/portable/cpu/util/stack_util.cpp | 121 - .../portable/cpu/util/upsample_util.cpp | 105 - .../engine/kernels/prim_ops/et_copy_index.cpp | 136 - ai_layer/engine/kernels/prim_ops/et_view.cpp | 126 - .../kernels/prim_ops/register_prim_ops.cpp | 592 - .../kernels/quantized/cpu/embeddingxb.cpp | 404 - .../engine/kernels/quantized/cpu/op_add.cpp | 205 - .../quantized/cpu/op_choose_qparams.cpp | 301 - .../kernels/quantized/cpu/op_dequantize.cpp | 657 - .../kernels/quantized/cpu/op_embedding.cpp | 366 - .../kernels/quantized/cpu/op_embedding2b.cpp | 123 - .../kernels/quantized/cpu/op_embedding4b.cpp | 125 - .../kernels/quantized/cpu/op_mixed_linear.cpp | 140 - .../kernels/quantized/cpu/op_mixed_mm.cpp | 115 - .../kernels/quantized/cpu/op_quantize.cpp | 423 - .../CustomOpsNativeFunctions.h | 43 - .../quantized/quantized_ops_lib/Functions.h | 144 - .../quantized_ops_lib/NativeFunctions.h | 63 - ...egisterCodegenUnboxedKernelsEverything.cpp | 674 - ai_layer/engine/lib/libcortex_m_kernels.a | Bin 20432 -> 0 bytes ai_layer/engine/lib/libcortex_m_ops_lib.a | Bin 12934 -> 0 bytes ai_layer/engine/lib/libexecutorch.a | Bin 53108 -> 0 bytes ai_layer/engine/lib/libexecutorch_core.a | Bin 221684 -> 0 bytes .../lib/libexecutorch_delegate_ethos_u.a | Bin 19036 -> 0 bytes ai_layer/engine/lib/libportable_kernels.a | Bin 9583760 -> 0 bytes ai_layer/engine/lib/libportable_ops_lib.a | Bin 203902 -> 0 bytes ai_layer/engine/lib/libquantized_kernels.a | Bin 244300 -> 0 bytes ai_layer/engine/lib/libquantized_ops_lib.a | Bin 29408 -> 0 bytes ai_layer/engine/meta/selected_operators.yaml | 23 - .../engine/model/ethos_u_minimal_example.pte | Bin 3840 -> 0 bytes ai_layer/engine/runtime/backend/interface.cpp | 107 - ai_layer/engine/runtime/core/evalue.cpp | 31 - .../util/tensor_shape_to_c_string.cpp | 67 - .../exec_aten/util/tensor_util_portable.cpp | 223 - .../core/portable_type/tensor_impl.cpp | 145 - ai_layer/engine/runtime/core/tag.cpp | 52 - .../engine/runtime/core/tensor_layout.cpp | 55 - ai_layer/engine/runtime/executor/method.cpp | 1740 - .../engine/runtime/executor/method_meta.cpp | 380 - ai_layer/engine/runtime/executor/program.cpp | 578 - .../engine/runtime/executor/pte_data_map.cpp | 89 - .../executor/tensor_parser_exec_aten.cpp | 264 - .../executor/tensor_parser_portable.cpp | 188 - .../runtime/kernel/operator_registry.cpp | 266 - ai_layer/engine/runtime/platform/abort.cpp | 24 - ai_layer/engine/runtime/platform/log.cpp | 143 - ai_layer/engine/runtime/platform/platform.cpp | 160 - ai_layer/engine/runtime/platform/profiler.cpp | 197 - ai_layer/engine/runtime/platform/runtime.cpp | 26 - ai_layer/engine/schema/extended_header.cpp | 110 - ai_layer/engine/stage1_source.clayer.yml | 97 - ai_layer/engine/stage2_source.clayer.yml | 206 - ai_layer/logs/build.log | 59 - ai_layer/logs/build_20260127_155447.log | 2338 - ai_layer/logs/build_summary.txt | 23 - ai_layer/logs/generate_report.log | 5 - ai_layer/logs/model_conversion.log | 87 - ai_layer/logs/model_to_header.log | 1 - ai_layer/logs/package_artifacts.log | 4 - ai_layer/logs/stage1_build.log | 731 - ai_layer/logs/stage2_build.log | 107 - ai_layer/{ => model}/REPORT.md | 0 ai_layer/model/model_pte.h | 253 +- ai_layer/stubs/posix_stub.cpp | 56 - ai_layer/stubs/random_ops_stubs.cpp | 65 - 1756 files changed, 186 insertions(+), 740565 deletions(-) delete mode 100644 ai_layer/engine/backends/arm/runtime/EthosUBackend.cpp delete mode 100644 ai_layer/engine/backends/arm/runtime/VelaBinStream.cpp delete mode 100644 ai_layer/engine/backends/cortex_m/cortex_m_ops_lib/CustomOpsNativeFunctions.h delete mode 100644 ai_layer/engine/backends/cortex_m/cortex_m_ops_lib/Functions.h delete mode 100644 ai_layer/engine/backends/cortex_m/cortex_m_ops_lib/NativeFunctions.h delete mode 100644 ai_layer/engine/backends/cortex_m/cortex_m_ops_lib/RegisterCodegenUnboxedKernelsEverything.cpp delete mode 100644 ai_layer/engine/backends/cortex_m/ops/op_dequantize_per_tensor.cpp delete mode 100644 ai_layer/engine/backends/cortex_m/ops/op_quantize_per_tensor.cpp delete mode 100644 ai_layer/engine/backends/cortex_m/ops/op_quantized_add.cpp delete mode 100644 ai_layer/engine/executorch_selected_kernels/Functions.h delete mode 100644 ai_layer/engine/executorch_selected_kernels/NativeFunctions.h delete mode 100644 ai_layer/engine/executorch_selected_kernels/RegisterCodegenUnboxedKernelsEverything.cpp delete mode 100644 ai_layer/engine/executorch_selected_kernels/RegisterCodegenUnboxedKernels_0.cpp delete mode 100644 ai_layer/engine/executorch_selected_kernels/RegisterKernels.h delete mode 100644 ai_layer/engine/executorch_selected_kernels/selected_operators.yaml delete mode 100644 ai_layer/engine/include/executorch/backends/arm/runtime/VGFSetup.h delete mode 100644 ai_layer/engine/include/executorch/backends/arm/runtime/VelaBinStream.h delete mode 100644 ai_layer/engine/include/executorch/backends/arm/third-party/ethos-u-core-driver/include/ethosu_driver.h delete mode 100644 ai_layer/engine/include/executorch/backends/arm/third-party/ethos-u-core-driver/include/ethosu_types.h delete mode 100644 ai_layer/engine/include/executorch/backends/arm/third-party/ethos-u-core-driver/include/pmu_ethosu.h delete mode 100644 ai_layer/engine/include/executorch/backends/arm/third-party/ethos-u-core-driver/src/ethosu55_interface.h delete mode 100644 ai_layer/engine/include/executorch/backends/arm/third-party/ethos-u-core-driver/src/ethosu65_interface.h delete mode 100644 ai_layer/engine/include/executorch/backends/arm/third-party/ethos-u-core-driver/src/ethosu85_interface.h delete mode 100644 ai_layer/engine/include/executorch/backends/arm/third-party/ethos-u-core-driver/src/ethosu_config_u55.h delete mode 100644 ai_layer/engine/include/executorch/backends/arm/third-party/ethos-u-core-driver/src/ethosu_config_u65.h delete mode 100644 ai_layer/engine/include/executorch/backends/arm/third-party/ethos-u-core-driver/src/ethosu_config_u85.h delete mode 100644 ai_layer/engine/include/executorch/backends/arm/third-party/ethos-u-core-driver/src/ethosu_device.h delete mode 100644 ai_layer/engine/include/executorch/backends/arm/third-party/ethos-u-core-driver/src/ethosu_interface.h delete mode 100644 ai_layer/engine/include/executorch/backends/arm/third-party/ethos-u-core-driver/src/ethosu_log.h delete mode 100644 ai_layer/engine/include/executorch/backends/cortex_m/ops/cortex_m_ops_common.h delete mode 100644 ai_layer/engine/include/executorch/extension/android/jni/jni_helper.h delete mode 100644 ai_layer/engine/include/executorch/extension/android/jni/jni_layer_constants.h delete mode 100644 ai_layer/engine/include/executorch/extension/android/jni/log.h delete mode 100644 ai_layer/engine/include/executorch/extension/apple/ExecuTorch/Exported/ExecuTorch.h delete mode 100644 ai_layer/engine/include/executorch/extension/apple/ExecuTorch/Exported/ExecuTorchError.h delete mode 100644 ai_layer/engine/include/executorch/extension/apple/ExecuTorch/Exported/ExecuTorchLog.h delete mode 100644 ai_layer/engine/include/executorch/extension/apple/ExecuTorch/Exported/ExecuTorchModule.h delete mode 100644 ai_layer/engine/include/executorch/extension/apple/ExecuTorch/Exported/ExecuTorchTensor.h delete mode 100644 ai_layer/engine/include/executorch/extension/apple/ExecuTorch/Exported/ExecuTorchValue.h delete mode 100644 ai_layer/engine/include/executorch/extension/apple/ExecuTorch/Internal/ExecuTorchUtils.h delete mode 100644 ai_layer/engine/include/executorch/extension/aten_util/aten_bridge.h delete mode 100644 ai_layer/engine/include/executorch/extension/aten_util/make_aten_functor_from_et_functor.h delete mode 100644 ai_layer/engine/include/executorch/extension/benchmark/apple/Benchmark/TestUtils/DynamicTestCase.h delete mode 100644 ai_layer/engine/include/executorch/extension/benchmark/apple/Benchmark/TestUtils/ResourceTestCase.h delete mode 100644 ai_layer/engine/include/executorch/extension/data_loader/buffer_data_loader.h delete mode 100644 ai_layer/engine/include/executorch/extension/data_loader/file_data_loader.h delete mode 100644 ai_layer/engine/include/executorch/extension/data_loader/file_descriptor_data_loader.h delete mode 100644 ai_layer/engine/include/executorch/extension/data_loader/mman.h delete mode 100644 ai_layer/engine/include/executorch/extension/data_loader/mman_windows.h delete mode 100644 ai_layer/engine/include/executorch/extension/data_loader/mmap_data_loader.h delete mode 100644 ai_layer/engine/include/executorch/extension/data_loader/shared_ptr_data_loader.h delete mode 100644 ai_layer/engine/include/executorch/extension/evalue_util/print_evalue.h delete mode 100644 ai_layer/engine/include/executorch/extension/flat_tensor/flat_tensor_data_map.h delete mode 100644 ai_layer/engine/include/executorch/extension/flat_tensor/serialize/flat_tensor_header.h delete mode 100644 ai_layer/engine/include/executorch/extension/flat_tensor/serialize/serialize.h delete mode 100644 ai_layer/engine/include/executorch/extension/kernel_util/make_boxed_from_unboxed_functor.h delete mode 100644 ai_layer/engine/include/executorch/extension/kernel_util/meta_programming.h delete mode 100644 ai_layer/engine/include/executorch/extension/kernel_util/type_list.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/apple/ExecuTorchLLM/Exported/ExecuTorchLLM.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/apple/ExecuTorchLLM/Exported/ExecuTorchLLMConfig.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/apple/ExecuTorchLLM/Exported/ExecuTorchLLMError.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/apple/ExecuTorchLLM/Exported/ExecuTorchLLMMultimodalRunner.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/apple/ExecuTorchLLM/Exported/ExecuTorchLLMTextRunner.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/custom_ops/op_fallback.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/custom_ops/op_fast_hadamard_transform.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/custom_ops/op_sdpa.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/custom_ops/op_sdpa_impl.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/custom_ops/op_tile_crop.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/custom_ops/op_update_cache.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/custom_ops/spinquant/fast_hadamard_transform.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/custom_ops/spinquant/fast_hadamard_transform_special.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/custom_ops/spinquant/test/fast_hadamard_transform_special_unstrided_cpu.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/custom_ops/spinquant/test/fast_hadamard_transform_test_impl.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/custom_ops/spinquant/third-party/FFHT/dumb_fht.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/custom_ops/spinquant/third-party/FFHT/fast_copy.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/custom_ops/spinquant/third-party/FFHT/fht.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/custom_ops/spinquant/third-party/FFHT/fht_impl.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/runner/audio.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/runner/constants.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/runner/image.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/runner/image_prefiller.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/runner/io_manager/io_manager.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/runner/irunner.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/runner/llm_runner_helper.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/runner/multimodal_decoder_runner.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/runner/multimodal_input.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/runner/multimodal_prefiller.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/runner/multimodal_runner.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/runner/stats.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/runner/text_decoder_runner.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/runner/text_llm_runner.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/runner/text_prefiller.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/runner/text_token_generator.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/runner/util.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/sampler/sampler.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/base64.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/bpe_tokenizer_base.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/compiler.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/error.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/hf_tokenizer.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/llama2c_tokenizer.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/log.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/normalizer.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/pcre2_regex.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/pre_tokenizer.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/re2_regex.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/regex.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/result.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/sentencepiece.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/std_regex.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/string_integer_map.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/tekken.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/tiktoken.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/token_decoder.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/tokenizer.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/algorithm/algorithm.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/algorithm/container.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/base/attributes.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/base/call_once.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/base/casts.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/base/config.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/base/const_init.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/base/dynamic_annotations.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/base/internal/atomic_hook.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/base/internal/atomic_hook_test_helper.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/base/internal/cycleclock.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/base/internal/cycleclock_config.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/base/internal/direct_mmap.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/base/internal/dynamic_annotations.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/base/internal/endian.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/base/internal/errno_saver.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/base/internal/exception_safety_testing.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/base/internal/exception_testing.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/base/internal/fast_type_id.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/base/internal/hide_ptr.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/base/internal/identity.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/base/internal/inline_variable.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/base/internal/inline_variable_testing.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/base/internal/invoke.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/base/internal/low_level_alloc.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/base/internal/low_level_scheduling.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/base/internal/nullability_impl.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/base/internal/per_thread_tls.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/base/internal/poison.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/base/internal/pretty_function.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/base/internal/raw_logging.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/base/internal/scheduling_mode.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/base/internal/scoped_set_env.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/base/internal/spinlock.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/base/internal/spinlock_wait.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/base/internal/strerror.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/base/internal/sysinfo.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/base/internal/thread_identity.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/base/internal/throw_delegate.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/base/internal/tracing.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/base/internal/tsan_mutex_interface.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/base/internal/unaligned_access.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/base/internal/unscaledcycleclock.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/base/internal/unscaledcycleclock_config.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/base/log_severity.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/base/macros.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/base/no_destructor.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/base/nullability.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/base/optimization.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/base/options.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/base/policy_checks.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/base/port.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/base/prefetch.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/base/thread_annotations.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/cleanup/cleanup.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/cleanup/internal/cleanup.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/container/btree_map.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/container/btree_set.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/container/btree_test.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/container/fixed_array.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/container/flat_hash_map.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/container/flat_hash_set.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/container/hash_container_defaults.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/container/inlined_vector.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/container/internal/btree.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/container/internal/btree_container.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/container/internal/common.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/container/internal/common_policy_traits.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/container/internal/compressed_tuple.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/container/internal/container_memory.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/container/internal/hash_function_defaults.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/container/internal/hash_generator_testing.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/container/internal/hash_policy_testing.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/container/internal/hash_policy_traits.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/container/internal/hashtable_debug.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/container/internal/hashtable_debug_hooks.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/container/internal/hashtablez_sampler.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/container/internal/inlined_vector.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/container/internal/layout.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/container/internal/node_slot_policy.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/container/internal/raw_hash_map.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/container/internal/raw_hash_set.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/container/internal/test_allocator.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/container/internal/test_instance_tracker.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/container/internal/tracked.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/container/internal/unordered_map_constructor_test.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/container/internal/unordered_map_lookup_test.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/container/internal/unordered_map_members_test.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/container/internal/unordered_map_modifiers_test.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/container/internal/unordered_set_constructor_test.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/container/internal/unordered_set_lookup_test.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/container/internal/unordered_set_members_test.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/container/internal/unordered_set_modifiers_test.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/container/node_hash_map.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/container/node_hash_set.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/crc/crc32c.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/crc/internal/cpu_detect.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/crc/internal/crc.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/crc/internal/crc32_x86_arm_combined_simd.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/crc/internal/crc32c.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/crc/internal/crc32c_inline.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/crc/internal/crc_cord_state.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/crc/internal/crc_internal.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/crc/internal/crc_memcpy.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/crc/internal/non_temporal_arm_intrinsics.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/crc/internal/non_temporal_memcpy.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/debugging/failure_signal_handler.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/debugging/internal/address_is_readable.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/debugging/internal/bounded_utf8_length_sequence.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/debugging/internal/decode_rust_punycode.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/debugging/internal/demangle.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/debugging/internal/demangle_rust.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/debugging/internal/elf_mem_image.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/debugging/internal/examine_stack.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/debugging/internal/stack_consumption.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/debugging/internal/stacktrace_config.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/debugging/internal/symbolize.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/debugging/internal/utf8_for_code_point.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/debugging/internal/vdso_support.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/debugging/leak_check.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/debugging/stacktrace.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/debugging/symbolize.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/flags/commandlineflag.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/flags/config.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/flags/declare.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/flags/flag.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/flags/internal/commandlineflag.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/flags/internal/flag.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/flags/internal/parse.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/flags/internal/path_util.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/flags/internal/private_handle_accessor.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/flags/internal/program_name.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/flags/internal/registry.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/flags/internal/sequence_lock.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/flags/internal/usage.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/flags/marshalling.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/flags/parse.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/flags/reflection.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/flags/usage.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/flags/usage_config.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/functional/any_invocable.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/functional/bind_front.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/functional/function_ref.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/functional/internal/any_invocable.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/functional/internal/front_binder.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/functional/internal/function_ref.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/functional/overload.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/hash/hash.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/hash/hash_testing.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/hash/internal/city.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/hash/internal/hash.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/hash/internal/hash_test.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/hash/internal/low_level_hash.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/hash/internal/spy_hash_state.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/log/absl_check.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/log/absl_log.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/log/absl_vlog_is_on.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/log/check.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/log/die_if_null.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/log/flags.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/log/globals.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/log/initialize.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/log/internal/append_truncated.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/log/internal/check_impl.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/log/internal/check_op.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/log/internal/conditions.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/log/internal/config.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/log/internal/flags.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/log/internal/fnmatch.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/log/internal/globals.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/log/internal/log_format.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/log/internal/log_impl.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/log/internal/log_message.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/log/internal/log_sink_set.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/log/internal/nullguard.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/log/internal/nullstream.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/log/internal/proto.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/log/internal/strip.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/log/internal/structured.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/log/internal/test_actions.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/log/internal/test_helpers.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/log/internal/test_matchers.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/log/internal/vlog_config.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/log/internal/voidify.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/log/log.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/log/log_entry.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/log/log_sink.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/log/log_sink_registry.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/log/log_streamer.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/log/scoped_mock_log.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/log/structured.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/log/vlog_is_on.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/memory/memory.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/meta/type_traits.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/numeric/bits.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/numeric/int128.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/numeric/internal/bits.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/numeric/internal/representation.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/profiling/internal/exponential_biased.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/profiling/internal/periodic_sampler.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/profiling/internal/sample_recorder.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/random/bernoulli_distribution.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/random/beta_distribution.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/random/bit_gen_ref.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/random/discrete_distribution.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/random/distributions.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/random/exponential_distribution.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/random/gaussian_distribution.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/random/internal/chi_square.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/random/internal/distribution_caller.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/random/internal/distribution_test_util.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/random/internal/explicit_seed_seq.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/random/internal/fast_uniform_bits.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/random/internal/fastmath.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/random/internal/generate_real.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/random/internal/iostream_state_saver.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/random/internal/mock_helpers.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/random/internal/mock_overload_set.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/random/internal/mock_validators.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/random/internal/nanobenchmark.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/random/internal/nonsecure_base.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/random/internal/pcg_engine.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/random/internal/platform.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/random/internal/pool_urbg.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/random/internal/randen.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/random/internal/randen_detect.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/random/internal/randen_engine.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/random/internal/randen_hwaes.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/random/internal/randen_slow.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/random/internal/randen_traits.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/random/internal/salted_seed_seq.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/random/internal/seed_material.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/random/internal/sequence_urbg.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/random/internal/traits.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/random/internal/uniform_helper.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/random/internal/wide_multiply.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/random/log_uniform_int_distribution.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/random/mock_distributions.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/random/mocking_bit_gen.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/random/poisson_distribution.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/random/random.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/random/seed_gen_exception.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/random/seed_sequences.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/random/uniform_int_distribution.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/random/uniform_real_distribution.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/random/zipf_distribution.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/status/internal/status_internal.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/status/internal/status_matchers.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/status/internal/statusor_internal.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/status/status.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/status/status_matchers.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/status/status_payload_printer.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/status/statusor.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/strings/ascii.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/strings/charconv.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/strings/charset.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/strings/cord.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/strings/cord_analysis.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/strings/cord_buffer.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/strings/cord_test_helpers.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/strings/cordz_test_helpers.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/strings/escaping.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/strings/has_absl_stringify.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/strings/has_ostream_operator.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/strings/internal/charconv_bigint.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/strings/internal/charconv_parse.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/strings/internal/cord_data_edge.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/strings/internal/cord_internal.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/strings/internal/cord_rep_btree.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/strings/internal/cord_rep_btree_navigator.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/strings/internal/cord_rep_btree_reader.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/strings/internal/cord_rep_consume.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/strings/internal/cord_rep_crc.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/strings/internal/cord_rep_flat.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/strings/internal/cord_rep_test_util.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/strings/internal/cordz_functions.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/strings/internal/cordz_handle.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/strings/internal/cordz_info.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/strings/internal/cordz_sample_token.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/strings/internal/cordz_statistics.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/strings/internal/cordz_update_scope.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/strings/internal/cordz_update_tracker.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/strings/internal/damerau_levenshtein_distance.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/strings/internal/escaping.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/strings/internal/escaping_test_common.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/strings/internal/memutil.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/strings/internal/numbers_test_common.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/strings/internal/ostringstream.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/strings/internal/pow10_helper.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/strings/internal/resize_uninitialized.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/strings/internal/stl_type_traits.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/strings/internal/str_format/arg.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/strings/internal/str_format/bind.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/strings/internal/str_format/checker.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/strings/internal/str_format/constexpr_parser.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/strings/internal/str_format/extension.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/strings/internal/str_format/float_conversion.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/strings/internal/str_format/output.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/strings/internal/str_format/parser.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/strings/internal/str_join_internal.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/strings/internal/str_split_internal.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/strings/internal/string_constant.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/strings/internal/stringify_sink.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/strings/internal/utf8.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/strings/match.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/strings/numbers.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/strings/str_cat.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/strings/str_format.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/strings/str_join.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/strings/str_replace.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/strings/str_split.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/strings/string_view.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/strings/strip.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/strings/substitute.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/synchronization/barrier.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/synchronization/blocking_counter.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/synchronization/internal/create_thread_identity.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/synchronization/internal/futex.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/synchronization/internal/futex_waiter.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/synchronization/internal/graphcycles.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/synchronization/internal/kernel_timeout.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/synchronization/internal/per_thread_sem.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/synchronization/internal/pthread_waiter.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/synchronization/internal/sem_waiter.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/synchronization/internal/stdcpp_waiter.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/synchronization/internal/thread_pool.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/synchronization/internal/waiter.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/synchronization/internal/waiter_base.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/synchronization/internal/win32_waiter.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/synchronization/mutex.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/synchronization/notification.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/time/civil_time.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/time/clock.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/time/internal/cctz/include/cctz/civil_time.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/time/internal/cctz/include/cctz/civil_time_detail.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/time/internal/cctz/include/cctz/time_zone.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/time/internal/cctz/include/cctz/zone_info_source.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/time/internal/cctz/src/time_zone_fixed.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/time/internal/cctz/src/time_zone_if.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/time/internal/cctz/src/time_zone_impl.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/time/internal/cctz/src/time_zone_info.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/time/internal/cctz/src/time_zone_libc.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/time/internal/cctz/src/time_zone_posix.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/time/internal/cctz/src/tzfile.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/time/internal/test_util.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/time/time.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/types/any.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/types/bad_any_cast.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/types/bad_optional_access.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/types/bad_variant_access.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/types/compare.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/types/internal/optional.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/types/internal/span.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/types/internal/variant.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/types/optional.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/types/span.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/types/variant.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/utility/internal/if_constexpr.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/absl/utility/utility.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/abseil-cpp/ci/absl_alternate_options.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/json/tests/thirdparty/Fuzzer/FuzzerCorpus.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/json/tests/thirdparty/Fuzzer/FuzzerDefs.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/json/tests/thirdparty/Fuzzer/FuzzerDictionary.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/json/tests/thirdparty/Fuzzer/FuzzerExtFunctions.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/json/tests/thirdparty/Fuzzer/FuzzerIO.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/json/tests/thirdparty/Fuzzer/FuzzerInterface.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/json/tests/thirdparty/Fuzzer/FuzzerInternal.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/json/tests/thirdparty/Fuzzer/FuzzerMerge.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/json/tests/thirdparty/Fuzzer/FuzzerMutate.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/json/tests/thirdparty/Fuzzer/FuzzerOptions.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/json/tests/thirdparty/Fuzzer/FuzzerRandom.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/json/tests/thirdparty/Fuzzer/FuzzerSHA1.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/json/tests/thirdparty/Fuzzer/FuzzerTracePC.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/json/tests/thirdparty/Fuzzer/FuzzerUtil.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/json/tests/thirdparty/Fuzzer/FuzzerValueBitMap.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/json/tests/thirdparty/doctest/doctest.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/json/tests/thirdparty/doctest/doctest_compatibility.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/llama.cpp-unicode/include/unicode-data.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/llama.cpp-unicode/include/unicode.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/pcre2/deps/sljit/regex_src/regexJIT.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/pcre2/deps/sljit/sljit_src/sljitConfig.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/pcre2/deps/sljit/sljit_src/sljitConfigCPU.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/pcre2/deps/sljit/sljit_src/sljitConfigInternal.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/pcre2/deps/sljit/sljit_src/sljitLir.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/pcre2/deps/sljit/test_src/sljitConfigPost.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/pcre2/deps/sljit/test_src/sljitConfigPre.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/pcre2/deps/sljit/test_src/sljitTestBuffers.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/pcre2/deps/sljit/test_src/sljitTestCall.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/pcre2/deps/sljit/test_src/sljitTestFloat.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/pcre2/deps/sljit/test_src/sljitTestSerialize.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/pcre2/deps/sljit/test_src/sljitTestSimd.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/pcre2/src/pcre2_compile.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/pcre2/src/pcre2_internal.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/pcre2/src/pcre2_intmodedep.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/pcre2/src/pcre2_jit_char_inc.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/pcre2/src/pcre2_jit_match_inc.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/pcre2/src/pcre2_jit_misc_inc.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/pcre2/src/pcre2_jit_neon_inc.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/pcre2/src/pcre2_jit_simd_inc.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/pcre2/src/pcre2_printint_inc.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/pcre2/src/pcre2_ucp.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/pcre2/src/pcre2_ucptables_inc.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/pcre2/src/pcre2_util.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/pcre2/src/pcre2posix.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/pcre2/vms/stdint.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/re2/re2/bitmap256.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/re2/re2/filtered_re2.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/re2/re2/pod_array.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/re2/re2/prefilter.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/re2/re2/prefilter_tree.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/re2/re2/prog.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/re2/re2/re2.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/re2/re2/regexp.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/re2/re2/set.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/re2/re2/sparse_array.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/re2/re2/sparse_set.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/re2/re2/stringpiece.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/re2/re2/testing/exhaustive_tester.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/re2/re2/testing/regexp_generator.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/re2/re2/testing/string_generator.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/re2/re2/testing/tester.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/re2/re2/unicode_casefold.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/re2/re2/unicode_groups.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/re2/re2/walker-inl.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/re2/util/malloc_counter.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/re2/util/pcre.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/re2/util/strutil.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/re2/util/utf.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/src/bpe_model.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/src/bpe_model_trainer.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/src/builder.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/src/builtin_pb/sentencepiece.pb.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/src/builtin_pb/sentencepiece_model.pb.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/src/char_model.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/src/char_model_trainer.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/src/common.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/src/filesystem.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/src/freelist.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/src/init.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/src/model_factory.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/src/model_interface.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/src/normalization_rule.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/src/normalizer.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/src/pretokenizer_for_training.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/src/sentencepiece_processor.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/src/sentencepiece_trainer.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/src/spec_parser.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/src/testharness.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/src/trainer_factory.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/src/trainer_interface.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/src/unicode_script.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/src/unicode_script_map.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/src/unigram_model.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/src/unigram_model_trainer.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/src/util.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/src/word_model.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/src/word_model_trainer.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/absl/container/btree_set.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/absl/container/flat_hash_map.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/absl/container/flat_hash_set.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/absl/flags/flag.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/absl/flags/parse.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/absl/flags/usage.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/absl/strings/ascii.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/absl/strings/match.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/absl/strings/numbers.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/absl/strings/str_cat.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/absl/strings/str_format.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/absl/strings/str_join.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/absl/strings/str_replace.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/absl/strings/str_split.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/absl/strings/string_view.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/absl/strings/strip.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/darts_clone/darts.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/protobuf-lite/google/protobuf/any.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/protobuf-lite/google/protobuf/arena.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/protobuf-lite/google/protobuf/arena_impl.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/protobuf-lite/google/protobuf/arenastring.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/protobuf-lite/google/protobuf/descriptor.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/protobuf-lite/google/protobuf/extension_set.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/protobuf-lite/google/protobuf/extension_set_inl.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/protobuf-lite/google/protobuf/generated_enum_reflection.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/protobuf-lite/google/protobuf/generated_enum_util.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/protobuf-lite/google/protobuf/generated_message_table_driven.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/protobuf-lite/google/protobuf/generated_message_table_driven_lite.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/protobuf-lite/google/protobuf/generated_message_util.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/protobuf-lite/google/protobuf/has_bits.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/protobuf-lite/google/protobuf/implicit_weak_message.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/protobuf-lite/google/protobuf/io/coded_stream.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/protobuf-lite/google/protobuf/io/io_win32.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/protobuf-lite/google/protobuf/io/zero_copy_stream.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/protobuf-lite/google/protobuf/io/zero_copy_stream_impl.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/protobuf-lite/google/protobuf/io/zero_copy_stream_impl_lite.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/protobuf-lite/google/protobuf/map.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/protobuf-lite/google/protobuf/map_entry_lite.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/protobuf-lite/google/protobuf/map_field_lite.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/protobuf-lite/google/protobuf/map_type_handler.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/protobuf-lite/google/protobuf/message_lite.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/protobuf-lite/google/protobuf/metadata_lite.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/protobuf-lite/google/protobuf/parse_context.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/protobuf-lite/google/protobuf/port.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/protobuf-lite/google/protobuf/repeated_field.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/protobuf-lite/google/protobuf/stubs/bytestream.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/protobuf-lite/google/protobuf/stubs/callback.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/protobuf-lite/google/protobuf/stubs/casts.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/protobuf-lite/google/protobuf/stubs/common.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/protobuf-lite/google/protobuf/stubs/hash.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/protobuf-lite/google/protobuf/stubs/int128.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/protobuf-lite/google/protobuf/stubs/logging.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/protobuf-lite/google/protobuf/stubs/macros.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/protobuf-lite/google/protobuf/stubs/map_util.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/protobuf-lite/google/protobuf/stubs/mutex.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/protobuf-lite/google/protobuf/stubs/once.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/protobuf-lite/google/protobuf/stubs/platform_macros.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/protobuf-lite/google/protobuf/stubs/port.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/protobuf-lite/google/protobuf/stubs/status.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/protobuf-lite/google/protobuf/stubs/statusor.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/protobuf-lite/google/protobuf/stubs/stl_util.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/protobuf-lite/google/protobuf/stubs/stringpiece.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/protobuf-lite/google/protobuf/stubs/stringprintf.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/protobuf-lite/google/protobuf/stubs/strutil.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/protobuf-lite/google/protobuf/stubs/time.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/protobuf-lite/google/protobuf/unknown_field_set.h delete mode 100644 ai_layer/engine/include/executorch/extension/llm/tokenizers/third-party/sentencepiece/third_party/protobuf-lite/google/protobuf/wire_format_lite.h delete mode 100644 ai_layer/engine/include/executorch/extension/memory_allocator/malloc_memory_allocator.h delete mode 100644 ai_layer/engine/include/executorch/extension/module/bundled_module.h delete mode 100644 ai_layer/engine/include/executorch/extension/module/module.h delete mode 100644 ai_layer/engine/include/executorch/extension/named_data_map/merged_data_map.h delete mode 100644 ai_layer/engine/include/executorch/extension/parallel/thread_parallel.h delete mode 100644 ai_layer/engine/include/executorch/extension/pytree/aten_util/ivalue_util.h delete mode 100644 ai_layer/engine/include/executorch/extension/pytree/function_ref.h delete mode 100644 ai_layer/engine/include/executorch/extension/pytree/pytree.h delete mode 100644 ai_layer/engine/include/executorch/extension/runner_util/inputs.h delete mode 100644 ai_layer/engine/include/executorch/extension/tensor/tensor.h delete mode 100644 ai_layer/engine/include/executorch/extension/tensor/tensor_accessor.h delete mode 100644 ai_layer/engine/include/executorch/extension/tensor/tensor_ptr.h delete mode 100644 ai_layer/engine/include/executorch/extension/tensor/tensor_ptr_maker.h delete mode 100644 ai_layer/engine/include/executorch/extension/testing_util/temp_file.h delete mode 100644 ai_layer/engine/include/executorch/extension/threadpool/cpuinfo_utils.h delete mode 100644 ai_layer/engine/include/executorch/extension/threadpool/threadpool.h delete mode 100644 ai_layer/engine/include/executorch/extension/threadpool/threadpool_guard.h delete mode 100644 ai_layer/engine/include/executorch/extension/training/module/state_dict_util.h delete mode 100644 ai_layer/engine/include/executorch/extension/training/module/training_module.h delete mode 100644 ai_layer/engine/include/executorch/extension/training/optimizer/sgd.h delete mode 100644 ai_layer/engine/include/executorch/generated/backends/cortex_m/cortex_m_ops_lib/CustomOpsNativeFunctions.h delete mode 100644 ai_layer/engine/include/executorch/generated/backends/cortex_m/cortex_m_ops_lib/Functions.h delete mode 100644 ai_layer/engine/include/executorch/generated/backends/cortex_m/cortex_m_ops_lib/NativeFunctions.h delete mode 100644 ai_layer/engine/include/executorch/generated/kernels/portable/portable_ops_lib/Functions.h delete mode 100644 ai_layer/engine/include/executorch/generated/kernels/portable/portable_ops_lib/NativeFunctions.h delete mode 100644 ai_layer/engine/include/executorch/generated/kernels/quantized/quantized_ops_lib/CustomOpsNativeFunctions.h delete mode 100644 ai_layer/engine/include/executorch/generated/kernels/quantized/quantized_ops_lib/Functions.h delete mode 100644 ai_layer/engine/include/executorch/generated/kernels/quantized/quantized_ops_lib/NativeFunctions.h delete mode 100644 ai_layer/engine/include/executorch/kernels/aten/cpu/util/copy_ops_util.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/blas/BlasKernel.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/blas/CPUBlas.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/cpu/binary_ops.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/cpu/fft_utils.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/cpu/moments_utils.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/cpu/op_add_sub_impl.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/AccelerateSupport/AccelerateSupport.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/AccelerateSupport/InternalHeaderCheck.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Cholesky/InternalHeaderCheck.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Cholesky/LDLT.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Cholesky/LLT.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Cholesky/LLT_LAPACKE.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/CholmodSupport/CholmodSupport.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/CholmodSupport/InternalHeaderCheck.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/ArithmeticSequence.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/Array.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/ArrayBase.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/ArrayWrapper.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/Assign.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/AssignEvaluator.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/Assign_MKL.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/BandMatrix.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/Block.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/CommaInitializer.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/ConditionEstimator.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/CoreEvaluators.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/CoreIterators.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/CwiseBinaryOp.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/CwiseNullaryOp.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/CwiseTernaryOp.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/CwiseUnaryOp.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/CwiseUnaryView.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/DenseBase.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/DenseCoeffsBase.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/DenseStorage.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/DeviceWrapper.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/Diagonal.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/DiagonalMatrix.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/DiagonalProduct.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/Dot.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/EigenBase.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/Fill.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/ForceAlignedAccess.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/Fuzzy.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/GeneralProduct.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/GenericPacketMath.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/GlobalFunctions.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/IO.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/IndexedView.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/InnerProduct.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/InternalHeaderCheck.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/Inverse.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/Map.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/MapBase.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/MathFunctions.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/MathFunctionsImpl.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/Matrix.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/MatrixBase.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/NestByValue.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/NoAlias.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/NumTraits.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/PartialReduxEvaluator.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/PermutationMatrix.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/PlainObjectBase.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/Product.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/ProductEvaluators.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/Random.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/RandomImpl.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/Redux.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/Ref.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/Replicate.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/Reshaped.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/ReturnByValue.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/Reverse.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/Select.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/SelfAdjointView.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/SelfCwiseBinaryOp.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/SkewSymmetricMatrix3.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/Solve.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/SolveTriangular.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/SolverBase.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/StableNorm.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/StlIterators.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/Stride.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/Swap.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/Transpose.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/Transpositions.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/TriangularMatrix.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/VectorBlock.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/VectorwiseOp.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/Visitor.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/arch/AVX/Complex.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/arch/AVX/MathFunctions.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/arch/AVX/PacketMath.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/arch/AVX/TypeCasting.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/arch/AVX512/Complex.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/arch/AVX512/GemmKernel.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/arch/AVX512/MathFunctions.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/arch/AVX512/MathFunctionsFP16.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/arch/AVX512/PacketMath.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/arch/AVX512/PacketMathFP16.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/arch/AVX512/TrsmKernel.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/arch/AVX512/TypeCasting.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/arch/AVX512/TypeCastingFP16.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/arch/AltiVec/Complex.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/arch/AltiVec/MathFunctions.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/arch/AltiVec/MatrixProduct.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/arch/AltiVec/MatrixProductCommon.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/arch/AltiVec/MatrixProductMMA.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/arch/AltiVec/MatrixProductMMAbfloat16.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/arch/AltiVec/PacketMath.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/arch/AltiVec/TypeCasting.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/arch/Default/BFloat16.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/arch/Default/ConjHelper.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/arch/Default/GenericPacketMathFunctions.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/arch/Default/GenericPacketMathFunctionsFwd.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/arch/Default/Half.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/arch/Default/Settings.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/arch/GPU/Complex.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/arch/GPU/MathFunctions.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/arch/GPU/PacketMath.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/arch/GPU/Tuple.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/arch/GPU/TypeCasting.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/arch/HIP/hcc/math_constants.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/arch/HVX/PacketMath.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/arch/LSX/Complex.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/arch/LSX/GeneralBlockPanelKernel.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/arch/LSX/MathFunctions.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/arch/LSX/PacketMath.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/arch/LSX/TypeCasting.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/arch/MSA/Complex.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/arch/MSA/MathFunctions.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/arch/MSA/PacketMath.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/arch/NEON/Complex.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/arch/NEON/GeneralBlockPanelKernel.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/arch/NEON/MathFunctions.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/arch/NEON/PacketMath.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/arch/NEON/TypeCasting.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/arch/NEON/UnaryFunctors.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/arch/SSE/Complex.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/arch/SSE/MathFunctions.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/arch/SSE/PacketMath.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/arch/SSE/TypeCasting.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/arch/SVE/MathFunctions.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/arch/SVE/PacketMath.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/arch/SVE/TypeCasting.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/arch/SYCL/InteropHeaders.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/arch/SYCL/MathFunctions.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/arch/SYCL/PacketMath.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/arch/SYCL/TypeCasting.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/arch/ZVector/Complex.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/arch/ZVector/MathFunctions.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/arch/ZVector/PacketMath.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/functors/AssignmentFunctors.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/functors/BinaryFunctors.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/functors/NullaryFunctors.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/functors/StlFunctors.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/functors/TernaryFunctors.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/functors/UnaryFunctors.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/products/GeneralBlockPanelKernel.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/products/GeneralMatrixMatrix.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/products/GeneralMatrixMatrixTriangular.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/products/GeneralMatrixMatrixTriangular_BLAS.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/products/GeneralMatrixMatrix_BLAS.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/products/GeneralMatrixVector.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/products/GeneralMatrixVector_BLAS.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/products/Parallelizer.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/products/SelfadjointMatrixMatrix.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/products/SelfadjointMatrixMatrix_BLAS.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/products/SelfadjointMatrixVector.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/products/SelfadjointMatrixVector_BLAS.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/products/SelfadjointProduct.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/products/SelfadjointRank2Update.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/products/TriangularMatrixMatrix.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/products/TriangularMatrixMatrix_BLAS.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/products/TriangularMatrixVector.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/products/TriangularMatrixVector_BLAS.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/products/TriangularSolverMatrix.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/products/TriangularSolverMatrix_BLAS.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/products/TriangularSolverVector.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/util/Assert.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/util/BlasUtil.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/util/ConfigureVectorization.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/util/Constants.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/util/DisableStupidWarnings.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/util/EmulateArray.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/util/ForwardDeclarations.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/util/IndexedViewHelper.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/util/IntegralConstant.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/util/MKL_support.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/util/Macros.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/util/MaxSizeVector.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/util/Memory.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/util/Meta.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/util/MoreMeta.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/util/ReenableStupidWarnings.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/util/ReshapedHelper.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/util/Serializer.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/util/StaticAssert.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/util/SymbolicIndex.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Core/util/XprHelper.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Eigenvalues/ComplexEigenSolver.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Eigenvalues/ComplexSchur.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Eigenvalues/ComplexSchur_LAPACKE.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Eigenvalues/EigenSolver.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Eigenvalues/GeneralizedEigenSolver.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Eigenvalues/HessenbergDecomposition.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Eigenvalues/InternalHeaderCheck.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Eigenvalues/MatrixBaseEigenvalues.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Eigenvalues/RealQZ.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Eigenvalues/RealSchur.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Eigenvalues/RealSchur_LAPACKE.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Eigenvalues/SelfAdjointEigenSolver.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Eigenvalues/SelfAdjointEigenSolver_LAPACKE.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Eigenvalues/Tridiagonalization.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Geometry/AlignedBox.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Geometry/AngleAxis.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Geometry/EulerAngles.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Geometry/Homogeneous.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Geometry/Hyperplane.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Geometry/InternalHeaderCheck.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Geometry/OrthoMethods.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Geometry/ParametrizedLine.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Geometry/Quaternion.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Geometry/Rotation2D.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Geometry/RotationBase.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Geometry/Scaling.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Geometry/Transform.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Geometry/Translation.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Geometry/Umeyama.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Geometry/arch/Geometry_SIMD.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Householder/BlockHouseholder.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Householder/Householder.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Householder/HouseholderSequence.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Householder/InternalHeaderCheck.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/IterativeLinearSolvers/BasicPreconditioners.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/IterativeLinearSolvers/BiCGSTAB.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/IterativeLinearSolvers/ConjugateGradient.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/IterativeLinearSolvers/IncompleteCholesky.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/IterativeLinearSolvers/IncompleteLUT.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/IterativeLinearSolvers/InternalHeaderCheck.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/IterativeLinearSolvers/IterativeSolverBase.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/IterativeLinearSolvers/LeastSquareConjugateGradient.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/IterativeLinearSolvers/SolveWithGuess.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Jacobi/InternalHeaderCheck.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/Jacobi/Jacobi.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/KLUSupport/InternalHeaderCheck.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/KLUSupport/KLUSupport.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/LU/Determinant.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/LU/FullPivLU.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/LU/InternalHeaderCheck.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/LU/InverseImpl.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/LU/PartialPivLU.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/LU/PartialPivLU_LAPACKE.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/LU/arch/InverseSize4.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/MetisSupport/InternalHeaderCheck.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/MetisSupport/MetisSupport.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/OrderingMethods/Amd.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/OrderingMethods/Eigen_Colamd.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/OrderingMethods/InternalHeaderCheck.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/OrderingMethods/Ordering.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/PaStiXSupport/InternalHeaderCheck.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/PaStiXSupport/PaStiXSupport.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/PardisoSupport/InternalHeaderCheck.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/PardisoSupport/PardisoSupport.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/QR/ColPivHouseholderQR.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/QR/ColPivHouseholderQR_LAPACKE.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/QR/CompleteOrthogonalDecomposition.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/QR/FullPivHouseholderQR.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/QR/HouseholderQR.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/QR/HouseholderQR_LAPACKE.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/QR/InternalHeaderCheck.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SPQRSupport/InternalHeaderCheck.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SPQRSupport/SuiteSparseQRSupport.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SVD/BDCSVD.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SVD/BDCSVD_LAPACKE.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SVD/InternalHeaderCheck.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SVD/JacobiSVD.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SVD/JacobiSVD_LAPACKE.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SVD/SVDBase.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SVD/UpperBidiagonalization.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SparseCholesky/InternalHeaderCheck.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SparseCholesky/SimplicialCholesky.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SparseCholesky/SimplicialCholesky_impl.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SparseCore/AmbiVector.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SparseCore/CompressedStorage.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SparseCore/ConservativeSparseSparseProduct.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SparseCore/InternalHeaderCheck.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SparseCore/SparseAssign.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SparseCore/SparseBlock.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SparseCore/SparseColEtree.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SparseCore/SparseCompressedBase.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SparseCore/SparseCwiseBinaryOp.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SparseCore/SparseCwiseUnaryOp.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SparseCore/SparseDenseProduct.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SparseCore/SparseDiagonalProduct.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SparseCore/SparseDot.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SparseCore/SparseFuzzy.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SparseCore/SparseMap.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SparseCore/SparseMatrix.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SparseCore/SparseMatrixBase.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SparseCore/SparsePermutation.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SparseCore/SparseProduct.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SparseCore/SparseRedux.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SparseCore/SparseRef.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SparseCore/SparseSelfAdjointView.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SparseCore/SparseSolverBase.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SparseCore/SparseSparseProductWithPruning.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SparseCore/SparseTranspose.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SparseCore/SparseTriangularView.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SparseCore/SparseUtil.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SparseCore/SparseVector.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SparseCore/SparseView.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SparseCore/TriangularSolver.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SparseLU/InternalHeaderCheck.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SparseLU/SparseLU.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SparseLU/SparseLUImpl.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SparseLU/SparseLU_Memory.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SparseLU/SparseLU_Structs.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SparseLU/SparseLU_SupernodalMatrix.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SparseLU/SparseLU_Utils.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SparseLU/SparseLU_column_bmod.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SparseLU/SparseLU_column_dfs.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SparseLU/SparseLU_copy_to_ucol.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SparseLU/SparseLU_heap_relax_snode.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SparseLU/SparseLU_kernel_bmod.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SparseLU/SparseLU_panel_bmod.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SparseLU/SparseLU_panel_dfs.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SparseLU/SparseLU_pivotL.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SparseLU/SparseLU_pruneL.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SparseLU/SparseLU_relax_snode.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SparseQR/InternalHeaderCheck.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SparseQR/SparseQR.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/StlSupport/StdDeque.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/StlSupport/StdList.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/StlSupport/StdVector.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/StlSupport/details.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SuperLUSupport/InternalHeaderCheck.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/SuperLUSupport/SuperLUSupport.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/ThreadPool/Barrier.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/ThreadPool/CoreThreadPoolDevice.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/ThreadPool/EventCount.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/ThreadPool/ForkJoin.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/ThreadPool/InternalHeaderCheck.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/ThreadPool/NonBlockingThreadPool.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/ThreadPool/RunQueue.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/ThreadPool/ThreadCancel.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/ThreadPool/ThreadEnvironment.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/ThreadPool/ThreadLocal.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/ThreadPool/ThreadPoolInterface.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/ThreadPool/ThreadYield.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/UmfPackSupport/InternalHeaderCheck.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/UmfPackSupport/UmfPackSupport.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/misc/Image.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/misc/InternalHeaderCheck.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/misc/Kernel.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/misc/RealSvd2x2.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/misc/blas.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/misc/lapacke.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/misc/lapacke_helpers.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/Eigen/src/misc/lapacke_mangling.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/bench/BenchSparseUtil.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/bench/BenchTimer.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/bench/BenchUtil.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/bench/basicbenchmark.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/bench/btl/generic_bench/utils/utilities.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/bench/btl/libs/BLAS/blas.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/bench/btl/libs/BLAS/c_interface_base.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/bench/perf_monitoring/gemm_common.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/bench/perf_monitoring/gemv_common.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/bench/spbench/spbenchsolver.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/bench/spbench/spbenchstyle.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/bench/tensors/benchmark.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/bench/tensors/tensor_benchmarks.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/blas/BandTriangularSolver.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/blas/GeneralRank1Update.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/blas/PackedSelfadjointProduct.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/blas/PackedTriangularMatrixVector.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/blas/PackedTriangularSolverVector.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/blas/Rank2Update.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/blas/blas.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/blas/common.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/blas/f2c/datatypes.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/blas/level1_cplx_impl.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/blas/level1_impl.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/blas/level1_real_impl.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/blas/level2_cplx_impl.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/blas/level2_impl.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/blas/level2_real_impl.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/blas/level3_impl.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/demos/mandelbrot/mandelbrot.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/demos/mix_eigen_and_c/binary_library.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/demos/opengl/camera.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/demos/opengl/gpuhelper.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/demos/opengl/icosphere.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/demos/opengl/quaternion_demo.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/demos/opengl/trackball.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/lapack/lapack.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/lapack/lapack_common.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/test/AnnoyingScalar.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/test/CustomComplex.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/test/MovableScalar.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/test/OffByOneScalar.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/test/SafeScalar.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/test/bug1213.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/test/evaluator_common.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/test/gpu_common.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/test/gpu_test_helper.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/test/main.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/test/packetmath_test_shared.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/test/product.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/test/random_matrix_helper.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/test/random_without_cast_overflow.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/test/solverbase.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/test/sparse.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/test/sparse_solver.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/test/split_test_helper.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/test/svd_common.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/test/svd_fill.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/InternalHeaderCheck.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/Tensor.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorArgMax.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorAssign.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorBase.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorBlock.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorBroadcasting.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorChipping.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorConcatenation.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorContraction.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorContractionBlocking.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorContractionCuda.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorContractionMapper.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorContractionSycl.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorContractionThreadPool.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorConversion.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorConvolution.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorConvolutionSycl.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorCostModel.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorCustomOp.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorDevice.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorDeviceCuda.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorDeviceDefault.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorDeviceGpu.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorDeviceSycl.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorDeviceThreadPool.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorDimensionList.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorDimensions.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorEvalTo.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorEvaluator.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorExecutor.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorExpr.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorFFT.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorFixedSize.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorForcedEval.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorForwardDeclarations.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorFunctors.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorGenerator.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorGlobalFunctions.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorGpuHipCudaDefines.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorGpuHipCudaUndefines.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorIO.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorImagePatch.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorIndexList.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorInflation.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorInitializer.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorIntDiv.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorLayoutSwap.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorMacros.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorMap.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorMeta.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorMorphing.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorPadding.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorPatch.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorRandom.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorReduction.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorReductionGpu.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorReductionSycl.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorRef.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorReverse.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorRoll.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorScan.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorScanSycl.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorShuffling.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorStorage.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorStriding.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorTrace.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorTraits.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorUInt128.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorVolumePatch.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/TensorSymmetry/DynamicSymmetry.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/TensorSymmetry/InternalHeaderCheck.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/TensorSymmetry/StaticSymmetry.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/TensorSymmetry/Symmetry.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/TensorSymmetry/util/TemplateGroupTheory.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/util/CXX11Meta.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/CXX11/src/util/CXX11Workarounds.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/AutoDiff/AutoDiffJacobian.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/AutoDiff/AutoDiffScalar.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/AutoDiff/AutoDiffVector.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/AutoDiff/CoherentPadOp.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/AutoDiff/InternalHeaderCheck.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/BVH/BVAlgorithms.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/BVH/InternalHeaderCheck.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/BVH/KdBVH.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/Eigenvalues/ArpackSelfAdjointEigenSolver.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/Eigenvalues/InternalHeaderCheck.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/EulerAngles/EulerAngles.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/EulerAngles/EulerSystem.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/EulerAngles/InternalHeaderCheck.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/FFT/InternalHeaderCheck.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/FFT/ei_fftw_impl.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/FFT/ei_imklfft_impl.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/FFT/ei_kissfft_impl.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/FFT/ei_pocketfft_impl.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/IterativeSolvers/BiCGSTABL.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/IterativeSolvers/DGMRES.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/IterativeSolvers/GMRES.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/IterativeSolvers/IDRS.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/IterativeSolvers/IDRSTABL.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/IterativeSolvers/IncompleteLU.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/IterativeSolvers/InternalHeaderCheck.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/IterativeSolvers/MINRES.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/IterativeSolvers/Scaling.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/KroneckerProduct/InternalHeaderCheck.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/KroneckerProduct/KroneckerTensorProduct.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/LevenbergMarquardt/InternalHeaderCheck.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/LevenbergMarquardt/LMcovar.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/LevenbergMarquardt/LMonestep.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/LevenbergMarquardt/LMpar.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/LevenbergMarquardt/LMqrsolv.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/LevenbergMarquardt/LevenbergMarquardt.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/MatrixFunctions/InternalHeaderCheck.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/MatrixFunctions/MatrixExponential.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/MatrixFunctions/MatrixFunction.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/MatrixFunctions/MatrixLogarithm.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/MatrixFunctions/MatrixPower.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/MatrixFunctions/MatrixSquareRoot.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/MatrixFunctions/StemFunction.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/NonLinearOptimization/HybridNonLinearSolver.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/NonLinearOptimization/InternalHeaderCheck.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/NonLinearOptimization/LevenbergMarquardt.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/NonLinearOptimization/chkder.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/NonLinearOptimization/covar.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/NonLinearOptimization/dogleg.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/NonLinearOptimization/fdjac1.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/NonLinearOptimization/lmpar.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/NonLinearOptimization/qrsolv.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/NonLinearOptimization/r1mpyq.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/NonLinearOptimization/r1updt.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/NonLinearOptimization/rwupdt.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/NumericalDiff/InternalHeaderCheck.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/NumericalDiff/NumericalDiff.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/Polynomials/Companion.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/Polynomials/InternalHeaderCheck.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/Polynomials/PolynomialSolver.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/Polynomials/PolynomialUtils.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/SparseExtra/BlockSparseMatrix.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/SparseExtra/InternalHeaderCheck.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/SparseExtra/MarketIO.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/SparseExtra/RandomSetter.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/SparseExtra/SparseInverse.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/SpecialFunctions/BesselFunctionsArrayAPI.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/SpecialFunctions/BesselFunctionsBFloat16.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/SpecialFunctions/BesselFunctionsFunctors.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/SpecialFunctions/BesselFunctionsHalf.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/SpecialFunctions/BesselFunctionsImpl.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/SpecialFunctions/BesselFunctionsPacketMath.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/SpecialFunctions/HipVectorCompatibility.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/SpecialFunctions/InternalHeaderCheck.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/SpecialFunctions/SpecialFunctionsArrayAPI.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/SpecialFunctions/SpecialFunctionsBFloat16.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/SpecialFunctions/SpecialFunctionsFunctors.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/SpecialFunctions/SpecialFunctionsHalf.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/SpecialFunctions/SpecialFunctionsImpl.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/SpecialFunctions/SpecialFunctionsPacketMath.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/SpecialFunctions/arch/AVX/BesselFunctions.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/SpecialFunctions/arch/AVX/SpecialFunctions.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/SpecialFunctions/arch/AVX512/BesselFunctions.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/SpecialFunctions/arch/AVX512/SpecialFunctions.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/SpecialFunctions/arch/GPU/SpecialFunctions.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/SpecialFunctions/arch/NEON/BesselFunctions.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/SpecialFunctions/arch/NEON/SpecialFunctions.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/Splines/InternalHeaderCheck.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/Splines/Spline.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/Splines/SplineFitting.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/Eigen/src/Splines/SplineFwd.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/test/fft_test_shared.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/third-party/eigen/unsupported/test/matrix_functions.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/utils/llvmMathExtras.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/utils/math_utils.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/utils/unroll.h delete mode 100644 ai_layer/engine/include/executorch/kernels/optimized/vec/functional.h delete mode 100644 ai_layer/engine/include/executorch/kernels/portable/cpu/math_constants.h delete mode 100644 ai_layer/engine/include/executorch/kernels/portable/cpu/pattern/bitwise_op.h delete mode 100644 ai_layer/engine/include/executorch/kernels/portable/cpu/pattern/comparison_op.h delete mode 100644 ai_layer/engine/include/executorch/kernels/portable/cpu/pattern/logical_op.h delete mode 100644 ai_layer/engine/include/executorch/kernels/portable/cpu/pattern/pattern.h delete mode 100644 ai_layer/engine/include/executorch/kernels/portable/cpu/scalar_utils.h delete mode 100644 ai_layer/engine/include/executorch/kernels/portable/cpu/selective_build.h delete mode 100644 ai_layer/engine/include/executorch/kernels/portable/cpu/util/activation_ops_util.h delete mode 100644 ai_layer/engine/include/executorch/kernels/portable/cpu/util/advanced_index_util.h delete mode 100644 ai_layer/engine/include/executorch/kernels/portable/cpu/util/arange_util.h delete mode 100644 ai_layer/engine/include/executorch/kernels/portable/cpu/util/broadcast_indexes_range.h delete mode 100644 ai_layer/engine/include/executorch/kernels/portable/cpu/util/broadcast_util.h delete mode 100644 ai_layer/engine/include/executorch/kernels/portable/cpu/util/copy_ops_util.h delete mode 100644 ai_layer/engine/include/executorch/kernels/portable/cpu/util/delinearize_index.h delete mode 100644 ai_layer/engine/include/executorch/kernels/portable/cpu/util/distance_util.h delete mode 100644 ai_layer/engine/include/executorch/kernels/portable/cpu/util/dtype_util.h delete mode 100644 ai_layer/engine/include/executorch/kernels/portable/cpu/util/elementwise_util.h delete mode 100644 ai_layer/engine/include/executorch/kernels/portable/cpu/util/functional_util.h delete mode 100644 ai_layer/engine/include/executorch/kernels/portable/cpu/util/index_util.h delete mode 100644 ai_layer/engine/include/executorch/kernels/portable/cpu/util/kernel_ops_util.h delete mode 100644 ai_layer/engine/include/executorch/kernels/portable/cpu/util/math_util.h delete mode 100644 ai_layer/engine/include/executorch/kernels/portable/cpu/util/matmul_ops_util.h delete mode 100644 ai_layer/engine/include/executorch/kernels/portable/cpu/util/normalization_ops_util.h delete mode 100644 ai_layer/engine/include/executorch/kernels/portable/cpu/util/padding_util.h delete mode 100644 ai_layer/engine/include/executorch/kernels/portable/cpu/util/reduce_util.h delete mode 100644 ai_layer/engine/include/executorch/kernels/portable/cpu/util/repeat_util.h delete mode 100644 ai_layer/engine/include/executorch/kernels/portable/cpu/util/select_copy_util.h delete mode 100644 ai_layer/engine/include/executorch/kernels/portable/cpu/util/slice_util.h delete mode 100644 ai_layer/engine/include/executorch/kernels/portable/cpu/util/stack_util.h delete mode 100644 ai_layer/engine/include/executorch/kernels/portable/cpu/util/transpose_util.h delete mode 100644 ai_layer/engine/include/executorch/kernels/portable/cpu/util/upsample_util.h delete mode 100644 ai_layer/engine/include/executorch/kernels/portable/cpu/util/vectorized_math.h delete mode 100644 ai_layer/engine/include/executorch/kernels/portable/cpu/vec_ops.h delete mode 100644 ai_layer/engine/include/executorch/kernels/prim_ops/et_copy_index.h delete mode 100644 ai_layer/engine/include/executorch/kernels/prim_ops/et_view.h delete mode 100644 ai_layer/engine/include/executorch/kernels/quantized/cpu/embeddingxb.h delete mode 100644 ai_layer/engine/include/executorch/kernels/test/BinaryLogicalOpTest.h delete mode 100644 ai_layer/engine/include/executorch/kernels/test/ScalarOverflowTestMacros.h delete mode 100644 ai_layer/engine/include/executorch/kernels/test/TestUtil.h delete mode 100644 ai_layer/engine/include/executorch/kernels/test/UnaryUfuncRealHBBF16ToFloatHBF16Test.h delete mode 100644 ai_layer/engine/include/executorch/kernels/test/op_test.h delete mode 100644 ai_layer/engine/include/executorch/runtime/backend/backend_execution_context.h delete mode 100644 ai_layer/engine/include/executorch/runtime/backend/backend_init_context.h delete mode 100644 ai_layer/engine/include/executorch/runtime/backend/backend_option_context.h delete mode 100644 ai_layer/engine/include/executorch/runtime/backend/interface.h delete mode 100644 ai_layer/engine/include/executorch/runtime/backend/options.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/array_ref.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/data_loader.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/defines.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/error.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/evalue.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/event_tracer.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/event_tracer_hooks.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/event_tracer_hooks_delegate.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/exec_aten/exec_aten.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/exec_aten/testing_util/tensor_factory.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/exec_aten/testing_util/tensor_util.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/exec_aten/util/dim_order_util.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/exec_aten/util/scalar_type_util.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/exec_aten/util/tensor_dimension_limit.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/exec_aten/util/tensor_shape_to_c_string.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/exec_aten/util/tensor_util.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/freeable_buffer.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/function_ref.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/hierarchical_allocator.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/memory_allocator.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/named_data_map.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/portable_type/bfloat16.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/portable_type/bfloat16_math.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/portable_type/bits_types.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/portable_type/c10/c10/macros/Export.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/portable_type/c10/c10/macros/Macros.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/portable_type/c10/c10/util/BFloat16-inl.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/portable_type/c10/c10/util/BFloat16-math.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/portable_type/c10/c10/util/BFloat16.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/portable_type/c10/c10/util/Half-inl.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/portable_type/c10/c10/util/Half.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/portable_type/c10/c10/util/TypeSafeSignMath.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/portable_type/c10/c10/util/bit_cast.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/portable_type/c10/c10/util/complex.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/portable_type/c10/c10/util/complex_math.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/portable_type/c10/c10/util/complex_utils.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/portable_type/c10/c10/util/floating_point_utils.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/portable_type/c10/c10/util/irange.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/portable_type/c10/c10/util/llvmMathExtras.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/portable_type/c10/c10/util/overflows.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/portable_type/c10/c10/util/safe_numerics.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/portable_type/c10/torch/headeronly/macros/Export.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/portable_type/c10/torch/headeronly/macros/Macros.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/portable_type/c10/torch/headeronly/util/BFloat16.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/portable_type/c10/torch/headeronly/util/Half.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/portable_type/c10/torch/headeronly/util/TypeSafeSignMath.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/portable_type/c10/torch/headeronly/util/bit_cast.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/portable_type/c10/torch/headeronly/util/complex.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/portable_type/c10/torch/headeronly/util/floating_point_utils.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/portable_type/complex.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/portable_type/device.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/portable_type/half.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/portable_type/optional.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/portable_type/qint_types.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/portable_type/scalar.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/portable_type/scalar_type.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/portable_type/string_view.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/portable_type/tensor.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/portable_type/tensor_impl.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/portable_type/tensor_options.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/result.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/span.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/tag.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/tensor_layout.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/tensor_shape_dynamism.h delete mode 100644 ai_layer/engine/include/executorch/runtime/core/testing_util/error_matchers.h delete mode 100644 ai_layer/engine/include/executorch/runtime/executor/memory_manager.h delete mode 100644 ai_layer/engine/include/executorch/runtime/executor/merged_data_map.h delete mode 100644 ai_layer/engine/include/executorch/runtime/executor/method.h delete mode 100644 ai_layer/engine/include/executorch/runtime/executor/method_meta.h delete mode 100644 ai_layer/engine/include/executorch/runtime/executor/platform_memory_allocator.h delete mode 100644 ai_layer/engine/include/executorch/runtime/executor/program.h delete mode 100644 ai_layer/engine/include/executorch/runtime/executor/pte_data_map.h delete mode 100644 ai_layer/engine/include/executorch/runtime/executor/tensor_parser.h delete mode 100644 ai_layer/engine/include/executorch/runtime/executor/test/managed_memory_manager.h delete mode 100644 ai_layer/engine/include/executorch/runtime/kernel/kernel_includes.h delete mode 100644 ai_layer/engine/include/executorch/runtime/kernel/kernel_runtime_context.h delete mode 100644 ai_layer/engine/include/executorch/runtime/kernel/operator_registry.h delete mode 100644 ai_layer/engine/include/executorch/runtime/kernel/test/test_util.h delete mode 100644 ai_layer/engine/include/executorch/runtime/kernel/thread_parallel_interface.h delete mode 100644 ai_layer/engine/include/executorch/runtime/platform/abort.h delete mode 100644 ai_layer/engine/include/executorch/runtime/platform/assert.h delete mode 100644 ai_layer/engine/include/executorch/runtime/platform/clock.h delete mode 100644 ai_layer/engine/include/executorch/runtime/platform/compat_unistd.h delete mode 100644 ai_layer/engine/include/executorch/runtime/platform/compiler.h delete mode 100644 ai_layer/engine/include/executorch/runtime/platform/log.h delete mode 100644 ai_layer/engine/include/executorch/runtime/platform/platform.h delete mode 100644 ai_layer/engine/include/executorch/runtime/platform/profiler.h delete mode 100644 ai_layer/engine/include/executorch/runtime/platform/runtime.h delete mode 100644 ai_layer/engine/include/executorch/runtime/platform/system.h delete mode 100644 ai_layer/engine/include/executorch/runtime/platform/test/pal_spy.h delete mode 100644 ai_layer/engine/include/executorch/runtime/platform/test/stub_platform.h delete mode 100644 ai_layer/engine/include/executorch/runtime/platform/types.h delete mode 100644 ai_layer/engine/include/executorch/schema/extended_header.h delete mode 100644 ai_layer/engine/include/executorch/schema/program_generated.h delete mode 100644 ai_layer/engine/include/executorch/schema/scalar_type_generated.h delete mode 100644 ai_layer/engine/include/third-party/flatbuffers/include/flatbuffers/allocator.h delete mode 100644 ai_layer/engine/include/third-party/flatbuffers/include/flatbuffers/array.h delete mode 100644 ai_layer/engine/include/third-party/flatbuffers/include/flatbuffers/base.h delete mode 100644 ai_layer/engine/include/third-party/flatbuffers/include/flatbuffers/buffer.h delete mode 100644 ai_layer/engine/include/third-party/flatbuffers/include/flatbuffers/buffer_ref.h delete mode 100644 ai_layer/engine/include/third-party/flatbuffers/include/flatbuffers/code_generator.h delete mode 100644 ai_layer/engine/include/third-party/flatbuffers/include/flatbuffers/code_generators.h delete mode 100644 ai_layer/engine/include/third-party/flatbuffers/include/flatbuffers/default_allocator.h delete mode 100644 ai_layer/engine/include/third-party/flatbuffers/include/flatbuffers/detached_buffer.h delete mode 100644 ai_layer/engine/include/third-party/flatbuffers/include/flatbuffers/file_manager.h delete mode 100644 ai_layer/engine/include/third-party/flatbuffers/include/flatbuffers/flatbuffer_builder.h delete mode 100644 ai_layer/engine/include/third-party/flatbuffers/include/flatbuffers/flatbuffers.h delete mode 100644 ai_layer/engine/include/third-party/flatbuffers/include/flatbuffers/flatc.h delete mode 100644 ai_layer/engine/include/third-party/flatbuffers/include/flatbuffers/flex_flat_util.h delete mode 100644 ai_layer/engine/include/third-party/flatbuffers/include/flatbuffers/flexbuffers.h delete mode 100644 ai_layer/engine/include/third-party/flatbuffers/include/flatbuffers/grpc.h delete mode 100644 ai_layer/engine/include/third-party/flatbuffers/include/flatbuffers/hash.h delete mode 100644 ai_layer/engine/include/third-party/flatbuffers/include/flatbuffers/idl.h delete mode 100644 ai_layer/engine/include/third-party/flatbuffers/include/flatbuffers/minireflect.h delete mode 100644 ai_layer/engine/include/third-party/flatbuffers/include/flatbuffers/pch/flatc_pch.h delete mode 100644 ai_layer/engine/include/third-party/flatbuffers/include/flatbuffers/pch/pch.h delete mode 100644 ai_layer/engine/include/third-party/flatbuffers/include/flatbuffers/reflection.h delete mode 100644 ai_layer/engine/include/third-party/flatbuffers/include/flatbuffers/reflection_generated.h delete mode 100644 ai_layer/engine/include/third-party/flatbuffers/include/flatbuffers/registry.h delete mode 100644 ai_layer/engine/include/third-party/flatbuffers/include/flatbuffers/stl_emulation.h delete mode 100644 ai_layer/engine/include/third-party/flatbuffers/include/flatbuffers/string.h delete mode 100644 ai_layer/engine/include/third-party/flatbuffers/include/flatbuffers/struct.h delete mode 100644 ai_layer/engine/include/third-party/flatbuffers/include/flatbuffers/table.h delete mode 100644 ai_layer/engine/include/third-party/flatbuffers/include/flatbuffers/util.h delete mode 100644 ai_layer/engine/include/third-party/flatbuffers/include/flatbuffers/vector.h delete mode 100644 ai_layer/engine/include/third-party/flatbuffers/include/flatbuffers/vector_downward.h delete mode 100644 ai_layer/engine/include/third-party/flatbuffers/include/flatbuffers/verifier.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/flatcc.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/flatcc_accessors.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/flatcc_alloc.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/flatcc_assert.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/flatcc_builder.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/flatcc_emitter.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/flatcc_endian.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/flatcc_epilogue.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/flatcc_flatbuffers.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/flatcc_identifier.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/flatcc_iov.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/flatcc_json_parser.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/flatcc_json_printer.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/flatcc_portable.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/flatcc_prologue.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/flatcc_refmap.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/flatcc_rtconfig.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/flatcc_types.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/flatcc_unaligned.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/flatcc_verifier.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/flatcc_version.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/portable/LICENSE delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/portable/README.md delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/portable/grisu3_math.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/portable/grisu3_parse.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/portable/grisu3_print.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/portable/include/README delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/portable/include/linux/endian.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/portable/include/std/inttypes.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/portable/include/std/stdalign.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/portable/include/std/stdbool.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/portable/include/std/stdint.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/portable/paligned_alloc.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/portable/pattributes.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/portable/pbase64.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/portable/pcrt.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/portable/pdiagnostic.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/portable/pdiagnostic_pop.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/portable/pdiagnostic_push.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/portable/pendian.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/portable/pendian_detect.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/portable/pinline.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/portable/pinttypes.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/portable/pmemaccess.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/portable/portable.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/portable/portable_basic.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/portable/pparsefp.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/portable/pparseint.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/portable/pprintfp.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/portable/pprintint.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/portable/prestrict.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/portable/pstatic_assert.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/portable/pstatic_assert_scope.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/portable/pstdalign.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/portable/pstdbool.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/portable/pstdint.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/portable/punaligned.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/portable/pversion.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/portable/pwarnings.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/reflection/README delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/reflection/flatbuffers_common_builder.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/reflection/flatbuffers_common_reader.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/reflection/reflection_builder.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/reflection/reflection_reader.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/reflection/reflection_verifier.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/support/README delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/support/cdump.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/support/elapsed.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/support/hexdump.h delete mode 100644 ai_layer/engine/include/third-party/flatcc/include/flatcc/support/readfile.h delete mode 100644 ai_layer/engine/kernels/portable/cpu/op__clone_dim_order.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op__empty_dim_order.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op__to_dim_order_copy.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_abs.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_acos.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_acosh.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_add.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_addmm.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_alias_copy.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_allclose.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_amax.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_amin.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_any.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_arange.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_argmax.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_argmin.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_as_strided_copy.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_asin.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_asinh.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_atan.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_atan2.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_atanh.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_avg_pool2d.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_bitwise_and.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_bitwise_not.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_bitwise_or.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_bitwise_xor.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_bmm.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_cat.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_cdist_forward.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_ceil.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_clamp.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_clone.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_constant_pad_nd.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_convolution.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_convolution_backward.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_copy.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_cos.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_cosh.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_cumsum.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_detach_copy.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_diagonal_copy.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_div.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_elu.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_embedding.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_empty.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_eq.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_erf.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_exp.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_expand_copy.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_expm1.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_fill.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_flip.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_floor.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_floor_divide.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_fmod.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_full.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_full_like.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_gather.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_ge.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_gelu.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_glu.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_gt.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_hardtanh.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_index.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_index_put.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_index_select.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_isinf.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_isnan.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_le.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_leaky_relu.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_lift_fresh_copy.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_linear_scratch_example.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_log.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_log10.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_log1p.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_log2.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_log_softmax.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_logical_and.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_logical_not.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_logical_or.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_logical_xor.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_logit.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_lt.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_masked_fill.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_masked_scatter.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_masked_select.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_max.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_max_pool2d_with_indices.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_max_pool2d_with_indices_backward.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_maximum.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_mean.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_min.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_minimum.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_mm.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_mul.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_narrow_copy.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_native_batch_norm.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_native_group_norm.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_native_layer_norm.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_ne.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_neg.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_nonzero.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_ones.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_pdist_forward.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_permute_copy.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_pixel_shuffle.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_pixel_unshuffle.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_pow.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_prod.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_reciprocal.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_reflection_pad1d.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_reflection_pad2d.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_reflection_pad3d.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_relu.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_remainder.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_repeat.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_repeat_interleave.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_replication_pad1d.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_replication_pad2d.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_replication_pad3d.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_roll.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_round.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_rsqrt.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_rsub.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_scalar_tensor.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_scatter.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_scatter_add.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_select_copy.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_select_scatter.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_sigmoid.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_sign.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_sin.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_sinh.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_slice_copy.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_slice_scatter.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_softmax.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_split_copy.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_split_with_sizes_copy.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_sqrt.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_squeeze_copy.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_stack.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_sub.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_sum.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_t_copy.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_tan.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_tanh.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_to_copy.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_topk.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_transpose_copy.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_tril.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_trunc.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_unbind_copy.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_unfold_copy.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_unsqueeze_copy.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_upsample_bilinear2d.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_upsample_bilinear2d_aa.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_upsample_nearest2d.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_var.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_view_as_real_copy.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_view_copy.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_where.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/op_zeros.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/pattern/unary_ufunc_realhbbf16_to_bool.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/pattern/unary_ufunc_realhbbf16_to_floathbf16.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/pattern/unary_ufunc_realhbf16.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/util/activation_ops_util.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/util/advanced_index_util.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/util/arange_util.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/util/broadcast_util.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/util/copy_ops_util.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/util/delinearize_index.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/util/distance_util.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/util/dtype_util.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/util/index_util.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/util/kernel_ops_util.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/util/matmul_ops_util.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/util/normalization_ops_util.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/util/padding_util.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/util/reduce_util.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/util/repeat_util.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/util/select_copy_util.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/util/slice_util.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/util/stack_util.cpp delete mode 100644 ai_layer/engine/kernels/portable/cpu/util/upsample_util.cpp delete mode 100644 ai_layer/engine/kernels/prim_ops/et_copy_index.cpp delete mode 100644 ai_layer/engine/kernels/prim_ops/et_view.cpp delete mode 100644 ai_layer/engine/kernels/prim_ops/register_prim_ops.cpp delete mode 100644 ai_layer/engine/kernels/quantized/cpu/embeddingxb.cpp delete mode 100644 ai_layer/engine/kernels/quantized/cpu/op_add.cpp delete mode 100644 ai_layer/engine/kernels/quantized/cpu/op_choose_qparams.cpp delete mode 100644 ai_layer/engine/kernels/quantized/cpu/op_dequantize.cpp delete mode 100644 ai_layer/engine/kernels/quantized/cpu/op_embedding.cpp delete mode 100644 ai_layer/engine/kernels/quantized/cpu/op_embedding2b.cpp delete mode 100644 ai_layer/engine/kernels/quantized/cpu/op_embedding4b.cpp delete mode 100644 ai_layer/engine/kernels/quantized/cpu/op_mixed_linear.cpp delete mode 100644 ai_layer/engine/kernels/quantized/cpu/op_mixed_mm.cpp delete mode 100644 ai_layer/engine/kernels/quantized/cpu/op_quantize.cpp delete mode 100644 ai_layer/engine/kernels/quantized/quantized_ops_lib/CustomOpsNativeFunctions.h delete mode 100644 ai_layer/engine/kernels/quantized/quantized_ops_lib/Functions.h delete mode 100644 ai_layer/engine/kernels/quantized/quantized_ops_lib/NativeFunctions.h delete mode 100644 ai_layer/engine/kernels/quantized/quantized_ops_lib/RegisterCodegenUnboxedKernelsEverything.cpp delete mode 100644 ai_layer/engine/lib/libcortex_m_kernels.a delete mode 100644 ai_layer/engine/lib/libcortex_m_ops_lib.a delete mode 100644 ai_layer/engine/lib/libexecutorch.a delete mode 100644 ai_layer/engine/lib/libexecutorch_core.a delete mode 100644 ai_layer/engine/lib/libexecutorch_delegate_ethos_u.a delete mode 100644 ai_layer/engine/lib/libportable_kernels.a delete mode 100644 ai_layer/engine/lib/libportable_ops_lib.a delete mode 100644 ai_layer/engine/lib/libquantized_kernels.a delete mode 100644 ai_layer/engine/lib/libquantized_ops_lib.a delete mode 100644 ai_layer/engine/meta/selected_operators.yaml delete mode 100644 ai_layer/engine/model/ethos_u_minimal_example.pte delete mode 100644 ai_layer/engine/runtime/backend/interface.cpp delete mode 100644 ai_layer/engine/runtime/core/evalue.cpp delete mode 100644 ai_layer/engine/runtime/core/exec_aten/util/tensor_shape_to_c_string.cpp delete mode 100644 ai_layer/engine/runtime/core/exec_aten/util/tensor_util_portable.cpp delete mode 100644 ai_layer/engine/runtime/core/portable_type/tensor_impl.cpp delete mode 100644 ai_layer/engine/runtime/core/tag.cpp delete mode 100644 ai_layer/engine/runtime/core/tensor_layout.cpp delete mode 100644 ai_layer/engine/runtime/executor/method.cpp delete mode 100644 ai_layer/engine/runtime/executor/method_meta.cpp delete mode 100644 ai_layer/engine/runtime/executor/program.cpp delete mode 100644 ai_layer/engine/runtime/executor/pte_data_map.cpp delete mode 100644 ai_layer/engine/runtime/executor/tensor_parser_exec_aten.cpp delete mode 100644 ai_layer/engine/runtime/executor/tensor_parser_portable.cpp delete mode 100644 ai_layer/engine/runtime/kernel/operator_registry.cpp delete mode 100644 ai_layer/engine/runtime/platform/abort.cpp delete mode 100644 ai_layer/engine/runtime/platform/log.cpp delete mode 100644 ai_layer/engine/runtime/platform/platform.cpp delete mode 100644 ai_layer/engine/runtime/platform/profiler.cpp delete mode 100644 ai_layer/engine/runtime/platform/runtime.cpp delete mode 100644 ai_layer/engine/schema/extended_header.cpp delete mode 100644 ai_layer/engine/stage1_source.clayer.yml delete mode 100644 ai_layer/engine/stage2_source.clayer.yml delete mode 100644 ai_layer/logs/build.log delete mode 100644 ai_layer/logs/build_20260127_155447.log delete mode 100644 ai_layer/logs/build_summary.txt delete mode 100644 ai_layer/logs/generate_report.log delete mode 100644 ai_layer/logs/model_conversion.log delete mode 100644 ai_layer/logs/model_to_header.log delete mode 100644 ai_layer/logs/package_artifacts.log delete mode 100644 ai_layer/logs/stage1_build.log delete mode 100644 ai_layer/logs/stage2_build.log rename ai_layer/{ => model}/REPORT.md (100%) delete mode 100644 ai_layer/stubs/posix_stub.cpp delete mode 100644 ai_layer/stubs/random_ops_stubs.cpp diff --git a/ai_layer/ai_layer.clayer.yml b/ai_layer/ai_layer.clayer.yml index 93e9c43d..239e44bd 100644 --- a/ai_layer/ai_layer.clayer.yml +++ b/ai_layer/ai_layer.clayer.yml @@ -1,109 +1,39 @@ layer: - type: AI / Executorch - description: AI layer for ExecuTorch ARM runtime - - packs: - - pack: ARM::CMSIS-NN@7.0.0 + type: AI + description: AI layer using PyTorch ExecuTorch pack - add-path: - # Core ExecuTorch includes - - ./engine/include - - ./engine/include/executorch - - ./engine/include/executorch/runtime - - ./engine/include/executorch/runtime/core - - ./engine/include/executorch/runtime/executor - # - ./engine/include/executorch/runtime/platform - - ./engine/include/executorch/extension - - ./engine/include/executorch/extension/data_loader - - ./engine/include/executorch/extension/memory_allocator - - ./engine/include/executorch/extension/runner_util - - ./engine/include/executorch/util - - ./engine/include/executorch/schema - - ./engine/include/executorch/devtools - - ./engine/include/executorch/devtools/etdump - - # Core C10 includes - - ./engine/include/executorch/runtime/core/portable_type/c10 - - # Kernel and backend includes - - ./engine/include/executorch/kernels - - ./engine/include/executorch/kernels/portable - - ./engine/include/executorch/backends - - ./engine/include/executorch/backends/xnnpack - - ./engine/include/executorch/backends/cortex_m/ops - - # Third party includes - - ./engine/include/third-party - - ./engine/include/third-party/flatbuffers - - ./engine/include/third-party/flatbuffers/include + packs: + - pack: PyTorch::ExecuTorch - # Generated model includes - - ./model + define: + - ET_LOG_ENABLED : 0 components: - - component: CMSIS:NN Lib - + # ExecuTorch core runtime + - component: Machine Learning:ExecuTorch:Runtime + - component: Machine Learning:ExecuTorch:Kernel Utils + - component: Machine Learning:ExecuTorch:Kernel Registration + # Ethos-U NPU backend + - component: Machine Learning:ExecuTorch:Backend EthosU + # Bare-metal PAL stubs (replaces posix.cpp) + - component: Machine Learning:ExecuTorch:Platform Bare-Metal + # Random op stubs (no std::random_device on bare-metal) + - component: Machine Learning:ExecuTorch:Stubs RandomOps + # Portable operators used by the model + - component: Machine Learning:ExecuTorch:Operators Portable add + - component: Machine Learning:ExecuTorch:Operators Portable exp + - component: Machine Learning:ExecuTorch:Operators Portable mul + - component: Machine Learning:ExecuTorch:Operators Portable reciprocal + - component: Machine Learning:ExecuTorch:Operators Portable sigmoid + - component: Machine Learning:ExecuTorch:Operators Portable sum + - component: Machine Learning:ExecuTorch:Operators Portable unsqueeze_copy + # Quantized operators used by the model + - component: Machine Learning:ExecuTorch:Operators Quantized dequantize + - component: Machine Learning:ExecuTorch:Operators Quantized quantize groups: - - # Libraries with kernel registrations need whole-archive to preserve constructors - - group: ExecuTorch Libraries - not-for-context: .Debug-Source - for-compiler: GCC + # AI Model + - group: Executorch Model files: - # Core runtime libraries - - file: ./engine/lib/libexecutorch_core.a - - file: ./engine/lib/libportable_kernels.a - - # ARM Cortex-M optimized kernels - - file: ./engine/lib/libcortex_m_kernels.a - - # Quantized kernels - - file: ./engine/lib/libquantized_kernels.a - - # Libraries requiring whole-archive to preserve constructors/registrations - - file: ./engine/lib/libexecutorch.a - link: whole-archive - - file: ./engine/lib/libportable_ops_lib.a - link: whole-archive - - file: ./engine/lib/libcortex_m_ops_lib.a - link: whole-archive - - file: ./engine/lib/libquantized_ops_lib.a - link: whole-archive - - file: ./engine/lib/libexecutorch_delegate_ethos_u.a - link: whole-archive - - - group: Reports - files: - - file: ./REPORT.md - - # CLANG-specific: Stubs for missing libc++ features (posix_stub only, cxx_stubs is in board layer) - - group: Clang Platform Stubs - for-context: .Debug-Source - for-compiler: - - CLANG - files: - - file: ./stubs/posix_stub.cpp - - file: ./stubs/random_ops_stubs.cpp - - # GCC Debug-Source: Random op stubs (excluded from source build for consistency with Clang) - - group: GCC Random Op Stubs - for-context: .Debug-Source - for-compiler: - - GCC - files: - - file: ./stubs/random_ops_stubs.cpp - - # AC6 Debug-Source: Stubs for missing runtime features - - group: AC6 Platform Stubs - for-context: .Debug-Source - for-compiler: - - AC6 - files: - - file: ./stubs/posix_stub.cpp - - file: ./stubs/random_ops_stubs.cpp - - # Note: GCC could include actual random op sources, but we use stubs for consistency - # The random ops (op_rand.cpp, op_randn.cpp, op_native_dropout.cpp) are excluded from - # stage2 generation because they require std::random_device (not available in Clang) - + - file: ./model/model_pte.h + - file: ./model/REPORT.md diff --git a/ai_layer/engine/backends/arm/runtime/EthosUBackend.cpp b/ai_layer/engine/backends/arm/runtime/EthosUBackend.cpp deleted file mode 100644 index 08589c34..00000000 --- a/ai_layer/engine/backends/arm/runtime/EthosUBackend.cpp +++ /dev/null @@ -1,392 +0,0 @@ -/* - * Copyright 2023-2025 Arm Limited and/or its affiliates. - * - * This source code is licensed under the BSD-style license found in the - * LICENSE file in the root directory of this source tree. - */ - -/* - * Arm backend for Ethos-U baremetal driver stack, this relies on the - * ethos-u-core-driver for hardware interaction. - */ - -#include -#include -#include - -#include - -#if defined(ET_EVENT_TRACER_ENABLED) -#include -#include -using executorch::runtime::EventTracer; -using executorch::runtime::EventTracerEntry; - -class EventTraceScope { - public: - EventTraceScope(EventTracer* event_tracer_, const char* name) { - event_tracer = event_tracer_; - event_tracer_entry_scope = event_tracer->start_profiling(name); - } - ~EventTraceScope() { - event_tracer->end_profiling(event_tracer_entry_scope); - } - - private: - EventTracer* event_tracer; - EventTracerEntry event_tracer_entry_scope; -}; -#define EXECUTORCH_PROF_SCOPE(EVENTTRACER, NAME) \ - EventTraceScope event_tracer_scope = EventTraceScope(EVENTTRACER, NAME) -#define EXECUTORCH_PROF_START(EVENTTRACER, SCOPE, NAME) \ - SCOPE = EVENTTRACER->start_profiling(NAME) -#define EXECUTORCH_PROF_END(EVENTTRACER, SCOPE) \ - EVENTTRACER->end_profiling(SCOPE) - -#else -#define EXECUTORCH_PROF_SCOPE(EVENTTRACER, NAME) -#define EXECUTORCH_PROF_START(EVENTTRACER, SCOPE, NAME) -#define EXECUTORCH_PROF_END(EVENTTRACER, SCOPE) -#endif - -#include -#include -#include -#include -#include -#include - -using namespace std; - -using executorch::aten::ScalarType; -using executorch::runtime::ArrayRef; -using executorch::runtime::Backend; -using executorch::runtime::BackendExecutionContext; -using executorch::runtime::BackendInitContext; -using executorch::runtime::CompileSpec; -using executorch::runtime::DelegateHandle; -using executorch::runtime::Error; -using executorch::runtime::EValue; -using executorch::runtime::FreeableBuffer; -using executorch::runtime::MemoryAllocator; -using executorch::runtime::Result; -using executorch::runtime::Span; - -#define ETHOSU_NUM_BASE_ADDRS 3 - -namespace executorch { -namespace backends { -namespace arm { - -typedef struct { - FreeableBuffer* processed; -} ExecutionHandle; - -extern "C" { -void __attribute__((weak)) EthosUBackend_execute_begin() {} -void __attribute__((weak)) EthosUBackend_execute_end() {} -__attribute__((weak)) unsigned char* ethosu_fast_scratch = nullptr; -__attribute__((weak)) size_t ethosu_fast_scratch_size = 0; -} - -class EthosUBackendExecuteCallbacks { - public: - EthosUBackendExecuteCallbacks() { - EthosUBackend_execute_begin(); - } - ~EthosUBackendExecuteCallbacks() { - EthosUBackend_execute_end(); - } -}; - -class EthosUBackend final : public ::executorch::runtime::BackendInterface { - public: - EthosUBackend() {} - - ~EthosUBackend() = default; - - virtual bool is_available() const override { - // TODO: revise to use a register check/init function - return 1; - } - - Result init( - BackendInitContext& context, - FreeableBuffer* processed, - ArrayRef compile_specs) const override { - ET_LOG(Info, "data:%p", processed->data()); - - const char* data = static_cast(processed->data()); - size_t size = processed->size(); - - // Verify format of vela_bin - if (vela_bin_validate(data, size) == false) { - ET_LOG(Error, "Malformed vela_bin_stream found"); - return Error::InvalidProgram; - } - - MemoryAllocator* allocator = context.get_runtime_allocator(); - ExecutionHandle* handle = allocator->allocateInstance(); - if (handle == nullptr) { - return Error::MemoryAllocationFailed; - } - - handle->processed = processed; - - // Return the same buffer we were passed - this data will be - // executed directly - return handle; - } - - Error execute( - BackendExecutionContext& context, - DelegateHandle* input_handle, - Span args) const override { -#if defined(ET_EVENT_TRACER_ENABLED) - EventTracer* event_tracer = context.event_tracer(); - EventTracerEntry event_tracer_local_scope; -#endif - - EXECUTORCH_PROF_SCOPE(event_tracer, "EthosUBackend::execute()"); - - // CollectArm_CPU_Cycles is just used to save the numbers of CPU cycles - // used, If etdump is used the EXECUTORCH_PROF_SCOPE() above will do the - // same. If not, this is a cheap way of getting some stats and the - // CollectArm_CPU_Cycles object can safely be removed in production code. - // - // The EthosUBackendExecuteCallbacks class uses the C++ - // constructor/destructor to make sure that EthosUBackend_execute_begin() - // and EthosUBackend_execute_end() is called while CollectArm_CPU_Cycles is - // in scope. e.g. We meassure from now until we exit this metod (in any way - // we might do it). - EthosUBackendExecuteCallbacks CollectArm_CPU_Cycles; - - ExecutionHandle* execution_handle = - static_cast(input_handle); - VelaHandles handles; - - // Command stream - we know at this point it's aligned - EXECUTORCH_PROF_START( - event_tracer, - event_tracer_local_scope, - "+EthosUBackend::execute()processed_data"); - const char* data = - static_cast(execution_handle->processed->data()); - EXECUTORCH_PROF_END(event_tracer, event_tracer_local_scope); - - ET_LOG(Debug, "data:%p", data); - - EXECUTORCH_PROF_START( - event_tracer, - event_tracer_local_scope, - "+EthosUBackend::execute()vela_bin_read()"); - // Read key sections from the vela_bin_stream - if (vela_bin_read(data, &handles, execution_handle->processed->size()) == - false) { - ET_LOG(Error, "vela_read: error, invalid binary layout"); - return Error::InvalidProgram; - } - EXECUTORCH_PROF_END(event_tracer, event_tracer_local_scope); - - MemoryAllocator* temp_allocator = context.get_temp_allocator(); - // Use a temporary allocator for the intermediate tensors of the - // computation. The allocator is released in runtime/executor/method.cpp at - // the end of the execution of the Ethos-U custom delegate - // Ethos-U driver requires 16 bit alignment. - char* ethosu_scratch = static_cast( - temp_allocator->allocate(handles.scratch_data_size, 16UL)); - if (ethosu_scratch == nullptr) { - ET_LOG( - Error, - "Failed to allocate scratch buffer of %zu bytes from temp_allocator", - handles.scratch_data_size); - return Error::MemoryAllocationFailed; - } - ET_LOG( - Debug, - "Running program data:\n cmd %p %zu\n weight %p %zu\n scratch %p %zu\n fast scratch %p %zu\n", - handles.cmd_data, - handles.cmd_data_size, - handles.weight_data, - handles.weight_data_size, - ethosu_scratch, - handles.scratch_data_size, - ethosu_fast_scratch, - ethosu_fast_scratch_size); - - // Write argument values (from EValue tensor) into Ethos-U scratch - // TODO(MLETORCH-123): Optimise into direct write from Vela into the SRAM - // or DRAM output for compatible data layouts. - for (int i = 0; i < handles.inputs->count; i++) { - auto tensor_count = 1, io_count = 1; - auto tensor_in = args[i]->toTensor(); - char* scratch_addr = ethosu_scratch + handles.inputs->io[i].offset; - - // We accept: - bool supported = 0; - // 32 bit int (simple non-quantised test cases) - supported |= - (tensor_in.scalar_type() == ScalarType::Int and - handles.inputs->io[i].elem_size == 4); - // 8 bit int (IOQDQ pass prepared networks) - supported |= - (tensor_in.scalar_type() == ScalarType::Char and - handles.inputs->io[i].elem_size == 1); - // 16 bit int (IOQDQ pass prepared networks) - supported |= - (tensor_in.scalar_type() == ScalarType::Short and - handles.inputs->io[i].elem_size == 2); - // bool (IOQDQ pass prepared networks) - supported |= - (tensor_in.scalar_type() == ScalarType::Bool and - handles.inputs->io[i].elem_size == 1); - if (!supported) { - ET_LOG( - Error, - "Input %d expected Integer (4 byte), Char (1 byte) or Bool (1 byte) integer inputs, got ScalarType id %s size %d", - i, - executorch::runtime::toString(tensor_in.scalar_type()), - handles.inputs->io[i].elem_size); - return Error::InvalidProgram; - } - - // Select a compatible copy routine including checking for input layouts - // which require permutation. - bool both_int = tensor_in.scalar_type() == ScalarType::Int && - handles.inputs->io[i].elem_size == 4; - bool both_char = tensor_in.scalar_type() == ScalarType::Char && - handles.inputs->io[i].elem_size == 1; - bool both_short = tensor_in.scalar_type() == ScalarType::Short && - handles.inputs->io[i].elem_size == 2; - bool both_bool = tensor_in.scalar_type() == ScalarType::Bool && - (handles.inputs->io[i].elem_size == 1); - - if (both_char || both_int || both_short || both_bool) { - EXECUTORCH_PROF_SCOPE( - event_tracer, "+EthosUBackend::execute()handles.input.memcpy()"); - // Sizes match and elt size matches so memcpy - memcpy( - scratch_addr, - tensor_in.mutable_data_ptr(), - tensor_in.nbytes()); - } else { - ET_LOG(Error, "No matching input copy routine"); - return Error::InvalidProgram; - } - calculate_dimensions( - tensor_in, &handles.inputs->io[i], &tensor_count, &io_count); - if (tensor_count != io_count) { - ET_LOG(Error, "Input tensor sizes do not match"); - ET_LOG( - Error, - "Program expects %d elements but got %d", - io_count, - tensor_count); - return Error::InvalidProgram; - } - } - - // Allocate driver handle and synchronously invoke driver - auto driver = - std::unique_ptr( - ethosu_reserve_driver(), ethosu_release_driver); - if (driver == NULL) { - ET_LOG(Error, "ethosu_reserve_driver failed"); - return Error::InvalidState; - } - - // Ethos-U low level driver expected order for Ethos U-55, we have - // constant weight data, then scratch (which contains input and output) - // scratch is written above in this function. - - uint64_t bases[ETHOSU_NUM_BASE_ADDRS] = { - static_cast( - reinterpret_cast((handles.weight_data))), - static_cast(reinterpret_cast(ethosu_scratch)), - static_cast( - reinterpret_cast(ethosu_fast_scratch))}; - size_t bases_size[ETHOSU_NUM_BASE_ADDRS] = { - handles.weight_data_size, - handles.scratch_data_size, - ethosu_fast_scratch_size}; - int result = 0; - EXECUTORCH_PROF_START( - event_tracer, event_tracer_local_scope, "+EthosUBackend::execute()NPU"); - result = ethosu_invoke_v3( - driver.get(), - static_cast(handles.cmd_data), - handles.cmd_data_size, - bases, - bases_size, - ETHOSU_NUM_BASE_ADDRS, /* fixed array of pointers to binary interface*/ - nullptr); - EXECUTORCH_PROF_END(event_tracer, event_tracer_local_scope); - - if (result != 0) { - ET_LOG(Error, "Ethos-U invocation failed error (%d)", result); - return Error::InvalidProgram; - } - int tensor_dim = 0, io_dim = 0; - // Write outputs from scratch into EValue pointers - for (int i = 0; i < handles.outputs->count; i++) { - int tensor_count = 1, io_count = 1; - const char* output_addr = ethosu_scratch + handles.outputs->io[i].offset; - // Process input EValue into scratch - // Outputs are in the index immediately after inputs - auto tensor_out = args[handles.inputs->count + i]->toTensor(); - - calculate_dimensions( - tensor_out, &handles.outputs->io[i], &tensor_count, &io_count); - - // At times the topological order of the outputs may change. - // Lets instead ensure that the sum of dimensions match. - tensor_dim = tensor_dim + tensor_count; - io_dim = io_dim + io_count; - - EXECUTORCH_PROF_SCOPE( - event_tracer, "+EthosUBackend::execute()handles.output.memcpy()"); - - memcpy( - tensor_out.mutable_data_ptr(), - static_cast(output_addr), - tensor_out.nbytes()); - } - if (tensor_dim != io_dim) { - ET_LOG(Error, "Total output tensor sizes do not match"); - ET_LOG( - Error, "Program expects size of %d but got %d", tensor_dim, io_dim); - return Error::InvalidProgram; - } - return Error::Ok; - } - - void destroy(DelegateHandle* handle) const override { - return; - } - - private: - void calculate_dimensions( - const executorch::aten::Tensor tensor, - VelaIO* io, - int* tensor_count, - int* io_count) const { - for (int i = 0; i < tensor.dim(); i++) { - *tensor_count = *tensor_count * tensor.size(i); - } - - // The VelaIO type has a shape of fixed size 6 - for (int i = 0; i < shapeDim; i++) { - *io_count = *io_count * io->shape[i]; - } - } -}; - -namespace { -auto backend = EthosUBackend(); -Backend backend_id{"EthosUBackend", &backend}; -static auto registered = register_backend(backend_id); -} // namespace - -} // namespace arm -} // namespace backends -} // namespace executorch \ No newline at end of file diff --git a/ai_layer/engine/backends/arm/runtime/VelaBinStream.cpp b/ai_layer/engine/backends/arm/runtime/VelaBinStream.cpp deleted file mode 100644 index c8d56849..00000000 --- a/ai_layer/engine/backends/arm/runtime/VelaBinStream.cpp +++ /dev/null @@ -1,104 +0,0 @@ -/* - * Copyright 2023, 2025 Arm Limited and/or its affiliates. - * - * This source code is licensed under the BSD-style license found in the - * LICENSE file in the root directory of this source tree. - */ - -/* - * Warning: Do not change this without changing arm_vela.py::vela_compile - * as that function emits this format and the two need to align. - */ - -#include - -#include - -#include - -namespace executorch { -namespace backends { -namespace arm { - -// get next mul of 16 ptr, return n if already aligned -static uintptr_t next_mul_16(uintptr_t n) { - return ((n - 1) | 15) + 1; -} - -bool vela_bin_validate(const char* data, int size) { - const char* foot = data + size - sizeof(VelaBinBlock); - - // Check 16 byte alignment - bool valid = true; - if ((uintptr_t)data != next_mul_16((uintptr_t)data)) { - ET_LOG(Error, "Vela bin ptr not aligned to 16 bytes: %p", data); - valid = false; - } - if ((uintptr_t)foot != next_mul_16((uintptr_t)foot)) { - ET_LOG(Error, "End of vela bin not aligned to 16 bytes: %p", foot); - valid = false; - } - // Check header and footer blocks are the right format - if (strncmp(data, "vela_bin_stream", strlen("vela_bin_stream")) != 0) { - ET_LOG(Error, "Incorrect header in vela_bin_stream"); - valid = false; - } - if (strncmp(foot, "vela_end_stream", strlen("vela_end_stream")) != 0) { - ET_LOG(Error, "Incorrect footer in vela_bin_stream"); - valid = false; - } - - return valid; -} - -bool vela_bin_read(const char* data, VelaHandles* handles, int size) { - const char* ptr = data; - - while (ptr - data < size) { - VelaBinBlock* b = reinterpret_cast(const_cast(ptr)); - ptr += sizeof(VelaBinBlock) + next_mul_16(b->size); - - if (!strncmp(b->name, "vela_bin_stream", strlen("vela_bin_stream"))) { - // expect vela_bin_stream first - if (reinterpret_cast(b) != - reinterpret_cast(const_cast(data))) - return false; - } else if (!strncmp(b->name, "cmd_data", strlen("cmd_data"))) { - // This driver magic header confirms a valid command stream in binary - if (strncmp(b->data, "COP1", strlen("COP1"))) - return false; - handles->cmd_data = b->data; - handles->cmd_data_size = b->size; - } else if (!strncmp(b->name, "weight_data", strlen("weight_data"))) { - handles->weight_data = b->data; - handles->weight_data_size = b->size; - } else if (!strncmp(b->name, "scratch_size", strlen("scratch_size"))) { - const uint32_t* scratch_size_ptr = - reinterpret_cast(b->data); - handles->scratch_data_size = *scratch_size_ptr; - } else if (!strncmp(b->name, "inputs", strlen("inputs"))) { - handles->inputs = reinterpret_cast(b->data); - } else if (!strncmp(b->name, "outputs", strlen("outputs"))) { - handles->outputs = reinterpret_cast(b->data); - } else if (!strncmp( - b->name, "vela_end_stream", strlen("vela_end_stream"))) { - // expect vela_end_stream last - if (ptr - data != size) { - ET_LOG(Error, "Expected vela binary to end with vela_end_stream"); - return false; - } - return true; - } else { - // Unrecognised block name - ET_LOG(Error, "Invalid block name or malformed binary"); - return false; - } - } - - // We've fallen off the end without finding vela_end_stream - return false; -} - -} // namespace arm -} // namespace backends -} // namespace executorch diff --git a/ai_layer/engine/backends/cortex_m/cortex_m_ops_lib/CustomOpsNativeFunctions.h b/ai_layer/engine/backends/cortex_m/cortex_m_ops_lib/CustomOpsNativeFunctions.h deleted file mode 100644 index 4856b542..00000000 --- a/ai_layer/engine/backends/cortex_m/cortex_m_ops_lib/CustomOpsNativeFunctions.h +++ /dev/null @@ -1,26 +0,0 @@ -/* - * Copyright (c) Meta Platforms, Inc. and affiliates. - * All rights reserved. - * - * This source code is licensed under the BSD-style license found in the - * LICENSE file in the root directory of this source tree. - */ - -// clang-format off -#pragma once - -#include - -#include -#include - -// @generated by gen.py from NativeFunctions.h - -namespace cortex_m { -namespace native { -TORCH_API at::Tensor & quantize_per_tensor_out(const at::Tensor & input, double scale, int64_t zero_point, int64_t quant_min, int64_t quant_max, at::ScalarType dtype, at::Tensor & out); -TORCH_API at::Tensor & dequantize_per_tensor_out(const at::Tensor & input, double scale, int64_t zero_point, int64_t quant_min, int64_t quant_max, at::ScalarType dtype, at::Tensor & out); -TORCH_API at::Tensor quantized_add(const at::Tensor & self, const at::Scalar & self_zero_point, const at::Scalar & self_multiplier, const at::Scalar & self_shift, const at::Tensor & other, const at::Scalar & other_zero_point, const at::Scalar & other_multiplier, const at::Scalar & other_shift, const at::Scalar & output_zero_point, const at::Scalar & output_multiplier, const at::Scalar & output_shift); -TORCH_API at::Tensor & quantized_add_out(const at::Tensor & self, const at::Scalar & self_zero_point, const at::Scalar & self_multiplier, const at::Scalar & self_shift, const at::Tensor & other, const at::Scalar & other_zero_point, const at::Scalar & other_multiplier, const at::Scalar & other_shift, const at::Scalar & output_zero_point, const at::Scalar & output_multiplier, const at::Scalar & output_shift, at::Tensor & out); -} // namespace native -} // namespace cortex_m diff --git a/ai_layer/engine/backends/cortex_m/cortex_m_ops_lib/Functions.h b/ai_layer/engine/backends/cortex_m/cortex_m_ops_lib/Functions.h deleted file mode 100644 index 87dc9793..00000000 --- a/ai_layer/engine/backends/cortex_m/cortex_m_ops_lib/Functions.h +++ /dev/null @@ -1,54 +0,0 @@ -/* - * Copyright (c) Meta Platforms, Inc. and affiliates. - * All rights reserved. - * - * This source code is licensed under the BSD-style license found in the - * LICENSE file in the root directory of this source tree. - */ - -// clang-format off -#pragma once - -#include - -#include // at::Tensor etc. -#include // TORCH_API -#include - -// @generated by gen.py from Functions.h - -#include "NativeFunctions.h" - -namespace torch { -namespace executor { - - -namespace cortex_m { - -// cortex_m::quantize_per_tensor.out(Tensor input, float scale, int zero_point, int quant_min, int quant_max, ScalarType dtype, *, Tensor(a!) out) -> Tensor(a!) -TORCH_API inline torch::executor::Tensor & quantize_per_tensor_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & input, double scale, int64_t zero_point, int64_t quant_min, int64_t quant_max, torch::executor::ScalarType dtype, torch::executor::Tensor & out) { - return ::cortex_m::native::quantize_per_tensor_out(context, input, scale, zero_point, quant_min, quant_max, dtype, out); -} - - -// cortex_m::dequantize_per_tensor.out(Tensor input, float scale, int zero_point, int quant_min, int quant_max, ScalarType dtype, *, Tensor(a!) out) -> Tensor(a!) -TORCH_API inline torch::executor::Tensor & dequantize_per_tensor_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & input, double scale, int64_t zero_point, int64_t quant_min, int64_t quant_max, torch::executor::ScalarType dtype, torch::executor::Tensor & out) { - return ::cortex_m::native::dequantize_per_tensor_out(context, input, scale, zero_point, quant_min, quant_max, dtype, out); -} - - -// cortex_m::quantized_add(Tensor self, Scalar self_zero_point, Scalar self_multiplier, Scalar self_shift, Tensor other, Scalar other_zero_point, Scalar other_multiplier, Scalar other_shift, Scalar output_zero_point, Scalar output_multiplier, Scalar output_shift) -> Tensor -TORCH_API inline torch::executor::Tensor quantized_add(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & self_zero_point, const torch::executor::Scalar & self_multiplier, const torch::executor::Scalar & self_shift, const torch::executor::Tensor & other, const torch::executor::Scalar & other_zero_point, const torch::executor::Scalar & other_multiplier, const torch::executor::Scalar & other_shift, const torch::executor::Scalar & output_zero_point, const torch::executor::Scalar & output_multiplier, const torch::executor::Scalar & output_shift) { - return ::cortex_m::native::quantized_add(context, self, self_zero_point, self_multiplier, self_shift, other, other_zero_point, other_multiplier, other_shift, output_zero_point, output_multiplier, output_shift); -} - - -// cortex_m::quantized_add.out(Tensor self, Scalar self_zero_point, Scalar self_multiplier, Scalar self_shift, Tensor other, Scalar other_zero_point, Scalar other_multiplier, Scalar other_shift, Scalar output_zero_point, Scalar output_multiplier, Scalar output_shift, *, Tensor(a!) out) -> Tensor(a!) -TORCH_API inline torch::executor::Tensor & quantized_add_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & self_zero_point, const torch::executor::Scalar & self_multiplier, const torch::executor::Scalar & self_shift, const torch::executor::Tensor & other, const torch::executor::Scalar & other_zero_point, const torch::executor::Scalar & other_multiplier, const torch::executor::Scalar & other_shift, const torch::executor::Scalar & output_zero_point, const torch::executor::Scalar & output_multiplier, const torch::executor::Scalar & output_shift, torch::executor::Tensor & out) { - return ::cortex_m::native::quantized_add_out(context, self, self_zero_point, self_multiplier, self_shift, other, other_zero_point, other_multiplier, other_shift, output_zero_point, output_multiplier, output_shift, out); -} - -} // namespace cortex_m - -} // namespace executor -} // namespace torch diff --git a/ai_layer/engine/backends/cortex_m/cortex_m_ops_lib/NativeFunctions.h b/ai_layer/engine/backends/cortex_m/cortex_m_ops_lib/NativeFunctions.h deleted file mode 100644 index ee55797a..00000000 --- a/ai_layer/engine/backends/cortex_m/cortex_m_ops_lib/NativeFunctions.h +++ /dev/null @@ -1,31 +0,0 @@ -/* - * Copyright (c) Meta Platforms, Inc. and affiliates. - * All rights reserved. - * - * This source code is licensed under the BSD-style license found in the - * LICENSE file in the root directory of this source tree. - */ - -// clang-format off -#pragma once - -#include - -#include // at::Tensor etc. -#include -#include - -// @generated by gen.py from NativeFunctions.h - -namespace cortex_m { -namespace native { -torch::executor::Tensor & quantize_per_tensor_out(const torch::executor::Tensor & input, double scale, int64_t zero_point, int64_t quant_min, int64_t quant_max, torch::executor::ScalarType dtype, torch::executor::Tensor & out); -torch::executor::Tensor & quantize_per_tensor_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & input, double scale, int64_t zero_point, int64_t quant_min, int64_t quant_max, torch::executor::ScalarType dtype, torch::executor::Tensor & out); -torch::executor::Tensor & dequantize_per_tensor_out(const torch::executor::Tensor & input, double scale, int64_t zero_point, int64_t quant_min, int64_t quant_max, torch::executor::ScalarType dtype, torch::executor::Tensor & out); -torch::executor::Tensor & dequantize_per_tensor_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & input, double scale, int64_t zero_point, int64_t quant_min, int64_t quant_max, torch::executor::ScalarType dtype, torch::executor::Tensor & out); -torch::executor::Tensor quantized_add(const torch::executor::Tensor & self, const torch::executor::Scalar & self_zero_point, const torch::executor::Scalar & self_multiplier, const torch::executor::Scalar & self_shift, const torch::executor::Tensor & other, const torch::executor::Scalar & other_zero_point, const torch::executor::Scalar & other_multiplier, const torch::executor::Scalar & other_shift, const torch::executor::Scalar & output_zero_point, const torch::executor::Scalar & output_multiplier, const torch::executor::Scalar & output_shift); -torch::executor::Tensor quantized_add(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & self_zero_point, const torch::executor::Scalar & self_multiplier, const torch::executor::Scalar & self_shift, const torch::executor::Tensor & other, const torch::executor::Scalar & other_zero_point, const torch::executor::Scalar & other_multiplier, const torch::executor::Scalar & other_shift, const torch::executor::Scalar & output_zero_point, const torch::executor::Scalar & output_multiplier, const torch::executor::Scalar & output_shift); -torch::executor::Tensor & quantized_add_out(const torch::executor::Tensor & self, const torch::executor::Scalar & self_zero_point, const torch::executor::Scalar & self_multiplier, const torch::executor::Scalar & self_shift, const torch::executor::Tensor & other, const torch::executor::Scalar & other_zero_point, const torch::executor::Scalar & other_multiplier, const torch::executor::Scalar & other_shift, const torch::executor::Scalar & output_zero_point, const torch::executor::Scalar & output_multiplier, const torch::executor::Scalar & output_shift, torch::executor::Tensor & out); -torch::executor::Tensor & quantized_add_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & self_zero_point, const torch::executor::Scalar & self_multiplier, const torch::executor::Scalar & self_shift, const torch::executor::Tensor & other, const torch::executor::Scalar & other_zero_point, const torch::executor::Scalar & other_multiplier, const torch::executor::Scalar & other_shift, const torch::executor::Scalar & output_zero_point, const torch::executor::Scalar & output_multiplier, const torch::executor::Scalar & output_shift, torch::executor::Tensor & out); -} // namespace native -} // namespace cortex_m diff --git a/ai_layer/engine/backends/cortex_m/cortex_m_ops_lib/RegisterCodegenUnboxedKernelsEverything.cpp b/ai_layer/engine/backends/cortex_m/cortex_m_ops_lib/RegisterCodegenUnboxedKernelsEverything.cpp deleted file mode 100644 index 3c121a47..00000000 --- a/ai_layer/engine/backends/cortex_m/cortex_m_ops_lib/RegisterCodegenUnboxedKernelsEverything.cpp +++ /dev/null @@ -1,186 +0,0 @@ -/* - * Copyright (c) Meta Platforms, Inc. and affiliates. - * All rights reserved. - * - * This source code is licensed under the BSD-style license found in the - * LICENSE file in the root directory of this source tree. - */ - -#include -#include -#include -#include -#include -#include -#include "NativeFunctions.h" // Generated Function import headers -// @generated by gen.py from RegisterCodegenUnboxedKernels.cpp - -// NOTE [Sharded File]: This file is generated in a sharded fashion to speed up -// incremental rebuilds. See the comment at the top of -// templates/VariableType.cpp for an analogous, in-depth discussion. -// -// Generated by tools/jit/gen_unboxing.py. This file registers all ATen ops into -// JIT op registry instead of c10 dispatcher. JIT op registry only takes boxed -// kernels, so we are calling unboxing functions in UnboxingFunctions.h to cast -// arguments into C++ types (instead of IValue) and delegate to unboxed kernels. -using KernelSpan = ::executorch::runtime::Span< - const ::executorch::ET_RUNTIME_NAMESPACE::Kernel>; -namespace torch { -namespace executor { -namespace function { -namespace { - -static Kernel kernels_to_register[] = { - - Kernel( - "cortex_m::quantize_per_tensor.out", - [](torch::executor::KernelRuntimeContext & context, Span stack) { - ET_KERNEL_CHECK_MSG(context, stack.size() == 8, InvalidProgram, /*void*/, "Expected %" ET_PRIsize_t "args received %" ET_PRIsize_t, (size_t)8, stack.size()); - EValue& input = *stack[0]; - EValue& scale = *stack[1]; - EValue& zero_point = *stack[2]; - EValue& quant_min = *stack[3]; - EValue& quant_max = *stack[4]; - EValue& dtype = *stack[5]; - EValue& out = *stack[6]; - const torch::executor::Tensor & input_base = input.to(); - double scale_base = scale.to(); - int64_t zero_point_base = zero_point.to(); - int64_t quant_min_base = quant_min.to(); - int64_t quant_max_base = quant_max.to(); - torch::executor::ScalarType dtype_base = dtype.to(); - torch::executor::Tensor & out_base = out.to(); - - - internal::EventTracerProfileOpScope event_tracer_op_scope(context.internal_event_tracer(), "native_call_quantize_per_tensor.out"); - EXECUTORCH_SCOPE_PROF("native_call_quantize_per_tensor.out"); - cortex_m::native::quantize_per_tensor_out(context, input_base, scale_base, zero_point_base, quant_min_base, quant_max_base, dtype_base, out_base); - internal::event_tracer_log_evalue(context.internal_event_tracer(), *stack[6]); - - - - } - ), - - Kernel( - "cortex_m::dequantize_per_tensor.out", - [](torch::executor::KernelRuntimeContext & context, Span stack) { - ET_KERNEL_CHECK_MSG(context, stack.size() == 8, InvalidProgram, /*void*/, "Expected %" ET_PRIsize_t "args received %" ET_PRIsize_t, (size_t)8, stack.size()); - EValue& input = *stack[0]; - EValue& scale = *stack[1]; - EValue& zero_point = *stack[2]; - EValue& quant_min = *stack[3]; - EValue& quant_max = *stack[4]; - EValue& dtype = *stack[5]; - EValue& out = *stack[6]; - const torch::executor::Tensor & input_base = input.to(); - double scale_base = scale.to(); - int64_t zero_point_base = zero_point.to(); - int64_t quant_min_base = quant_min.to(); - int64_t quant_max_base = quant_max.to(); - torch::executor::ScalarType dtype_base = dtype.to(); - torch::executor::Tensor & out_base = out.to(); - - - internal::EventTracerProfileOpScope event_tracer_op_scope(context.internal_event_tracer(), "native_call_dequantize_per_tensor.out"); - EXECUTORCH_SCOPE_PROF("native_call_dequantize_per_tensor.out"); - cortex_m::native::dequantize_per_tensor_out(context, input_base, scale_base, zero_point_base, quant_min_base, quant_max_base, dtype_base, out_base); - internal::event_tracer_log_evalue(context.internal_event_tracer(), *stack[6]); - - - - } - ), - - Kernel( - "cortex_m::quantized_add", - [](torch::executor::KernelRuntimeContext & context, Span stack) { - ET_KERNEL_CHECK_MSG(context, stack.size() == 12, InvalidProgram, /*void*/, "Expected %" ET_PRIsize_t "args received %" ET_PRIsize_t, (size_t)12, stack.size()); - EValue& self = *stack[0]; - EValue& self_zero_point = *stack[1]; - EValue& self_multiplier = *stack[2]; - EValue& self_shift = *stack[3]; - EValue& other = *stack[4]; - EValue& other_zero_point = *stack[5]; - EValue& other_multiplier = *stack[6]; - EValue& other_shift = *stack[7]; - EValue& output_zero_point = *stack[8]; - EValue& output_multiplier = *stack[9]; - EValue& output_shift = *stack[10]; - const torch::executor::Tensor & self_base = self.to(); - const torch::executor::Scalar & self_zero_point_base = self_zero_point.to(); - const torch::executor::Scalar & self_multiplier_base = self_multiplier.to(); - const torch::executor::Scalar & self_shift_base = self_shift.to(); - const torch::executor::Tensor & other_base = other.to(); - const torch::executor::Scalar & other_zero_point_base = other_zero_point.to(); - const torch::executor::Scalar & other_multiplier_base = other_multiplier.to(); - const torch::executor::Scalar & other_shift_base = other_shift.to(); - const torch::executor::Scalar & output_zero_point_base = output_zero_point.to(); - const torch::executor::Scalar & output_multiplier_base = output_multiplier.to(); - const torch::executor::Scalar & output_shift_base = output_shift.to(); - - - internal::EventTracerProfileOpScope event_tracer_op_scope(context.internal_event_tracer(), "native_call_quantized_add"); - EXECUTORCH_SCOPE_PROF("native_call_quantized_add"); - torch::executor::Tensor result_ = cortex_m::native::quantized_add(context, self_base, self_zero_point_base, self_multiplier_base, self_shift_base, other_base, other_zero_point_base, other_multiplier_base, other_shift_base, output_zero_point_base, output_multiplier_base, output_shift_base); - internal::event_tracer_log_evalue(context.internal_event_tracer(), *stack[11]); - - *stack[11] = EValue(result_); - - } - ), - - Kernel( - "cortex_m::quantized_add.out", - [](torch::executor::KernelRuntimeContext & context, Span stack) { - ET_KERNEL_CHECK_MSG(context, stack.size() == 13, InvalidProgram, /*void*/, "Expected %" ET_PRIsize_t "args received %" ET_PRIsize_t, (size_t)13, stack.size()); - EValue& self = *stack[0]; - EValue& self_zero_point = *stack[1]; - EValue& self_multiplier = *stack[2]; - EValue& self_shift = *stack[3]; - EValue& other = *stack[4]; - EValue& other_zero_point = *stack[5]; - EValue& other_multiplier = *stack[6]; - EValue& other_shift = *stack[7]; - EValue& output_zero_point = *stack[8]; - EValue& output_multiplier = *stack[9]; - EValue& output_shift = *stack[10]; - EValue& out = *stack[11]; - const torch::executor::Tensor & self_base = self.to(); - const torch::executor::Scalar & self_zero_point_base = self_zero_point.to(); - const torch::executor::Scalar & self_multiplier_base = self_multiplier.to(); - const torch::executor::Scalar & self_shift_base = self_shift.to(); - const torch::executor::Tensor & other_base = other.to(); - const torch::executor::Scalar & other_zero_point_base = other_zero_point.to(); - const torch::executor::Scalar & other_multiplier_base = other_multiplier.to(); - const torch::executor::Scalar & other_shift_base = other_shift.to(); - const torch::executor::Scalar & output_zero_point_base = output_zero_point.to(); - const torch::executor::Scalar & output_multiplier_base = output_multiplier.to(); - const torch::executor::Scalar & output_shift_base = output_shift.to(); - torch::executor::Tensor & out_base = out.to(); - - - internal::EventTracerProfileOpScope event_tracer_op_scope(context.internal_event_tracer(), "native_call_quantized_add.out"); - EXECUTORCH_SCOPE_PROF("native_call_quantized_add.out"); - cortex_m::native::quantized_add_out(context, self_base, self_zero_point_base, self_multiplier_base, self_shift_base, other_base, other_zero_point_base, other_multiplier_base, other_shift_base, output_zero_point_base, output_multiplier_base, output_shift_base, out_base); - internal::event_tracer_log_evalue(context.internal_event_tracer(), *stack[11]); - - - - } - ), // Generated kernels -}; - -// Explicitly convert to Span, so that the API can take an empty C array of -// Kernels. -static KernelSpan kernel_span( - kernels_to_register, - kernels_to_register + sizeof(kernels_to_register) / sizeof(Kernel)); - -// Return value not used. Keep the static variable assignment to register -// kernels in static initialization time. -static auto success_with_kernel_reg = register_kernels(kernel_span); -} // namespace -} // namespace function -} // namespace executor -} // namespace torch diff --git a/ai_layer/engine/backends/cortex_m/ops/op_dequantize_per_tensor.cpp b/ai_layer/engine/backends/cortex_m/ops/op_dequantize_per_tensor.cpp deleted file mode 100644 index d598ab2f..00000000 --- a/ai_layer/engine/backends/cortex_m/ops/op_dequantize_per_tensor.cpp +++ /dev/null @@ -1,196 +0,0 @@ -/* - * Copyright (c) Meta Platforms, Inc. and affiliates. - * All rights reserved. - * - * This source code is licensed under the BSD-style license found in the - * LICENSE file in the root directory of this source tree. - */ - -#include -#include - -// Check for Helium/MVE support -#if defined(__ARM_FEATURE_MVE) && (__ARM_FEATURE_MVE & 1) -#include -#define HAS_HELIUM_SIMD 1 -#endif - -namespace cortex_m { -namespace native { - -using Tensor = executorch::aten::Tensor; -using ScalarType = executorch::aten::ScalarType; -using KernelRuntimeContext = torch::executor::KernelRuntimeContext; - -namespace { - -/** - * Asserts that the parameters are valid for float to int8 quantization. - */ -void check_dequantize_args( - const Tensor& input, - int64_t zero_point, - int64_t quant_min, - int64_t quant_max, - ScalarType dtype, - Tensor& out) { - // Ensure input is char type - ET_CHECK_MSG( - input.scalar_type() == ScalarType::Char, - "input.scalar_type() %" PRId8 " is not char type", - static_cast(input.scalar_type())); - - // Check zp range - ET_CHECK_MSG( - zero_point >= quant_min, - "zero_point must be %" PRId64 " <= quant_min %" PRId64, - zero_point, - quant_min); - ET_CHECK_MSG( - zero_point <= quant_max, - "zero_point must be %" PRId64 " >= quant_max %" PRId64, - zero_point, - quant_max); - - // Check output dtype is float - ET_CHECK_MSG( - out.scalar_type() == ScalarType::Float, - "out.scalar_type() %" PRId8 " is not float", - static_cast(out.scalar_type())); - - // Check dtype is int8 (Char) - ET_CHECK_MSG( - dtype == ScalarType::Char, - "dtype %" PRId8 " is not int8 (Char)", - static_cast(dtype)); - - // Validate quant_min and quant_max for int8 - int32_t quant_min_lower_bound = std::numeric_limits::min(); - int32_t quant_max_upper_bound = std::numeric_limits::max(); - - ET_CHECK_MSG( - quant_min >= quant_min_lower_bound, - "quant_min out of bound for int8, expected quant_min_lower_bound: %" PRId32 - " actual quant_min: %" PRId64, - quant_min_lower_bound, - quant_min); - - ET_CHECK_MSG( - quant_max <= quant_max_upper_bound, - "quant_max out of bound for int8, expected quant_max_upper_bound: %" PRId32 - " actual quant_max: %" PRId64, - quant_max_upper_bound, - quant_max); -} - -/** - * Scalar implementation of quantization for a single value. - */ -template -F dequantize_val(float scale, int32_t zero_point, Q qvalue) { - return static_cast((static_cast(qvalue) - zero_point) * scale); -} -} // namespace - -Tensor& dequantize_per_tensor_out( - KernelRuntimeContext& context, - const Tensor& input, - double scale, - int64_t zero_point, - int64_t quant_min, - int64_t quant_max, - ScalarType dtype, - Tensor& out) { - // Ignore context for now - (void)context; - - // Resize output tensor to match input dimensions - torch::executor::Error err = resize_tensor(out, input.sizes()); - ET_CHECK_MSG( - err == torch::executor::Error::Ok, - "Failed to resize out Tensor in dequantize_per_tensor_out"); - - // Validate input parameters - check_dequantize_args(input, zero_point, quant_min, quant_max, dtype, out); - - int32_t zp = static_cast(zero_point); - - // Get pointers to input and output data - const int8_t* input_data = input.const_data_ptr(); - float* out_data = out.mutable_data_ptr(); - const size_t numel = input.numel(); - - size_t i = 0; -#if defined(HAS_HELIUM_SIMD) - // Helium MVE implementation for int8 to float quantization - static uint8x16_t voffset{ - 0x0, - 0x8, - 0x4, - 0xC, - 0x1, - 0x9, - 0x5, - 0xD, - 0x2, - 0xA, - 0x6, - 0xE, - 0x3, - 0xB, - 0x7, - 0xF}; - - int16x8_t vzp = vdupq_n_s16(static_cast(zp)); - float32x4_t vscale = vdupq_n_f32(static_cast(scale)); - - for (; i + 15 < numel; i += 16) { - int8x16_t in_084C195D2A6E3B7F = - vldrbq_gather_offset_s8(input_data, voffset); - - int16x8_t in_04152637 = vsubq_s16(vmovlbq_s8(in_084C195D2A6E3B7F), vzp); - int16x8_t in_8C9DAEBF = vsubq_s16(vmovltq_s8(in_084C195D2A6E3B7F), vzp); - - float32x4_t inf_0123 = vcvtq_f32_s32(vmovlbq_s16(in_04152637)); - float32x4_t inf_4567 = vcvtq_f32_s32(vmovltq_s16(in_04152637)); - float32x4_t inf_89AB = vcvtq_f32_s32(vmovlbq_s16(in_8C9DAEBF)); - float32x4_t inf_CDEF = vcvtq_f32_s32(vmovltq_s16(in_8C9DAEBF)); - - float32x4_t out_0123 = vmulq_f32(inf_0123, vscale); - float32x4_t out_4567 = vmulq_f32(inf_4567, vscale); - float32x4_t out_89AB = vmulq_f32(inf_89AB, vscale); - float32x4_t out_CDEF = vmulq_f32(inf_CDEF, vscale); - - vstrwq_f32(out_data + 0, out_0123); - vstrwq_f32(out_data + 4, out_4567); - vstrwq_f32(out_data + 8, out_89AB); - vstrwq_f32(out_data + 12, out_CDEF); - - input_data += 16; - out_data += 16; - } -#endif // defined(HAS_HELIUM_SIMD) - - for (; i < numel; i++) { - *out_data = dequantize_val(scale, zp, *input_data); - input_data++; - out_data++; - } - return out; -} - -Tensor& dequantize_per_tensor_out( - const Tensor& input, - double scale, - int64_t zero_point, - int64_t quant_min, - int64_t quant_max, - ScalarType dtype, - Tensor& out) { - KernelRuntimeContext context; - return dequantize_per_tensor_out( - context, input, scale, zero_point, quant_min, quant_max, dtype, out); -} - -} // namespace native -} // namespace cortex_m diff --git a/ai_layer/engine/backends/cortex_m/ops/op_quantize_per_tensor.cpp b/ai_layer/engine/backends/cortex_m/ops/op_quantize_per_tensor.cpp deleted file mode 100644 index d92d2666..00000000 --- a/ai_layer/engine/backends/cortex_m/ops/op_quantize_per_tensor.cpp +++ /dev/null @@ -1,235 +0,0 @@ -/* - * Copyright (c) Meta Platforms, Inc. and affiliates. - * All rights reserved. - * - * This source code is licensed under the BSD-style license found in the - * LICENSE file in the root directory of this source tree. - */ - -#include -#include -#include -#include - -// Check for Helium/MVE support -#if defined(__ARM_FEATURE_MVE) && (__ARM_FEATURE_MVE & 1) -#include -#define HAS_HELIUM_SIMD 1 -#endif - -namespace cortex_m { -namespace native { - -using Tensor = executorch::aten::Tensor; -using ScalarType = executorch::aten::ScalarType; -using KernelRuntimeContext = torch::executor::KernelRuntimeContext; - -namespace { - -/** - * Asserts that the parameters are valid for float to int8 quantization. - */ -void check_quantize_args( - const Tensor& input, - int64_t quant_min, - int64_t quant_max, - ScalarType dtype, - Tensor& out) { - // Ensure input is float type - ET_CHECK_MSG( - input.scalar_type() == ScalarType::Float, - "input.scalar_type() %" PRId8 " is not float type", - static_cast(input.scalar_type())); - - // Check output dtype is int8 - ET_CHECK_MSG( - out.scalar_type() == ScalarType::Char, - "out.scalar_type() %" PRId8 " is not int8 (Char)", - static_cast(out.scalar_type())); - - // Check dtype is int8 - ET_CHECK_MSG( - dtype == ScalarType::Char, - "dtype %" PRId8 " is not int8 (Char)", - static_cast(dtype)); - - // Validate quant_min and quant_max for int8 - int32_t quant_min_lower_bound = std::numeric_limits::min(); - int32_t quant_max_upper_bound = std::numeric_limits::max(); - - ET_CHECK_MSG( - quant_min >= quant_min_lower_bound, - "quant_min out of bound for int8, expected quant_min_lower_bound: %" PRId32 - " actual quant_min: %" PRId64, - quant_min_lower_bound, - quant_min); - - ET_CHECK_MSG( - quant_max <= quant_max_upper_bound, - "quant_max out of bound for int8, expected quant_max_upper_bound: %" PRId32 - " actual quant_max: %" PRId64, - quant_max_upper_bound, - quant_max); -} - -/** - * Scalar implementation of quantization for a single value. - */ -template -Q quantize_val( - F inv_scale, - int32_t zero_point, - F value, - int64_t quant_min, - int64_t quant_max) { - int32_t qvalue = - zero_point + static_cast(std::nearbyint(inv_scale * value)); - qvalue = std::max(qvalue, static_cast(quant_min)); - qvalue = std::min(qvalue, static_cast(quant_max)); - return static_cast(qvalue); -} - -} // namespace - -Tensor& quantize_per_tensor_out( - KernelRuntimeContext& context, - const Tensor& input, - double scale, - int64_t zero_point, - int64_t quant_min, - int64_t quant_max, - ScalarType dtype, - Tensor& out) { - // Ignore context for now - (void)context; - - // Resize output tensor to match input dimensions - torch::executor::Error err = resize_tensor(out, input.sizes()); - ET_CHECK_MSG( - err == torch::executor::Error::Ok, - "Failed to resize out Tensor in quantize_per_tensor_out"); - - // Validate input parameters - check_quantize_args(input, quant_min, quant_max, dtype, out); - - // Pre-compute inverse scale for better performance - float inv_scale = 1.0f / static_cast(scale); - int32_t zp = static_cast(zero_point); - int32_t qmin = static_cast(quant_min); - int32_t qmax = static_cast(quant_max); - - // Get pointers to input and output data - const float* input_data = input.const_data_ptr(); - int8_t* out_data = out.mutable_data_ptr(); - const size_t numel = input.numel(); - - size_t i = 0; - -#if defined(HAS_HELIUM_SIMD) - // Helium MVE implementation for float32 to int8 quantization - static uint8x16_t voffset{ - 0x0, - 0x8, - 0x4, - 0xC, - 0x1, - 0x9, - 0x5, - 0xD, - 0x2, - 0xA, - 0x6, - 0xE, - 0x3, - 0xB, - 0x7, - 0xF}; - - float32x4_t inv_scale_vec = vdupq_n_f32(inv_scale); - - // Magic number for float to int conversion, round to nearest even integer - // int magic_round(float f): interpret_as_int32(f + magic_float) - magic_int - // where, - // magic_float = 12582912.0f = (2 ** 23 + 2 ** 22) = (1.5 * 2 ** 23) - // magic_int = 1262485504 = 0x4B400000 = bit_pattern_as_int32(magic_float) - - float magic_float = 12582912.0f; - int32_t magic_int = 1262485504; - - float32x4_t vmagic_float = vdupq_n_f32(magic_float); - int32x4_t vmagic_int_less_zp = - vdupq_n_s32(magic_int - static_cast(zp)); - - int16x8_t vqmin = vdupq_n_s16(qmin); - int16x8_t vqmax = vdupq_n_s16(qmax); - - // TODO: Measure performnce, we are spilling - for (; i + 15 < numel; i += 16) { - float32x4_t in_0123 = vldrwq_f32(input_data + 0); - float32x4_t in_4567 = vldrwq_f32(input_data + 4); - float32x4_t in_89AB = vldrwq_f32(input_data + 8); - float32x4_t in_CDEF = vldrwq_f32(input_data + 12); - - float32x4_t outf_0123 = vfmaq_f32(vmagic_float, in_0123, inv_scale_vec); - float32x4_t outf_4567 = vfmaq_f32(vmagic_float, in_4567, inv_scale_vec); - float32x4_t outf_89AB = vfmaq_f32(vmagic_float, in_89AB, inv_scale_vec); - float32x4_t outf_CDEF = vfmaq_f32(vmagic_float, in_CDEF, inv_scale_vec); - - int32x4_t out_0123 = - vsubq_s32(vreinterpretq_s32_f32(outf_0123), vmagic_int_less_zp); - int32x4_t out_4567 = - vsubq_s32(vreinterpretq_s32_f32(outf_4567), vmagic_int_less_zp); - int32x4_t out_89AB = - vsubq_s32(vreinterpretq_s32_f32(outf_89AB), vmagic_int_less_zp); - int32x4_t out_CDEF = - vsubq_s32(vreinterpretq_s32_f32(outf_CDEF), vmagic_int_less_zp); - - int16x8_t out_04152637; - int16x8_t out_8C9DAEBF; - out_04152637 = vmovnbq_s32(out_04152637, out_0123); - out_04152637 = vmovntq_s32(out_04152637, out_4567); - out_8C9DAEBF = vmovnbq_s32(out_8C9DAEBF, out_89AB); - out_8C9DAEBF = vmovntq_s32(out_8C9DAEBF, out_CDEF); - - int16x8_t out_04152637_clamped = - vminq_s16(vmaxq_s16(out_04152637, vqmin), vqmax); - int16x8_t out_8C9DAEBF_clamped = - vminq_s16(vmaxq_s16(out_8C9DAEBF, vqmin), vqmax); - - int8x16_t out_084C195D2A6E3B7F; - out_084C195D2A6E3B7F = - vmovnbq_s16(out_084C195D2A6E3B7F, out_04152637_clamped); - out_084C195D2A6E3B7F = - vmovntq_s16(out_084C195D2A6E3B7F, out_8C9DAEBF_clamped); - - vstrbq_scatter_offset_s8(out_data, voffset, out_084C195D2A6E3B7F); - input_data += 16; - out_data += 16; - } -#endif // defined(HAS_HELIUM_SIMD) - - for (; i < numel; i++) { - *out_data = - quantize_val(inv_scale, zp, *input_data, qmin, qmax); - input_data++; - out_data++; - } - - return out; -} - -Tensor& quantize_per_tensor_out( - const Tensor& input, - double scale, - int64_t zero_point, - int64_t quant_min, - int64_t quant_max, - ScalarType dtype, - Tensor& out) { - KernelRuntimeContext context; - return quantize_per_tensor_out( - context, input, scale, zero_point, quant_min, quant_max, dtype, out); -} - -} // namespace native -} // namespace cortex_m diff --git a/ai_layer/engine/backends/cortex_m/ops/op_quantized_add.cpp b/ai_layer/engine/backends/cortex_m/ops/op_quantized_add.cpp deleted file mode 100644 index 33d0e099..00000000 --- a/ai_layer/engine/backends/cortex_m/ops/op_quantized_add.cpp +++ /dev/null @@ -1,150 +0,0 @@ -/* - * Copyright (c) Meta Platforms, Inc. and affiliates. - * All rights reserved. - * - * This source code is licensed under the BSD-style license found in the - * LICENSE file in the root directory of this source tree. - */ - -#include "cortex_m_ops_common.h" - -// Include CMSIS-NN headers with C linkage -extern "C" { -#include "arm_nnfunctions.h" -} - -namespace cortex_m { -namespace native { -using KernelRuntimeContext = torch::executor::KernelRuntimeContext; - -Tensor& quantized_add_out( - KernelRuntimeContext& context, - const Tensor& input1_int8, - const Scalar& input1_zero_point, - const Scalar& input1_multiplier, - const Scalar& input1_shift, - const Tensor& input2_int8, - const Scalar& input2_zero_point, - const Scalar& input2_multiplier, - const Scalar& input2_shift, - const Scalar& output_zero_point, - const Scalar& output_multiplier, - const Scalar& output_shift, - Tensor& out) { - // Validate tensor types and dim order - validate_cmsis_nn_tensor_requirements(input1_int8, input2_int8, out); - - // Validate quantization parameters - validate_quantization_params( - input1_zero_point, - input1_multiplier, - input1_shift, - input2_zero_point, - input2_multiplier, - input2_shift, - output_zero_point, - output_multiplier, - output_shift, - out); - - // Broadcast if needed - auto result = resize_to_broadcast_target_size(input1_int8, input2_int8, out); - ET_CHECK_MSG( - (result == Error::Ok), - "Failed to resize output tensor. Status: [%d]", - result); - - ET_LOG( - Info, - "quantized_add_out: input1_int8.sizes() = %zu", - input1_int8.sizes().size()); - - int32_t zp1 = extractScalarToInt32(input1_zero_point); - int32_t input1_mult = extractScalarToInt32(input1_multiplier); - int input1_shift_val = extractScalarToInt(input1_shift); - int32_t zp2 = extractScalarToInt32(input2_zero_point); - int32_t input2_mult = extractScalarToInt32(input2_multiplier); - int input2_shift_val = extractScalarToInt(input2_shift); - int32_t out_zp = extractScalarToInt32(output_zero_point); - int32_t output_mult = extractScalarToInt32(output_multiplier); - int output_shift_val = extractScalarToInt(output_shift); - - // Left shift to maximize precision (tune as needed) - const int32_t left_shift = 20; - const int32_t activation_min = std::numeric_limits::min(); - const int32_t activation_max = std::numeric_limits::max(); - - ET_LOG( - Info, - "Using AoT-computed parameters: input1[mult=%d, shift=%d], input2[mult=%d, shift=%d], output[mult=%d, shift=%d]", - input1_mult, - input1_shift_val, - input2_mult, - input2_shift_val, - output_mult, - output_shift_val); - - // Call CMSIS-NN kernel with precomputed parameters - arm_cmsis_nn_status status = arm_elementwise_add_s8( - input1_int8.const_data_ptr(), - input2_int8.const_data_ptr(), - static_cast(zp1), - input1_mult, - input1_shift_val, - static_cast(zp2), - input2_mult, - input2_shift_val, - left_shift, - out.mutable_data_ptr(), - static_cast(out_zp), - output_mult, - output_shift_val, - static_cast(out.numel()), - activation_min, - activation_max); - - if (status != ARM_CMSIS_NN_SUCCESS) { - ET_LOG( - Error, - "quantized_add_out: arm_elementwise_add_s8 failed with status [%d]", - status); - - context.fail(Error::Internal); // Fail the execution context - return out; - } - ET_LOG( - Info, - "quantized_add_out: Successfully completed with AoT-computed parameters!"); - - return out; -} - -// Stub Implementation: Non-out variant for compatibility (functional variant) -// EXIR/ExecuTorch runs an out-variant pass that converts -// .default operations to .out variants before memory planning. -// In the pass we are calling quantized_add's default variant -// but ExecuTorch's kernel dispatch mechanism will end up calling the out -// variant. This stub is to make sure that compiler doesn't complain. -Tensor quantized_add( - KernelRuntimeContext& context, - const Tensor& input1_int8, - const Scalar& input1_zero_point, - const Scalar& input1_multiplier, - const Scalar& input1_shift, - const Tensor& input2_int8, - const Scalar& input2_zero_point, - const Scalar& input2_multiplier, - const Scalar& input2_shift, - const Scalar& output_zero_point, - const Scalar& output_multiplier, - const Scalar& output_shift) { - ET_LOG(Info, "quantized_add: input1_int8.sizes() = %zu", input1_int8.sizes()); - - // Crash on Debug builds if invoked - assert(false); - // This is to make sure compiler doesn't complain. - return const_cast(input1_int8); -} - -} // namespace native -} // namespace cortex_m diff --git a/ai_layer/engine/executorch_selected_kernels/Functions.h b/ai_layer/engine/executorch_selected_kernels/Functions.h deleted file mode 100644 index 9f92895a..00000000 --- a/ai_layer/engine/executorch_selected_kernels/Functions.h +++ /dev/null @@ -1,66 +0,0 @@ -/* - * Copyright (c) Meta Platforms, Inc. and affiliates. - * All rights reserved. - * - * This source code is licensed under the BSD-style license found in the - * LICENSE file in the root directory of this source tree. - */ - -// clang-format off -#pragma once - -#include - -#include // at::Tensor etc. -#include // TORCH_API -#include - -// @generated by gen.py from Functions.h - -#include "NativeFunctions.h" - -namespace torch { -namespace executor { - - -namespace aten { - -// aten::add.out(Tensor self, Tensor other, *, Scalar alpha=1, Tensor(a!) out) -> Tensor(a!) -TORCH_API inline torch::executor::Tensor & add_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, const torch::executor::Scalar & alpha, torch::executor::Tensor & out) { - return ::torch::executor::native::add_out(context, self, other, alpha, out); -} - - -// aten::mul.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) -TORCH_API inline torch::executor::Tensor & mul_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out) { - return ::torch::executor::native::mul_out(context, self, other, out); -} - - -// aten::permute_copy.out(Tensor self, int[] dims, *, Tensor(a!) out) -> Tensor(a!) -TORCH_API inline torch::executor::Tensor & permute_copy_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::ArrayRef dims, torch::executor::Tensor & out) { - return ::torch::executor::native::permute_copy_out(context, self, dims, out); -} - - -// aten::relu.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) -TORCH_API inline torch::executor::Tensor & relu_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out) { - return ::torch::executor::native::relu_out(context, self, out); -} - - -// aten::sigmoid.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) -TORCH_API inline torch::executor::Tensor & sigmoid_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out) { - return ::torch::executor::native::sigmoid_out(context, self, out); -} - - -// aten::view_copy.out(Tensor self, SymInt[] size, *, Tensor(a!) out) -> Tensor(a!) -TORCH_API inline torch::executor::Tensor & view_copy_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::ArrayRef size, torch::executor::Tensor & out) { - return ::torch::executor::native::view_copy_out(context, self, size, out); -} - -} // namespace aten - -} // namespace executor -} // namespace torch diff --git a/ai_layer/engine/executorch_selected_kernels/NativeFunctions.h b/ai_layer/engine/executorch_selected_kernels/NativeFunctions.h deleted file mode 100644 index af7ceeb4..00000000 --- a/ai_layer/engine/executorch_selected_kernels/NativeFunctions.h +++ /dev/null @@ -1,20 +0,0 @@ -/* - * Copyright (c) Meta Platforms, Inc. and affiliates. - * All rights reserved. - * - * This source code is licensed under the BSD-style license found in the - * LICENSE file in the root directory of this source tree. - */ - -// clang-format off -#pragma once - -#include - -#include // at::Tensor etc. -#include -#include - -// @generated by gen.py from NativeFunctions.h - - diff --git a/ai_layer/engine/executorch_selected_kernels/RegisterCodegenUnboxedKernelsEverything.cpp b/ai_layer/engine/executorch_selected_kernels/RegisterCodegenUnboxedKernelsEverything.cpp deleted file mode 100644 index 5ff1c887..00000000 --- a/ai_layer/engine/executorch_selected_kernels/RegisterCodegenUnboxedKernelsEverything.cpp +++ /dev/null @@ -1,49 +0,0 @@ -/* - * Copyright (c) Meta Platforms, Inc. and affiliates. - * All rights reserved. - * - * This source code is licensed under the BSD-style license found in the - * LICENSE file in the root directory of this source tree. - */ - -#include -#include -#include -#include -#include -#include -#include "NativeFunctions.h" // Generated Function import headers -// @generated by gen.py from RegisterCodegenUnboxedKernels.cpp - -// NOTE [Sharded File]: This file is generated in a sharded fashion to speed up -// incremental rebuilds. See the comment at the top of -// templates/VariableType.cpp for an analogous, in-depth discussion. -// -// Generated by tools/jit/gen_unboxing.py. This file registers all ATen ops into -// JIT op registry instead of c10 dispatcher. JIT op registry only takes boxed -// kernels, so we are calling unboxing functions in UnboxingFunctions.h to cast -// arguments into C++ types (instead of IValue) and delegate to unboxed kernels. -using KernelSpan = ::executorch::runtime::Span< - const ::executorch::ET_RUNTIME_NAMESPACE::Kernel>; -namespace torch { -namespace executor { -namespace function { -namespace { - -static Kernel kernels_to_register[] = { - // Generated kernels -}; - -// Explicitly convert to Span, so that the API can take an empty C array of -// Kernels. -static KernelSpan kernel_span( - kernels_to_register, - kernels_to_register + sizeof(kernels_to_register) / sizeof(Kernel)); - -// Return value not used. Keep the static variable assignment to register -// kernels in static initialization time. -static auto success_with_kernel_reg = register_kernels(kernel_span); -} // namespace -} // namespace function -} // namespace executor -} // namespace torch diff --git a/ai_layer/engine/executorch_selected_kernels/RegisterCodegenUnboxedKernels_0.cpp b/ai_layer/engine/executorch_selected_kernels/RegisterCodegenUnboxedKernels_0.cpp deleted file mode 100644 index 0e4d88e8..00000000 --- a/ai_layer/engine/executorch_selected_kernels/RegisterCodegenUnboxedKernels_0.cpp +++ /dev/null @@ -1,182 +0,0 @@ -/* - * Copyright (c) Meta Platforms, Inc. and affiliates. - * All rights reserved. - * - * This source code is licensed under the BSD-style license found in the - * LICENSE file in the root directory of this source tree. - */ - -#include -#include -#include -#include -#include -#include -#include "NativeFunctions.h" // Generated Function import headers -// @generated by gen.py from RegisterCodegenUnboxedKernels.cpp - -// NOTE [Sharded File]: This file is generated in a sharded fashion to speed up -// incremental rebuilds. See the comment at the top of -// templates/VariableType.cpp for an analogous, in-depth discussion. -// -// Generated by tools/jit/gen_unboxing.py. This file registers all ATen ops into -// JIT op registry instead of c10 dispatcher. JIT op registry only takes boxed -// kernels, so we are calling unboxing functions in UnboxingFunctions.h to cast -// arguments into C++ types (instead of IValue) and delegate to unboxed kernels. -using KernelSpan = ::executorch::runtime::Span< - const ::executorch::ET_RUNTIME_NAMESPACE::Kernel>; -namespace torch { -namespace executor { -namespace function { -namespace { - -static Kernel kernels_to_register[] = { - - Kernel( - "aten::add.out", - [](torch::executor::KernelRuntimeContext & context, Span stack) { - ET_KERNEL_CHECK_MSG(context, stack.size() == 5, InvalidProgram, /*void*/, "Expected %" ET_PRIsize_t "args received %" ET_PRIsize_t, (size_t)5, stack.size()); - EValue& self = *stack[0]; - EValue& other = *stack[1]; - EValue& alpha = *stack[2]; - EValue& out = *stack[3]; - const torch::executor::Tensor & self_base = self.to(); - const torch::executor::Tensor & other_base = other.to(); - const torch::executor::Scalar & alpha_base = alpha.to(); - torch::executor::Tensor & out_base = out.to(); - - - internal::EventTracerProfileOpScope event_tracer_op_scope(context.internal_event_tracer(), "native_call_add.out"); - EXECUTORCH_SCOPE_PROF("native_call_add.out"); - torch::executor::native::add_out(context, self_base, other_base, alpha_base, out_base); - internal::event_tracer_log_evalue(context.internal_event_tracer(), *stack[3]); - - - - } - ), - - Kernel( - "aten::mul.out", - [](torch::executor::KernelRuntimeContext & context, Span stack) { - ET_KERNEL_CHECK_MSG(context, stack.size() == 4, InvalidProgram, /*void*/, "Expected %" ET_PRIsize_t "args received %" ET_PRIsize_t, (size_t)4, stack.size()); - EValue& self = *stack[0]; - EValue& other = *stack[1]; - EValue& out = *stack[2]; - const torch::executor::Tensor & self_base = self.to(); - const torch::executor::Tensor & other_base = other.to(); - torch::executor::Tensor & out_base = out.to(); - - - internal::EventTracerProfileOpScope event_tracer_op_scope(context.internal_event_tracer(), "native_call_mul.out"); - EXECUTORCH_SCOPE_PROF("native_call_mul.out"); - torch::executor::native::mul_out(context, self_base, other_base, out_base); - internal::event_tracer_log_evalue(context.internal_event_tracer(), *stack[2]); - - - - } - ), - - Kernel( - "aten::permute_copy.out", - [](torch::executor::KernelRuntimeContext & context, Span stack) { - ET_KERNEL_CHECK_MSG(context, stack.size() == 4, InvalidProgram, /*void*/, "Expected %" ET_PRIsize_t "args received %" ET_PRIsize_t, (size_t)4, stack.size()); - EValue& self = *stack[0]; - EValue& dims = *stack[1]; - EValue& out = *stack[2]; - const torch::executor::Tensor & self_base = self.to(); - - auto dims_list_out = dims.toIntList(); - - torch::executor::Tensor & out_base = out.to(); - - - internal::EventTracerProfileOpScope event_tracer_op_scope(context.internal_event_tracer(), "native_call_permute_copy.out"); - EXECUTORCH_SCOPE_PROF("native_call_permute_copy.out"); - torch::executor::native::permute_copy_out(context, self_base, dims_list_out, out_base); - internal::event_tracer_log_evalue(context.internal_event_tracer(), *stack[2]); - - - - } - ), - - Kernel( - "aten::relu.out", - [](torch::executor::KernelRuntimeContext & context, Span stack) { - ET_KERNEL_CHECK_MSG(context, stack.size() == 3, InvalidProgram, /*void*/, "Expected %" ET_PRIsize_t "args received %" ET_PRIsize_t, (size_t)3, stack.size()); - EValue& self = *stack[0]; - EValue& out = *stack[1]; - const torch::executor::Tensor & self_base = self.to(); - torch::executor::Tensor & out_base = out.to(); - - - internal::EventTracerProfileOpScope event_tracer_op_scope(context.internal_event_tracer(), "native_call_relu.out"); - EXECUTORCH_SCOPE_PROF("native_call_relu.out"); - torch::executor::native::relu_out(context, self_base, out_base); - internal::event_tracer_log_evalue(context.internal_event_tracer(), *stack[1]); - - - - } - ), - - Kernel( - "aten::sigmoid.out", - [](torch::executor::KernelRuntimeContext & context, Span stack) { - ET_KERNEL_CHECK_MSG(context, stack.size() == 3, InvalidProgram, /*void*/, "Expected %" ET_PRIsize_t "args received %" ET_PRIsize_t, (size_t)3, stack.size()); - EValue& self = *stack[0]; - EValue& out = *stack[1]; - const torch::executor::Tensor & self_base = self.to(); - torch::executor::Tensor & out_base = out.to(); - - - internal::EventTracerProfileOpScope event_tracer_op_scope(context.internal_event_tracer(), "native_call_sigmoid.out"); - EXECUTORCH_SCOPE_PROF("native_call_sigmoid.out"); - torch::executor::native::sigmoid_out(context, self_base, out_base); - internal::event_tracer_log_evalue(context.internal_event_tracer(), *stack[1]); - - - - } - ), - - Kernel( - "aten::view_copy.out", - [](torch::executor::KernelRuntimeContext & context, Span stack) { - ET_KERNEL_CHECK_MSG(context, stack.size() == 4, InvalidProgram, /*void*/, "Expected %" ET_PRIsize_t "args received %" ET_PRIsize_t, (size_t)4, stack.size()); - EValue& self = *stack[0]; - EValue& size = *stack[1]; - EValue& out = *stack[2]; - const torch::executor::Tensor & self_base = self.to(); - - auto size_list_out = size.toIntList(); - - torch::executor::Tensor & out_base = out.to(); - - - internal::EventTracerProfileOpScope event_tracer_op_scope(context.internal_event_tracer(), "native_call_view_copy.out"); - EXECUTORCH_SCOPE_PROF("native_call_view_copy.out"); - torch::executor::native::view_copy_out(context, self_base, size_list_out, out_base); - internal::event_tracer_log_evalue(context.internal_event_tracer(), *stack[2]); - - - - } - ), // Generated kernels -}; - -// Explicitly convert to Span, so that the API can take an empty C array of -// Kernels. -static KernelSpan kernel_span( - kernels_to_register, - kernels_to_register + sizeof(kernels_to_register) / sizeof(Kernel)); - -// Return value not used. Keep the static variable assignment to register -// kernels in static initialization time. -static auto success_with_kernel_reg = register_kernels(kernel_span); -} // namespace -} // namespace function -} // namespace executor -} // namespace torch diff --git a/ai_layer/engine/executorch_selected_kernels/RegisterKernels.h b/ai_layer/engine/executorch_selected_kernels/RegisterKernels.h deleted file mode 100644 index cba37dad..00000000 --- a/ai_layer/engine/executorch_selected_kernels/RegisterKernels.h +++ /dev/null @@ -1,22 +0,0 @@ -/* - * Copyright (c) Meta Platforms, Inc. and affiliates. - * All rights reserved. - * - * This source code is licensed under the BSD-style license found in the - * LICENSE file in the root directory of this source tree. - */ - -// @generated by torchgen/gen_executorch.py -// Exposing an API for registering all kernels at once. -#include -#include -#include -#include - -namespace torch { -namespace executor { - -Error register_all_kernels(); - -} // namespace executor -} // namespace torch diff --git a/ai_layer/engine/executorch_selected_kernels/selected_operators.yaml b/ai_layer/engine/executorch_selected_kernels/selected_operators.yaml deleted file mode 100644 index 4c53aa83..00000000 --- a/ai_layer/engine/executorch_selected_kernels/selected_operators.yaml +++ /dev/null @@ -1,79 +0,0 @@ -build_features: [] -custom_classes: [] -et_kernel_metadata: - aten::add.out: - - default - aten::conv2d.out: - - default - aten::linear.out: - - default - aten::mul.out: - - default - aten::permute_copy.out: - - default - aten::relu.out: - - default - aten::sigmoid.out: - - default - aten::softmax.out: - - default - aten::view_copy.out: - - default -include_all_non_op_selectives: false -include_all_operators: false -kernel_metadata: {} -operators: - aten::add.out: - debug_info: - - None - include_all_overloads: false - is_root_operator: true - is_used_for_training: true - aten::conv2d.out: - debug_info: - - None - include_all_overloads: false - is_root_operator: true - is_used_for_training: true - aten::linear.out: - debug_info: - - None - include_all_overloads: false - is_root_operator: true - is_used_for_training: true - aten::mul.out: - debug_info: - - None - include_all_overloads: false - is_root_operator: true - is_used_for_training: true - aten::permute_copy.out: - debug_info: - - None - include_all_overloads: false - is_root_operator: true - is_used_for_training: true - aten::relu.out: - debug_info: - - None - include_all_overloads: false - is_root_operator: true - is_used_for_training: true - aten::sigmoid.out: - debug_info: - - None - include_all_overloads: false - is_root_operator: true - is_used_for_training: true - aten::softmax.out: - debug_info: - - None - include_all_overloads: false - is_root_operator: true - is_used_for_training: true - aten::view_copy.out: - debug_info: - - None - include_all_overloads: false - is_root_operator: true - is_used_for_training: true diff --git a/ai_layer/engine/include/executorch/backends/arm/runtime/VGFSetup.h b/ai_layer/engine/include/executorch/backends/arm/runtime/VGFSetup.h deleted file mode 100644 index 3faa7ca6..00000000 --- a/ai_layer/engine/include/executorch/backends/arm/runtime/VGFSetup.h +++ /dev/null @@ -1,121 +0,0 @@ -/* - * Copyright 2025 Arm Limited and/or its affiliates. - * - * This source code is licensed under the BSD-style license found in the - * LICENSE file in the root directory of this source tree. - */ - -#include -#include -#include -using namespace std; - -#include - -using executorch::runtime::ArrayRef; -using executorch::runtime::CompileSpec; - -// We use the platform and runtime environment provided by the Vulkan delegate -#include - -namespace executorch { -namespace backends { -namespace vgf { - -class VgfRepr; - -/* - * Info about IOs used during execution - */ -typedef struct IO { - vector size; - vector stride; - size_t elt_size; - VkTensorARM tensor; - VkTensorViewARM tensor_view; - VkDeviceMemory tensor_memory; - bool is_input; -} IO; - -/* - * In memory, and in-vulkan-object representation of the loaded - * VGF graph - ready to be dispatched based on provided inputs. - */ -class VgfRepr { - public: - VgfRepr( - VkInstance inst, - VkPhysicalDevice phys, - VkDevice dev, - VkQueue queue, - VkCommandPool pool) - : vk_instance(inst), - vk_physical(phys), - vk_device(dev), - vk_queue(queue), - vk_command_pool(pool) {} - - /* - * Process a VGF ready for execution, allocate necessary Vulkan objects. - */ - bool process_vgf(const char* vgf_data, ArrayRef specs); - - /* - * Execute the VGF we've previously processed. - */ - bool execute_vgf(); - - /* - * Free any allocations made in process_vgf. - */ - void free_vgf(); - - /* - * input and outputs from the VGF - these are memory mapped and populated - * with the EValues coming the backend execute call - */ - vector IOs; - vector intermediates; - - bool map_io(IO* io, void** handle) { - VkResult result = - vkMapMemory(vk_device, io->tensor_memory, 0, VK_WHOLE_SIZE, 0, handle); - if (result != VK_SUCCESS) { - ET_LOG(Error, "Failed to map Vulkan IO memory"); - return false; - } - return true; - } - - void unmap_io(IO* io) { - vkUnmapMemory(vk_device, io->tensor_memory); - } - - ~VgfRepr() { - free_vgf(); - } - - private: - // Basic Vulkan objects passed to us and re-used - VkInstance vk_instance; - VkPhysicalDevice vk_physical; - VkDevice vk_device; - VkQueue vk_queue; - VkCommandPool vk_command_pool; - - // per-VgfRepr-instance objects allocated in process_vgf, used (can be more - // than once) in execute_vgf - VkCommandBuffer vk_execute_cmd = VK_NULL_HANDLE; - VkDataGraphPipelineSessionARM vk_session = VK_NULL_HANDLE; - VkPipeline vk_pipeline = VK_NULL_HANDLE; - VkPipelineLayout vk_pipeline_layout = VK_NULL_HANDLE; - VkDescriptorPool vk_descriptor_pool; - VkDescriptorSetLayout vk_layout; - VkShaderModule vk_shader; - // Note: the vector of tensor memory is stored in IOs above - vector descriptor_sets; -}; - -} // namespace vgf -} // namespace backends -} // namespace executorch diff --git a/ai_layer/engine/include/executorch/backends/arm/runtime/VelaBinStream.h b/ai_layer/engine/include/executorch/backends/arm/runtime/VelaBinStream.h deleted file mode 100644 index 7f660620..00000000 --- a/ai_layer/engine/include/executorch/backends/arm/runtime/VelaBinStream.h +++ /dev/null @@ -1,79 +0,0 @@ -/* - * Copyright 2023-2025 Arm Limited and/or its affiliates. - * - * This source code is licensed under the BSD-style license found in the - * LICENSE file in the root directory of this source tree. - */ - -/* - * Minimal reading function for vela_bin_stream wire format. This is an - * implementation detail of the arm backend AoT flow and ArmBackendEthosU - * and subject to change. - * This format captures the command stream, I/O and memory layout data to - * enable execution of the command stream on Ethos-U hardware. - */ - -#pragma once - -#include -#include - -namespace executorch { -namespace backends { -namespace arm { - -// Standard block name size -const uint32_t kVelaBlockNameLength = 16; - -// Generic block within the vela_bin_stream encoded by the python vela_compile -// step -typedef struct { - char name[kVelaBlockNameLength]; // string name, can be shorter or truncated - uint32_t size; // unpadded size, BinBlock size will be rounded to next_mul_16 - char _pad[12]; // Our data often need 16 byte alignemnt - char data[]; // block.name specific format data -} VelaBinBlock; - -constexpr int shapeDim = 6; // Number of dimensions in VelaIO - -// A Vela input or output descriptor in the binary stream -typedef struct { - int shape[shapeDim]; // Shape of input or output - int elem_size; // Element sizeof in bytes - int offset; // Offset in bytes within SRAM working data - int region; // Scratch region this belongs to -} VelaIO; - -// A list of VelaIOs from the binary stream -typedef struct { - int count; - VelaIO io[]; -} VelaIOs; - -// Processed data used by the backend to invoke the payload -typedef struct { - const char* cmd_data; - size_t cmd_data_size; - const char* weight_data; - size_t weight_data_size; - char* scratch_data; - size_t scratch_data_size; - VelaIOs* inputs; - VelaIOs* outputs; -} VelaHandles; - -/* Takes in the preprocessed vela_bin_stream wire format and returns data - * needed to launch the workload on the Ethos-U and wire up input and - * output values. - */ -bool vela_bin_read(const char* data, VelaHandles* handles, int size); - -/* Does minimal validation of a vela_bin_stream to ensure the overall - * structure is correct and so likely to contain valid binary data for launch - * on the Ethos-U. - */ -bool vela_bin_validate(const char* data, int size); - -} // namespace arm -} // namespace backends -} // namespace executorch diff --git a/ai_layer/engine/include/executorch/backends/arm/third-party/ethos-u-core-driver/include/ethosu_driver.h b/ai_layer/engine/include/executorch/backends/arm/third-party/ethos-u-core-driver/include/ethosu_driver.h deleted file mode 100644 index 1e71791b..00000000 --- a/ai_layer/engine/include/executorch/backends/arm/third-party/ethos-u-core-driver/include/ethosu_driver.h +++ /dev/null @@ -1,399 +0,0 @@ -/* - * SPDX-FileCopyrightText: Copyright 2019-2024 Arm Limited and/or its affiliates - * SPDX-License-Identifier: Apache-2.0 - * - * Licensed under the Apache License, Version 2.0 (the License); you may - * not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an AS IS BASIS, WITHOUT - * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef ETHOSU_DRIVER_H -#define ETHOSU_DRIVER_H - -/****************************************************************************** - * Includes - ******************************************************************************/ - -#include "ethosu_types.h" - -#include -#include -#include - -#ifdef __cplusplus -extern "C" { -#endif - -/****************************************************************************** - * Defines - ******************************************************************************/ - -#define ETHOSU_DRIVER_VERSION_MAJOR 0 ///< Driver major version -#define ETHOSU_DRIVER_VERSION_MINOR 16 ///< Driver minor version -#define ETHOSU_DRIVER_VERSION_PATCH 0 ///< Driver patch version - -#define ETHOSU_SEMAPHORE_WAIT_FOREVER (UINT64_MAX) - -#ifndef ETHOSU_SEMAPHORE_WAIT_INFERENCE -#define ETHOSU_SEMAPHORE_WAIT_INFERENCE ETHOSU_SEMAPHORE_WAIT_FOREVER -#endif - -/****************************************************************************** - * Types - ******************************************************************************/ - -enum ethosu_job_state -{ - ETHOSU_JOB_IDLE = 0, - ETHOSU_JOB_RUNNING, - ETHOSU_JOB_DONE -}; - -enum ethosu_job_result -{ - ETHOSU_JOB_RESULT_OK = 0, - ETHOSU_JOB_RESULT_TIMEOUT, - ETHOSU_JOB_RESULT_ERROR -}; - -struct ethosu_job -{ - volatile enum ethosu_job_state state; - volatile enum ethosu_job_result result; - const void *custom_data_ptr; - int custom_data_size; - const uint64_t *base_addr; - const size_t *base_addr_size; - int num_base_addr; - void *user_arg; -}; - -struct ethosu_driver -{ - struct ethosu_device dev; - struct ethosu_driver *next; - struct ethosu_job job; - void *semaphore; - uint64_t fast_memory; - size_t fast_memory_size; - uint32_t power_request_counter; - bool reserved; - uint8_t basep_flush_mask; - uint8_t basep_invalidate_mask; -}; - -struct ethosu_driver_version -{ - uint8_t major; - uint8_t minor; - uint8_t patch; -}; - -enum ethosu_request_clients -{ - ETHOSU_PMU_REQUEST = 0, - ETHOSU_INFERENCE_REQUEST = 1, -}; - -/****************************************************************************** - * Prototypes (weak functions in driver) - ******************************************************************************/ - -/** - * Interrupt handler to be called on IRQ from Ethos-U - * - * @param drv Pointer to driver handle - */ -void ethosu_irq_handler(struct ethosu_driver *drv); - -/** - * Flush/clean the data cache by address and size. - * NOTE: It is not recommended to implement this, but let the application code - * make sure that any data needed by the NPU is flushed before invoking - * an inference. - * - * Addresses passed to this function must be 32 byte aligned. - * - * @param p 32 byte aligned address - * @param bytes Size of memory block in bytes - */ -void ethosu_flush_dcache(uint32_t *p, size_t bytes); - -/** - * Invalidate the data cache by address and size. - * NOTE: The driver will only call this for the scratch/tensor arena base - * pointer. - * - * Addresses passed to this function must be 32 byte aligned. - * - * @param p 32 byte aligned address - * @param bytes Size in bytes - */ -void ethosu_invalidate_dcache(uint32_t *p, size_t bytes); - -/** - * Minimal mutex implementation for baremetal applications. See - * ethosu_driver.c. - * - * @return Pointer to mutex handle - */ -void *ethosu_mutex_create(void); - -/** - * Destroy mutex. - * - * @param mutex Pointer to mutex handle - */ -void ethosu_mutex_destroy(void *mutex); - -/** - * Minimal sempahore implementation for baremetal applications. See - * ethosu_driver.c. - * - * @return Pointer to semaphore handle - */ -void *ethosu_semaphore_create(void); - -/** - * Destroy semaphore. - * - * @param sem Pointer to semaphore handle - */ -void ethosu_semaphore_destroy(void *sem); - -/** - * Lock mutex. - * - * @param mutex Pointer to mutex handle - * @returns 0 on success, else negative error code - */ -int ethosu_mutex_lock(void *mutex); - -/** - * Unlock mutex. - * - * @param mutex Pointer to mutex handle - * @returns 0 on success, else negative error code - */ -int ethosu_mutex_unlock(void *mutex); - -/** - * Take semaphore. - * - * @param sem Pointer to semaphore handle - * @param timeout Timeout value (unit impl. defined) - * @returns 0 on success else negative error code - */ -int ethosu_semaphore_take(void *sem, uint64_t timeout); - -/** - * Give semaphore. - * - * @param sem Pointer to semaphore handle - * @returns 0 on success, else negative error code - */ -int ethosu_semaphore_give(void *sem); - -/** - * Callback invoked just before the inference is started. - * - * @param drv Pointer to driver handle - * @param user_arg User argument provided to ethosu_invoke_*() - */ -void ethosu_inference_begin(struct ethosu_driver *drv, void *user_arg); - -/** - * Callback invoked just after the inference has completed. - * - * @param drv Pointer to driver handle - * @param user_arg User argument provided to ethosu_invoke_*() - */ -void ethosu_inference_end(struct ethosu_driver *drv, void *user_arg); - -/** - * Remapping command stream and base pointer addresses. - * - * @param address Address to be remapped. - * @param index -1 command stream, 0-n base address index - * - * @return Remapped address - */ -uint64_t ethosu_address_remap(uint64_t address, int index); - -/****************************************************************************** - * Prototypes - ******************************************************************************/ - -/** - * Set cache mask for cache flush/clean and invalidation per base pointer. - * - * @param drv Pointer to driver handle - * @param flush_mask Base pointer cache flush mask (bit 0 == basep 0) - * @param invalidate_mask Base pointer cache invalidation mask (bit 0 == basep 0) - */ -void ethosu_set_basep_cache_mask(struct ethosu_driver *drv, uint8_t flush_mask, uint8_t invalidate_mask); - -/** - * Initialize the Ethos-U driver. - * - * @param drv Pointer to driver handle - * @param base_address NPU register base address - * @param fast_memory Fast memory area, used for Ethos-U65 with spilling - * @param fast_memory_size Size in bytes of fast memory area - * @param secure_enable Configure NPU in secure- or non-secure mode - * @param privilege_enable Configure NPU in privileged- or non-privileged mode - * @return 0 on success, else negative error code - */ -int ethosu_init(struct ethosu_driver *drv, - void *const base_address, - const void *fast_memory, - const size_t fast_memory_size, - uint32_t secure_enable, - uint32_t privilege_enable); - -/** - * Deinitialize the Ethos-U driver. - * - * @param drv Pointer to driver handle - */ -void ethosu_deinit(struct ethosu_driver *drv); - -/** - * Soft resets the Ethos-U device. - * - * @param drv Pointer to driver handle - * @return 0 on success, else negative error code - */ -int ethosu_soft_reset(struct ethosu_driver *drv); - -/** - * Request to disable Q-channel power gating of the Ethos-U device. - * Power requests are ref.counted. Increases count. - * (Note: clock gating is made to follow power gating) - * - * @param drv Pointer to driver handle - * @return 0 on success, else negative error code - */ -int ethosu_request_power(struct ethosu_driver *drv); - -/** - * Release disable request for Q-channel power gating of the Ethos-U device. - * Power requests are ref.counted. Decreases count. - * - * @param drv Pointer to driver handle - */ -void ethosu_release_power(struct ethosu_driver *drv); - -/** - * Get Ethos-U driver version. - * - * @param ver Driver version struct - */ -void ethosu_get_driver_version(struct ethosu_driver_version *ver); - -/** - * Get Ethos-U hardware information. - * - * @param drv Pointer to driver handle - * @param hw Hardware information struct - */ -void ethosu_get_hw_info(struct ethosu_driver *drv, struct ethosu_hw_info *hw); - -/** - * Invoke command stream. - * - * @param drv Pointer to driver handle - * @param custom_data_ptr Custom data payload - * @param custom_data_size Size in bytes of custom data - * @param base_addr Array of base address pointers - * @param base_addr_size Size in bytes of each address in base_addr - * @param num_base_addr Number of elements in base_addr array - * @param user_arg User argument, will be passed to - * ethosu_inference_begin() and ethosu_inference_end() - * @return 0 on success, else negative error code - */ -int ethosu_invoke_v3(struct ethosu_driver *drv, - const void *custom_data_ptr, - const int custom_data_size, - uint64_t *const base_addr, - const size_t *base_addr_size, - const int num_base_addr, - void *user_arg); - -#define ethosu_invoke(drv, custom_data_ptr, custom_data_size, base_addr, base_addr_size, num_base_addr) \ - ethosu_invoke_v3(drv, custom_data_ptr, custom_data_size, base_addr, base_addr_size, num_base_addr, 0) - -/** - * Invoke command stream using async interface. - * Must be followed by call(s) to ethosu_wait() upon successful return. - * - * @see ethosu_invoke_v3 for documentation. - */ -int ethosu_invoke_async(struct ethosu_driver *drv, - const void *custom_data_ptr, - const int custom_data_size, - uint64_t *const base_addr, - const size_t *base_addr_size, - const int num_base_addr, - void *user_arg); - -/** - * Wait for inference to complete (block=true) - * Poll status or finish up if inference is complete (block=false) - * (This function is only intended to be used in conjuction with ethosu_invoke_async) - * - * @param drv Pointer to driver handle - * @param block If call should block if inference is running - * @return -2 on inference not invoked, -1 on inference error, 0 on success, 1 on inference running - */ -int ethosu_wait(struct ethosu_driver *drv, bool block); - -/** - * Reserves a driver to execute inference with. Call will block until a driver - * is available. - * - * @return Pointer to driver handle. - */ -struct ethosu_driver *ethosu_reserve_driver(void); - -/** - * Release driver that was previously reserved with @see ethosu_reserve_driver. - * - * @param drv Pointer to driver handle - */ -void ethosu_release_driver(struct ethosu_driver *drv); - -/** - * Static inline for backwards-compatibility. - * - * @see ethosu_invoke_v3 for documentation. - */ -static inline int ethosu_invoke_v2(const void *custom_data_ptr, - const int custom_data_size, - uint64_t *const base_addr, - const size_t *base_addr_size, - const int num_base_addr) -{ - struct ethosu_driver *drv = ethosu_reserve_driver(); - if (!drv) - { - return -1; - } - int result = ethosu_invoke_v3(drv, custom_data_ptr, custom_data_size, base_addr, base_addr_size, num_base_addr, 0); - ethosu_release_driver(drv); - return result; -} - -#ifdef __cplusplus -} -#endif - -#endif // ETHOSU_DRIVER_H diff --git a/ai_layer/engine/include/executorch/backends/arm/third-party/ethos-u-core-driver/include/ethosu_types.h b/ai_layer/engine/include/executorch/backends/arm/third-party/ethos-u-core-driver/include/ethosu_types.h deleted file mode 100644 index 9d14a601..00000000 --- a/ai_layer/engine/include/executorch/backends/arm/third-party/ethos-u-core-driver/include/ethosu_types.h +++ /dev/null @@ -1,84 +0,0 @@ -/* - * SPDX-FileCopyrightText: Copyright 2019-2021, 2024 Arm Limited and/or its affiliates - * SPDX-License-Identifier: Apache-2.0 - * - * Licensed under the Apache License, Version 2.0 (the License); you may - * not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an AS IS BASIS, WITHOUT - * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef ETHOSU_TYPES_H -#define ETHOSU_TYPES_H - -/****************************************************************************** - * Includes - ******************************************************************************/ - -#include - -/****************************************************************************** - * Types - ******************************************************************************/ - -struct NPU_REG; // Forward declare, to be implemented by each device - -struct ethosu_device -{ - volatile struct NPU_REG *reg; // Register map - uint32_t secure; - uint32_t privileged; -}; - -enum ethosu_error_codes -{ - ETHOSU_SUCCESS = 0, ///< Success - ETHOSU_GENERIC_FAILURE = -1, ///< Generic failure - ETHOSU_INVALID_PARAM = -2 ///< Invalid parameter -}; - -enum ethosu_clock_q_request -{ - ETHOSU_CLOCK_Q_DISABLE = 0, ///< Disable NPU signal ready for clock off. - ETHOSU_CLOCK_Q_ENABLE = 1, ///< Enable NPU signal ready for clock off when stop+idle state reached. - ETHOSU_CLOCK_Q_UNCHANGED = 2 ///< Keep current clock q setting -}; - -enum ethosu_power_q_request -{ - ETHOSU_POWER_Q_DISABLE = 0, ///< Disable NPU signal ready for power off. - ETHOSU_POWER_Q_ENABLE = 1, ///< Enable NPU signal ready for power off when stop+idle state reached. - ETHOSU_POWER_Q_UNCHANGED = 2 ///< Keep current power q setting -}; - -struct ethosu_id -{ - uint32_t version_status; ///< Version status - uint32_t version_minor; ///< Version minor - uint32_t version_major; ///< Version major - uint32_t product_major; ///< Product major - uint32_t arch_patch_rev; ///< Architecture version patch - uint32_t arch_minor_rev; ///< Architecture version minor - uint32_t arch_major_rev; ///< Architecture version major -}; - -struct ethosu_config -{ - uint32_t macs_per_cc; ///< MACs per clock cycle - uint32_t cmd_stream_version; ///< NPU command stream version - uint32_t custom_dma; ///< Custom DMA enabled -}; - -struct ethosu_hw_info -{ - struct ethosu_id version; - struct ethosu_config cfg; -}; -#endif // ETHOSU_TYPES_H diff --git a/ai_layer/engine/include/executorch/backends/arm/third-party/ethos-u-core-driver/include/pmu_ethosu.h b/ai_layer/engine/include/executorch/backends/arm/third-party/ethos-u-core-driver/include/pmu_ethosu.h deleted file mode 100644 index 76abc61c..00000000 --- a/ai_layer/engine/include/executorch/backends/arm/third-party/ethos-u-core-driver/include/pmu_ethosu.h +++ /dev/null @@ -1,515 +0,0 @@ -/* - * SPDX-FileCopyrightText: Copyright 2019-2024 Arm Limited and/or its affiliates - * SPDX-License-Identifier: Apache-2.0 - * - * Licensed under the Apache License, Version 2.0 (the License); you may - * not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an AS IS BASIS, WITHOUT - * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef PMU_ETHOSU_H -#define PMU_ETHOSU_H - -/***************************************************************************** - * Includes - *****************************************************************************/ -#include - -#include "ethosu_driver.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/***************************************************************************** - * Defines - *****************************************************************************/ -#ifdef ETHOSU85 -#define ETHOSU_PMU_NCOUNTERS 8 -#else -#define ETHOSU_PMU_NCOUNTERS 4 -#endif - -#define ETHOSU_PMU_CNT1_Msk (1UL << 0) -#define ETHOSU_PMU_CNT2_Msk (1UL << 1) -#define ETHOSU_PMU_CNT3_Msk (1UL << 2) -#define ETHOSU_PMU_CNT4_Msk (1UL << 3) -#ifdef ETHOSU85 -#define ETHOSU_PMU_CNT5_Msk (1UL << 4) -#define ETHOSU_PMU_CNT6_Msk (1UL << 5) -#define ETHOSU_PMU_CNT7_Msk (1UL << 6) -#define ETHOSU_PMU_CNT8_Msk (1UL << 7) -#endif - -#define ETHOSU_PMU_CCNT_Msk (1UL << 31) - -/***************************************************************************** - * Types - *****************************************************************************/ - -/** \brief HW Supported ETHOSU PMU Events - * - * Note: These values are symbolic. Actual HW-values may change. I.e. always use API - * to set/get actual event-type value. - * */ -#if defined(ETHOSU55) || defined(ETHOSU65) -enum ethosu_pmu_event_type -{ - ETHOSU_PMU_NO_EVENT = 0, - ETHOSU_PMU_CYCLE, - ETHOSU_PMU_NPU_IDLE, - ETHOSU_PMU_CC_STALLED_ON_BLOCKDEP, - ETHOSU_PMU_CC_STALLED_ON_SHRAM_RECONFIG, - ETHOSU_PMU_NPU_ACTIVE, - ETHOSU_PMU_MAC_ACTIVE, - ETHOSU_PMU_MAC_ACTIVE_8BIT, - ETHOSU_PMU_MAC_ACTIVE_16BIT, - ETHOSU_PMU_MAC_DPU_ACTIVE, - ETHOSU_PMU_MAC_STALLED_BY_WD_ACC, - ETHOSU_PMU_MAC_STALLED_BY_WD, - ETHOSU_PMU_MAC_STALLED_BY_ACC, - ETHOSU_PMU_MAC_STALLED_BY_IB, - ETHOSU_PMU_MAC_ACTIVE_32BIT, - ETHOSU_PMU_MAC_STALLED_BY_INT_W, - ETHOSU_PMU_MAC_STALLED_BY_INT_ACC, - ETHOSU_PMU_AO_ACTIVE, - ETHOSU_PMU_AO_ACTIVE_8BIT, - ETHOSU_PMU_AO_ACTIVE_16BIT, - ETHOSU_PMU_AO_STALLED_BY_OFMP_OB, - ETHOSU_PMU_AO_STALLED_BY_OFMP, - ETHOSU_PMU_AO_STALLED_BY_OB, - ETHOSU_PMU_AO_STALLED_BY_ACC_IB, - ETHOSU_PMU_AO_STALLED_BY_ACC, - ETHOSU_PMU_AO_STALLED_BY_IB, - ETHOSU_PMU_WD_ACTIVE, - ETHOSU_PMU_WD_STALLED, - ETHOSU_PMU_WD_STALLED_BY_WS, - ETHOSU_PMU_WD_STALLED_BY_WD_BUF, - ETHOSU_PMU_WD_PARSE_ACTIVE, - ETHOSU_PMU_WD_PARSE_STALLED, - ETHOSU_PMU_WD_PARSE_STALLED_IN, - ETHOSU_PMU_WD_PARSE_STALLED_OUT, - ETHOSU_PMU_WD_TRANS_WS, - ETHOSU_PMU_WD_TRANS_WB, - ETHOSU_PMU_WD_TRANS_DW0, - ETHOSU_PMU_WD_TRANS_DW1, - ETHOSU_PMU_AXI0_RD_TRANS_ACCEPTED, - ETHOSU_PMU_AXI0_RD_TRANS_COMPLETED, - ETHOSU_PMU_AXI0_RD_DATA_BEAT_RECEIVED, - ETHOSU_PMU_AXI0_RD_TRAN_REQ_STALLED, - ETHOSU_PMU_AXI0_WR_TRANS_ACCEPTED, - ETHOSU_PMU_AXI0_WR_TRANS_COMPLETED_M, - ETHOSU_PMU_AXI0_WR_TRANS_COMPLETED_S, - ETHOSU_PMU_AXI0_WR_DATA_BEAT_WRITTEN, - ETHOSU_PMU_AXI0_WR_TRAN_REQ_STALLED, - ETHOSU_PMU_AXI0_WR_DATA_BEAT_STALLED, - ETHOSU_PMU_AXI0_ENABLED_CYCLES, - ETHOSU_PMU_AXI0_RD_STALL_LIMIT, - ETHOSU_PMU_AXI0_WR_STALL_LIMIT, - ETHOSU_PMU_AXI_LATENCY_ANY, - ETHOSU_PMU_AXI_LATENCY_32, - ETHOSU_PMU_AXI_LATENCY_64, - ETHOSU_PMU_AXI_LATENCY_128, - ETHOSU_PMU_AXI_LATENCY_256, - ETHOSU_PMU_AXI_LATENCY_512, - ETHOSU_PMU_AXI_LATENCY_1024, - ETHOSU_PMU_ECC_DMA, - ETHOSU_PMU_ECC_SB0, - ETHOSU_PMU_AXI1_RD_TRANS_ACCEPTED, - ETHOSU_PMU_AXI1_RD_TRANS_COMPLETED, - ETHOSU_PMU_AXI1_RD_DATA_BEAT_RECEIVED, - ETHOSU_PMU_AXI1_RD_TRAN_REQ_STALLED, - ETHOSU_PMU_AXI1_WR_TRANS_ACCEPTED, - ETHOSU_PMU_AXI1_WR_TRANS_COMPLETED_M, - ETHOSU_PMU_AXI1_WR_TRANS_COMPLETED_S, - ETHOSU_PMU_AXI1_WR_DATA_BEAT_WRITTEN, - ETHOSU_PMU_AXI1_WR_TRAN_REQ_STALLED, - ETHOSU_PMU_AXI1_WR_DATA_BEAT_STALLED, - ETHOSU_PMU_AXI1_ENABLED_CYCLES, - ETHOSU_PMU_AXI1_RD_STALL_LIMIT, - ETHOSU_PMU_AXI1_WR_STALL_LIMIT, - ETHOSU_PMU_ECC_SB1, - - ETHOSU_PMU_SENTINEL // End-marker (not event) -}; -#elif defined(ETHOSU85) -enum ethosu_pmu_event_type -{ - ETHOSU_PMU_NO_EVENT = 0, - ETHOSU_PMU_CYCLE, - ETHOSU_PMU_NPU_IDLE, - ETHOSU_PMU_CC_STALLED_ON_BLOCKDEP, - ETHOSU_PMU_NPU_ACTIVE, - ETHOSU_PMU_MAC_ACTIVE, - ETHOSU_PMU_MAC_DPU_ACTIVE, - ETHOSU_PMU_MAC_STALLED_BY_W_OR_ACC, - ETHOSU_PMU_MAC_STALLED_BY_W, - ETHOSU_PMU_MAC_STALLED_BY_ACC, - ETHOSU_PMU_MAC_STALLED_BY_IB, - ETHOSU_PMU_AO_ACTIVE, - ETHOSU_PMU_AO_STALLED_BY_BS_OR_OB, - ETHOSU_PMU_AO_STALLED_BY_BS, - ETHOSU_PMU_AO_STALLED_BY_OB, - ETHOSU_PMU_AO_STALLED_BY_AB_OR_CB, - ETHOSU_PMU_AO_STALLED_BY_AB, - ETHOSU_PMU_AO_STALLED_BY_CB, - ETHOSU_PMU_WD_ACTIVE, - ETHOSU_PMU_WD_STALLED, - ETHOSU_PMU_WD_STALLED_BY_WD_BUF, - ETHOSU_PMU_WD_STALLED_BY_WS_FC, - ETHOSU_PMU_WD_STALLED_BY_WS_TC, - ETHOSU_PMU_WD_TRANS_WBLK, - ETHOSU_PMU_WD_TRANS_WS_FC, - ETHOSU_PMU_WD_TRANS_WS_TC, - ETHOSU_PMU_WD_STALLED_BY_WS_SC0, - ETHOSU_PMU_WD_STALLED_BY_WS_SC1, - ETHOSU_PMU_WD_STALLED_BY_WS_SC2, - ETHOSU_PMU_WD_STALLED_BY_WS_SC3, - ETHOSU_PMU_WD_PARSE_ACTIVE_SC0, - ETHOSU_PMU_WD_PARSE_ACTIVE_SC1, - ETHOSU_PMU_WD_PARSE_ACTIVE_SC2, - ETHOSU_PMU_WD_PARSE_ACTIVE_SC3, - ETHOSU_PMU_WD_PARSE_STALL_SC0, - ETHOSU_PMU_WD_PARSE_STALL_SC1, - ETHOSU_PMU_WD_PARSE_STALL_SC2, - ETHOSU_PMU_WD_PARSE_STALL_SC3, - ETHOSU_PMU_WD_PARSE_STALL_IN_SC0, - ETHOSU_PMU_WD_PARSE_STALL_IN_SC1, - ETHOSU_PMU_WD_PARSE_STALL_IN_SC2, - ETHOSU_PMU_WD_PARSE_STALL_IN_SC3, - ETHOSU_PMU_WD_PARSE_STALL_OUT_SC0, - ETHOSU_PMU_WD_PARSE_STALL_OUT_SC1, - ETHOSU_PMU_WD_PARSE_STALL_OUT_SC2, - ETHOSU_PMU_WD_PARSE_STALL_OUT_SC3, - ETHOSU_PMU_WD_TRANS_WS_SC0, - ETHOSU_PMU_WD_TRANS_WS_SC1, - ETHOSU_PMU_WD_TRANS_WS_SC2, - ETHOSU_PMU_WD_TRANS_WS_SC3, - ETHOSU_PMU_WD_TRANS_WB0, - ETHOSU_PMU_WD_TRANS_WB1, - ETHOSU_PMU_WD_TRANS_WB2, - ETHOSU_PMU_WD_TRANS_WB3, - ETHOSU_PMU_SRAM_RD_TRANS_ACCEPTED, - ETHOSU_PMU_SRAM_RD_TRANS_COMPLETED, - ETHOSU_PMU_SRAM_RD_DATA_BEAT_RECEIVED, - ETHOSU_PMU_SRAM_RD_TRAN_REQ_STALLED, - ETHOSU_PMU_SRAM_WR_TRANS_ACCEPTED, - ETHOSU_PMU_SRAM_WR_TRANS_COMPLETED_M, - ETHOSU_PMU_SRAM_WR_TRANS_COMPLETED_S, - ETHOSU_PMU_SRAM_WR_DATA_BEAT_WRITTEN, - ETHOSU_PMU_SRAM_WR_TRAN_REQ_STALLED, - ETHOSU_PMU_SRAM_WR_DATA_BEAT_STALLED, - ETHOSU_PMU_SRAM_ENABLED_CYCLES, - ETHOSU_PMU_SRAM_RD_STALL_LIMIT, - ETHOSU_PMU_SRAM_WR_STALL_LIMIT, - ETHOSU_PMU_AXI_LATENCY_ANY, - ETHOSU_PMU_AXI_LATENCY_32, - ETHOSU_PMU_AXI_LATENCY_64, - ETHOSU_PMU_AXI_LATENCY_128, - ETHOSU_PMU_AXI_LATENCY_256, - ETHOSU_PMU_AXI_LATENCY_512, - ETHOSU_PMU_AXI_LATENCY_1024, - ETHOSU_PMU_ECC_DMA, - ETHOSU_PMU_ECC_MAC_IB, - ETHOSU_PMU_ECC_MAC_AB, - ETHOSU_PMU_ECC_AO_CB, - ETHOSU_PMU_ECC_AO_OB, - ETHOSU_PMU_ECC_AO_LUT, - ETHOSU_PMU_EXT_RD_TRANS_ACCEPTED, - ETHOSU_PMU_EXT_RD_TRANS_COMPLETED, - ETHOSU_PMU_EXT_RD_DATA_BEAT_RECEIVED, - ETHOSU_PMU_EXT_RD_TRAN_REQ_STALLED, - ETHOSU_PMU_EXT_WR_TRANS_ACCEPTED, - ETHOSU_PMU_EXT_WR_TRANS_COMPLETED_M, - ETHOSU_PMU_EXT_WR_TRANS_COMPLETED_S, - ETHOSU_PMU_EXT_WR_DATA_BEAT_WRITTEN, - ETHOSU_PMU_EXT_WR_TRAN_REQ_STALLED, - ETHOSU_PMU_EXT_WR_DATA_BEAT_STALLED, - ETHOSU_PMU_EXT_ENABLED_CYCLES, - ETHOSU_PMU_EXT_RD_STALL_LIMIT, - ETHOSU_PMU_EXT_WR_STALL_LIMIT, - ETHOSU_PMU_SRAM0_RD_TRANS_ACCEPTED, - ETHOSU_PMU_SRAM0_RD_TRANS_COMPLETED, - ETHOSU_PMU_SRAM0_RD_DATA_BEAT_RECEIVED, - ETHOSU_PMU_SRAM0_RD_TRAN_REQ_STALLED, - ETHOSU_PMU_SRAM0_WR_TRANS_ACCEPTED, - ETHOSU_PMU_SRAM0_WR_TRANS_COMPLETED_M, - ETHOSU_PMU_SRAM0_WR_TRANS_COMPLETED_S, - ETHOSU_PMU_SRAM0_WR_DATA_BEAT_WRITTEN, - ETHOSU_PMU_SRAM0_WR_TRAN_REQ_STALLED, - ETHOSU_PMU_SRAM0_WR_DATA_BEAT_STALLED, - ETHOSU_PMU_SRAM0_ENABLED_CYCLES, - ETHOSU_PMU_SRAM0_RD_STALL_LIMIT, - ETHOSU_PMU_SRAM0_WR_STALL_LIMIT, - ETHOSU_PMU_SRAM1_RD_TRANS_ACCEPTED, - ETHOSU_PMU_SRAM1_RD_TRANS_COMPLETED, - ETHOSU_PMU_SRAM1_RD_DATA_BEAT_RECEIVED, - ETHOSU_PMU_SRAM1_RD_TRAN_REQ_STALLED, - ETHOSU_PMU_SRAM1_WR_TRANS_ACCEPTED, - ETHOSU_PMU_SRAM1_WR_TRANS_COMPLETED_M, - ETHOSU_PMU_SRAM1_WR_TRANS_COMPLETED_S, - ETHOSU_PMU_SRAM1_WR_DATA_BEAT_WRITTEN, - ETHOSU_PMU_SRAM1_WR_TRAN_REQ_STALLED, - ETHOSU_PMU_SRAM1_WR_DATA_BEAT_STALLED, - ETHOSU_PMU_SRAM1_ENABLED_CYCLES, - ETHOSU_PMU_SRAM1_RD_STALL_LIMIT, - ETHOSU_PMU_SRAM1_WR_STALL_LIMIT, - ETHOSU_PMU_SRAM2_RD_TRANS_ACCEPTED, - ETHOSU_PMU_SRAM2_RD_TRANS_COMPLETED, - ETHOSU_PMU_SRAM2_RD_DATA_BEAT_RECEIVED, - ETHOSU_PMU_SRAM2_RD_TRAN_REQ_STALLED, - ETHOSU_PMU_SRAM2_WR_TRANS_ACCEPTED, - ETHOSU_PMU_SRAM2_WR_TRANS_COMPLETED_M, - ETHOSU_PMU_SRAM2_WR_TRANS_COMPLETED_S, - ETHOSU_PMU_SRAM2_WR_DATA_BEAT_WRITTEN, - ETHOSU_PMU_SRAM2_WR_TRAN_REQ_STALLED, - ETHOSU_PMU_SRAM2_WR_DATA_BEAT_STALLED, - ETHOSU_PMU_SRAM2_ENABLED_CYCLES, - ETHOSU_PMU_SRAM2_RD_STALL_LIMIT, - ETHOSU_PMU_SRAM2_WR_STALL_LIMIT, - ETHOSU_PMU_SRAM3_RD_TRANS_ACCEPTED, - ETHOSU_PMU_SRAM3_RD_TRANS_COMPLETED, - ETHOSU_PMU_SRAM3_RD_DATA_BEAT_RECEIVED, - ETHOSU_PMU_SRAM3_RD_TRAN_REQ_STALLED, - ETHOSU_PMU_SRAM3_WR_TRANS_ACCEPTED, - ETHOSU_PMU_SRAM3_WR_TRANS_COMPLETED_M, - ETHOSU_PMU_SRAM3_WR_TRANS_COMPLETED_S, - ETHOSU_PMU_SRAM3_WR_DATA_BEAT_WRITTEN, - ETHOSU_PMU_SRAM3_WR_TRAN_REQ_STALLED, - ETHOSU_PMU_SRAM3_WR_DATA_BEAT_STALLED, - ETHOSU_PMU_SRAM3_ENABLED_CYCLES, - ETHOSU_PMU_SRAM3_RD_STALL_LIMIT, - ETHOSU_PMU_SRAM3_WR_STALL_LIMIT, - ETHOSU_PMU_EXT0_RD_TRANS_ACCEPTED, - ETHOSU_PMU_EXT0_RD_TRANS_COMPLETED, - ETHOSU_PMU_EXT0_RD_DATA_BEAT_RECEIVED, - ETHOSU_PMU_EXT0_RD_TRAN_REQ_STALLED, - ETHOSU_PMU_EXT0_WR_TRANS_ACCEPTED, - ETHOSU_PMU_EXT0_WR_TRANS_COMPLETED_M, - ETHOSU_PMU_EXT0_WR_TRANS_COMPLETED_S, - ETHOSU_PMU_EXT0_WR_DATA_BEAT_WRITTEN, - ETHOSU_PMU_EXT0_WR_TRAN_REQ_STALLED, - ETHOSU_PMU_EXT0_WR_DATA_BEAT_STALLED, - ETHOSU_PMU_EXT0_ENABLED_CYCLES, - ETHOSU_PMU_EXT0_RD_STALL_LIMIT, - ETHOSU_PMU_EXT0_WR_STALL_LIMIT, - ETHOSU_PMU_EXT1_RD_TRANS_ACCEPTED, - ETHOSU_PMU_EXT1_RD_TRANS_COMPLETED, - ETHOSU_PMU_EXT1_RD_DATA_BEAT_RECEIVED, - ETHOSU_PMU_EXT1_RD_TRAN_REQ_STALLED, - ETHOSU_PMU_EXT1_WR_TRANS_ACCEPTED, - ETHOSU_PMU_EXT1_WR_TRANS_COMPLETED_M, - ETHOSU_PMU_EXT1_WR_TRANS_COMPLETED_S, - ETHOSU_PMU_EXT1_WR_DATA_BEAT_WRITTEN, - ETHOSU_PMU_EXT1_WR_TRAN_REQ_STALLED, - ETHOSU_PMU_EXT1_WR_DATA_BEAT_STALLED, - ETHOSU_PMU_EXT1_ENABLED_CYCLES, - ETHOSU_PMU_EXT1_RD_STALL_LIMIT, - ETHOSU_PMU_EXT1_WR_STALL_LIMIT, - - ETHOSU_PMU_SENTINEL // End-marker (not event) -}; -#else -#error No NPU target defined -#endif - -/***************************************************************************** - * Functions - *****************************************************************************/ - -/** - * \brief Enable the PMU - */ -void ETHOSU_PMU_Enable(struct ethosu_driver *drv); - -/** - * \brief Disable the PMU - */ -void ETHOSU_PMU_Disable(struct ethosu_driver *drv); - -/** - * \brief Set event to count for PMU eventer counter - * \param [in] num Event counter (0-ETHOSU_PMU_NCOUNTERS) to configure - * \param [in] type Event to count - */ -void ETHOSU_PMU_Set_EVTYPER(struct ethosu_driver *drv, uint32_t num, enum ethosu_pmu_event_type type); - -/** - * \brief Get number of PMU event counters - * \return Number of event counters - */ -uint32_t ETHOSU_PMU_Get_NumEventCounters(void); - -/** - * \brief Get event to count for PMU eventer counter - * \param [in] num Event counter (0-ETHOSU_PMU_NCOUNTERS) to configure - * \return type Event to count - */ -enum ethosu_pmu_event_type ETHOSU_PMU_Get_EVTYPER(struct ethosu_driver *drv, uint32_t num); - -/** - * \brief Reset cycle counter - */ -void ETHOSU_PMU_CYCCNT_Reset(struct ethosu_driver *drv); - -/** - * \brief Reset all event counters - */ -void ETHOSU_PMU_EVCNTR_ALL_Reset(struct ethosu_driver *drv); - -/** - * \brief Enable counters - * \param [in] mask Counters to enable - * \note Enables one or more of the following: - * - event counters (bit 0-ETHOSU_PMU_NCOUNTERS) - * - cycle counter (bit 31) - */ -void ETHOSU_PMU_CNTR_Enable(struct ethosu_driver *drv, uint32_t mask); - -/** - * \brief Disable counters - * \param [in] mask Counters to disable - * \note Disables one or more of the following: - * - event counters (bit 0-ETHOSU_PMU_NCOUNTERS) - * - cycle counter (bit 31) - */ -void ETHOSU_PMU_CNTR_Disable(struct ethosu_driver *drv, uint32_t mask); - -/** - * \brief Determine counters activation - * - * \return Event count - * \param [in] mask Counters to enable - * \return a bitmask where bit-set means: - * - event counters activated (bit 0-ETHOSU_PMU_NCOUNTERS) - * - cycle counter activate (bit 31) - * \note ETHOSU specific. Usage breaks CMSIS complience - */ -uint32_t ETHOSU_PMU_CNTR_Status(struct ethosu_driver *drv); - -/** - * \brief Read cycle counter (64 bit) - * \return Cycle count - * \note Two HW 32-bit registers that can increment independently in-between reads. - * To work-around raciness yet still avoid turning - * off the event both are read as one value twice. If the latter read - * is not greater than the former, it means overflow of LSW without - * incrementing MSW has occurred, in which case the former value is used. - */ -uint64_t ETHOSU_PMU_Get_CCNTR(struct ethosu_driver *drv); - -/** - * \brief Set cycle counter (64 bit) - * \param [in] val Conter value - * \note Two HW 32-bit registers that can increment independently in-between reads. - * To work-around raciness, counter is temporary disabled if enabled. - * \note ETHOSU specific. Usage breaks CMSIS complience - */ -void ETHOSU_PMU_Set_CCNTR(struct ethosu_driver *drv, uint64_t val); - -/** - * \brief Read event counter - * \param [in] num Event counter (0-ETHOSU_PMU_NCOUNTERS) - * \return Event count - */ -uint32_t ETHOSU_PMU_Get_EVCNTR(struct ethosu_driver *drv, uint32_t num); - -/** - * \brief Set event counter value - * \param [in] num Event counter (0-ETHOSU_PMU_NCOUNTERS) - * \param [in] val Conter value - * \note ETHOSU specific. Usage breaks CMSIS complience - */ -void ETHOSU_PMU_Set_EVCNTR(struct ethosu_driver *drv, uint32_t num, uint32_t val); - -/** - * \brief Read counter overflow status - * \return Counter overflow status bits for the following: - * - event counters (bit 0-ETHOSU_PMU_NCOUNTERS)) - * - cycle counter (bit 31) - */ -uint32_t ETHOSU_PMU_Get_CNTR_OVS(struct ethosu_driver *drv); - -/** - * \brief Clear counter overflow status - * \param [in] mask Counter overflow status bits to clear - * \note Clears overflow status bits for one or more of the following: - * - event counters (bit 0-ETHOSU_PMU_NCOUNTERS) - * - cycle counter (bit 31) - */ -void ETHOSU_PMU_Set_CNTR_OVS(struct ethosu_driver *drv, uint32_t mask); - -/** - * \brief Enable counter overflow interrupt request - * \param [in] mask Counter overflow interrupt request bits to set - * \note Sets overflow interrupt request bits for one or more of the following: - * - event counters (bit 0-ETHOSU_PMU_NCOUNTERS) - * - cycle counter (bit 31) - */ -void ETHOSU_PMU_Set_CNTR_IRQ_Enable(struct ethosu_driver *drv, uint32_t mask); - -/** - * \brief Disable counter overflow interrupt request - * \param [in] mask Counter overflow interrupt request bits to clear - * \note Clears overflow interrupt request bits for one or more of the following: - * - event counters (bit 0-ETHOSU_PMU_NCOUNTERS) - * - cycle counter (bit 31) - */ -void ETHOSU_PMU_Set_CNTR_IRQ_Disable(struct ethosu_driver *drv, uint32_t mask); - -/** - * \brief Get counters overflow interrupt request stiinings - * \return mask Counter overflow interrupt request bits - * \note Sets overflow interrupt request bits for one or more of the following: - * - event counters (bit 0-ETHOSU_PMU_NCOUNTERS) - * - cycle counter (bit 31) - * \note ETHOSU specific. Usage breaks CMSIS compliance - */ -uint32_t ETHOSU_PMU_Get_IRQ_Enable(struct ethosu_driver *drv); - -/** - * \brief Software increment event counter - * \param [in] mask Counters to increment - * - event counters (bit 0-ETHOSU_PMU_NCOUNTERS) - * - cycle counter (bit 31) - * \note Software increment bits for one or more event counters. - */ -void ETHOSU_PMU_CNTR_Increment(struct ethosu_driver *drv, uint32_t mask); - -/** - * \brief Set start event number for the cycle counter - * \param [in] start_event Event to trigger start of the cycle counter - * \note Sets the event number that starts the cycle counter. - */ -void ETHOSU_PMU_PMCCNTR_CFG_Set_Start_Event(struct ethosu_driver *drv, enum ethosu_pmu_event_type start_event); - -/** - * \brief Set stop event number for the cycle counter - * \param [in] stop_event Event number - * \note Sets the event number that stops the cycle counter. - */ -void ETHOSU_PMU_PMCCNTR_CFG_Set_Stop_Event(struct ethosu_driver *drv, enum ethosu_pmu_event_type stop_event); - -/** - * \brief Read qread register - */ -uint32_t ETHOSU_PMU_Get_QREAD(struct ethosu_driver *drv); - -/** - * \brief Read status register - */ -uint32_t ETHOSU_PMU_Get_STATUS(struct ethosu_driver *drv); - -#ifdef __cplusplus -} -#endif - -#endif /* PMU_ETHOSU_H */ diff --git a/ai_layer/engine/include/executorch/backends/arm/third-party/ethos-u-core-driver/src/ethosu55_interface.h b/ai_layer/engine/include/executorch/backends/arm/third-party/ethos-u-core-driver/src/ethosu55_interface.h deleted file mode 100644 index 37472b9c..00000000 --- a/ai_layer/engine/include/executorch/backends/arm/third-party/ethos-u-core-driver/src/ethosu55_interface.h +++ /dev/null @@ -1,26197 +0,0 @@ -/* - * Copyright (c) 2020-2021 Arm Limited. All rights reserved. - * - * SPDX-License-Identifier: Apache-2.0 - * - * Licensed under the Apache License, Version 2.0 (the License); you may - * not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an AS IS BASIS, WITHOUT - * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef ETHOSU55_INTERFACE_H -#define ETHOSU55_INTERFACE_H - -#ifdef __KERNEL__ -#include -#else -#include -#endif - -#if !defined(__cplusplus) || __cplusplus < 201402L -#define CONSTEXPR -#else -#define CONSTEXPR constexpr -#endif - -#ifndef __cplusplus -#define STRUCT struct -#else -#define STRUCT -#endif - -#if defined(__cplusplus) && defined(NPU_DISASSEMBLE) -#include -#include -#include -#endif - -#if defined(__cplusplus) && !defined(NPU_NAMESPACE) -#define NPU_NAMESPACE npu -#endif - -#ifdef __cplusplus -#include -#include -#endif - -#ifdef __cplusplus -namespace NPU_NAMESPACE -{ -#endif -#define NNX_ARCH_VERSION_MAJOR 1 -#define NNX_ARCH_VERSION_MINOR 1 -#define NNX_ARCH_VERSION_PATCH 0 - -// Register offsets -// -// Register subpage BASE -// -#define NPU_REG_ID 0x0000 -#define NPU_REG_STATUS 0x0004 -#define NPU_REG_CMD 0x0008 -#define NPU_REG_RESET 0x000C -#define NPU_REG_QBASE 0x0010 -#define NPU_REG_QBASE_HI 0x0014 -#define NPU_REG_QREAD 0x0018 -#define NPU_REG_QCONFIG 0x001C -#define NPU_REG_QSIZE 0x0020 -#define NPU_REG_PROT 0x0024 -#define NPU_REG_CONFIG 0x0028 -#define NPU_REG_LOCK 0x002C -#define NPU_REG_REGIONCFG 0x003C -#define NPU_REG_AXI_LIMIT0 0x0040 -#define NPU_REG_AXI_LIMIT1 0x0044 -#define NPU_REG_AXI_LIMIT2 0x0048 -#define NPU_REG_AXI_LIMIT3 0x004C -#define BASE_REGISTERS_SIZE 0x0080 - -// -// Register subpage BASE_POINTERS -// -#define NPU_REG_BASEP_BASE 0x0080 -#define NPU_REG_BASEP_ARRLEN 0x0008 -#define BASE_POINTERS_REGISTERS_SIZE 0x0100 - -// -// Register subpage DEBUG -// -#define NPU_REG_WD_STATUS 0x0100 -#define NPU_REG_MAC_STATUS 0x0104 -#define NPU_REG_AO_STATUS 0x0108 -#define NPU_REG_DMA_STATUS0 0x0110 -#define NPU_REG_DMA_STATUS1 0x0114 -#define NPU_REG_CLKFORCE 0x0140 -#define NPU_REG_DEBUG_ADDRESS 0x0144 -#define NPU_REG_DEBUG_MISC 0x0148 -#define NPU_REG_DEBUG_BLOCK 0x0150 -#define DEBUG_REGISTERS_SIZE 0x0180 - -// -// Register subpage PMU -// -#define NPU_REG_PMCR 0x0180 -#define NPU_REG_PMCNTENSET 0x0184 -#define NPU_REG_PMCNTENCLR 0x0188 -#define NPU_REG_PMOVSSET 0x018C -#define NPU_REG_PMOVSCLR 0x0190 -#define NPU_REG_PMINTSET 0x0194 -#define NPU_REG_PMINTCLR 0x0198 -#define NPU_REG_PMCCNTR 0x01A0 -#define NPU_REG_PMCCNTR_HI 0x01A4 -#define NPU_REG_PMCCNTR_CFG 0x01A8 -#define NPU_REG_PMCAXI_CHAN 0x01AC -#define PMU_REGISTERS_SIZE 0x0200 - -// -// Register subpage TSU_DEBUG -// -#define NPU_REG_KERNEL_X 0x0200 -#define NPU_REG_KERNEL_Y 0x0204 -#define NPU_REG_KERNEL_W_M1 0x0208 -#define NPU_REG_KERNEL_H_M1 0x020C -#define NPU_REG_OFM_CBLK_WIDTH_M1 0x0210 -#define NPU_REG_OFM_CBLK_HEIGHT_M1 0x0214 -#define NPU_REG_OFM_CBLK_DEPTH_M1 0x0218 -#define NPU_REG_IFM_CBLK_DEPTH_M1 0x021C -#define NPU_REG_OFM_X 0x0220 -#define NPU_REG_OFM_Y 0x0224 -#define NPU_REG_OFM_Z 0x0228 -#define NPU_REG_IFM_Z 0x022C -#define NPU_REG_PAD_TOP 0x0230 -#define NPU_REG_PAD_LEFT 0x0234 -#define NPU_REG_IFM_CBLK_WIDTH 0x0238 -#define NPU_REG_IFM_CBLK_HEIGHT 0x023C -#define NPU_REG_DMA_IFM_SRC 0x0240 -#define NPU_REG_DMA_IFM_SRC_HI 0x0244 -#define NPU_REG_DMA_IFM_DST 0x0248 -#define NPU_REG_DMA_OFM_SRC 0x024C -#define NPU_REG_DMA_OFM_DST 0x0250 -#define NPU_REG_DMA_OFM_DST_HI 0x0254 -#define NPU_REG_DMA_WEIGHT_SRC 0x0258 -#define NPU_REG_DMA_WEIGHT_SRC_HI 0x025C -#define NPU_REG_DMA_CMD_SRC 0x0260 -#define NPU_REG_DMA_CMD_SRC_HI 0x0264 -#define NPU_REG_DMA_CMD_SIZE 0x0268 -#define NPU_REG_DMA_M2M_SRC 0x026C -#define NPU_REG_DMA_M2M_SRC_HI 0x0270 -#define NPU_REG_DMA_M2M_DST 0x0274 -#define NPU_REG_DMA_M2M_DST_HI 0x0278 -#define NPU_REG_CURRENT_QREAD 0x027C -#define NPU_REG_DMA_SCALE_SRC 0x0280 -#define NPU_REG_DMA_SCALE_SRC_HI 0x0284 -#define NPU_REG_CURRENT_BLOCK 0x02B4 -#define NPU_REG_CURRENT_OP 0x02B8 -#define NPU_REG_CURRENT_CMD 0x02BC -#define TSU_DEBUG_REGISTERS_SIZE 0x02C0 - -// -// Register subpage PMU_COUNTERS -// -#define NPU_REG_PMEVCNTR_BASE 0x0300 -#define NPU_REG_PMEVCNTR_ARRLEN 0x0004 -#define NPU_REG_PMEVTYPER_BASE 0x0380 -#define NPU_REG_PMEVTYPER_ARRLEN 0x0004 -#define PMU_COUNTERS_REGISTERS_SIZE 0x0400 - -// -// Register subpage SHARED_BUFFER -// -#define NPU_REG_SHARED_BUFFER_BASE 0x0400 -#define NPU_REG_SHARED_BUFFER_ARRLEN 0x0100 -#define SHARED_BUFFER_REGISTERS_SIZE 0x0800 - -// -// Register subpage TSU_IFM -// -#define NPU_REG_IFM_PAD_TOP 0x0800 -#define NPU_REG_IFM_PAD_LEFT 0x0804 -#define NPU_REG_IFM_PAD_RIGHT 0x0808 -#define NPU_REG_IFM_PAD_BOTTOM 0x080C -#define NPU_REG_IFM_DEPTH_M1 0x0810 -#define NPU_REG_IFM_PRECISION 0x0814 -#define NPU_REG_IFM_UPSCALE 0x081C -#define NPU_REG_IFM_ZERO_POINT 0x0824 -#define NPU_REG_IFM_WIDTH0_M1 0x0828 -#define NPU_REG_IFM_HEIGHT0_M1 0x082C -#define NPU_REG_IFM_HEIGHT1_M1 0x0830 -#define NPU_REG_IFM_IB_END 0x0834 -#define NPU_REG_IFM_REGION 0x083C -#define TSU_IFM_REGISTERS_SIZE 0x0840 - -// -// Register subpage TSU_OFM -// -#define NPU_REG_OFM_WIDTH_M1 0x0844 -#define NPU_REG_OFM_HEIGHT_M1 0x0848 -#define NPU_REG_OFM_DEPTH_M1 0x084C -#define NPU_REG_OFM_PRECISION 0x0850 -#define NPU_REG_OFM_BLK_WIDTH_M1 0x0854 -#define NPU_REG_OFM_BLK_HEIGHT_M1 0x0858 -#define NPU_REG_OFM_BLK_DEPTH_M1 0x085C -#define NPU_REG_OFM_ZERO_POINT 0x0860 -#define NPU_REG_OFM_WIDTH0_M1 0x0868 -#define NPU_REG_OFM_HEIGHT0_M1 0x086C -#define NPU_REG_OFM_HEIGHT1_M1 0x0870 -#define NPU_REG_OFM_REGION 0x087C -#define TSU_OFM_REGISTERS_SIZE 0x0880 - -// -// Register subpage TSU_KERNEL -// -#define NPU_REG_KERNEL_WIDTH_M1 0x0880 -#define NPU_REG_KERNEL_HEIGHT_M1 0x0884 -#define NPU_REG_KERNEL_STRIDE 0x0888 -#define NPU_REG_ACC_FORMAT 0x0890 -#define NPU_REG_ACTIVATION 0x0894 -#define NPU_REG_ACTIVATION_MIN 0x0898 -#define NPU_REG_ACTIVATION_MAX 0x089C -#define NPU_REG_WEIGHT_REGION 0x08A0 -#define NPU_REG_SCALE_REGION 0x08A4 -#define NPU_REG_AB_START 0x08B4 -#define NPU_REG_BLOCKDEP 0x08BC -#define TSU_KERNEL_REGISTERS_SIZE 0x08C0 - -// -// Register subpage TSU_DMA -// -#define NPU_REG_DMA0_SRC_REGION 0x08C0 -#define NPU_REG_DMA0_DST_REGION 0x08C4 -#define NPU_REG_DMA0_SIZE0 0x08C8 -#define NPU_REG_DMA0_SIZE1 0x08CC -#define TSU_DMA_REGISTERS_SIZE 0x0900 - -// -// Register subpage TSU_IFM2 -// -#define NPU_REG_IFM2_BROADCAST 0x0900 -#define NPU_REG_IFM2_SCALAR 0x0904 -#define NPU_REG_IFM2_PRECISION 0x0914 -#define NPU_REG_IFM2_ZERO_POINT 0x0924 -#define NPU_REG_IFM2_WIDTH0_M1 0x0928 -#define NPU_REG_IFM2_HEIGHT0_M1 0x092C -#define NPU_REG_IFM2_HEIGHT1_M1 0x0930 -#define NPU_REG_IFM2_IB_START 0x0934 -#define NPU_REG_IFM2_REGION 0x093C -#define TSU_IFM2_REGISTERS_SIZE 0x0940 - -// -// Register subpage TSU_IFM_BASE -// -#define NPU_REG_IFM_BASE0 0x0A00 -#define NPU_REG_IFM_BASE0_HI 0x0A04 -#define NPU_REG_IFM_BASE1 0x0A08 -#define NPU_REG_IFM_BASE1_HI 0x0A0C -#define NPU_REG_IFM_BASE2 0x0A10 -#define NPU_REG_IFM_BASE2_HI 0x0A14 -#define NPU_REG_IFM_BASE3 0x0A18 -#define NPU_REG_IFM_BASE3_HI 0x0A1C -#define NPU_REG_IFM_STRIDE_X 0x0A20 -#define NPU_REG_IFM_STRIDE_X_HI 0x0A24 -#define NPU_REG_IFM_STRIDE_Y 0x0A28 -#define NPU_REG_IFM_STRIDE_Y_HI 0x0A2C -#define NPU_REG_IFM_STRIDE_C 0x0A30 -#define NPU_REG_IFM_STRIDE_C_HI 0x0A34 -#define TSU_IFM_BASE_REGISTERS_SIZE 0x0A40 - -// -// Register subpage TSU_OFM_BASE -// -#define NPU_REG_OFM_BASE0 0x0A40 -#define NPU_REG_OFM_BASE0_HI 0x0A44 -#define NPU_REG_OFM_BASE1 0x0A48 -#define NPU_REG_OFM_BASE1_HI 0x0A4C -#define NPU_REG_OFM_BASE2 0x0A50 -#define NPU_REG_OFM_BASE2_HI 0x0A54 -#define NPU_REG_OFM_BASE3 0x0A58 -#define NPU_REG_OFM_BASE3_HI 0x0A5C -#define NPU_REG_OFM_STRIDE_X 0x0A60 -#define NPU_REG_OFM_STRIDE_X_HI 0x0A64 -#define NPU_REG_OFM_STRIDE_Y 0x0A68 -#define NPU_REG_OFM_STRIDE_Y_HI 0x0A6C -#define NPU_REG_OFM_STRIDE_C 0x0A70 -#define NPU_REG_OFM_STRIDE_C_HI 0x0A74 -#define TSU_OFM_BASE_REGISTERS_SIZE 0x0A80 - -// -// Register subpage TSU_WS_BASE -// -#define NPU_REG_WEIGHT_BASE 0x0A80 -#define NPU_REG_WEIGHT_BASE_HI 0x0A84 -#define NPU_REG_WEIGHT_LENGTH 0x0A88 -#define NPU_REG_WEIGHT_LENGTH_HI 0x0A8C -#define NPU_REG_SCALE_BASE 0x0A90 -#define NPU_REG_SCALE_BASE_HI 0x0A94 -#define NPU_REG_SCALE_LENGTH 0x0A98 -#define NPU_REG_SCALE_LENGTH_HI 0x0A9C -#define NPU_REG_OFM_SCALE 0x0AA0 -#define NPU_REG_OFM_SCALE_SHIFT 0x0AA4 -#define NPU_REG_OPA_SCALE 0x0AA8 -#define NPU_REG_OPA_SCALE_SHIFT 0x0AAC -#define NPU_REG_OPB_SCALE 0x0AB0 -#define TSU_WS_BASE_REGISTERS_SIZE 0x0AC0 - -// -// Register subpage TSU_DMA_BASE -// -#define NPU_REG_DMA0_SRC 0x0AC0 -#define NPU_REG_DMA0_SRC_HI 0x0AC4 -#define NPU_REG_DMA0_DST 0x0AC8 -#define NPU_REG_DMA0_DST_HI 0x0ACC -#define NPU_REG_DMA0_LEN 0x0AD0 -#define NPU_REG_DMA0_LEN_HI 0x0AD4 -#define TSU_DMA_BASE_REGISTERS_SIZE 0x0B00 - -// -// Register subpage TSU_IFM2_BASE -// -#define NPU_REG_IFM2_BASE0 0x0B00 -#define NPU_REG_IFM2_BASE0_HI 0x0B04 -#define NPU_REG_IFM2_BASE1 0x0B08 -#define NPU_REG_IFM2_BASE1_HI 0x0B0C -#define NPU_REG_IFM2_BASE2 0x0B10 -#define NPU_REG_IFM2_BASE2_HI 0x0B14 -#define NPU_REG_IFM2_BASE3 0x0B18 -#define NPU_REG_IFM2_BASE3_HI 0x0B1C -#define NPU_REG_IFM2_STRIDE_X 0x0B20 -#define NPU_REG_IFM2_STRIDE_X_HI 0x0B24 -#define NPU_REG_IFM2_STRIDE_Y 0x0B28 -#define NPU_REG_IFM2_STRIDE_Y_HI 0x0B2C -#define NPU_REG_IFM2_STRIDE_C 0x0B30 -#define NPU_REG_IFM2_STRIDE_C_HI 0x0B34 -#define TSU_IFM2_BASE_REGISTERS_SIZE 0x0B40 - -// -// Register subpage TSU_WS1_BASE -// -#define TSU_WS1_BASE_REGISTERS_SIZE 0x0B80 - -// -// Register subpage TSU_USER_BASE -// -#define NPU_REG_USER_DEFINED_BASE 0x0B80 -#define NPU_REG_USER_DEFINED_ARRLEN 0x0008 -#define TSU_USER_BASE_REGISTERS_SIZE 0x0BC0 - -// -// Register subpage TSU_DMA_EBASE -// -#define TSU_DMA_EBASE_REGISTERS_SIZE 0x0C00 - -// -// Register subpage ID -// -#define NPU_REG_REVISION 0x0FC0 -#define NPU_REG_PID4 0x0FD0 -#define NPU_REG_PID5 0x0FD4 -#define NPU_REG_PID6 0x0FD8 -#define NPU_REG_PID7 0x0FDC -#define NPU_REG_PID0 0x0FE0 -#define NPU_REG_PID1 0x0FE4 -#define NPU_REG_PID2 0x0FE8 -#define NPU_REG_PID3 0x0FEC -#define NPU_REG_CID0 0x0FF0 -#define NPU_REG_CID1 0x0FF4 -#define NPU_REG_CID2 0x0FF8 -#define NPU_REG_CID3 0x0FFC -#define ID_REGISTERS_SIZE 0x1000 - -#ifdef __cplusplus -// Enum types -enum class acc_format : uint8_t -{ - I32 = 0, - I40 = 1, - F16 = 2, -}; - -enum class activation_clip_range : uint8_t -{ - OFM_PRECISION = 0, - FORCE_UINT8 = 2, - FORCE_INT8 = 3, - FORCE_INT16 = 5, -}; - -enum class activation_format : uint8_t -{ - NHWC = 0, - NHCWB16 = 1, -}; - -enum class activation_function : uint8_t -{ - RELU = 0, - TANH = 3, - SIGMOID = 4, - TABLE_0 = 16, - TABLE_1 = 17, - TABLE_2 = 18, - TABLE_3 = 19, - TABLE_4 = 20, - TABLE_5 = 21, - TABLE_6 = 22, - TABLE_7 = 23, -}; - -enum class activation_precision : uint8_t -{ - B8 = 0, - B16 = 1, - B32 = 2, - B64 = 3, -}; - -enum class activation_type : uint8_t -{ - UNSIGNED = 0, - SIGNED = 1, -}; - -enum class axi_mem_encoding : uint8_t -{ - DEVICE_NON_BUFFERABLE = 0, - DEVICE_BUFFERABLE = 1, - NORMAL_NON_CACHEABLE_NON_BUFFERABLE = 2, - NORMAL_NON_CACHEABLE_BUFFERABLE = 3, - WRITE_THROUGH_NO_ALLOCATE = 4, - WRITE_THROUGH_READ_ALLOCATE = 5, - WRITE_THROUGH_WRITE_ALLOCATE = 6, - WRITE_THROUGH_READ_AND_WRITE_ALLOCATE = 7, - WRITE_BACK_NO_ALLOCATE = 8, - WRITE_BACK_READ_ALLOCATE = 9, - WRITE_BACK_WRITE_ALLOCATE = 10, - WRITE_BACK_READ_AND_WRITE_ALLOCATE = 11, -}; - -enum class broadcast_mode : uint8_t -{ - DISABLE = 0, - ENABLE = 1, -}; - -enum class cmd0_opcode : uint16_t -{ - NPU_OP_STOP = 0, - NPU_OP_IRQ = 1, - NPU_OP_CONV = 2, - NPU_OP_DEPTHWISE = 3, - NPU_OP_POOL = 5, - NPU_OP_ELEMENTWISE = 6, - NPU_OP_DMA_START = 16, - NPU_OP_DMA_WAIT = 17, - NPU_OP_KERNEL_WAIT = 18, - NPU_OP_PMU_MASK = 19, - NPU_SET_IFM_PAD_TOP = 256, - NPU_SET_IFM_PAD_LEFT = 257, - NPU_SET_IFM_PAD_RIGHT = 258, - NPU_SET_IFM_PAD_BOTTOM = 259, - NPU_SET_IFM_DEPTH_M1 = 260, - NPU_SET_IFM_PRECISION = 261, - NPU_SET_IFM_UPSCALE = 263, - NPU_SET_IFM_ZERO_POINT = 265, - NPU_SET_IFM_WIDTH0_M1 = 266, - NPU_SET_IFM_HEIGHT0_M1 = 267, - NPU_SET_IFM_HEIGHT1_M1 = 268, - NPU_SET_IFM_IB_END = 269, - NPU_SET_IFM_REGION = 271, - NPU_SET_OFM_WIDTH_M1 = 273, - NPU_SET_OFM_HEIGHT_M1 = 274, - NPU_SET_OFM_DEPTH_M1 = 275, - NPU_SET_OFM_PRECISION = 276, - NPU_SET_OFM_BLK_WIDTH_M1 = 277, - NPU_SET_OFM_BLK_HEIGHT_M1 = 278, - NPU_SET_OFM_BLK_DEPTH_M1 = 279, - NPU_SET_OFM_ZERO_POINT = 280, - NPU_SET_OFM_WIDTH0_M1 = 282, - NPU_SET_OFM_HEIGHT0_M1 = 283, - NPU_SET_OFM_HEIGHT1_M1 = 284, - NPU_SET_OFM_REGION = 287, - NPU_SET_KERNEL_WIDTH_M1 = 288, - NPU_SET_KERNEL_HEIGHT_M1 = 289, - NPU_SET_KERNEL_STRIDE = 290, - NPU_SET_ACC_FORMAT = 292, - NPU_SET_ACTIVATION = 293, - NPU_SET_ACTIVATION_MIN = 294, - NPU_SET_ACTIVATION_MAX = 295, - NPU_SET_WEIGHT_REGION = 296, - NPU_SET_SCALE_REGION = 297, - NPU_SET_AB_START = 301, - NPU_SET_BLOCKDEP = 303, - NPU_SET_DMA0_SRC_REGION = 304, - NPU_SET_DMA0_DST_REGION = 305, - NPU_SET_DMA0_SIZE0 = 306, - NPU_SET_DMA0_SIZE1 = 307, - NPU_SET_IFM2_BROADCAST = 384, - NPU_SET_IFM2_SCALAR = 385, - NPU_SET_IFM2_PRECISION = 389, - NPU_SET_IFM2_ZERO_POINT = 393, - NPU_SET_IFM2_WIDTH0_M1 = 394, - NPU_SET_IFM2_HEIGHT0_M1 = 395, - NPU_SET_IFM2_HEIGHT1_M1 = 396, - NPU_SET_IFM2_IB_START = 397, - NPU_SET_IFM2_REGION = 399, -}; - -enum class cmd1_opcode : uint16_t -{ - NPU_SET_IFM_BASE0 = 0, - NPU_SET_IFM_BASE1 = 1, - NPU_SET_IFM_BASE2 = 2, - NPU_SET_IFM_BASE3 = 3, - NPU_SET_IFM_STRIDE_X = 4, - NPU_SET_IFM_STRIDE_Y = 5, - NPU_SET_IFM_STRIDE_C = 6, - NPU_SET_OFM_BASE0 = 16, - NPU_SET_OFM_BASE1 = 17, - NPU_SET_OFM_BASE2 = 18, - NPU_SET_OFM_BASE3 = 19, - NPU_SET_OFM_STRIDE_X = 20, - NPU_SET_OFM_STRIDE_Y = 21, - NPU_SET_OFM_STRIDE_C = 22, - NPU_SET_WEIGHT_BASE = 32, - NPU_SET_WEIGHT_LENGTH = 33, - NPU_SET_SCALE_BASE = 34, - NPU_SET_SCALE_LENGTH = 35, - NPU_SET_OFM_SCALE = 36, - NPU_SET_OPA_SCALE = 37, - NPU_SET_OPB_SCALE = 38, - NPU_SET_DMA0_SRC = 48, - NPU_SET_DMA0_DST = 49, - NPU_SET_DMA0_LEN = 50, - NPU_SET_IFM2_BASE0 = 128, - NPU_SET_IFM2_BASE1 = 129, - NPU_SET_IFM2_BASE2 = 130, - NPU_SET_IFM2_BASE3 = 131, - NPU_SET_IFM2_STRIDE_X = 132, - NPU_SET_IFM2_STRIDE_Y = 133, - NPU_SET_IFM2_STRIDE_C = 134, - NPU_SET_USER_DEFINED0 = 160, - NPU_SET_USER_DEFINED1 = 161, - NPU_SET_USER_DEFINED2 = 162, - NPU_SET_USER_DEFINED3 = 163, - NPU_SET_USER_DEFINED4 = 164, - NPU_SET_USER_DEFINED5 = 165, - NPU_SET_USER_DEFINED6 = 166, - NPU_SET_USER_DEFINED7 = 167, -}; - -enum class cmd_ctrl : uint8_t -{ - CMD0_CTRL = 0, - CMD1_CTRL = 1, -}; - -enum class custom_dma_cs : uint8_t -{ - DISABLE = 0, - ENABLE = 1, -}; - -enum class custom_dma : uint8_t -{ - NOT_IMPLEMENTED = 0, - IMPLEMENTED = 1, -}; - -enum class dma_fault_src : uint8_t -{ - AXI_M0 = 0, - AXI_M1 = 1, -}; - -enum class dma_region_mode : uint8_t -{ - EXTERNAL = 0, - INTERNAL = 1, -}; - -enum class dma_stride_mode : uint8_t -{ - D1 = 0, -}; - -enum class elementwise_mode : uint8_t -{ - MUL = 0, - ADD = 1, - SUB = 2, - MIN = 3, - MAX = 4, - LRELU = 5, - ABS = 6, - CLZ = 7, - SHR = 8, - SHL = 9, -}; - -enum class functional_safety : uint8_t -{ - NOT_IMPLEMENTED = 0, - IMPLEMENTED = 1, -}; - -enum class ifm2_operand_order : uint8_t -{ - ORDER_B = 0, - ORDER_A = 1, -}; - -enum class ifm_scale_mode : uint8_t -{ - OPA_OPB_16 = 0, - OPA_32 = 1, - OPB_32 = 2, -}; - -enum class ifm_upscale_mode : uint8_t -{ - NONE = 0, - NEAREST = 1, - ZEROS = 2, -}; - -enum class kernel_decomposition : uint8_t -{ - D8X8 = 0, - D4X4 = 1, -}; - -enum class kernel_dilation : uint8_t -{ - NONE = 0, - X2 = 1, -}; - -enum class max_beats : uint8_t -{ - B64 = 0, - B128 = 1, - B256 = 2, -}; - -enum class mem_attr : uint8_t -{ - AXI0_OUTSTANDING_COUNTER0 = 0, - AXI0_OUTSTANDING_COUNTER1 = 1, - AXI1_OUTSTANDING_COUNTER2 = 2, - AXI1_OUTSTANDING_COUNTER3 = 3, -}; - -enum class ofm_scale_mode : uint8_t -{ - PER_CHANNEL = 0, - GLOBAL = 1, -}; - -enum class pmu_axi_channel : uint8_t -{ - RD_CMD = 0, - RD_IFM = 1, - RD_WEIGHTS = 2, - RD_SCALE_BIAS = 3, - RD_MEM2MEM = 4, - WR_OFM = 8, - WR_MEM2MEM = 9, -}; - -enum class pmu_event : uint16_t -{ - NO_EVENT = 0, - CYCLE = 17, - NPU_IDLE = 32, - CC_STALLED_ON_BLOCKDEP = 33, - CC_STALLED_ON_SHRAM_RECONFIG = 34, - NPU_ACTIVE = 35, - MAC_ACTIVE = 48, - MAC_ACTIVE_8BIT = 49, - MAC_ACTIVE_16BIT = 50, - MAC_DPU_ACTIVE = 51, - MAC_STALLED_BY_WD_ACC = 52, - MAC_STALLED_BY_WD = 53, - MAC_STALLED_BY_ACC = 54, - MAC_STALLED_BY_IB = 55, - MAC_ACTIVE_32BIT = 56, - MAC_STALLED_BY_INT_W = 57, - MAC_STALLED_BY_INT_ACC = 58, - AO_ACTIVE = 64, - AO_ACTIVE_8BIT = 65, - AO_ACTIVE_16BIT = 66, - AO_STALLED_BY_OFMP_OB = 67, - AO_STALLED_BY_OFMP = 68, - AO_STALLED_BY_OB = 69, - AO_STALLED_BY_ACC_IB = 70, - AO_STALLED_BY_ACC = 71, - AO_STALLED_BY_IB = 72, - WD_ACTIVE = 80, - WD_STALLED = 81, - WD_STALLED_BY_WS = 82, - WD_STALLED_BY_WD_BUF = 83, - WD_PARSE_ACTIVE = 84, - WD_PARSE_STALLED = 85, - WD_PARSE_STALLED_IN = 86, - WD_PARSE_STALLED_OUT = 87, - WD_TRANS_WS = 88, - WD_TRANS_WB = 89, - WD_TRANS_DW0 = 90, - WD_TRANS_DW1 = 91, - AXI0_RD_TRANS_ACCEPTED = 128, - AXI0_RD_TRANS_COMPLETED = 129, - AXI0_RD_DATA_BEAT_RECEIVED = 130, - AXI0_RD_TRAN_REQ_STALLED = 131, - AXI0_WR_TRANS_ACCEPTED = 132, - AXI0_WR_TRANS_COMPLETED_M = 133, - AXI0_WR_TRANS_COMPLETED_S = 134, - AXI0_WR_DATA_BEAT_WRITTEN = 135, - AXI0_WR_TRAN_REQ_STALLED = 136, - AXI0_WR_DATA_BEAT_STALLED = 137, - AXI0_ENABLED_CYCLES = 140, - AXI0_RD_STALL_LIMIT = 142, - AXI0_WR_STALL_LIMIT = 143, - AXI_LATENCY_ANY = 160, - AXI_LATENCY_32 = 161, - AXI_LATENCY_64 = 162, - AXI_LATENCY_128 = 163, - AXI_LATENCY_256 = 164, - AXI_LATENCY_512 = 165, - AXI_LATENCY_1024 = 166, - ECC_DMA = 176, - ECC_SB0 = 177, - AXI1_RD_TRANS_ACCEPTED = 384, - AXI1_RD_TRANS_COMPLETED = 385, - AXI1_RD_DATA_BEAT_RECEIVED = 386, - AXI1_RD_TRAN_REQ_STALLED = 387, - AXI1_WR_TRANS_ACCEPTED = 388, - AXI1_WR_TRANS_COMPLETED_M = 389, - AXI1_WR_TRANS_COMPLETED_S = 390, - AXI1_WR_DATA_BEAT_WRITTEN = 391, - AXI1_WR_TRAN_REQ_STALLED = 392, - AXI1_WR_DATA_BEAT_STALLED = 393, - AXI1_ENABLED_CYCLES = 396, - AXI1_RD_STALL_LIMIT = 398, - AXI1_WR_STALL_LIMIT = 399, - ECC_SB1 = 433, -}; - -enum class pooling_mode : uint8_t -{ - MAX = 0, - AVERAGE = 1, - REDUCE_SUM = 2, -}; - -enum class privilege_level : uint8_t -{ - USER = 0, - PRIVILEGED = 1, -}; - -enum class round_mode : uint8_t -{ - DBL = 0, - TRUNCATE = 1, - NATURAL = 2, -}; - -enum class security_level : uint8_t -{ - SECURE = 0, - NON_SECURE = 1, -}; - -enum class state : uint8_t -{ - STOPPED = 0, - RUNNING = 1, -}; - -enum class wd_core_slice_state : uint8_t -{ - HEADER = 0, - PALETTE = 1, - WEIGHTS = 2, -}; - -enum class wd_ctrl_state : uint8_t -{ - IDLE = 0, - DRAIN = 1, - OFD_INIT = 2, - OFD_RUN = 3, -}; - -enum class weight_order : uint8_t -{ - DEPTH_FIRST = 0, - PART_KERNEL_FIRST = 1, -}; - -#else - -enum acc_format -{ - ACC_FORMAT_I32 = 0, - ACC_FORMAT_I40 = 1, - ACC_FORMAT_F16 = 2, -}; - -enum activation_clip_range -{ - ACTIVATION_CLIP_RANGE_OFM_PRECISION = 0, - ACTIVATION_CLIP_RANGE_FORCE_UINT8 = 2, - ACTIVATION_CLIP_RANGE_FORCE_INT8 = 3, - ACTIVATION_CLIP_RANGE_FORCE_INT16 = 5, -}; - -enum activation_format -{ - ACTIVATION_FORMAT_NHWC = 0, - ACTIVATION_FORMAT_NHCWB16 = 1, -}; - -enum activation_function -{ - ACTIVATION_FUNCTION_RELU = 0, - ACTIVATION_FUNCTION_TANH = 3, - ACTIVATION_FUNCTION_SIGMOID = 4, - ACTIVATION_FUNCTION_TABLE_0 = 16, - ACTIVATION_FUNCTION_TABLE_1 = 17, - ACTIVATION_FUNCTION_TABLE_2 = 18, - ACTIVATION_FUNCTION_TABLE_3 = 19, - ACTIVATION_FUNCTION_TABLE_4 = 20, - ACTIVATION_FUNCTION_TABLE_5 = 21, - ACTIVATION_FUNCTION_TABLE_6 = 22, - ACTIVATION_FUNCTION_TABLE_7 = 23, -}; - -enum activation_precision -{ - ACTIVATION_PRECISION_B8 = 0, - ACTIVATION_PRECISION_B16 = 1, - ACTIVATION_PRECISION_B32 = 2, - ACTIVATION_PRECISION_B64 = 3, -}; - -enum activation_type -{ - ACTIVATION_TYPE_UNSIGNED = 0, - ACTIVATION_TYPE_SIGNED = 1, -}; - -enum axi_mem_encoding -{ - AXI_MEM_ENCODING_DEVICE_NON_BUFFERABLE = 0, - AXI_MEM_ENCODING_DEVICE_BUFFERABLE = 1, - AXI_MEM_ENCODING_NORMAL_NON_CACHEABLE_NON_BUFFERABLE = 2, - AXI_MEM_ENCODING_NORMAL_NON_CACHEABLE_BUFFERABLE = 3, - AXI_MEM_ENCODING_WRITE_THROUGH_NO_ALLOCATE = 4, - AXI_MEM_ENCODING_WRITE_THROUGH_READ_ALLOCATE = 5, - AXI_MEM_ENCODING_WRITE_THROUGH_WRITE_ALLOCATE = 6, - AXI_MEM_ENCODING_WRITE_THROUGH_READ_AND_WRITE_ALLOCATE = 7, - AXI_MEM_ENCODING_WRITE_BACK_NO_ALLOCATE = 8, - AXI_MEM_ENCODING_WRITE_BACK_READ_ALLOCATE = 9, - AXI_MEM_ENCODING_WRITE_BACK_WRITE_ALLOCATE = 10, - AXI_MEM_ENCODING_WRITE_BACK_READ_AND_WRITE_ALLOCATE = 11, -}; - -enum broadcast_mode -{ - BROADCAST_MODE_DISABLE = 0, - BROADCAST_MODE_ENABLE = 1, -}; - -enum cmd0_opcode -{ - CMD0_OPCODE_NPU_OP_STOP = 0, - CMD0_OPCODE_NPU_OP_IRQ = 1, - CMD0_OPCODE_NPU_OP_CONV = 2, - CMD0_OPCODE_NPU_OP_DEPTHWISE = 3, - CMD0_OPCODE_NPU_OP_POOL = 5, - CMD0_OPCODE_NPU_OP_ELEMENTWISE = 6, - CMD0_OPCODE_NPU_OP_DMA_START = 16, - CMD0_OPCODE_NPU_OP_DMA_WAIT = 17, - CMD0_OPCODE_NPU_OP_KERNEL_WAIT = 18, - CMD0_OPCODE_NPU_OP_PMU_MASK = 19, - CMD0_OPCODE_NPU_SET_IFM_PAD_TOP = 256, - CMD0_OPCODE_NPU_SET_IFM_PAD_LEFT = 257, - CMD0_OPCODE_NPU_SET_IFM_PAD_RIGHT = 258, - CMD0_OPCODE_NPU_SET_IFM_PAD_BOTTOM = 259, - CMD0_OPCODE_NPU_SET_IFM_DEPTH_M1 = 260, - CMD0_OPCODE_NPU_SET_IFM_PRECISION = 261, - CMD0_OPCODE_NPU_SET_IFM_UPSCALE = 263, - CMD0_OPCODE_NPU_SET_IFM_ZERO_POINT = 265, - CMD0_OPCODE_NPU_SET_IFM_WIDTH0_M1 = 266, - CMD0_OPCODE_NPU_SET_IFM_HEIGHT0_M1 = 267, - CMD0_OPCODE_NPU_SET_IFM_HEIGHT1_M1 = 268, - CMD0_OPCODE_NPU_SET_IFM_IB_END = 269, - CMD0_OPCODE_NPU_SET_IFM_REGION = 271, - CMD0_OPCODE_NPU_SET_OFM_WIDTH_M1 = 273, - CMD0_OPCODE_NPU_SET_OFM_HEIGHT_M1 = 274, - CMD0_OPCODE_NPU_SET_OFM_DEPTH_M1 = 275, - CMD0_OPCODE_NPU_SET_OFM_PRECISION = 276, - CMD0_OPCODE_NPU_SET_OFM_BLK_WIDTH_M1 = 277, - CMD0_OPCODE_NPU_SET_OFM_BLK_HEIGHT_M1 = 278, - CMD0_OPCODE_NPU_SET_OFM_BLK_DEPTH_M1 = 279, - CMD0_OPCODE_NPU_SET_OFM_ZERO_POINT = 280, - CMD0_OPCODE_NPU_SET_OFM_WIDTH0_M1 = 282, - CMD0_OPCODE_NPU_SET_OFM_HEIGHT0_M1 = 283, - CMD0_OPCODE_NPU_SET_OFM_HEIGHT1_M1 = 284, - CMD0_OPCODE_NPU_SET_OFM_REGION = 287, - CMD0_OPCODE_NPU_SET_KERNEL_WIDTH_M1 = 288, - CMD0_OPCODE_NPU_SET_KERNEL_HEIGHT_M1 = 289, - CMD0_OPCODE_NPU_SET_KERNEL_STRIDE = 290, - CMD0_OPCODE_NPU_SET_ACC_FORMAT = 292, - CMD0_OPCODE_NPU_SET_ACTIVATION = 293, - CMD0_OPCODE_NPU_SET_ACTIVATION_MIN = 294, - CMD0_OPCODE_NPU_SET_ACTIVATION_MAX = 295, - CMD0_OPCODE_NPU_SET_WEIGHT_REGION = 296, - CMD0_OPCODE_NPU_SET_SCALE_REGION = 297, - CMD0_OPCODE_NPU_SET_AB_START = 301, - CMD0_OPCODE_NPU_SET_BLOCKDEP = 303, - CMD0_OPCODE_NPU_SET_DMA0_SRC_REGION = 304, - CMD0_OPCODE_NPU_SET_DMA0_DST_REGION = 305, - CMD0_OPCODE_NPU_SET_DMA0_SIZE0 = 306, - CMD0_OPCODE_NPU_SET_DMA0_SIZE1 = 307, - CMD0_OPCODE_NPU_SET_IFM2_BROADCAST = 384, - CMD0_OPCODE_NPU_SET_IFM2_SCALAR = 385, - CMD0_OPCODE_NPU_SET_IFM2_PRECISION = 389, - CMD0_OPCODE_NPU_SET_IFM2_ZERO_POINT = 393, - CMD0_OPCODE_NPU_SET_IFM2_WIDTH0_M1 = 394, - CMD0_OPCODE_NPU_SET_IFM2_HEIGHT0_M1 = 395, - CMD0_OPCODE_NPU_SET_IFM2_HEIGHT1_M1 = 396, - CMD0_OPCODE_NPU_SET_IFM2_IB_START = 397, - CMD0_OPCODE_NPU_SET_IFM2_REGION = 399, -}; - -enum cmd1_opcode -{ - CMD1_OPCODE_NPU_SET_IFM_BASE0 = 0, - CMD1_OPCODE_NPU_SET_IFM_BASE1 = 1, - CMD1_OPCODE_NPU_SET_IFM_BASE2 = 2, - CMD1_OPCODE_NPU_SET_IFM_BASE3 = 3, - CMD1_OPCODE_NPU_SET_IFM_STRIDE_X = 4, - CMD1_OPCODE_NPU_SET_IFM_STRIDE_Y = 5, - CMD1_OPCODE_NPU_SET_IFM_STRIDE_C = 6, - CMD1_OPCODE_NPU_SET_OFM_BASE0 = 16, - CMD1_OPCODE_NPU_SET_OFM_BASE1 = 17, - CMD1_OPCODE_NPU_SET_OFM_BASE2 = 18, - CMD1_OPCODE_NPU_SET_OFM_BASE3 = 19, - CMD1_OPCODE_NPU_SET_OFM_STRIDE_X = 20, - CMD1_OPCODE_NPU_SET_OFM_STRIDE_Y = 21, - CMD1_OPCODE_NPU_SET_OFM_STRIDE_C = 22, - CMD1_OPCODE_NPU_SET_WEIGHT_BASE = 32, - CMD1_OPCODE_NPU_SET_WEIGHT_LENGTH = 33, - CMD1_OPCODE_NPU_SET_SCALE_BASE = 34, - CMD1_OPCODE_NPU_SET_SCALE_LENGTH = 35, - CMD1_OPCODE_NPU_SET_OFM_SCALE = 36, - CMD1_OPCODE_NPU_SET_OPA_SCALE = 37, - CMD1_OPCODE_NPU_SET_OPB_SCALE = 38, - CMD1_OPCODE_NPU_SET_DMA0_SRC = 48, - CMD1_OPCODE_NPU_SET_DMA0_DST = 49, - CMD1_OPCODE_NPU_SET_DMA0_LEN = 50, - CMD1_OPCODE_NPU_SET_IFM2_BASE0 = 128, - CMD1_OPCODE_NPU_SET_IFM2_BASE1 = 129, - CMD1_OPCODE_NPU_SET_IFM2_BASE2 = 130, - CMD1_OPCODE_NPU_SET_IFM2_BASE3 = 131, - CMD1_OPCODE_NPU_SET_IFM2_STRIDE_X = 132, - CMD1_OPCODE_NPU_SET_IFM2_STRIDE_Y = 133, - CMD1_OPCODE_NPU_SET_IFM2_STRIDE_C = 134, - CMD1_OPCODE_NPU_SET_USER_DEFINED0 = 160, - CMD1_OPCODE_NPU_SET_USER_DEFINED1 = 161, - CMD1_OPCODE_NPU_SET_USER_DEFINED2 = 162, - CMD1_OPCODE_NPU_SET_USER_DEFINED3 = 163, - CMD1_OPCODE_NPU_SET_USER_DEFINED4 = 164, - CMD1_OPCODE_NPU_SET_USER_DEFINED5 = 165, - CMD1_OPCODE_NPU_SET_USER_DEFINED6 = 166, - CMD1_OPCODE_NPU_SET_USER_DEFINED7 = 167, -}; - -enum cmd_ctrl -{ - CMD_CTRL_CMD0_CTRL = 0, - CMD_CTRL_CMD1_CTRL = 1, -}; - -enum custom_dma_cs -{ - CUSTOM_DMA_CS_DISABLE = 0, - CUSTOM_DMA_CS_ENABLE = 1, -}; - -enum custom_dma -{ - CUSTOM_DMA_NOT_IMPLEMENTED = 0, - CUSTOM_DMA_IMPLEMENTED = 1, -}; - -enum dma_fault_src -{ - DMA_FAULT_SRC_AXI_M0 = 0, - DMA_FAULT_SRC_AXI_M1 = 1, -}; - -enum dma_region_mode -{ - DMA_REGION_MODE_EXTERNAL = 0, - DMA_REGION_MODE_INTERNAL = 1, -}; - -enum dma_stride_mode -{ - DMA_STRIDE_MODE_D1 = 0, -}; - -enum elementwise_mode -{ - ELEMENTWISE_MODE_MUL = 0, - ELEMENTWISE_MODE_ADD = 1, - ELEMENTWISE_MODE_SUB = 2, - ELEMENTWISE_MODE_MIN = 3, - ELEMENTWISE_MODE_MAX = 4, - ELEMENTWISE_MODE_LRELU = 5, - ELEMENTWISE_MODE_ABS = 6, - ELEMENTWISE_MODE_CLZ = 7, - ELEMENTWISE_MODE_SHR = 8, - ELEMENTWISE_MODE_SHL = 9, -}; - -enum functional_safety -{ - FUNCTIONAL_SAFETY_NOT_IMPLEMENTED = 0, - FUNCTIONAL_SAFETY_IMPLEMENTED = 1, -}; - -enum ifm2_operand_order -{ - IFM2_OPERAND_ORDER_ORDER_B = 0, - IFM2_OPERAND_ORDER_ORDER_A = 1, -}; - -enum ifm_scale_mode -{ - IFM_SCALE_MODE_OPA_OPB_16 = 0, - IFM_SCALE_MODE_OPA_32 = 1, - IFM_SCALE_MODE_OPB_32 = 2, -}; - -enum ifm_upscale_mode -{ - IFM_UPSCALE_MODE_NONE = 0, - IFM_UPSCALE_MODE_NEAREST = 1, - IFM_UPSCALE_MODE_ZEROS = 2, -}; - -enum kernel_decomposition -{ - KERNEL_DECOMPOSITION_D8X8 = 0, - KERNEL_DECOMPOSITION_D4X4 = 1, -}; - -enum kernel_dilation -{ - KERNEL_DILATION_NONE = 0, - KERNEL_DILATION_X2 = 1, -}; - -enum max_beats -{ - MAX_BEATS_B64 = 0, - MAX_BEATS_B128 = 1, - MAX_BEATS_B256 = 2, -}; - -enum mem_attr -{ - MEM_ATTR_AXI0_OUTSTANDING_COUNTER0 = 0, - MEM_ATTR_AXI0_OUTSTANDING_COUNTER1 = 1, - MEM_ATTR_AXI1_OUTSTANDING_COUNTER2 = 2, - MEM_ATTR_AXI1_OUTSTANDING_COUNTER3 = 3, -}; - -enum ofm_scale_mode -{ - OFM_SCALE_MODE_PER_CHANNEL = 0, - OFM_SCALE_MODE_GLOBAL = 1, -}; - -enum pmu_axi_channel -{ - PMU_AXI_CHANNEL_RD_CMD = 0, - PMU_AXI_CHANNEL_RD_IFM = 1, - PMU_AXI_CHANNEL_RD_WEIGHTS = 2, - PMU_AXI_CHANNEL_RD_SCALE_BIAS = 3, - PMU_AXI_CHANNEL_RD_MEM2MEM = 4, - PMU_AXI_CHANNEL_WR_OFM = 8, - PMU_AXI_CHANNEL_WR_MEM2MEM = 9, -}; - -enum pmu_event -{ - PMU_EVENT_NO_EVENT = 0, - PMU_EVENT_CYCLE = 17, - PMU_EVENT_NPU_IDLE = 32, - PMU_EVENT_CC_STALLED_ON_BLOCKDEP = 33, - PMU_EVENT_CC_STALLED_ON_SHRAM_RECONFIG = 34, - PMU_EVENT_NPU_ACTIVE = 35, - PMU_EVENT_MAC_ACTIVE = 48, - PMU_EVENT_MAC_ACTIVE_8BIT = 49, - PMU_EVENT_MAC_ACTIVE_16BIT = 50, - PMU_EVENT_MAC_DPU_ACTIVE = 51, - PMU_EVENT_MAC_STALLED_BY_WD_ACC = 52, - PMU_EVENT_MAC_STALLED_BY_WD = 53, - PMU_EVENT_MAC_STALLED_BY_ACC = 54, - PMU_EVENT_MAC_STALLED_BY_IB = 55, - PMU_EVENT_MAC_ACTIVE_32BIT = 56, - PMU_EVENT_MAC_STALLED_BY_INT_W = 57, - PMU_EVENT_MAC_STALLED_BY_INT_ACC = 58, - PMU_EVENT_AO_ACTIVE = 64, - PMU_EVENT_AO_ACTIVE_8BIT = 65, - PMU_EVENT_AO_ACTIVE_16BIT = 66, - PMU_EVENT_AO_STALLED_BY_OFMP_OB = 67, - PMU_EVENT_AO_STALLED_BY_OFMP = 68, - PMU_EVENT_AO_STALLED_BY_OB = 69, - PMU_EVENT_AO_STALLED_BY_ACC_IB = 70, - PMU_EVENT_AO_STALLED_BY_ACC = 71, - PMU_EVENT_AO_STALLED_BY_IB = 72, - PMU_EVENT_WD_ACTIVE = 80, - PMU_EVENT_WD_STALLED = 81, - PMU_EVENT_WD_STALLED_BY_WS = 82, - PMU_EVENT_WD_STALLED_BY_WD_BUF = 83, - PMU_EVENT_WD_PARSE_ACTIVE = 84, - PMU_EVENT_WD_PARSE_STALLED = 85, - PMU_EVENT_WD_PARSE_STALLED_IN = 86, - PMU_EVENT_WD_PARSE_STALLED_OUT = 87, - PMU_EVENT_WD_TRANS_WS = 88, - PMU_EVENT_WD_TRANS_WB = 89, - PMU_EVENT_WD_TRANS_DW0 = 90, - PMU_EVENT_WD_TRANS_DW1 = 91, - PMU_EVENT_AXI0_RD_TRANS_ACCEPTED = 128, - PMU_EVENT_AXI0_RD_TRANS_COMPLETED = 129, - PMU_EVENT_AXI0_RD_DATA_BEAT_RECEIVED = 130, - PMU_EVENT_AXI0_RD_TRAN_REQ_STALLED = 131, - PMU_EVENT_AXI0_WR_TRANS_ACCEPTED = 132, - PMU_EVENT_AXI0_WR_TRANS_COMPLETED_M = 133, - PMU_EVENT_AXI0_WR_TRANS_COMPLETED_S = 134, - PMU_EVENT_AXI0_WR_DATA_BEAT_WRITTEN = 135, - PMU_EVENT_AXI0_WR_TRAN_REQ_STALLED = 136, - PMU_EVENT_AXI0_WR_DATA_BEAT_STALLED = 137, - PMU_EVENT_AXI0_ENABLED_CYCLES = 140, - PMU_EVENT_AXI0_RD_STALL_LIMIT = 142, - PMU_EVENT_AXI0_WR_STALL_LIMIT = 143, - PMU_EVENT_AXI_LATENCY_ANY = 160, - PMU_EVENT_AXI_LATENCY_32 = 161, - PMU_EVENT_AXI_LATENCY_64 = 162, - PMU_EVENT_AXI_LATENCY_128 = 163, - PMU_EVENT_AXI_LATENCY_256 = 164, - PMU_EVENT_AXI_LATENCY_512 = 165, - PMU_EVENT_AXI_LATENCY_1024 = 166, - PMU_EVENT_ECC_DMA = 176, - PMU_EVENT_ECC_SB0 = 177, - PMU_EVENT_AXI1_RD_TRANS_ACCEPTED = 384, - PMU_EVENT_AXI1_RD_TRANS_COMPLETED = 385, - PMU_EVENT_AXI1_RD_DATA_BEAT_RECEIVED = 386, - PMU_EVENT_AXI1_RD_TRAN_REQ_STALLED = 387, - PMU_EVENT_AXI1_WR_TRANS_ACCEPTED = 388, - PMU_EVENT_AXI1_WR_TRANS_COMPLETED_M = 389, - PMU_EVENT_AXI1_WR_TRANS_COMPLETED_S = 390, - PMU_EVENT_AXI1_WR_DATA_BEAT_WRITTEN = 391, - PMU_EVENT_AXI1_WR_TRAN_REQ_STALLED = 392, - PMU_EVENT_AXI1_WR_DATA_BEAT_STALLED = 393, - PMU_EVENT_AXI1_ENABLED_CYCLES = 396, - PMU_EVENT_AXI1_RD_STALL_LIMIT = 398, - PMU_EVENT_AXI1_WR_STALL_LIMIT = 399, - PMU_EVENT_ECC_SB1 = 433, -}; - -enum pooling_mode -{ - POOLING_MODE_MAX = 0, - POOLING_MODE_AVERAGE = 1, - POOLING_MODE_REDUCE_SUM = 2, -}; - -enum privilege_level -{ - PRIVILEGE_LEVEL_USER = 0, - PRIVILEGE_LEVEL_PRIVILEGED = 1, -}; - -enum round_mode -{ - ROUND_MODE_DBL = 0, - ROUND_MODE_TRUNCATE = 1, - ROUND_MODE_NATURAL = 2, -}; - -enum security_level -{ - SECURITY_LEVEL_SECURE = 0, - SECURITY_LEVEL_NON_SECURE = 1, -}; - -enum state -{ - STATE_STOPPED = 0, - STATE_RUNNING = 1, -}; - -enum wd_core_slice_state -{ - WD_CORE_SLICE_STATE_HEADER = 0, - WD_CORE_SLICE_STATE_PALETTE = 1, - WD_CORE_SLICE_STATE_WEIGHTS = 2, -}; - -enum wd_ctrl_state -{ - WD_CTRL_STATE_IDLE = 0, - WD_CTRL_STATE_DRAIN = 1, - WD_CTRL_STATE_OFD_INIT = 2, - WD_CTRL_STATE_OFD_RUN = 3, -}; - -enum weight_order -{ - WEIGHT_ORDER_DEPTH_FIRST = 0, - WEIGHT_ORDER_PART_KERNEL_FIRST = 1, -}; - -#endif - -#ifdef NPU_DISASSEMBLE - -static const char *acc_format_str[] = { - "ACC_FORMAT_I32", - "ACC_FORMAT_I40", - "ACC_FORMAT_F16", -}; - -static const char *activation_clip_range_str[] = { - "ACTIVATION_CLIP_RANGE_OFM_PRECISION", - "****", - "ACTIVATION_CLIP_RANGE_FORCE_UINT8", - "ACTIVATION_CLIP_RANGE_FORCE_INT8", - "****", - "ACTIVATION_CLIP_RANGE_FORCE_INT16", -}; - -static const char *activation_format_str[] = { - "ACTIVATION_FORMAT_NHWC", - "ACTIVATION_FORMAT_NHCWB16", -}; - -static const char *activation_function_str[] = { - "ACTIVATION_FUNCTION_RELU", - "****", - "****", - "ACTIVATION_FUNCTION_TANH", - "ACTIVATION_FUNCTION_SIGMOID", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "ACTIVATION_FUNCTION_TABLE_0", - "ACTIVATION_FUNCTION_TABLE_1", - "ACTIVATION_FUNCTION_TABLE_2", - "ACTIVATION_FUNCTION_TABLE_3", - "ACTIVATION_FUNCTION_TABLE_4", - "ACTIVATION_FUNCTION_TABLE_5", - "ACTIVATION_FUNCTION_TABLE_6", - "ACTIVATION_FUNCTION_TABLE_7", -}; - -static const char *activation_precision_str[] = { - "ACTIVATION_PRECISION_B8", - "ACTIVATION_PRECISION_B16", - "ACTIVATION_PRECISION_B32", - "ACTIVATION_PRECISION_B64", -}; - -static const char *activation_type_str[] = { - "ACTIVATION_TYPE_UNSIGNED", - "ACTIVATION_TYPE_SIGNED", -}; - -static const char *axi_mem_encoding_str[] = { - "AXI_MEM_ENCODING_DEVICE_NON_BUFFERABLE", - "AXI_MEM_ENCODING_DEVICE_BUFFERABLE", - "AXI_MEM_ENCODING_NORMAL_NON_CACHEABLE_NON_BUFFERABLE", - "AXI_MEM_ENCODING_NORMAL_NON_CACHEABLE_BUFFERABLE", - "AXI_MEM_ENCODING_WRITE_THROUGH_NO_ALLOCATE", - "AXI_MEM_ENCODING_WRITE_THROUGH_READ_ALLOCATE", - "AXI_MEM_ENCODING_WRITE_THROUGH_WRITE_ALLOCATE", - "AXI_MEM_ENCODING_WRITE_THROUGH_READ_AND_WRITE_ALLOCATE", - "AXI_MEM_ENCODING_WRITE_BACK_NO_ALLOCATE", - "AXI_MEM_ENCODING_WRITE_BACK_READ_ALLOCATE", - "AXI_MEM_ENCODING_WRITE_BACK_WRITE_ALLOCATE", - "AXI_MEM_ENCODING_WRITE_BACK_READ_AND_WRITE_ALLOCATE", -}; - -static const char *broadcast_mode_str[] = { - "BROADCAST_MODE_DISABLE", - "BROADCAST_MODE_ENABLE", -}; - -static const char *cmd0_opcode_str[] = { - "CMD0_OPCODE_NPU_OP_STOP", - "CMD0_OPCODE_NPU_OP_IRQ", - "CMD0_OPCODE_NPU_OP_CONV", - "CMD0_OPCODE_NPU_OP_DEPTHWISE", - "****", - "CMD0_OPCODE_NPU_OP_POOL", - "CMD0_OPCODE_NPU_OP_ELEMENTWISE", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "CMD0_OPCODE_NPU_OP_DMA_START", - "CMD0_OPCODE_NPU_OP_DMA_WAIT", - "CMD0_OPCODE_NPU_OP_KERNEL_WAIT", - "CMD0_OPCODE_NPU_OP_PMU_MASK", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "CMD0_OPCODE_NPU_SET_IFM_PAD_TOP", - "CMD0_OPCODE_NPU_SET_IFM_PAD_LEFT", - "CMD0_OPCODE_NPU_SET_IFM_PAD_RIGHT", - "CMD0_OPCODE_NPU_SET_IFM_PAD_BOTTOM", - "CMD0_OPCODE_NPU_SET_IFM_DEPTH_M1", - "CMD0_OPCODE_NPU_SET_IFM_PRECISION", - "****", - "CMD0_OPCODE_NPU_SET_IFM_UPSCALE", - "****", - "CMD0_OPCODE_NPU_SET_IFM_ZERO_POINT", - "CMD0_OPCODE_NPU_SET_IFM_WIDTH0_M1", - "CMD0_OPCODE_NPU_SET_IFM_HEIGHT0_M1", - "CMD0_OPCODE_NPU_SET_IFM_HEIGHT1_M1", - "CMD0_OPCODE_NPU_SET_IFM_IB_END", - "****", - "CMD0_OPCODE_NPU_SET_IFM_REGION", - "****", - "CMD0_OPCODE_NPU_SET_OFM_WIDTH_M1", - "CMD0_OPCODE_NPU_SET_OFM_HEIGHT_M1", - "CMD0_OPCODE_NPU_SET_OFM_DEPTH_M1", - "CMD0_OPCODE_NPU_SET_OFM_PRECISION", - "CMD0_OPCODE_NPU_SET_OFM_BLK_WIDTH_M1", - "CMD0_OPCODE_NPU_SET_OFM_BLK_HEIGHT_M1", - "CMD0_OPCODE_NPU_SET_OFM_BLK_DEPTH_M1", - "CMD0_OPCODE_NPU_SET_OFM_ZERO_POINT", - "****", - "CMD0_OPCODE_NPU_SET_OFM_WIDTH0_M1", - "CMD0_OPCODE_NPU_SET_OFM_HEIGHT0_M1", - "CMD0_OPCODE_NPU_SET_OFM_HEIGHT1_M1", - "****", - "****", - "CMD0_OPCODE_NPU_SET_OFM_REGION", - "CMD0_OPCODE_NPU_SET_KERNEL_WIDTH_M1", - "CMD0_OPCODE_NPU_SET_KERNEL_HEIGHT_M1", - "CMD0_OPCODE_NPU_SET_KERNEL_STRIDE", - "****", - "CMD0_OPCODE_NPU_SET_ACC_FORMAT", - "CMD0_OPCODE_NPU_SET_ACTIVATION", - "CMD0_OPCODE_NPU_SET_ACTIVATION_MIN", - "CMD0_OPCODE_NPU_SET_ACTIVATION_MAX", - "CMD0_OPCODE_NPU_SET_WEIGHT_REGION", - "CMD0_OPCODE_NPU_SET_SCALE_REGION", - "****", - "****", - "****", - "CMD0_OPCODE_NPU_SET_AB_START", - "****", - "CMD0_OPCODE_NPU_SET_BLOCKDEP", - "CMD0_OPCODE_NPU_SET_DMA0_SRC_REGION", - "CMD0_OPCODE_NPU_SET_DMA0_DST_REGION", - "CMD0_OPCODE_NPU_SET_DMA0_SIZE0", - "CMD0_OPCODE_NPU_SET_DMA0_SIZE1", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "CMD0_OPCODE_NPU_SET_IFM2_BROADCAST", - "CMD0_OPCODE_NPU_SET_IFM2_SCALAR", - "****", - "****", - "****", - "CMD0_OPCODE_NPU_SET_IFM2_PRECISION", - "****", - "****", - "****", - "CMD0_OPCODE_NPU_SET_IFM2_ZERO_POINT", - "CMD0_OPCODE_NPU_SET_IFM2_WIDTH0_M1", - "CMD0_OPCODE_NPU_SET_IFM2_HEIGHT0_M1", - "CMD0_OPCODE_NPU_SET_IFM2_HEIGHT1_M1", - "CMD0_OPCODE_NPU_SET_IFM2_IB_START", - "****", - "CMD0_OPCODE_NPU_SET_IFM2_REGION", -}; - -static const char *cmd1_opcode_str[] = { - "CMD1_OPCODE_NPU_SET_IFM_BASE0", - "CMD1_OPCODE_NPU_SET_IFM_BASE1", - "CMD1_OPCODE_NPU_SET_IFM_BASE2", - "CMD1_OPCODE_NPU_SET_IFM_BASE3", - "CMD1_OPCODE_NPU_SET_IFM_STRIDE_X", - "CMD1_OPCODE_NPU_SET_IFM_STRIDE_Y", - "CMD1_OPCODE_NPU_SET_IFM_STRIDE_C", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "CMD1_OPCODE_NPU_SET_OFM_BASE0", - "CMD1_OPCODE_NPU_SET_OFM_BASE1", - "CMD1_OPCODE_NPU_SET_OFM_BASE2", - "CMD1_OPCODE_NPU_SET_OFM_BASE3", - "CMD1_OPCODE_NPU_SET_OFM_STRIDE_X", - "CMD1_OPCODE_NPU_SET_OFM_STRIDE_Y", - "CMD1_OPCODE_NPU_SET_OFM_STRIDE_C", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "CMD1_OPCODE_NPU_SET_WEIGHT_BASE", - "CMD1_OPCODE_NPU_SET_WEIGHT_LENGTH", - "CMD1_OPCODE_NPU_SET_SCALE_BASE", - "CMD1_OPCODE_NPU_SET_SCALE_LENGTH", - "CMD1_OPCODE_NPU_SET_OFM_SCALE", - "CMD1_OPCODE_NPU_SET_OPA_SCALE", - "CMD1_OPCODE_NPU_SET_OPB_SCALE", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "CMD1_OPCODE_NPU_SET_DMA0_SRC", - "CMD1_OPCODE_NPU_SET_DMA0_DST", - "CMD1_OPCODE_NPU_SET_DMA0_LEN", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "CMD1_OPCODE_NPU_SET_IFM2_BASE0", - "CMD1_OPCODE_NPU_SET_IFM2_BASE1", - "CMD1_OPCODE_NPU_SET_IFM2_BASE2", - "CMD1_OPCODE_NPU_SET_IFM2_BASE3", - "CMD1_OPCODE_NPU_SET_IFM2_STRIDE_X", - "CMD1_OPCODE_NPU_SET_IFM2_STRIDE_Y", - "CMD1_OPCODE_NPU_SET_IFM2_STRIDE_C", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "CMD1_OPCODE_NPU_SET_USER_DEFINED0", - "CMD1_OPCODE_NPU_SET_USER_DEFINED1", - "CMD1_OPCODE_NPU_SET_USER_DEFINED2", - "CMD1_OPCODE_NPU_SET_USER_DEFINED3", - "CMD1_OPCODE_NPU_SET_USER_DEFINED4", - "CMD1_OPCODE_NPU_SET_USER_DEFINED5", - "CMD1_OPCODE_NPU_SET_USER_DEFINED6", - "CMD1_OPCODE_NPU_SET_USER_DEFINED7", -}; - -static const char *cmd_ctrl_str[] = { - "CMD_CTRL_CMD0_CTRL", - "CMD_CTRL_CMD1_CTRL", -}; - -static const char *custom_dma_cs_str[] = { - "CUSTOM_DMA_CS_DISABLE", - "CUSTOM_DMA_CS_ENABLE", -}; - -static const char *custom_dma_str[] = { - "CUSTOM_DMA_NOT_IMPLEMENTED", - "CUSTOM_DMA_IMPLEMENTED", -}; - -static const char *dma_fault_src_str[] = { - "DMA_FAULT_SRC_AXI_M0", - "DMA_FAULT_SRC_AXI_M1", -}; - -static const char *dma_region_mode_str[] = { - "DMA_REGION_MODE_EXTERNAL", - "DMA_REGION_MODE_INTERNAL", -}; - -static const char *dma_stride_mode_str[] = { - "DMA_STRIDE_MODE_D1", -}; - -static const char *elementwise_mode_str[] = { - "ELEMENTWISE_MODE_MUL", - "ELEMENTWISE_MODE_ADD", - "ELEMENTWISE_MODE_SUB", - "ELEMENTWISE_MODE_MIN", - "ELEMENTWISE_MODE_MAX", - "ELEMENTWISE_MODE_LRELU", - "ELEMENTWISE_MODE_ABS", - "ELEMENTWISE_MODE_CLZ", - "ELEMENTWISE_MODE_SHR", - "ELEMENTWISE_MODE_SHL", -}; - -static const char *functional_safety_str[] = { - "FUNCTIONAL_SAFETY_NOT_IMPLEMENTED", - "FUNCTIONAL_SAFETY_IMPLEMENTED", -}; - -static const char *ifm2_operand_order_str[] = { - "IFM2_OPERAND_ORDER_ORDER_B", - "IFM2_OPERAND_ORDER_ORDER_A", -}; - -static const char *ifm_scale_mode_str[] = { - "IFM_SCALE_MODE_OPA_OPB_16", - "IFM_SCALE_MODE_OPA_32", - "IFM_SCALE_MODE_OPB_32", -}; - -static const char *ifm_upscale_mode_str[] = { - "IFM_UPSCALE_MODE_NONE", - "IFM_UPSCALE_MODE_NEAREST", - "IFM_UPSCALE_MODE_ZEROS", -}; - -static const char *kernel_decomposition_str[] = { - "KERNEL_DECOMPOSITION_D8X8", - "KERNEL_DECOMPOSITION_D4X4", -}; - -static const char *kernel_dilation_str[] = { - "KERNEL_DILATION_NONE", - "KERNEL_DILATION_X2", -}; - -static const char *max_beats_str[] = { - "MAX_BEATS_B64", - "MAX_BEATS_B128", - "MAX_BEATS_B256", -}; - -static const char *mem_attr_str[] = { - "MEM_ATTR_AXI0_OUTSTANDING_COUNTER0", - "MEM_ATTR_AXI0_OUTSTANDING_COUNTER1", - "MEM_ATTR_AXI1_OUTSTANDING_COUNTER2", - "MEM_ATTR_AXI1_OUTSTANDING_COUNTER3", -}; - -static const char *ofm_scale_mode_str[] = { - "OFM_SCALE_MODE_PER_CHANNEL", - "OFM_SCALE_MODE_GLOBAL", -}; - -static const char *pmu_axi_channel_str[] = { - "PMU_AXI_CHANNEL_RD_CMD", - "PMU_AXI_CHANNEL_RD_IFM", - "PMU_AXI_CHANNEL_RD_WEIGHTS", - "PMU_AXI_CHANNEL_RD_SCALE_BIAS", - "PMU_AXI_CHANNEL_RD_MEM2MEM", - "****", - "****", - "****", - "PMU_AXI_CHANNEL_WR_OFM", - "PMU_AXI_CHANNEL_WR_MEM2MEM", -}; - -static const char *pmu_event_str[] = { - "PMU_EVENT_NO_EVENT", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "PMU_EVENT_CYCLE", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "PMU_EVENT_NPU_IDLE", - "PMU_EVENT_CC_STALLED_ON_BLOCKDEP", - "PMU_EVENT_CC_STALLED_ON_SHRAM_RECONFIG", - "PMU_EVENT_NPU_ACTIVE", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "PMU_EVENT_MAC_ACTIVE", - "PMU_EVENT_MAC_ACTIVE_8BIT", - "PMU_EVENT_MAC_ACTIVE_16BIT", - "PMU_EVENT_MAC_DPU_ACTIVE", - "PMU_EVENT_MAC_STALLED_BY_WD_ACC", - "PMU_EVENT_MAC_STALLED_BY_WD", - "PMU_EVENT_MAC_STALLED_BY_ACC", - "PMU_EVENT_MAC_STALLED_BY_IB", - "PMU_EVENT_MAC_ACTIVE_32BIT", - "PMU_EVENT_MAC_STALLED_BY_INT_W", - "PMU_EVENT_MAC_STALLED_BY_INT_ACC", - "****", - "****", - "****", - "****", - "****", - "PMU_EVENT_AO_ACTIVE", - "PMU_EVENT_AO_ACTIVE_8BIT", - "PMU_EVENT_AO_ACTIVE_16BIT", - "PMU_EVENT_AO_STALLED_BY_OFMP_OB", - "PMU_EVENT_AO_STALLED_BY_OFMP", - "PMU_EVENT_AO_STALLED_BY_OB", - "PMU_EVENT_AO_STALLED_BY_ACC_IB", - "PMU_EVENT_AO_STALLED_BY_ACC", - "PMU_EVENT_AO_STALLED_BY_IB", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "PMU_EVENT_WD_ACTIVE", - "PMU_EVENT_WD_STALLED", - "PMU_EVENT_WD_STALLED_BY_WS", - "PMU_EVENT_WD_STALLED_BY_WD_BUF", - "PMU_EVENT_WD_PARSE_ACTIVE", - "PMU_EVENT_WD_PARSE_STALLED", - "PMU_EVENT_WD_PARSE_STALLED_IN", - "PMU_EVENT_WD_PARSE_STALLED_OUT", - "PMU_EVENT_WD_TRANS_WS", - "PMU_EVENT_WD_TRANS_WB", - "PMU_EVENT_WD_TRANS_DW0", - "PMU_EVENT_WD_TRANS_DW1", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "PMU_EVENT_AXI0_RD_TRANS_ACCEPTED", - "PMU_EVENT_AXI0_RD_TRANS_COMPLETED", - "PMU_EVENT_AXI0_RD_DATA_BEAT_RECEIVED", - "PMU_EVENT_AXI0_RD_TRAN_REQ_STALLED", - "PMU_EVENT_AXI0_WR_TRANS_ACCEPTED", - "PMU_EVENT_AXI0_WR_TRANS_COMPLETED_M", - "PMU_EVENT_AXI0_WR_TRANS_COMPLETED_S", - "PMU_EVENT_AXI0_WR_DATA_BEAT_WRITTEN", - "PMU_EVENT_AXI0_WR_TRAN_REQ_STALLED", - "PMU_EVENT_AXI0_WR_DATA_BEAT_STALLED", - "****", - "****", - "PMU_EVENT_AXI0_ENABLED_CYCLES", - "****", - "PMU_EVENT_AXI0_RD_STALL_LIMIT", - "PMU_EVENT_AXI0_WR_STALL_LIMIT", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "PMU_EVENT_AXI_LATENCY_ANY", - "PMU_EVENT_AXI_LATENCY_32", - "PMU_EVENT_AXI_LATENCY_64", - "PMU_EVENT_AXI_LATENCY_128", - "PMU_EVENT_AXI_LATENCY_256", - "PMU_EVENT_AXI_LATENCY_512", - "PMU_EVENT_AXI_LATENCY_1024", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "PMU_EVENT_ECC_DMA", - "PMU_EVENT_ECC_SB0", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "PMU_EVENT_AXI1_RD_TRANS_ACCEPTED", - "PMU_EVENT_AXI1_RD_TRANS_COMPLETED", - "PMU_EVENT_AXI1_RD_DATA_BEAT_RECEIVED", - "PMU_EVENT_AXI1_RD_TRAN_REQ_STALLED", - "PMU_EVENT_AXI1_WR_TRANS_ACCEPTED", - "PMU_EVENT_AXI1_WR_TRANS_COMPLETED_M", - "PMU_EVENT_AXI1_WR_TRANS_COMPLETED_S", - "PMU_EVENT_AXI1_WR_DATA_BEAT_WRITTEN", - "PMU_EVENT_AXI1_WR_TRAN_REQ_STALLED", - "PMU_EVENT_AXI1_WR_DATA_BEAT_STALLED", - "****", - "****", - "PMU_EVENT_AXI1_ENABLED_CYCLES", - "****", - "PMU_EVENT_AXI1_RD_STALL_LIMIT", - "PMU_EVENT_AXI1_WR_STALL_LIMIT", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "PMU_EVENT_ECC_SB1", -}; - -static const char *pooling_mode_str[] = { - "POOLING_MODE_MAX", - "POOLING_MODE_AVERAGE", - "POOLING_MODE_REDUCE_SUM", -}; - -static const char *privilege_level_str[] = { - "PRIVILEGE_LEVEL_USER", - "PRIVILEGE_LEVEL_PRIVILEGED", -}; - -static const char *round_mode_str[] = { - "ROUND_MODE_DBL", - "ROUND_MODE_TRUNCATE", - "ROUND_MODE_NATURAL", -}; - -static const char *security_level_str[] = { - "SECURITY_LEVEL_SECURE", - "SECURITY_LEVEL_NON_SECURE", -}; - -static const char *state_str[] = { - "STATE_STOPPED", - "STATE_RUNNING", -}; - -static const char *wd_core_slice_state_str[] = { - "WD_CORE_SLICE_STATE_HEADER", - "WD_CORE_SLICE_STATE_PALETTE", - "WD_CORE_SLICE_STATE_WEIGHTS", -}; - -static const char *wd_ctrl_state_str[] = { - "WD_CTRL_STATE_IDLE", - "WD_CTRL_STATE_DRAIN", - "WD_CTRL_STATE_OFD_INIT", - "WD_CTRL_STATE_OFD_RUN", -}; - -static const char *weight_order_str[] = { - "WEIGHT_ORDER_DEPTH_FIRST", - "WEIGHT_ORDER_PART_KERNEL_FIRST", -}; - -#endif - -// Register type structs -// id_r - ID register -struct id_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t version_status : 4; // This is the version of the product - uint32_t version_minor : 4; // This is the n for the P part of an RnPn release number - uint32_t version_major : 4; // This is the n for the R part of an RnPn release number - uint32_t product_major : 4; // Product major ID number (unique per base product) - uint32_t arch_patch_rev : 4; // This is the patch number of the architecture version a.b - uint32_t - arch_minor_rev : 8; // This is the minor architecture version number, b in the architecture version a.b - uint32_t - arch_major_rev : 4; // This is the major architecture version number, a in the architecture version a.b - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR id_r() : word0(269500929) {} - CONSTEXPR id_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - id_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_version_status() const - { - uint32_t value = ((1U << 4) - 1) & (word0 >> 0); - return value; - } - uint32_t get_version_status() const volatile - { - uint32_t value = ((1U << 4) - 1) & (word0 >> 0); - return value; - } - CONSTEXPR id_r &set_version_status(uint32_t value) - { - word0 = (((~((1U << 4) - 1)) << 0) & word0) | ((((1U << 4) - 1) & value) << 0); - return *this; - } - volatile id_r &set_version_status(uint32_t value) volatile - { - word0 = (((~((1U << 4) - 1)) << 0) & word0) | ((((1U << 4) - 1) & value) << 0); - return *this; - } - CONSTEXPR uint32_t get_version_minor() const - { - uint32_t value = ((1U << 4) - 1) & (word0 >> 4); - return value; - } - uint32_t get_version_minor() const volatile - { - uint32_t value = ((1U << 4) - 1) & (word0 >> 4); - return value; - } - CONSTEXPR id_r &set_version_minor(uint32_t value) - { - word0 = (((~((1U << 4) - 1)) << 4) & word0) | ((((1U << 4) - 1) & value) << 4); - return *this; - } - volatile id_r &set_version_minor(uint32_t value) volatile - { - word0 = (((~((1U << 4) - 1)) << 4) & word0) | ((((1U << 4) - 1) & value) << 4); - return *this; - } - CONSTEXPR uint32_t get_version_major() const - { - uint32_t value = ((1U << 4) - 1) & (word0 >> 8); - return value; - } - uint32_t get_version_major() const volatile - { - uint32_t value = ((1U << 4) - 1) & (word0 >> 8); - return value; - } - CONSTEXPR id_r &set_version_major(uint32_t value) - { - word0 = (((~((1U << 4) - 1)) << 8) & word0) | ((((1U << 4) - 1) & value) << 8); - return *this; - } - volatile id_r &set_version_major(uint32_t value) volatile - { - word0 = (((~((1U << 4) - 1)) << 8) & word0) | ((((1U << 4) - 1) & value) << 8); - return *this; - } - CONSTEXPR uint32_t get_product_major() const - { - uint32_t value = ((1U << 4) - 1) & (word0 >> 12); - return value; - } - uint32_t get_product_major() const volatile - { - uint32_t value = ((1U << 4) - 1) & (word0 >> 12); - return value; - } - CONSTEXPR id_r &set_product_major(uint32_t value) - { - word0 = (((~((1U << 4) - 1)) << 12) & word0) | ((((1U << 4) - 1) & value) << 12); - return *this; - } - volatile id_r &set_product_major(uint32_t value) volatile - { - word0 = (((~((1U << 4) - 1)) << 12) & word0) | ((((1U << 4) - 1) & value) << 12); - return *this; - } - CONSTEXPR uint32_t get_arch_patch_rev() const - { - uint32_t value = ((1U << 4) - 1) & (word0 >> 16); - return value; - } - uint32_t get_arch_patch_rev() const volatile - { - uint32_t value = ((1U << 4) - 1) & (word0 >> 16); - return value; - } - CONSTEXPR id_r &set_arch_patch_rev(uint32_t value) - { - word0 = (((~((1U << 4) - 1)) << 16) & word0) | ((((1U << 4) - 1) & value) << 16); - return *this; - } - volatile id_r &set_arch_patch_rev(uint32_t value) volatile - { - word0 = (((~((1U << 4) - 1)) << 16) & word0) | ((((1U << 4) - 1) & value) << 16); - return *this; - } - CONSTEXPR uint32_t get_arch_minor_rev() const - { - uint32_t value = ((1U << 8) - 1) & (word0 >> 20); - return value; - } - uint32_t get_arch_minor_rev() const volatile - { - uint32_t value = ((1U << 8) - 1) & (word0 >> 20); - return value; - } - CONSTEXPR id_r &set_arch_minor_rev(uint32_t value) - { - word0 = (((~((1U << 8) - 1)) << 20) & word0) | ((((1U << 8) - 1) & value) << 20); - return *this; - } - volatile id_r &set_arch_minor_rev(uint32_t value) volatile - { - word0 = (((~((1U << 8) - 1)) << 20) & word0) | ((((1U << 8) - 1) & value) << 20); - return *this; - } - CONSTEXPR uint32_t get_arch_major_rev() const - { - uint32_t value = ((1U << 4) - 1) & (word0 >> 28); - return value; - } - uint32_t get_arch_major_rev() const volatile - { - uint32_t value = ((1U << 4) - 1) & (word0 >> 28); - return value; - } - CONSTEXPR id_r &set_arch_major_rev(uint32_t value) - { - word0 = (((~((1U << 4) - 1)) << 28) & word0) | ((((1U << 4) - 1) & value) << 28); - return *this; - } - volatile id_r &set_arch_major_rev(uint32_t value) volatile - { - word0 = (((~((1U << 4) - 1)) << 28) & word0) | ((((1U << 4) - 1) & value) << 28); - return *this; - } -#endif -}; - -// status_r - Register describes the current operating status of the NPU -struct status_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t state : 1; // NPU state, 0 = Stopped, 1 = Running - uint32_t irq_raised : 1; // Raw IRQ status, 0 = IRQ not raised, 1 = IRQ raised. IRQ is cleared using command - // register bit 1 - uint32_t - bus_status : 1; // 0=OK, 1=Bus abort detected and processing halted (NPU will reach IDLE state and not - // to start process any more commands/AXI transactions). Can only be cleared by a reset - uint32_t reset_status : 1; // Reset is ongoing and only this register can be read (other registers read as 0 - // and writes are ignored.) A value of 0 means NPU is not being reset and can be - // accessed as normal - uint32_t - cmd_parse_error : 1; // 0=No error 1=Command stream parsing error detected. Can only be cleared by reset - uint32_t cmd_end_reached : 1; // 0=Not reached, 1=Reached. Cleared by writing QBASE or QSIZE when NPU is in - // stopped state - uint32_t pmu_irq_raised : 1; // 0=No PMU IRQ, 1=PMU IRQ raised. Cleared by using command register bit 1 - uint32_t wd_fault : 1; // Weight decoder state: 0=no fault 1=weight decoder decompression fault. Can only be - // cleared by reset - uint32_t ecc_fault : 1; // ECC state for internal RAMs: 0=no fault 1=ECC fault signalled. Can only be - // cleared by reset - uint32_t reserved0 : 2; - uint32_t faulting_interface : 1; // Faulting interface on bus abort - uint32_t faulting_channel : 4; // Faulting channel on a bus abort. Read: 0=Cmd 1=IFM 2=Weights 3=Scale+Bias - // 4=Mem2Mem; Write: 8=OFM 9=Mem2Mem - uint32_t irq_history_mask : 16; // IRQ History mask - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR status_r() : word0(8) {} - CONSTEXPR status_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - status_r copy() volatile - { - return *this; - } - CONSTEXPR NPU_NAMESPACE::state get_state() const - { - NPU_NAMESPACE::state value = static_cast(((1U << 1) - 1) & (word0 >> 0)); - return value; - } - NPU_NAMESPACE::state get_state() const volatile - { - NPU_NAMESPACE::state value = static_cast(((1U << 1) - 1) & (word0 >> 0)); - return value; - } - CONSTEXPR status_r &set_state(NPU_NAMESPACE::state value) - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & static_cast(value)) << 0); - return *this; - } - volatile status_r &set_state(NPU_NAMESPACE::state value) volatile - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & static_cast(value)) << 0); - return *this; - } - CONSTEXPR uint32_t get_irq_raised() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 1); - return value; - } - uint32_t get_irq_raised() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 1); - return value; - } - CONSTEXPR status_r &set_irq_raised(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - volatile status_r &set_irq_raised(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - CONSTEXPR uint32_t get_bus_status() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 2); - return value; - } - uint32_t get_bus_status() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 2); - return value; - } - CONSTEXPR status_r &set_bus_status(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - volatile status_r &set_bus_status(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - CONSTEXPR uint32_t get_reset_status() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 3); - return value; - } - uint32_t get_reset_status() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 3); - return value; - } - CONSTEXPR status_r &set_reset_status(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - volatile status_r &set_reset_status(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - CONSTEXPR uint32_t get_cmd_parse_error() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 4); - return value; - } - uint32_t get_cmd_parse_error() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 4); - return value; - } - CONSTEXPR status_r &set_cmd_parse_error(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 4) & word0) | ((((1U << 1) - 1) & value) << 4); - return *this; - } - volatile status_r &set_cmd_parse_error(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 4) & word0) | ((((1U << 1) - 1) & value) << 4); - return *this; - } - CONSTEXPR uint32_t get_cmd_end_reached() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 5); - return value; - } - uint32_t get_cmd_end_reached() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 5); - return value; - } - CONSTEXPR status_r &set_cmd_end_reached(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 5) & word0) | ((((1U << 1) - 1) & value) << 5); - return *this; - } - volatile status_r &set_cmd_end_reached(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 5) & word0) | ((((1U << 1) - 1) & value) << 5); - return *this; - } - CONSTEXPR uint32_t get_pmu_irq_raised() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 6); - return value; - } - uint32_t get_pmu_irq_raised() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 6); - return value; - } - CONSTEXPR status_r &set_pmu_irq_raised(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 6) & word0) | ((((1U << 1) - 1) & value) << 6); - return *this; - } - volatile status_r &set_pmu_irq_raised(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 6) & word0) | ((((1U << 1) - 1) & value) << 6); - return *this; - } - CONSTEXPR uint32_t get_wd_fault() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 7); - return value; - } - uint32_t get_wd_fault() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 7); - return value; - } - CONSTEXPR status_r &set_wd_fault(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 7) & word0) | ((((1U << 1) - 1) & value) << 7); - return *this; - } - volatile status_r &set_wd_fault(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 7) & word0) | ((((1U << 1) - 1) & value) << 7); - return *this; - } - CONSTEXPR uint32_t get_ecc_fault() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 8); - return value; - } - uint32_t get_ecc_fault() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 8); - return value; - } - CONSTEXPR status_r &set_ecc_fault(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 8) & word0) | ((((1U << 1) - 1) & value) << 8); - return *this; - } - volatile status_r &set_ecc_fault(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 8) & word0) | ((((1U << 1) - 1) & value) << 8); - return *this; - } - CONSTEXPR NPU_NAMESPACE::dma_fault_src get_faulting_interface() const - { - NPU_NAMESPACE::dma_fault_src value = static_cast(((1U << 1) - 1) & (word0 >> 11)); - return value; - } - NPU_NAMESPACE::dma_fault_src get_faulting_interface() const volatile - { - NPU_NAMESPACE::dma_fault_src value = static_cast(((1U << 1) - 1) & (word0 >> 11)); - return value; - } - CONSTEXPR status_r &set_faulting_interface(NPU_NAMESPACE::dma_fault_src value) - { - word0 = (((~((1U << 1) - 1)) << 11) & word0) | ((((1U << 1) - 1) & static_cast(value)) << 11); - return *this; - } - volatile status_r &set_faulting_interface(NPU_NAMESPACE::dma_fault_src value) volatile - { - word0 = (((~((1U << 1) - 1)) << 11) & word0) | ((((1U << 1) - 1) & static_cast(value)) << 11); - return *this; - } - CONSTEXPR uint32_t get_faulting_channel() const - { - uint32_t value = ((1U << 4) - 1) & (word0 >> 12); - return value; - } - uint32_t get_faulting_channel() const volatile - { - uint32_t value = ((1U << 4) - 1) & (word0 >> 12); - return value; - } - CONSTEXPR status_r &set_faulting_channel(uint32_t value) - { - word0 = (((~((1U << 4) - 1)) << 12) & word0) | ((((1U << 4) - 1) & value) << 12); - return *this; - } - volatile status_r &set_faulting_channel(uint32_t value) volatile - { - word0 = (((~((1U << 4) - 1)) << 12) & word0) | ((((1U << 4) - 1) & value) << 12); - return *this; - } - CONSTEXPR uint32_t get_irq_history_mask() const - { - uint32_t value = ((1U << 16) - 1) & (word0 >> 16); - return value; - } - uint32_t get_irq_history_mask() const volatile - { - uint32_t value = ((1U << 16) - 1) & (word0 >> 16); - return value; - } - CONSTEXPR status_r &set_irq_history_mask(uint32_t value) - { - word0 = (((~((1U << 16) - 1)) << 16) & word0) | ((((1U << 16) - 1) & value) << 16); - return *this; - } - volatile status_r &set_irq_history_mask(uint32_t value) volatile - { - word0 = (((~((1U << 16) - 1)) << 16) & word0) | ((((1U << 16) - 1) & value) << 16); - return *this; - } -#endif -}; - -// cmd_r - Command register, reads as last written command -struct cmd_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t transition_to_running_state : 1; // Write 1 to transition the NPU to running state. Writing 0 has - // no effect - uint32_t clear_irq : 1; // Write 1 to clear the IRQ status in the STATUS register. Writing 0 has no effect - uint32_t clock_q_enable : 1; // Write 1 to this bit to enable clock off using clock q-interface and enable - // the requester clock gate - uint32_t power_q_enable : 1; // Write 1 to this bit to enable power off using power q-interface - uint32_t - stop_request : 1; // Write 1 to this bit to request STOP after completing any already-started commands - uint32_t reserved0 : 11; - uint32_t clear_irq_history : 16; // Clears the IRQ history mask - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR cmd_r() : word0(12) {} - CONSTEXPR cmd_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - cmd_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_transition_to_running_state() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 0); - return value; - } - uint32_t get_transition_to_running_state() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 0); - return value; - } - CONSTEXPR cmd_r &set_transition_to_running_state(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - volatile cmd_r &set_transition_to_running_state(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - CONSTEXPR uint32_t get_clear_irq() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 1); - return value; - } - uint32_t get_clear_irq() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 1); - return value; - } - CONSTEXPR cmd_r &set_clear_irq(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - volatile cmd_r &set_clear_irq(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - CONSTEXPR uint32_t get_clock_q_enable() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 2); - return value; - } - uint32_t get_clock_q_enable() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 2); - return value; - } - CONSTEXPR cmd_r &set_clock_q_enable(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - volatile cmd_r &set_clock_q_enable(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - CONSTEXPR uint32_t get_power_q_enable() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 3); - return value; - } - uint32_t get_power_q_enable() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 3); - return value; - } - CONSTEXPR cmd_r &set_power_q_enable(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - volatile cmd_r &set_power_q_enable(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - CONSTEXPR uint32_t get_stop_request() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 4); - return value; - } - uint32_t get_stop_request() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 4); - return value; - } - CONSTEXPR cmd_r &set_stop_request(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 4) & word0) | ((((1U << 1) - 1) & value) << 4); - return *this; - } - volatile cmd_r &set_stop_request(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 4) & word0) | ((((1U << 1) - 1) & value) << 4); - return *this; - } - CONSTEXPR uint32_t get_clear_irq_history() const - { - uint32_t value = ((1U << 16) - 1) & (word0 >> 16); - return value; - } - uint32_t get_clear_irq_history() const volatile - { - uint32_t value = ((1U << 16) - 1) & (word0 >> 16); - return value; - } - CONSTEXPR cmd_r &set_clear_irq_history(uint32_t value) - { - word0 = (((~((1U << 16) - 1)) << 16) & word0) | ((((1U << 16) - 1) & value) << 16); - return *this; - } - volatile cmd_r &set_clear_irq_history(uint32_t value) volatile - { - word0 = (((~((1U << 16) - 1)) << 16) & word0) | ((((1U << 16) - 1) & value) << 16); - return *this; - } -#endif -}; - -// reset_r - Request Reset and new security mode -struct reset_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t pending_CPL : 1; // Current privilege level 0=User 1=Privileged - uint32_t pending_CSL : 1; // Current security level 0=Secure 1=Non secure - uint32_t reserved0 : 30; - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR reset_r() : word0(0) {} - CONSTEXPR reset_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - reset_r copy() volatile - { - return *this; - } - CONSTEXPR NPU_NAMESPACE::privilege_level get_pending_CPL() const - { - NPU_NAMESPACE::privilege_level value = - static_cast(((1U << 1) - 1) & (word0 >> 0)); - return value; - } - NPU_NAMESPACE::privilege_level get_pending_CPL() const volatile - { - NPU_NAMESPACE::privilege_level value = - static_cast(((1U << 1) - 1) & (word0 >> 0)); - return value; - } - CONSTEXPR reset_r &set_pending_CPL(NPU_NAMESPACE::privilege_level value) - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & static_cast(value)) << 0); - return *this; - } - volatile reset_r &set_pending_CPL(NPU_NAMESPACE::privilege_level value) volatile - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & static_cast(value)) << 0); - return *this; - } - CONSTEXPR NPU_NAMESPACE::security_level get_pending_CSL() const - { - NPU_NAMESPACE::security_level value = - static_cast(((1U << 1) - 1) & (word0 >> 1)); - return value; - } - NPU_NAMESPACE::security_level get_pending_CSL() const volatile - { - NPU_NAMESPACE::security_level value = - static_cast(((1U << 1) - 1) & (word0 >> 1)); - return value; - } - CONSTEXPR reset_r &set_pending_CSL(NPU_NAMESPACE::security_level value) - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & static_cast(value)) << 1); - return *this; - } - volatile reset_r &set_pending_CSL(NPU_NAMESPACE::security_level value) volatile - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & static_cast(value)) << 1); - return *this; - } -#endif -}; - -// qbase_r - Base address of the command stream in bytes -struct qbase_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t offset : 32; // Offset - uint32_t reserved0 : 32; - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR qbase_r() : word0(0), word1(0) {} - CONSTEXPR qbase_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - qbase_r copy() volatile - { - return *this; - } -#endif -}; - -// qread_r - Read offset in the command stream in bytes. Multiple of 4 in the range 0 to 16 MB -struct qread_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t QREAD : 32; // The read offset of the current command under execution - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR qread_r() : word0(0) {} - CONSTEXPR qread_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - qread_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_QREAD() const - { - uint32_t value = word0; - return value; - } - uint32_t get_QREAD() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR qread_r &set_QREAD(uint32_t value) - { - word0 = value; - return *this; - } - volatile qread_r &set_QREAD(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// qconfig_r - AXI configuration for the command stream in the range 0-3. Same encoding as for REGIONCFG -struct qconfig_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t cmd_region0 : 2; // Command region configuration - uint32_t reserved0 : 30; - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR qconfig_r() : word0(0) {} - CONSTEXPR qconfig_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - qconfig_r copy() volatile - { - return *this; - } - CONSTEXPR NPU_NAMESPACE::mem_attr get_cmd_region0() const - { - NPU_NAMESPACE::mem_attr value = static_cast(((1U << 2) - 1) & (word0 >> 0)); - return value; - } - NPU_NAMESPACE::mem_attr get_cmd_region0() const volatile - { - NPU_NAMESPACE::mem_attr value = static_cast(((1U << 2) - 1) & (word0 >> 0)); - return value; - } - CONSTEXPR qconfig_r &set_cmd_region0(NPU_NAMESPACE::mem_attr value) - { - word0 = (((~((1U << 2) - 1)) << 0) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 0); - return *this; - } - volatile qconfig_r &set_cmd_region0(NPU_NAMESPACE::mem_attr value) volatile - { - word0 = (((~((1U << 2) - 1)) << 0) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 0); - return *this; - } -#endif -}; - -// qsize_r - Size of the command stream in bytes. Multiple of 4 in the range 0 to 16 MB -struct qsize_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t QSIZE : 32; // Size of the next command stream to be executed by the NPU - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR qsize_r() : word0(0) {} - CONSTEXPR qsize_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - qsize_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_QSIZE() const - { - uint32_t value = word0; - return value; - } - uint32_t get_QSIZE() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR qsize_r &set_QSIZE(uint32_t value) - { - word0 = value; - return *this; - } - volatile qsize_r &set_QSIZE(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// prot_r - Protection level configured for the NPU when acting as an AXI requester -struct prot_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t active_CPL : 1; // Current privilege level 0=User 1=Privileged - uint32_t active_CSL : 1; // Current security level 0=Secure 1=Non secure - uint32_t reserved0 : 30; - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR prot_r() : word0(0) {} - CONSTEXPR prot_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - prot_r copy() volatile - { - return *this; - } - CONSTEXPR NPU_NAMESPACE::privilege_level get_active_CPL() const - { - NPU_NAMESPACE::privilege_level value = - static_cast(((1U << 1) - 1) & (word0 >> 0)); - return value; - } - NPU_NAMESPACE::privilege_level get_active_CPL() const volatile - { - NPU_NAMESPACE::privilege_level value = - static_cast(((1U << 1) - 1) & (word0 >> 0)); - return value; - } - CONSTEXPR prot_r &set_active_CPL(NPU_NAMESPACE::privilege_level value) - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & static_cast(value)) << 0); - return *this; - } - volatile prot_r &set_active_CPL(NPU_NAMESPACE::privilege_level value) volatile - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & static_cast(value)) << 0); - return *this; - } - CONSTEXPR NPU_NAMESPACE::security_level get_active_CSL() const - { - NPU_NAMESPACE::security_level value = - static_cast(((1U << 1) - 1) & (word0 >> 1)); - return value; - } - NPU_NAMESPACE::security_level get_active_CSL() const volatile - { - NPU_NAMESPACE::security_level value = - static_cast(((1U << 1) - 1) & (word0 >> 1)); - return value; - } - CONSTEXPR prot_r &set_active_CSL(NPU_NAMESPACE::security_level value) - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & static_cast(value)) << 1); - return *this; - } - volatile prot_r &set_active_CSL(NPU_NAMESPACE::security_level value) volatile - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & static_cast(value)) << 1); - return *this; - } -#endif -}; - -// config_r - RTL configuration -struct config_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t macs_per_cc : 4; // The log2(macs/clock cycle) - uint32_t cmd_stream_version : 4; // command stream version accepted by this NPU - uint32_t shram_size : 8; // Total size in KB of internal SHRAM - uint32_t reserved0 : 10; - uint32_t functional_safety : 1; // Functional safety configuration - uint32_t custom_dma : 1; // Custom DMA configuration - uint32_t product : 4; // Product configuration - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR config_r() : word0(0) {} - CONSTEXPR config_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - config_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_macs_per_cc() const - { - uint32_t value = ((1U << 4) - 1) & (word0 >> 0); - return value; - } - uint32_t get_macs_per_cc() const volatile - { - uint32_t value = ((1U << 4) - 1) & (word0 >> 0); - return value; - } - CONSTEXPR config_r &set_macs_per_cc(uint32_t value) - { - word0 = (((~((1U << 4) - 1)) << 0) & word0) | ((((1U << 4) - 1) & value) << 0); - return *this; - } - volatile config_r &set_macs_per_cc(uint32_t value) volatile - { - word0 = (((~((1U << 4) - 1)) << 0) & word0) | ((((1U << 4) - 1) & value) << 0); - return *this; - } - CONSTEXPR uint32_t get_cmd_stream_version() const - { - uint32_t value = ((1U << 4) - 1) & (word0 >> 4); - return value; - } - uint32_t get_cmd_stream_version() const volatile - { - uint32_t value = ((1U << 4) - 1) & (word0 >> 4); - return value; - } - CONSTEXPR config_r &set_cmd_stream_version(uint32_t value) - { - word0 = (((~((1U << 4) - 1)) << 4) & word0) | ((((1U << 4) - 1) & value) << 4); - return *this; - } - volatile config_r &set_cmd_stream_version(uint32_t value) volatile - { - word0 = (((~((1U << 4) - 1)) << 4) & word0) | ((((1U << 4) - 1) & value) << 4); - return *this; - } - CONSTEXPR uint32_t get_shram_size() const - { - uint32_t value = ((1U << 8) - 1) & (word0 >> 8); - return value; - } - uint32_t get_shram_size() const volatile - { - uint32_t value = ((1U << 8) - 1) & (word0 >> 8); - return value; - } - CONSTEXPR config_r &set_shram_size(uint32_t value) - { - word0 = (((~((1U << 8) - 1)) << 8) & word0) | ((((1U << 8) - 1) & value) << 8); - return *this; - } - volatile config_r &set_shram_size(uint32_t value) volatile - { - word0 = (((~((1U << 8) - 1)) << 8) & word0) | ((((1U << 8) - 1) & value) << 8); - return *this; - } - CONSTEXPR NPU_NAMESPACE::functional_safety get_functional_safety() const - { - NPU_NAMESPACE::functional_safety value = - static_cast(((1U << 1) - 1) & (word0 >> 26)); - return value; - } - NPU_NAMESPACE::functional_safety get_functional_safety() const volatile - { - NPU_NAMESPACE::functional_safety value = - static_cast(((1U << 1) - 1) & (word0 >> 26)); - return value; - } - CONSTEXPR config_r &set_functional_safety(NPU_NAMESPACE::functional_safety value) - { - word0 = (((~((1U << 1) - 1)) << 26) & word0) | ((((1U << 1) - 1) & static_cast(value)) << 26); - return *this; - } - volatile config_r &set_functional_safety(NPU_NAMESPACE::functional_safety value) volatile - { - word0 = (((~((1U << 1) - 1)) << 26) & word0) | ((((1U << 1) - 1) & static_cast(value)) << 26); - return *this; - } - CONSTEXPR NPU_NAMESPACE::custom_dma get_custom_dma() const - { - NPU_NAMESPACE::custom_dma value = static_cast(((1U << 1) - 1) & (word0 >> 27)); - return value; - } - NPU_NAMESPACE::custom_dma get_custom_dma() const volatile - { - NPU_NAMESPACE::custom_dma value = static_cast(((1U << 1) - 1) & (word0 >> 27)); - return value; - } - CONSTEXPR config_r &set_custom_dma(NPU_NAMESPACE::custom_dma value) - { - word0 = (((~((1U << 1) - 1)) << 27) & word0) | ((((1U << 1) - 1) & static_cast(value)) << 27); - return *this; - } - volatile config_r &set_custom_dma(NPU_NAMESPACE::custom_dma value) volatile - { - word0 = (((~((1U << 1) - 1)) << 27) & word0) | ((((1U << 1) - 1) & static_cast(value)) << 27); - return *this; - } - CONSTEXPR uint32_t get_product() const - { - uint32_t value = ((1U << 4) - 1) & (word0 >> 28); - return value; - } - uint32_t get_product() const volatile - { - uint32_t value = ((1U << 4) - 1) & (word0 >> 28); - return value; - } - CONSTEXPR config_r &set_product(uint32_t value) - { - word0 = (((~((1U << 4) - 1)) << 28) & word0) | ((((1U << 4) - 1) & value) << 28); - return *this; - } - volatile config_r &set_product(uint32_t value) volatile - { - word0 = (((~((1U << 4) - 1)) << 28) & word0) | ((((1U << 4) - 1) & value) << 28); - return *this; - } -#endif -}; - -// lock_r - Lock register. This register is designed for driver use and does not affect NPU functionality -struct lock_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t LOCK : 32; // 32 bit value for LOCK configuration - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR lock_r() : word0(0) {} - CONSTEXPR lock_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - lock_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_LOCK() const - { - uint32_t value = word0; - return value; - } - uint32_t get_LOCK() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR lock_r &set_LOCK(uint32_t value) - { - word0 = value; - return *this; - } - volatile lock_r &set_LOCK(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// regioncfg_r - Region memory type configuration. Bits[2*k+1:2*k] give the memory type for REGION[k] -struct regioncfg_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t region0 : 2; // Bits for Region0 Configuration - uint32_t region1 : 2; // Bits for Region1 Configuration - uint32_t region2 : 2; // Bits for Region2 Configuration - uint32_t region3 : 2; // Bits for Region3 Configuration - uint32_t region4 : 2; // Bits for Region4 Configuration - uint32_t region5 : 2; // Bits for Region5 Configuration - uint32_t region6 : 2; // Bits for Region6 Configuration - uint32_t region7 : 2; // Bits for Region7 Configuration - uint32_t reserved0 : 16; - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR regioncfg_r() : word0(0) {} - CONSTEXPR regioncfg_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - regioncfg_r copy() volatile - { - return *this; - } - CONSTEXPR NPU_NAMESPACE::mem_attr get_region0() const - { - NPU_NAMESPACE::mem_attr value = static_cast(((1U << 2) - 1) & (word0 >> 0)); - return value; - } - NPU_NAMESPACE::mem_attr get_region0() const volatile - { - NPU_NAMESPACE::mem_attr value = static_cast(((1U << 2) - 1) & (word0 >> 0)); - return value; - } - CONSTEXPR regioncfg_r &set_region0(NPU_NAMESPACE::mem_attr value) - { - word0 = (((~((1U << 2) - 1)) << 0) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 0); - return *this; - } - volatile regioncfg_r &set_region0(NPU_NAMESPACE::mem_attr value) volatile - { - word0 = (((~((1U << 2) - 1)) << 0) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 0); - return *this; - } - CONSTEXPR NPU_NAMESPACE::mem_attr get_region1() const - { - NPU_NAMESPACE::mem_attr value = static_cast(((1U << 2) - 1) & (word0 >> 2)); - return value; - } - NPU_NAMESPACE::mem_attr get_region1() const volatile - { - NPU_NAMESPACE::mem_attr value = static_cast(((1U << 2) - 1) & (word0 >> 2)); - return value; - } - CONSTEXPR regioncfg_r &set_region1(NPU_NAMESPACE::mem_attr value) - { - word0 = (((~((1U << 2) - 1)) << 2) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 2); - return *this; - } - volatile regioncfg_r &set_region1(NPU_NAMESPACE::mem_attr value) volatile - { - word0 = (((~((1U << 2) - 1)) << 2) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 2); - return *this; - } - CONSTEXPR NPU_NAMESPACE::mem_attr get_region2() const - { - NPU_NAMESPACE::mem_attr value = static_cast(((1U << 2) - 1) & (word0 >> 4)); - return value; - } - NPU_NAMESPACE::mem_attr get_region2() const volatile - { - NPU_NAMESPACE::mem_attr value = static_cast(((1U << 2) - 1) & (word0 >> 4)); - return value; - } - CONSTEXPR regioncfg_r &set_region2(NPU_NAMESPACE::mem_attr value) - { - word0 = (((~((1U << 2) - 1)) << 4) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 4); - return *this; - } - volatile regioncfg_r &set_region2(NPU_NAMESPACE::mem_attr value) volatile - { - word0 = (((~((1U << 2) - 1)) << 4) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 4); - return *this; - } - CONSTEXPR NPU_NAMESPACE::mem_attr get_region3() const - { - NPU_NAMESPACE::mem_attr value = static_cast(((1U << 2) - 1) & (word0 >> 6)); - return value; - } - NPU_NAMESPACE::mem_attr get_region3() const volatile - { - NPU_NAMESPACE::mem_attr value = static_cast(((1U << 2) - 1) & (word0 >> 6)); - return value; - } - CONSTEXPR regioncfg_r &set_region3(NPU_NAMESPACE::mem_attr value) - { - word0 = (((~((1U << 2) - 1)) << 6) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 6); - return *this; - } - volatile regioncfg_r &set_region3(NPU_NAMESPACE::mem_attr value) volatile - { - word0 = (((~((1U << 2) - 1)) << 6) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 6); - return *this; - } - CONSTEXPR NPU_NAMESPACE::mem_attr get_region4() const - { - NPU_NAMESPACE::mem_attr value = static_cast(((1U << 2) - 1) & (word0 >> 8)); - return value; - } - NPU_NAMESPACE::mem_attr get_region4() const volatile - { - NPU_NAMESPACE::mem_attr value = static_cast(((1U << 2) - 1) & (word0 >> 8)); - return value; - } - CONSTEXPR regioncfg_r &set_region4(NPU_NAMESPACE::mem_attr value) - { - word0 = (((~((1U << 2) - 1)) << 8) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 8); - return *this; - } - volatile regioncfg_r &set_region4(NPU_NAMESPACE::mem_attr value) volatile - { - word0 = (((~((1U << 2) - 1)) << 8) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 8); - return *this; - } - CONSTEXPR NPU_NAMESPACE::mem_attr get_region5() const - { - NPU_NAMESPACE::mem_attr value = static_cast(((1U << 2) - 1) & (word0 >> 10)); - return value; - } - NPU_NAMESPACE::mem_attr get_region5() const volatile - { - NPU_NAMESPACE::mem_attr value = static_cast(((1U << 2) - 1) & (word0 >> 10)); - return value; - } - CONSTEXPR regioncfg_r &set_region5(NPU_NAMESPACE::mem_attr value) - { - word0 = (((~((1U << 2) - 1)) << 10) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 10); - return *this; - } - volatile regioncfg_r &set_region5(NPU_NAMESPACE::mem_attr value) volatile - { - word0 = (((~((1U << 2) - 1)) << 10) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 10); - return *this; - } - CONSTEXPR NPU_NAMESPACE::mem_attr get_region6() const - { - NPU_NAMESPACE::mem_attr value = static_cast(((1U << 2) - 1) & (word0 >> 12)); - return value; - } - NPU_NAMESPACE::mem_attr get_region6() const volatile - { - NPU_NAMESPACE::mem_attr value = static_cast(((1U << 2) - 1) & (word0 >> 12)); - return value; - } - CONSTEXPR regioncfg_r &set_region6(NPU_NAMESPACE::mem_attr value) - { - word0 = (((~((1U << 2) - 1)) << 12) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 12); - return *this; - } - volatile regioncfg_r &set_region6(NPU_NAMESPACE::mem_attr value) volatile - { - word0 = (((~((1U << 2) - 1)) << 12) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 12); - return *this; - } - CONSTEXPR NPU_NAMESPACE::mem_attr get_region7() const - { - NPU_NAMESPACE::mem_attr value = static_cast(((1U << 2) - 1) & (word0 >> 14)); - return value; - } - NPU_NAMESPACE::mem_attr get_region7() const volatile - { - NPU_NAMESPACE::mem_attr value = static_cast(((1U << 2) - 1) & (word0 >> 14)); - return value; - } - CONSTEXPR regioncfg_r &set_region7(NPU_NAMESPACE::mem_attr value) - { - word0 = (((~((1U << 2) - 1)) << 14) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 14); - return *this; - } - volatile regioncfg_r &set_region7(NPU_NAMESPACE::mem_attr value) volatile - { - word0 = (((~((1U << 2) - 1)) << 14) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 14); - return *this; - } -#endif -}; - -// axi_limit0_r - AXI limits for port 0 counter 0 -struct axi_limit0_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t max_beats : 2; // Burst split alignment - uint32_t reserved0 : 2; - uint32_t memtype : 4; // Memtype to be used to encode AxCACHE signals - uint32_t reserved1 : 8; - uint32_t - max_outstanding_read_m1 : 5; // Maximum number of outstanding AXI read transactions - 1 in range 0 to 31 - uint32_t reserved2 : 3; - uint32_t max_outstanding_write_m1 : 4; // Maximum number of outstanding AXI write transactions - 1 in range - // 0 to 15 - uint32_t reserved3 : 4; - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR axi_limit0_r() : word0(0) {} - CONSTEXPR axi_limit0_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - axi_limit0_r copy() volatile - { - return *this; - } - CONSTEXPR NPU_NAMESPACE::max_beats get_max_beats() const - { - NPU_NAMESPACE::max_beats value = static_cast(((1U << 2) - 1) & (word0 >> 0)); - return value; - } - NPU_NAMESPACE::max_beats get_max_beats() const volatile - { - NPU_NAMESPACE::max_beats value = static_cast(((1U << 2) - 1) & (word0 >> 0)); - return value; - } - CONSTEXPR axi_limit0_r &set_max_beats(NPU_NAMESPACE::max_beats value) - { - word0 = (((~((1U << 2) - 1)) << 0) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 0); - return *this; - } - volatile axi_limit0_r &set_max_beats(NPU_NAMESPACE::max_beats value) volatile - { - word0 = (((~((1U << 2) - 1)) << 0) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 0); - return *this; - } - CONSTEXPR NPU_NAMESPACE::axi_mem_encoding get_memtype() const - { - NPU_NAMESPACE::axi_mem_encoding value = - static_cast(((1U << 4) - 1) & (word0 >> 4)); - return value; - } - NPU_NAMESPACE::axi_mem_encoding get_memtype() const volatile - { - NPU_NAMESPACE::axi_mem_encoding value = - static_cast(((1U << 4) - 1) & (word0 >> 4)); - return value; - } - CONSTEXPR axi_limit0_r &set_memtype(NPU_NAMESPACE::axi_mem_encoding value) - { - word0 = (((~((1U << 4) - 1)) << 4) & word0) | ((((1U << 4) - 1) & static_cast(value)) << 4); - return *this; - } - volatile axi_limit0_r &set_memtype(NPU_NAMESPACE::axi_mem_encoding value) volatile - { - word0 = (((~((1U << 4) - 1)) << 4) & word0) | ((((1U << 4) - 1) & static_cast(value)) << 4); - return *this; - } - CONSTEXPR uint32_t get_max_outstanding_read_m1() const - { - uint32_t value = ((1U << 5) - 1) & (word0 >> 16); - return value; - } - uint32_t get_max_outstanding_read_m1() const volatile - { - uint32_t value = ((1U << 5) - 1) & (word0 >> 16); - return value; - } - CONSTEXPR axi_limit0_r &set_max_outstanding_read_m1(uint32_t value) - { - word0 = (((~((1U << 5) - 1)) << 16) & word0) | ((((1U << 5) - 1) & value) << 16); - return *this; - } - volatile axi_limit0_r &set_max_outstanding_read_m1(uint32_t value) volatile - { - word0 = (((~((1U << 5) - 1)) << 16) & word0) | ((((1U << 5) - 1) & value) << 16); - return *this; - } - CONSTEXPR uint32_t get_max_outstanding_write_m1() const - { - uint32_t value = ((1U << 4) - 1) & (word0 >> 24); - return value; - } - uint32_t get_max_outstanding_write_m1() const volatile - { - uint32_t value = ((1U << 4) - 1) & (word0 >> 24); - return value; - } - CONSTEXPR axi_limit0_r &set_max_outstanding_write_m1(uint32_t value) - { - word0 = (((~((1U << 4) - 1)) << 24) & word0) | ((((1U << 4) - 1) & value) << 24); - return *this; - } - volatile axi_limit0_r &set_max_outstanding_write_m1(uint32_t value) volatile - { - word0 = (((~((1U << 4) - 1)) << 24) & word0) | ((((1U << 4) - 1) & value) << 24); - return *this; - } -#endif -}; - -// axi_limit1_r - AXI limits for port 0 counter 1 -struct axi_limit1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t max_beats : 2; // Burst split alignment - uint32_t reserved0 : 2; - uint32_t memtype : 4; // Memtype to be used to encode AxCACHE signals - uint32_t reserved1 : 8; - uint32_t - max_outstanding_read_m1 : 5; // Maximum number of outstanding AXI read transactions - 1 in range 0 to 31 - uint32_t reserved2 : 3; - uint32_t max_outstanding_write_m1 : 4; // Maximum number of outstanding AXI write transactions - 1 in range - // 0 to 15 - uint32_t reserved3 : 4; - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR axi_limit1_r() : word0(0) {} - CONSTEXPR axi_limit1_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - axi_limit1_r copy() volatile - { - return *this; - } - CONSTEXPR NPU_NAMESPACE::max_beats get_max_beats() const - { - NPU_NAMESPACE::max_beats value = static_cast(((1U << 2) - 1) & (word0 >> 0)); - return value; - } - NPU_NAMESPACE::max_beats get_max_beats() const volatile - { - NPU_NAMESPACE::max_beats value = static_cast(((1U << 2) - 1) & (word0 >> 0)); - return value; - } - CONSTEXPR axi_limit1_r &set_max_beats(NPU_NAMESPACE::max_beats value) - { - word0 = (((~((1U << 2) - 1)) << 0) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 0); - return *this; - } - volatile axi_limit1_r &set_max_beats(NPU_NAMESPACE::max_beats value) volatile - { - word0 = (((~((1U << 2) - 1)) << 0) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 0); - return *this; - } - CONSTEXPR NPU_NAMESPACE::axi_mem_encoding get_memtype() const - { - NPU_NAMESPACE::axi_mem_encoding value = - static_cast(((1U << 4) - 1) & (word0 >> 4)); - return value; - } - NPU_NAMESPACE::axi_mem_encoding get_memtype() const volatile - { - NPU_NAMESPACE::axi_mem_encoding value = - static_cast(((1U << 4) - 1) & (word0 >> 4)); - return value; - } - CONSTEXPR axi_limit1_r &set_memtype(NPU_NAMESPACE::axi_mem_encoding value) - { - word0 = (((~((1U << 4) - 1)) << 4) & word0) | ((((1U << 4) - 1) & static_cast(value)) << 4); - return *this; - } - volatile axi_limit1_r &set_memtype(NPU_NAMESPACE::axi_mem_encoding value) volatile - { - word0 = (((~((1U << 4) - 1)) << 4) & word0) | ((((1U << 4) - 1) & static_cast(value)) << 4); - return *this; - } - CONSTEXPR uint32_t get_max_outstanding_read_m1() const - { - uint32_t value = ((1U << 5) - 1) & (word0 >> 16); - return value; - } - uint32_t get_max_outstanding_read_m1() const volatile - { - uint32_t value = ((1U << 5) - 1) & (word0 >> 16); - return value; - } - CONSTEXPR axi_limit1_r &set_max_outstanding_read_m1(uint32_t value) - { - word0 = (((~((1U << 5) - 1)) << 16) & word0) | ((((1U << 5) - 1) & value) << 16); - return *this; - } - volatile axi_limit1_r &set_max_outstanding_read_m1(uint32_t value) volatile - { - word0 = (((~((1U << 5) - 1)) << 16) & word0) | ((((1U << 5) - 1) & value) << 16); - return *this; - } - CONSTEXPR uint32_t get_max_outstanding_write_m1() const - { - uint32_t value = ((1U << 4) - 1) & (word0 >> 24); - return value; - } - uint32_t get_max_outstanding_write_m1() const volatile - { - uint32_t value = ((1U << 4) - 1) & (word0 >> 24); - return value; - } - CONSTEXPR axi_limit1_r &set_max_outstanding_write_m1(uint32_t value) - { - word0 = (((~((1U << 4) - 1)) << 24) & word0) | ((((1U << 4) - 1) & value) << 24); - return *this; - } - volatile axi_limit1_r &set_max_outstanding_write_m1(uint32_t value) volatile - { - word0 = (((~((1U << 4) - 1)) << 24) & word0) | ((((1U << 4) - 1) & value) << 24); - return *this; - } -#endif -}; - -// axi_limit2_r - AXI limits for port 1 counter 2 -struct axi_limit2_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t max_beats : 2; // Burst split alignment - uint32_t reserved0 : 2; - uint32_t memtype : 4; // Memtype to be used to encode AxCACHE signals - uint32_t reserved1 : 8; - uint32_t - max_outstanding_read_m1 : 5; // Maximum number of outstanding AXI read transactions - 1 in range 0 to 31 - uint32_t reserved2 : 3; - uint32_t max_outstanding_write_m1 : 4; // Maximum number of outstanding AXI write transactions - 1 in range - // 0 to 15 - uint32_t reserved3 : 4; - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR axi_limit2_r() : word0(0) {} - CONSTEXPR axi_limit2_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - axi_limit2_r copy() volatile - { - return *this; - } - CONSTEXPR NPU_NAMESPACE::max_beats get_max_beats() const - { - NPU_NAMESPACE::max_beats value = static_cast(((1U << 2) - 1) & (word0 >> 0)); - return value; - } - NPU_NAMESPACE::max_beats get_max_beats() const volatile - { - NPU_NAMESPACE::max_beats value = static_cast(((1U << 2) - 1) & (word0 >> 0)); - return value; - } - CONSTEXPR axi_limit2_r &set_max_beats(NPU_NAMESPACE::max_beats value) - { - word0 = (((~((1U << 2) - 1)) << 0) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 0); - return *this; - } - volatile axi_limit2_r &set_max_beats(NPU_NAMESPACE::max_beats value) volatile - { - word0 = (((~((1U << 2) - 1)) << 0) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 0); - return *this; - } - CONSTEXPR NPU_NAMESPACE::axi_mem_encoding get_memtype() const - { - NPU_NAMESPACE::axi_mem_encoding value = - static_cast(((1U << 4) - 1) & (word0 >> 4)); - return value; - } - NPU_NAMESPACE::axi_mem_encoding get_memtype() const volatile - { - NPU_NAMESPACE::axi_mem_encoding value = - static_cast(((1U << 4) - 1) & (word0 >> 4)); - return value; - } - CONSTEXPR axi_limit2_r &set_memtype(NPU_NAMESPACE::axi_mem_encoding value) - { - word0 = (((~((1U << 4) - 1)) << 4) & word0) | ((((1U << 4) - 1) & static_cast(value)) << 4); - return *this; - } - volatile axi_limit2_r &set_memtype(NPU_NAMESPACE::axi_mem_encoding value) volatile - { - word0 = (((~((1U << 4) - 1)) << 4) & word0) | ((((1U << 4) - 1) & static_cast(value)) << 4); - return *this; - } - CONSTEXPR uint32_t get_max_outstanding_read_m1() const - { - uint32_t value = ((1U << 5) - 1) & (word0 >> 16); - return value; - } - uint32_t get_max_outstanding_read_m1() const volatile - { - uint32_t value = ((1U << 5) - 1) & (word0 >> 16); - return value; - } - CONSTEXPR axi_limit2_r &set_max_outstanding_read_m1(uint32_t value) - { - word0 = (((~((1U << 5) - 1)) << 16) & word0) | ((((1U << 5) - 1) & value) << 16); - return *this; - } - volatile axi_limit2_r &set_max_outstanding_read_m1(uint32_t value) volatile - { - word0 = (((~((1U << 5) - 1)) << 16) & word0) | ((((1U << 5) - 1) & value) << 16); - return *this; - } - CONSTEXPR uint32_t get_max_outstanding_write_m1() const - { - uint32_t value = ((1U << 4) - 1) & (word0 >> 24); - return value; - } - uint32_t get_max_outstanding_write_m1() const volatile - { - uint32_t value = ((1U << 4) - 1) & (word0 >> 24); - return value; - } - CONSTEXPR axi_limit2_r &set_max_outstanding_write_m1(uint32_t value) - { - word0 = (((~((1U << 4) - 1)) << 24) & word0) | ((((1U << 4) - 1) & value) << 24); - return *this; - } - volatile axi_limit2_r &set_max_outstanding_write_m1(uint32_t value) volatile - { - word0 = (((~((1U << 4) - 1)) << 24) & word0) | ((((1U << 4) - 1) & value) << 24); - return *this; - } -#endif -}; - -// axi_limit3_r - AXI limits for port 1 counter 3 -struct axi_limit3_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t max_beats : 2; // Burst split alignment - uint32_t reserved0 : 2; - uint32_t memtype : 4; // Memtype to be used to encode AxCACHE signals - uint32_t reserved1 : 8; - uint32_t - max_outstanding_read_m1 : 5; // Maximum number of outstanding AXI read transactions - 1 in range 0 to 31 - uint32_t reserved2 : 3; - uint32_t max_outstanding_write_m1 : 4; // Maximum number of outstanding AXI write transactions - 1 in range - // 0 to 15 - uint32_t reserved3 : 4; - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR axi_limit3_r() : word0(0) {} - CONSTEXPR axi_limit3_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - axi_limit3_r copy() volatile - { - return *this; - } - CONSTEXPR NPU_NAMESPACE::max_beats get_max_beats() const - { - NPU_NAMESPACE::max_beats value = static_cast(((1U << 2) - 1) & (word0 >> 0)); - return value; - } - NPU_NAMESPACE::max_beats get_max_beats() const volatile - { - NPU_NAMESPACE::max_beats value = static_cast(((1U << 2) - 1) & (word0 >> 0)); - return value; - } - CONSTEXPR axi_limit3_r &set_max_beats(NPU_NAMESPACE::max_beats value) - { - word0 = (((~((1U << 2) - 1)) << 0) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 0); - return *this; - } - volatile axi_limit3_r &set_max_beats(NPU_NAMESPACE::max_beats value) volatile - { - word0 = (((~((1U << 2) - 1)) << 0) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 0); - return *this; - } - CONSTEXPR NPU_NAMESPACE::axi_mem_encoding get_memtype() const - { - NPU_NAMESPACE::axi_mem_encoding value = - static_cast(((1U << 4) - 1) & (word0 >> 4)); - return value; - } - NPU_NAMESPACE::axi_mem_encoding get_memtype() const volatile - { - NPU_NAMESPACE::axi_mem_encoding value = - static_cast(((1U << 4) - 1) & (word0 >> 4)); - return value; - } - CONSTEXPR axi_limit3_r &set_memtype(NPU_NAMESPACE::axi_mem_encoding value) - { - word0 = (((~((1U << 4) - 1)) << 4) & word0) | ((((1U << 4) - 1) & static_cast(value)) << 4); - return *this; - } - volatile axi_limit3_r &set_memtype(NPU_NAMESPACE::axi_mem_encoding value) volatile - { - word0 = (((~((1U << 4) - 1)) << 4) & word0) | ((((1U << 4) - 1) & static_cast(value)) << 4); - return *this; - } - CONSTEXPR uint32_t get_max_outstanding_read_m1() const - { - uint32_t value = ((1U << 5) - 1) & (word0 >> 16); - return value; - } - uint32_t get_max_outstanding_read_m1() const volatile - { - uint32_t value = ((1U << 5) - 1) & (word0 >> 16); - return value; - } - CONSTEXPR axi_limit3_r &set_max_outstanding_read_m1(uint32_t value) - { - word0 = (((~((1U << 5) - 1)) << 16) & word0) | ((((1U << 5) - 1) & value) << 16); - return *this; - } - volatile axi_limit3_r &set_max_outstanding_read_m1(uint32_t value) volatile - { - word0 = (((~((1U << 5) - 1)) << 16) & word0) | ((((1U << 5) - 1) & value) << 16); - return *this; - } - CONSTEXPR uint32_t get_max_outstanding_write_m1() const - { - uint32_t value = ((1U << 4) - 1) & (word0 >> 24); - return value; - } - uint32_t get_max_outstanding_write_m1() const volatile - { - uint32_t value = ((1U << 4) - 1) & (word0 >> 24); - return value; - } - CONSTEXPR axi_limit3_r &set_max_outstanding_write_m1(uint32_t value) - { - word0 = (((~((1U << 4) - 1)) << 24) & word0) | ((((1U << 4) - 1) & value) << 24); - return *this; - } - volatile axi_limit3_r &set_max_outstanding_write_m1(uint32_t value) volatile - { - word0 = (((~((1U << 4) - 1)) << 24) & word0) | ((((1U << 4) - 1) & value) << 24); - return *this; - } -#endif -}; - -// basep_r - The driver can use this address to relocate the command stream on region 0. If the region contains data -// requiring A-byte alignment then the base must be a multiple of A -struct basep_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t offset : 32; // Offset - uint32_t reserved0 : 32; - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR basep_r() : word0(0), word1(0) {} - CONSTEXPR basep_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - basep_r copy() volatile - { - return *this; - } -#endif -}; - -// wd_status_r - WD_STATUS -struct wd_status_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t core_slice_state : 2; // WD core slice parser state - uint32_t core_idle : 1; // Core idle - uint32_t ctrl_state : 2; // WD control state - uint32_t ctrl_idle : 1; // All stripe jobs idle (all weights consumed) - uint32_t write_buf_index0 : 3; // current write index for next data from core - uint32_t write_buf_valid0 : 1; // write buf valid (full) - uint32_t write_buf_idle0 : 1; // write buf idle (empty) - uint32_t write_buf_index1 : 3; // current write index for next data from core - uint32_t write_buf_valid1 : 1; // write buf valid (full) - uint32_t write_buf_idle1 : 1; // write buf idle (empty) - uint32_t events : 12; // WD events mapped as appendix A - uint32_t reserved0 : 4; - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR wd_status_r() : word0(0) {} - CONSTEXPR wd_status_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - wd_status_r copy() volatile - { - return *this; - } - CONSTEXPR NPU_NAMESPACE::wd_core_slice_state get_core_slice_state() const - { - NPU_NAMESPACE::wd_core_slice_state value = - static_cast(((1U << 2) - 1) & (word0 >> 0)); - return value; - } - NPU_NAMESPACE::wd_core_slice_state get_core_slice_state() const volatile - { - NPU_NAMESPACE::wd_core_slice_state value = - static_cast(((1U << 2) - 1) & (word0 >> 0)); - return value; - } - CONSTEXPR wd_status_r &set_core_slice_state(NPU_NAMESPACE::wd_core_slice_state value) - { - word0 = (((~((1U << 2) - 1)) << 0) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 0); - return *this; - } - volatile wd_status_r &set_core_slice_state(NPU_NAMESPACE::wd_core_slice_state value) volatile - { - word0 = (((~((1U << 2) - 1)) << 0) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 0); - return *this; - } - CONSTEXPR uint32_t get_core_idle() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 2); - return value; - } - uint32_t get_core_idle() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 2); - return value; - } - CONSTEXPR wd_status_r &set_core_idle(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - volatile wd_status_r &set_core_idle(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - CONSTEXPR NPU_NAMESPACE::wd_ctrl_state get_ctrl_state() const - { - NPU_NAMESPACE::wd_ctrl_state value = static_cast(((1U << 2) - 1) & (word0 >> 3)); - return value; - } - NPU_NAMESPACE::wd_ctrl_state get_ctrl_state() const volatile - { - NPU_NAMESPACE::wd_ctrl_state value = static_cast(((1U << 2) - 1) & (word0 >> 3)); - return value; - } - CONSTEXPR wd_status_r &set_ctrl_state(NPU_NAMESPACE::wd_ctrl_state value) - { - word0 = (((~((1U << 2) - 1)) << 3) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 3); - return *this; - } - volatile wd_status_r &set_ctrl_state(NPU_NAMESPACE::wd_ctrl_state value) volatile - { - word0 = (((~((1U << 2) - 1)) << 3) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 3); - return *this; - } - CONSTEXPR uint32_t get_ctrl_idle() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 5); - return value; - } - uint32_t get_ctrl_idle() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 5); - return value; - } - CONSTEXPR wd_status_r &set_ctrl_idle(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 5) & word0) | ((((1U << 1) - 1) & value) << 5); - return *this; - } - volatile wd_status_r &set_ctrl_idle(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 5) & word0) | ((((1U << 1) - 1) & value) << 5); - return *this; - } - CONSTEXPR uint32_t get_write_buf_index0() const - { - uint32_t value = ((1U << 3) - 1) & (word0 >> 6); - return value; - } - uint32_t get_write_buf_index0() const volatile - { - uint32_t value = ((1U << 3) - 1) & (word0 >> 6); - return value; - } - CONSTEXPR wd_status_r &set_write_buf_index0(uint32_t value) - { - word0 = (((~((1U << 3) - 1)) << 6) & word0) | ((((1U << 3) - 1) & value) << 6); - return *this; - } - volatile wd_status_r &set_write_buf_index0(uint32_t value) volatile - { - word0 = (((~((1U << 3) - 1)) << 6) & word0) | ((((1U << 3) - 1) & value) << 6); - return *this; - } - CONSTEXPR uint32_t get_write_buf_valid0() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 9); - return value; - } - uint32_t get_write_buf_valid0() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 9); - return value; - } - CONSTEXPR wd_status_r &set_write_buf_valid0(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 9) & word0) | ((((1U << 1) - 1) & value) << 9); - return *this; - } - volatile wd_status_r &set_write_buf_valid0(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 9) & word0) | ((((1U << 1) - 1) & value) << 9); - return *this; - } - CONSTEXPR uint32_t get_write_buf_idle0() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 10); - return value; - } - uint32_t get_write_buf_idle0() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 10); - return value; - } - CONSTEXPR wd_status_r &set_write_buf_idle0(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 10) & word0) | ((((1U << 1) - 1) & value) << 10); - return *this; - } - volatile wd_status_r &set_write_buf_idle0(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 10) & word0) | ((((1U << 1) - 1) & value) << 10); - return *this; - } - CONSTEXPR uint32_t get_write_buf_index1() const - { - uint32_t value = ((1U << 3) - 1) & (word0 >> 11); - return value; - } - uint32_t get_write_buf_index1() const volatile - { - uint32_t value = ((1U << 3) - 1) & (word0 >> 11); - return value; - } - CONSTEXPR wd_status_r &set_write_buf_index1(uint32_t value) - { - word0 = (((~((1U << 3) - 1)) << 11) & word0) | ((((1U << 3) - 1) & value) << 11); - return *this; - } - volatile wd_status_r &set_write_buf_index1(uint32_t value) volatile - { - word0 = (((~((1U << 3) - 1)) << 11) & word0) | ((((1U << 3) - 1) & value) << 11); - return *this; - } - CONSTEXPR uint32_t get_write_buf_valid1() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 14); - return value; - } - uint32_t get_write_buf_valid1() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 14); - return value; - } - CONSTEXPR wd_status_r &set_write_buf_valid1(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 14) & word0) | ((((1U << 1) - 1) & value) << 14); - return *this; - } - volatile wd_status_r &set_write_buf_valid1(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 14) & word0) | ((((1U << 1) - 1) & value) << 14); - return *this; - } - CONSTEXPR uint32_t get_write_buf_idle1() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 15); - return value; - } - uint32_t get_write_buf_idle1() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 15); - return value; - } - CONSTEXPR wd_status_r &set_write_buf_idle1(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 15) & word0) | ((((1U << 1) - 1) & value) << 15); - return *this; - } - volatile wd_status_r &set_write_buf_idle1(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 15) & word0) | ((((1U << 1) - 1) & value) << 15); - return *this; - } - CONSTEXPR uint32_t get_events() const - { - uint32_t value = ((1U << 12) - 1) & (word0 >> 16); - return value; - } - uint32_t get_events() const volatile - { - uint32_t value = ((1U << 12) - 1) & (word0 >> 16); - return value; - } - CONSTEXPR wd_status_r &set_events(uint32_t value) - { - word0 = (((~((1U << 12) - 1)) << 16) & word0) | ((((1U << 12) - 1) & value) << 16); - return *this; - } - volatile wd_status_r &set_events(uint32_t value) volatile - { - word0 = (((~((1U << 12) - 1)) << 16) & word0) | ((((1U << 12) - 1) & value) << 16); - return *this; - } -#endif -}; - -// mac_status_r - MAC_STATUS -struct mac_status_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t block_cfg_valid : 1; // MAC has a valid block configuration - uint32_t trav_en : 1; // MAC is doing block traversal - uint32_t wait_for_ib : 1; // MAC is waiting for an Input Buffer to become available - uint32_t wait_for_acc_buf : 1; // MAC is waiting for an Accumulator Buffer to become available - uint32_t wait_for_weights : 1; // MAC is waiting for a Weight Block to become available - uint32_t stall_stripe : 1; // MAC is stalling between two stripes - uint32_t dw_sel : 1; // Currently used weight interface in MAC AI - uint32_t wait_for_dw0_ready : 1; // MAC AI is waiting for MAC DPU to send dw0_ready to WD - uint32_t wait_for_dw1_ready : 1; // MAC AI is waiting for MAC DPU to send dw1_ready to WD - uint32_t acc_buf_sel_ai : 1; // Currently used AccBuf interface in MAC AI - uint32_t wait_for_acc0_ready : 1; // MAC AI is waiting for acc0_ready from AO - uint32_t wait_for_acc1_ready : 1; // MAC AI is waiting for acc1_ready from AO - uint32_t acc_buf_sel_aa : 1; // Currently used AccBuf interface in MAC ADDER_ARRAY - uint32_t acc0_valid : 1; // MAC outgoing value of acc0_valid - uint32_t acc1_valid : 1; // MAC outgoing value of acc1_valid - uint32_t reserved0 : 1; - uint32_t events : 11; // Mapped to MAC events described in Appendix A - uint32_t reserved1 : 5; - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR mac_status_r() : word0(0) {} - CONSTEXPR mac_status_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - mac_status_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_block_cfg_valid() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 0); - return value; - } - uint32_t get_block_cfg_valid() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 0); - return value; - } - CONSTEXPR mac_status_r &set_block_cfg_valid(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - volatile mac_status_r &set_block_cfg_valid(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - CONSTEXPR uint32_t get_trav_en() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 1); - return value; - } - uint32_t get_trav_en() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 1); - return value; - } - CONSTEXPR mac_status_r &set_trav_en(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - volatile mac_status_r &set_trav_en(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - CONSTEXPR uint32_t get_wait_for_ib() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 2); - return value; - } - uint32_t get_wait_for_ib() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 2); - return value; - } - CONSTEXPR mac_status_r &set_wait_for_ib(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - volatile mac_status_r &set_wait_for_ib(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - CONSTEXPR uint32_t get_wait_for_acc_buf() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 3); - return value; - } - uint32_t get_wait_for_acc_buf() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 3); - return value; - } - CONSTEXPR mac_status_r &set_wait_for_acc_buf(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - volatile mac_status_r &set_wait_for_acc_buf(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - CONSTEXPR uint32_t get_wait_for_weights() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 4); - return value; - } - uint32_t get_wait_for_weights() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 4); - return value; - } - CONSTEXPR mac_status_r &set_wait_for_weights(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 4) & word0) | ((((1U << 1) - 1) & value) << 4); - return *this; - } - volatile mac_status_r &set_wait_for_weights(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 4) & word0) | ((((1U << 1) - 1) & value) << 4); - return *this; - } - CONSTEXPR uint32_t get_stall_stripe() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 5); - return value; - } - uint32_t get_stall_stripe() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 5); - return value; - } - CONSTEXPR mac_status_r &set_stall_stripe(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 5) & word0) | ((((1U << 1) - 1) & value) << 5); - return *this; - } - volatile mac_status_r &set_stall_stripe(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 5) & word0) | ((((1U << 1) - 1) & value) << 5); - return *this; - } - CONSTEXPR uint32_t get_dw_sel() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 6); - return value; - } - uint32_t get_dw_sel() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 6); - return value; - } - CONSTEXPR mac_status_r &set_dw_sel(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 6) & word0) | ((((1U << 1) - 1) & value) << 6); - return *this; - } - volatile mac_status_r &set_dw_sel(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 6) & word0) | ((((1U << 1) - 1) & value) << 6); - return *this; - } - CONSTEXPR uint32_t get_wait_for_dw0_ready() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 7); - return value; - } - uint32_t get_wait_for_dw0_ready() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 7); - return value; - } - CONSTEXPR mac_status_r &set_wait_for_dw0_ready(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 7) & word0) | ((((1U << 1) - 1) & value) << 7); - return *this; - } - volatile mac_status_r &set_wait_for_dw0_ready(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 7) & word0) | ((((1U << 1) - 1) & value) << 7); - return *this; - } - CONSTEXPR uint32_t get_wait_for_dw1_ready() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 8); - return value; - } - uint32_t get_wait_for_dw1_ready() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 8); - return value; - } - CONSTEXPR mac_status_r &set_wait_for_dw1_ready(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 8) & word0) | ((((1U << 1) - 1) & value) << 8); - return *this; - } - volatile mac_status_r &set_wait_for_dw1_ready(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 8) & word0) | ((((1U << 1) - 1) & value) << 8); - return *this; - } - CONSTEXPR uint32_t get_acc_buf_sel_ai() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 9); - return value; - } - uint32_t get_acc_buf_sel_ai() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 9); - return value; - } - CONSTEXPR mac_status_r &set_acc_buf_sel_ai(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 9) & word0) | ((((1U << 1) - 1) & value) << 9); - return *this; - } - volatile mac_status_r &set_acc_buf_sel_ai(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 9) & word0) | ((((1U << 1) - 1) & value) << 9); - return *this; - } - CONSTEXPR uint32_t get_wait_for_acc0_ready() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 10); - return value; - } - uint32_t get_wait_for_acc0_ready() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 10); - return value; - } - CONSTEXPR mac_status_r &set_wait_for_acc0_ready(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 10) & word0) | ((((1U << 1) - 1) & value) << 10); - return *this; - } - volatile mac_status_r &set_wait_for_acc0_ready(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 10) & word0) | ((((1U << 1) - 1) & value) << 10); - return *this; - } - CONSTEXPR uint32_t get_wait_for_acc1_ready() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 11); - return value; - } - uint32_t get_wait_for_acc1_ready() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 11); - return value; - } - CONSTEXPR mac_status_r &set_wait_for_acc1_ready(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 11) & word0) | ((((1U << 1) - 1) & value) << 11); - return *this; - } - volatile mac_status_r &set_wait_for_acc1_ready(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 11) & word0) | ((((1U << 1) - 1) & value) << 11); - return *this; - } - CONSTEXPR uint32_t get_acc_buf_sel_aa() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 12); - return value; - } - uint32_t get_acc_buf_sel_aa() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 12); - return value; - } - CONSTEXPR mac_status_r &set_acc_buf_sel_aa(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 12) & word0) | ((((1U << 1) - 1) & value) << 12); - return *this; - } - volatile mac_status_r &set_acc_buf_sel_aa(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 12) & word0) | ((((1U << 1) - 1) & value) << 12); - return *this; - } - CONSTEXPR uint32_t get_acc0_valid() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 13); - return value; - } - uint32_t get_acc0_valid() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 13); - return value; - } - CONSTEXPR mac_status_r &set_acc0_valid(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 13) & word0) | ((((1U << 1) - 1) & value) << 13); - return *this; - } - volatile mac_status_r &set_acc0_valid(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 13) & word0) | ((((1U << 1) - 1) & value) << 13); - return *this; - } - CONSTEXPR uint32_t get_acc1_valid() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 14); - return value; - } - uint32_t get_acc1_valid() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 14); - return value; - } - CONSTEXPR mac_status_r &set_acc1_valid(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 14) & word0) | ((((1U << 1) - 1) & value) << 14); - return *this; - } - volatile mac_status_r &set_acc1_valid(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 14) & word0) | ((((1U << 1) - 1) & value) << 14); - return *this; - } - CONSTEXPR uint32_t get_events() const - { - uint32_t value = ((1U << 11) - 1) & (word0 >> 16); - return value; - } - uint32_t get_events() const volatile - { - uint32_t value = ((1U << 11) - 1) & (word0 >> 16); - return value; - } - CONSTEXPR mac_status_r &set_events(uint32_t value) - { - word0 = (((~((1U << 11) - 1)) << 16) & word0) | ((((1U << 11) - 1) & value) << 16); - return *this; - } - volatile mac_status_r &set_events(uint32_t value) volatile - { - word0 = (((~((1U << 11) - 1)) << 16) & word0) | ((((1U << 11) - 1) & value) << 16); - return *this; - } -#endif -}; - -// ao_status_r - AO_STATUS -struct ao_status_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t cmd_sbw_valid : 1; // Block command to shared buffer write module is valid - uint32_t cmd_act_valid : 1; // Block command to activation function module is valid - uint32_t cmd_ctl_valid : 1; // Block command to control module is valid - uint32_t cmd_scl_valid : 1; // Block command to scale module is valid - uint32_t cmd_sbr_valid : 1; // Block command to shared buffer read module is valid - uint32_t cmd_ofm_valid : 1; // Block command to ofm parameter module is valid - uint32_t blk_cmd_ready : 1; // Ready to accept block command - uint32_t blk_cmd_valid : 1; // Block command from CC is valid - uint32_t reserved0 : 8; - uint32_t events : 8; // Mapped to AO events described in Appendix A - uint32_t reserved1 : 8; - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ao_status_r() : word0(0) {} - CONSTEXPR ao_status_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ao_status_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_cmd_sbw_valid() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 0); - return value; - } - uint32_t get_cmd_sbw_valid() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 0); - return value; - } - CONSTEXPR ao_status_r &set_cmd_sbw_valid(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - volatile ao_status_r &set_cmd_sbw_valid(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - CONSTEXPR uint32_t get_cmd_act_valid() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 1); - return value; - } - uint32_t get_cmd_act_valid() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 1); - return value; - } - CONSTEXPR ao_status_r &set_cmd_act_valid(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - volatile ao_status_r &set_cmd_act_valid(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - CONSTEXPR uint32_t get_cmd_ctl_valid() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 2); - return value; - } - uint32_t get_cmd_ctl_valid() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 2); - return value; - } - CONSTEXPR ao_status_r &set_cmd_ctl_valid(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - volatile ao_status_r &set_cmd_ctl_valid(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - CONSTEXPR uint32_t get_cmd_scl_valid() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 3); - return value; - } - uint32_t get_cmd_scl_valid() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 3); - return value; - } - CONSTEXPR ao_status_r &set_cmd_scl_valid(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - volatile ao_status_r &set_cmd_scl_valid(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - CONSTEXPR uint32_t get_cmd_sbr_valid() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 4); - return value; - } - uint32_t get_cmd_sbr_valid() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 4); - return value; - } - CONSTEXPR ao_status_r &set_cmd_sbr_valid(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 4) & word0) | ((((1U << 1) - 1) & value) << 4); - return *this; - } - volatile ao_status_r &set_cmd_sbr_valid(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 4) & word0) | ((((1U << 1) - 1) & value) << 4); - return *this; - } - CONSTEXPR uint32_t get_cmd_ofm_valid() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 5); - return value; - } - uint32_t get_cmd_ofm_valid() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 5); - return value; - } - CONSTEXPR ao_status_r &set_cmd_ofm_valid(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 5) & word0) | ((((1U << 1) - 1) & value) << 5); - return *this; - } - volatile ao_status_r &set_cmd_ofm_valid(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 5) & word0) | ((((1U << 1) - 1) & value) << 5); - return *this; - } - CONSTEXPR uint32_t get_blk_cmd_ready() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 6); - return value; - } - uint32_t get_blk_cmd_ready() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 6); - return value; - } - CONSTEXPR ao_status_r &set_blk_cmd_ready(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 6) & word0) | ((((1U << 1) - 1) & value) << 6); - return *this; - } - volatile ao_status_r &set_blk_cmd_ready(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 6) & word0) | ((((1U << 1) - 1) & value) << 6); - return *this; - } - CONSTEXPR uint32_t get_blk_cmd_valid() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 7); - return value; - } - uint32_t get_blk_cmd_valid() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 7); - return value; - } - CONSTEXPR ao_status_r &set_blk_cmd_valid(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 7) & word0) | ((((1U << 1) - 1) & value) << 7); - return *this; - } - volatile ao_status_r &set_blk_cmd_valid(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 7) & word0) | ((((1U << 1) - 1) & value) << 7); - return *this; - } - CONSTEXPR uint32_t get_events() const - { - uint32_t value = ((1U << 8) - 1) & (word0 >> 16); - return value; - } - uint32_t get_events() const volatile - { - uint32_t value = ((1U << 8) - 1) & (word0 >> 16); - return value; - } - CONSTEXPR ao_status_r &set_events(uint32_t value) - { - word0 = (((~((1U << 8) - 1)) << 16) & word0) | ((((1U << 8) - 1) & value) << 16); - return *this; - } - volatile ao_status_r &set_events(uint32_t value) volatile - { - word0 = (((~((1U << 8) - 1)) << 16) & word0) | ((((1U << 8) - 1) & value) << 16); - return *this; - } -#endif -}; - -// dma_status0_r - DMA_STATUS0 -struct dma_status0_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t cmd_idle : 1; // When this bit is high means that the CMD block is not busy in generating addresses - // for a CMD job - uint32_t ifm_idle : 1; // When this bit is high means that there are no ongoing IFM jobs - uint32_t wgt_idle_c0 : 1; // When this bit is high means that the WGT block is not busy in generating - // addresses for a WGT job - uint32_t bas_idle_c0 : 1; // When this bit is high means that the BAS block is not busy in generating - // addresses for a BAS job - uint32_t m2m_idle : 1; // When this bit is high means that there are no ongoing M2M jobs - uint32_t ofm_idle : 1; // When this bit is high means that there are no ongoing OFM jobs - uint32_t halt_req : 1; // CPM has requested to HALT AXI bus before soft reset - uint32_t halt_ack : 1; // DMA is in condition to halt the AXI bus since there are no pending transactions - uint32_t pause_req : 1; // CC has requested to pause the AXI - uint32_t pause_ack : 1; // DMA is in condition to pause the AXI bus since there are no pending transactions - uint32_t ib0_ai_valid_c0 : 1; // Data for AI to be read in IFM input buffer 0 - Core 0 - uint32_t ib0_ai_ready_c0 : 1; // Data consumed from AI in IFM input buffer 0 - Core 0 - uint32_t ib1_ai_valid_c0 : 1; // Data for AI to be read in IFM input buffer 1 - Core 0 - uint32_t ib1_ai_ready_c0 : 1; // Data consumed from AI in IFM input buffer 1 - Core 0 - uint32_t ib0_ao_valid_c0 : 1; // Data for AO to be read in IFM input buffer 0 - Core 0 - uint32_t ib0_ao_ready_c0 : 1; // Data consumed from AO in IFM input buffer 0 - Core 0 - uint32_t ib1_ao_valid_c0 : 1; // Data for AO to be read in IFM input buffer 0 - Core 0 - uint32_t ib1_ao_ready_c0 : 1; // Data consumed from AO in IFM input buffer 1 - Core 0 - uint32_t ob0_valid_c0 : 1; // Data for DMA ready to be consumed in OFM output buffer 0 - Core 0 - uint32_t ob0_ready_c0 : 1; // Data consumed from DMA in OFM output buffer 0 - Core 0 - uint32_t ob1_valid_c0 : 1; // Data for DMA ready to be consumed in OFM output buffer 1 - Core 0 - uint32_t ob1_ready_c0 : 1; // Data consumed from DMA in OFM output buffer 1 - Core 0 - uint32_t cmd_valid : 1; // New command word for CC to be consumed - uint32_t cmd_ready : 1; // command word consumed by CC - uint32_t wd_bitstream_valid_c0 : 1; // New weight word for WD to be consumed - Core 0 - uint32_t wd_bitstream_ready_c0 : 1; // Weight word consumed by WD - Core 0 - uint32_t bs_bitstream_valid_c0 : 1; // New BaS word for AO to be consumed - Core 0 - uint32_t bs_bitstream_ready_c0 : 1; // BaS word consumed by AO - Core 0 - uint32_t axi0_ar_stalled : 1; // Read transfer request stalled on arready low AXI0 (due to memory system) - uint32_t axi0_rd_limit_stall : 1; // Read stalled due to one AXI0 limit counter being reached - uint32_t axi0_aw_stalled : 1; // Write transfer request stalled on awready low AXI0 (due to memory system) - uint32_t axi0_w_stalled : 1; // Write transfer stalled on awready low AXI0 (due to memory system) - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR dma_status0_r() : word0(0) {} - CONSTEXPR dma_status0_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - dma_status0_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_cmd_idle() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 0); - return value; - } - uint32_t get_cmd_idle() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 0); - return value; - } - CONSTEXPR dma_status0_r &set_cmd_idle(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - volatile dma_status0_r &set_cmd_idle(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - CONSTEXPR uint32_t get_ifm_idle() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 1); - return value; - } - uint32_t get_ifm_idle() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 1); - return value; - } - CONSTEXPR dma_status0_r &set_ifm_idle(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - volatile dma_status0_r &set_ifm_idle(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - CONSTEXPR uint32_t get_wgt_idle_c0() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 2); - return value; - } - uint32_t get_wgt_idle_c0() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 2); - return value; - } - CONSTEXPR dma_status0_r &set_wgt_idle_c0(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - volatile dma_status0_r &set_wgt_idle_c0(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - CONSTEXPR uint32_t get_bas_idle_c0() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 3); - return value; - } - uint32_t get_bas_idle_c0() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 3); - return value; - } - CONSTEXPR dma_status0_r &set_bas_idle_c0(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - volatile dma_status0_r &set_bas_idle_c0(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - CONSTEXPR uint32_t get_m2m_idle() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 4); - return value; - } - uint32_t get_m2m_idle() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 4); - return value; - } - CONSTEXPR dma_status0_r &set_m2m_idle(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 4) & word0) | ((((1U << 1) - 1) & value) << 4); - return *this; - } - volatile dma_status0_r &set_m2m_idle(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 4) & word0) | ((((1U << 1) - 1) & value) << 4); - return *this; - } - CONSTEXPR uint32_t get_ofm_idle() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 5); - return value; - } - uint32_t get_ofm_idle() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 5); - return value; - } - CONSTEXPR dma_status0_r &set_ofm_idle(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 5) & word0) | ((((1U << 1) - 1) & value) << 5); - return *this; - } - volatile dma_status0_r &set_ofm_idle(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 5) & word0) | ((((1U << 1) - 1) & value) << 5); - return *this; - } - CONSTEXPR uint32_t get_halt_req() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 6); - return value; - } - uint32_t get_halt_req() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 6); - return value; - } - CONSTEXPR dma_status0_r &set_halt_req(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 6) & word0) | ((((1U << 1) - 1) & value) << 6); - return *this; - } - volatile dma_status0_r &set_halt_req(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 6) & word0) | ((((1U << 1) - 1) & value) << 6); - return *this; - } - CONSTEXPR uint32_t get_halt_ack() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 7); - return value; - } - uint32_t get_halt_ack() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 7); - return value; - } - CONSTEXPR dma_status0_r &set_halt_ack(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 7) & word0) | ((((1U << 1) - 1) & value) << 7); - return *this; - } - volatile dma_status0_r &set_halt_ack(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 7) & word0) | ((((1U << 1) - 1) & value) << 7); - return *this; - } - CONSTEXPR uint32_t get_pause_req() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 8); - return value; - } - uint32_t get_pause_req() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 8); - return value; - } - CONSTEXPR dma_status0_r &set_pause_req(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 8) & word0) | ((((1U << 1) - 1) & value) << 8); - return *this; - } - volatile dma_status0_r &set_pause_req(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 8) & word0) | ((((1U << 1) - 1) & value) << 8); - return *this; - } - CONSTEXPR uint32_t get_pause_ack() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 9); - return value; - } - uint32_t get_pause_ack() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 9); - return value; - } - CONSTEXPR dma_status0_r &set_pause_ack(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 9) & word0) | ((((1U << 1) - 1) & value) << 9); - return *this; - } - volatile dma_status0_r &set_pause_ack(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 9) & word0) | ((((1U << 1) - 1) & value) << 9); - return *this; - } - CONSTEXPR uint32_t get_ib0_ai_valid_c0() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 10); - return value; - } - uint32_t get_ib0_ai_valid_c0() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 10); - return value; - } - CONSTEXPR dma_status0_r &set_ib0_ai_valid_c0(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 10) & word0) | ((((1U << 1) - 1) & value) << 10); - return *this; - } - volatile dma_status0_r &set_ib0_ai_valid_c0(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 10) & word0) | ((((1U << 1) - 1) & value) << 10); - return *this; - } - CONSTEXPR uint32_t get_ib0_ai_ready_c0() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 11); - return value; - } - uint32_t get_ib0_ai_ready_c0() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 11); - return value; - } - CONSTEXPR dma_status0_r &set_ib0_ai_ready_c0(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 11) & word0) | ((((1U << 1) - 1) & value) << 11); - return *this; - } - volatile dma_status0_r &set_ib0_ai_ready_c0(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 11) & word0) | ((((1U << 1) - 1) & value) << 11); - return *this; - } - CONSTEXPR uint32_t get_ib1_ai_valid_c0() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 12); - return value; - } - uint32_t get_ib1_ai_valid_c0() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 12); - return value; - } - CONSTEXPR dma_status0_r &set_ib1_ai_valid_c0(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 12) & word0) | ((((1U << 1) - 1) & value) << 12); - return *this; - } - volatile dma_status0_r &set_ib1_ai_valid_c0(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 12) & word0) | ((((1U << 1) - 1) & value) << 12); - return *this; - } - CONSTEXPR uint32_t get_ib1_ai_ready_c0() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 13); - return value; - } - uint32_t get_ib1_ai_ready_c0() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 13); - return value; - } - CONSTEXPR dma_status0_r &set_ib1_ai_ready_c0(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 13) & word0) | ((((1U << 1) - 1) & value) << 13); - return *this; - } - volatile dma_status0_r &set_ib1_ai_ready_c0(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 13) & word0) | ((((1U << 1) - 1) & value) << 13); - return *this; - } - CONSTEXPR uint32_t get_ib0_ao_valid_c0() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 14); - return value; - } - uint32_t get_ib0_ao_valid_c0() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 14); - return value; - } - CONSTEXPR dma_status0_r &set_ib0_ao_valid_c0(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 14) & word0) | ((((1U << 1) - 1) & value) << 14); - return *this; - } - volatile dma_status0_r &set_ib0_ao_valid_c0(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 14) & word0) | ((((1U << 1) - 1) & value) << 14); - return *this; - } - CONSTEXPR uint32_t get_ib0_ao_ready_c0() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 15); - return value; - } - uint32_t get_ib0_ao_ready_c0() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 15); - return value; - } - CONSTEXPR dma_status0_r &set_ib0_ao_ready_c0(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 15) & word0) | ((((1U << 1) - 1) & value) << 15); - return *this; - } - volatile dma_status0_r &set_ib0_ao_ready_c0(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 15) & word0) | ((((1U << 1) - 1) & value) << 15); - return *this; - } - CONSTEXPR uint32_t get_ib1_ao_valid_c0() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 16); - return value; - } - uint32_t get_ib1_ao_valid_c0() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 16); - return value; - } - CONSTEXPR dma_status0_r &set_ib1_ao_valid_c0(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 16) & word0) | ((((1U << 1) - 1) & value) << 16); - return *this; - } - volatile dma_status0_r &set_ib1_ao_valid_c0(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 16) & word0) | ((((1U << 1) - 1) & value) << 16); - return *this; - } - CONSTEXPR uint32_t get_ib1_ao_ready_c0() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 17); - return value; - } - uint32_t get_ib1_ao_ready_c0() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 17); - return value; - } - CONSTEXPR dma_status0_r &set_ib1_ao_ready_c0(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 17) & word0) | ((((1U << 1) - 1) & value) << 17); - return *this; - } - volatile dma_status0_r &set_ib1_ao_ready_c0(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 17) & word0) | ((((1U << 1) - 1) & value) << 17); - return *this; - } - CONSTEXPR uint32_t get_ob0_valid_c0() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 18); - return value; - } - uint32_t get_ob0_valid_c0() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 18); - return value; - } - CONSTEXPR dma_status0_r &set_ob0_valid_c0(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 18) & word0) | ((((1U << 1) - 1) & value) << 18); - return *this; - } - volatile dma_status0_r &set_ob0_valid_c0(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 18) & word0) | ((((1U << 1) - 1) & value) << 18); - return *this; - } - CONSTEXPR uint32_t get_ob0_ready_c0() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 19); - return value; - } - uint32_t get_ob0_ready_c0() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 19); - return value; - } - CONSTEXPR dma_status0_r &set_ob0_ready_c0(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 19) & word0) | ((((1U << 1) - 1) & value) << 19); - return *this; - } - volatile dma_status0_r &set_ob0_ready_c0(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 19) & word0) | ((((1U << 1) - 1) & value) << 19); - return *this; - } - CONSTEXPR uint32_t get_ob1_valid_c0() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 20); - return value; - } - uint32_t get_ob1_valid_c0() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 20); - return value; - } - CONSTEXPR dma_status0_r &set_ob1_valid_c0(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 20) & word0) | ((((1U << 1) - 1) & value) << 20); - return *this; - } - volatile dma_status0_r &set_ob1_valid_c0(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 20) & word0) | ((((1U << 1) - 1) & value) << 20); - return *this; - } - CONSTEXPR uint32_t get_ob1_ready_c0() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 21); - return value; - } - uint32_t get_ob1_ready_c0() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 21); - return value; - } - CONSTEXPR dma_status0_r &set_ob1_ready_c0(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 21) & word0) | ((((1U << 1) - 1) & value) << 21); - return *this; - } - volatile dma_status0_r &set_ob1_ready_c0(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 21) & word0) | ((((1U << 1) - 1) & value) << 21); - return *this; - } - CONSTEXPR uint32_t get_cmd_valid() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 22); - return value; - } - uint32_t get_cmd_valid() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 22); - return value; - } - CONSTEXPR dma_status0_r &set_cmd_valid(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 22) & word0) | ((((1U << 1) - 1) & value) << 22); - return *this; - } - volatile dma_status0_r &set_cmd_valid(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 22) & word0) | ((((1U << 1) - 1) & value) << 22); - return *this; - } - CONSTEXPR uint32_t get_cmd_ready() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 23); - return value; - } - uint32_t get_cmd_ready() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 23); - return value; - } - CONSTEXPR dma_status0_r &set_cmd_ready(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 23) & word0) | ((((1U << 1) - 1) & value) << 23); - return *this; - } - volatile dma_status0_r &set_cmd_ready(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 23) & word0) | ((((1U << 1) - 1) & value) << 23); - return *this; - } - CONSTEXPR uint32_t get_wd_bitstream_valid_c0() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 24); - return value; - } - uint32_t get_wd_bitstream_valid_c0() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 24); - return value; - } - CONSTEXPR dma_status0_r &set_wd_bitstream_valid_c0(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 24) & word0) | ((((1U << 1) - 1) & value) << 24); - return *this; - } - volatile dma_status0_r &set_wd_bitstream_valid_c0(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 24) & word0) | ((((1U << 1) - 1) & value) << 24); - return *this; - } - CONSTEXPR uint32_t get_wd_bitstream_ready_c0() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 25); - return value; - } - uint32_t get_wd_bitstream_ready_c0() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 25); - return value; - } - CONSTEXPR dma_status0_r &set_wd_bitstream_ready_c0(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 25) & word0) | ((((1U << 1) - 1) & value) << 25); - return *this; - } - volatile dma_status0_r &set_wd_bitstream_ready_c0(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 25) & word0) | ((((1U << 1) - 1) & value) << 25); - return *this; - } - CONSTEXPR uint32_t get_bs_bitstream_valid_c0() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 26); - return value; - } - uint32_t get_bs_bitstream_valid_c0() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 26); - return value; - } - CONSTEXPR dma_status0_r &set_bs_bitstream_valid_c0(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 26) & word0) | ((((1U << 1) - 1) & value) << 26); - return *this; - } - volatile dma_status0_r &set_bs_bitstream_valid_c0(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 26) & word0) | ((((1U << 1) - 1) & value) << 26); - return *this; - } - CONSTEXPR uint32_t get_bs_bitstream_ready_c0() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 27); - return value; - } - uint32_t get_bs_bitstream_ready_c0() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 27); - return value; - } - CONSTEXPR dma_status0_r &set_bs_bitstream_ready_c0(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 27) & word0) | ((((1U << 1) - 1) & value) << 27); - return *this; - } - volatile dma_status0_r &set_bs_bitstream_ready_c0(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 27) & word0) | ((((1U << 1) - 1) & value) << 27); - return *this; - } - CONSTEXPR uint32_t get_axi0_ar_stalled() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 28); - return value; - } - uint32_t get_axi0_ar_stalled() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 28); - return value; - } - CONSTEXPR dma_status0_r &set_axi0_ar_stalled(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 28) & word0) | ((((1U << 1) - 1) & value) << 28); - return *this; - } - volatile dma_status0_r &set_axi0_ar_stalled(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 28) & word0) | ((((1U << 1) - 1) & value) << 28); - return *this; - } - CONSTEXPR uint32_t get_axi0_rd_limit_stall() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 29); - return value; - } - uint32_t get_axi0_rd_limit_stall() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 29); - return value; - } - CONSTEXPR dma_status0_r &set_axi0_rd_limit_stall(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 29) & word0) | ((((1U << 1) - 1) & value) << 29); - return *this; - } - volatile dma_status0_r &set_axi0_rd_limit_stall(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 29) & word0) | ((((1U << 1) - 1) & value) << 29); - return *this; - } - CONSTEXPR uint32_t get_axi0_aw_stalled() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 30); - return value; - } - uint32_t get_axi0_aw_stalled() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 30); - return value; - } - CONSTEXPR dma_status0_r &set_axi0_aw_stalled(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 30) & word0) | ((((1U << 1) - 1) & value) << 30); - return *this; - } - volatile dma_status0_r &set_axi0_aw_stalled(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 30) & word0) | ((((1U << 1) - 1) & value) << 30); - return *this; - } - CONSTEXPR uint32_t get_axi0_w_stalled() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 31); - return value; - } - uint32_t get_axi0_w_stalled() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 31); - return value; - } - CONSTEXPR dma_status0_r &set_axi0_w_stalled(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 31) & word0) | ((((1U << 1) - 1) & value) << 31); - return *this; - } - volatile dma_status0_r &set_axi0_w_stalled(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 31) & word0) | ((((1U << 1) - 1) & value) << 31); - return *this; - } -#endif -}; - -// dma_status1_r - DMA_STATUS1 -struct dma_status1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t axi0_wr_limit_stall : 1; // Write stalled due to one AXI0 limit counter being reached - uint32_t axi1_ar_stalled : 1; // Read transfer request stalled on arready low AXI1 (due to memory system) - uint32_t axi1_rd_limit_stall : 1; // Read stalled due to one AXI1 limit counter being reached - uint32_t axi1_wr_stalled : 1; // Write transfer request stalled on awready low AXI1 (due to memory system) - uint32_t axi1_w_stalled : 1; // Write transfer stalled on wready low AXI1 (due to memory system) - uint32_t axi1_wr_limit_stall : 1; // Write stalled due to one AXI1 limit counter being reached - uint32_t wgt_idle_c1 : 1; // When this bit is high means that the WGT block is not busy in generating - // addresses for a WGT job - uint32_t bas_idle_c1 : 1; // When this bit is high means that the BAS block is not busy in generating - // addresses for a BAS job - uint32_t ib0_ai_valid_c1 : 1; // Data for AI to be read in IFM input buffer 0 - Core 1 - uint32_t ib0_ai_ready_c1 : 1; // Data consumed from AI in IFM input buffer 0 - Core 1 - uint32_t ib1_ai_valid_c1 : 1; // Data for AI to be read in IFM input buffer 1 - Core 1 - uint32_t ib1_ai_ready_c1 : 1; // Data consumed from AI in IFM input buffer 1 - Core 1 - uint32_t ib0_ao_valid_c1 : 1; // Data for AO to be read in IFM input buffer 0 - Core 1 - uint32_t ib0_ao_ready_c1 : 1; // Data consumed from AO in IFM input buffer 0 - Core 1 - uint32_t ib1_ao_valid_c1 : 1; // Data for AO to be read in IFM input buffer 0 - Core 1 - uint32_t ib1_ao_ready_c1 : 1; // Data consumed from AO in IFM input buffer 1 - Core 1 - uint32_t ob0_valid_c1 : 1; // Data for DMA ready to be consumed in OFM output buffer 0 - Core 1 - uint32_t ob0_ready_c1 : 1; // Data consumed from DMA in OFM output buffer 0 - Core 1 - uint32_t ob1_valid_c1 : 1; // Data for DMA ready to be consumed in OFM output buffer 1 - Core 1 - uint32_t ob1_ready_c1 : 1; // Data consumed from DMA in OFM output buffer 1 - Core 1 - uint32_t wd_bitstream_valid_c1 : 1; // New weight word for WD to be consumed - Core 1 - uint32_t wd_bitstream_ready_c1 : 1; // Weight word consumed by WD - Core 1 - uint32_t bs_bitstream_valid_c1 : 1; // New BaS word for AO to be consumed - Core 1 - uint32_t bs_bitstream_ready_c1 : 1; // BaS word consumed by AO - Core 1 - uint32_t reserved0 : 8; - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR dma_status1_r() : word0(0) {} - CONSTEXPR dma_status1_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - dma_status1_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_axi0_wr_limit_stall() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 0); - return value; - } - uint32_t get_axi0_wr_limit_stall() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 0); - return value; - } - CONSTEXPR dma_status1_r &set_axi0_wr_limit_stall(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - volatile dma_status1_r &set_axi0_wr_limit_stall(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - CONSTEXPR uint32_t get_axi1_ar_stalled() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 1); - return value; - } - uint32_t get_axi1_ar_stalled() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 1); - return value; - } - CONSTEXPR dma_status1_r &set_axi1_ar_stalled(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - volatile dma_status1_r &set_axi1_ar_stalled(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - CONSTEXPR uint32_t get_axi1_rd_limit_stall() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 2); - return value; - } - uint32_t get_axi1_rd_limit_stall() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 2); - return value; - } - CONSTEXPR dma_status1_r &set_axi1_rd_limit_stall(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - volatile dma_status1_r &set_axi1_rd_limit_stall(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - CONSTEXPR uint32_t get_axi1_wr_stalled() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 3); - return value; - } - uint32_t get_axi1_wr_stalled() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 3); - return value; - } - CONSTEXPR dma_status1_r &set_axi1_wr_stalled(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - volatile dma_status1_r &set_axi1_wr_stalled(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - CONSTEXPR uint32_t get_axi1_w_stalled() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 4); - return value; - } - uint32_t get_axi1_w_stalled() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 4); - return value; - } - CONSTEXPR dma_status1_r &set_axi1_w_stalled(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 4) & word0) | ((((1U << 1) - 1) & value) << 4); - return *this; - } - volatile dma_status1_r &set_axi1_w_stalled(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 4) & word0) | ((((1U << 1) - 1) & value) << 4); - return *this; - } - CONSTEXPR uint32_t get_axi1_wr_limit_stall() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 5); - return value; - } - uint32_t get_axi1_wr_limit_stall() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 5); - return value; - } - CONSTEXPR dma_status1_r &set_axi1_wr_limit_stall(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 5) & word0) | ((((1U << 1) - 1) & value) << 5); - return *this; - } - volatile dma_status1_r &set_axi1_wr_limit_stall(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 5) & word0) | ((((1U << 1) - 1) & value) << 5); - return *this; - } - CONSTEXPR uint32_t get_wgt_idle_c1() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 6); - return value; - } - uint32_t get_wgt_idle_c1() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 6); - return value; - } - CONSTEXPR dma_status1_r &set_wgt_idle_c1(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 6) & word0) | ((((1U << 1) - 1) & value) << 6); - return *this; - } - volatile dma_status1_r &set_wgt_idle_c1(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 6) & word0) | ((((1U << 1) - 1) & value) << 6); - return *this; - } - CONSTEXPR uint32_t get_bas_idle_c1() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 7); - return value; - } - uint32_t get_bas_idle_c1() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 7); - return value; - } - CONSTEXPR dma_status1_r &set_bas_idle_c1(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 7) & word0) | ((((1U << 1) - 1) & value) << 7); - return *this; - } - volatile dma_status1_r &set_bas_idle_c1(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 7) & word0) | ((((1U << 1) - 1) & value) << 7); - return *this; - } - CONSTEXPR uint32_t get_ib0_ai_valid_c1() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 8); - return value; - } - uint32_t get_ib0_ai_valid_c1() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 8); - return value; - } - CONSTEXPR dma_status1_r &set_ib0_ai_valid_c1(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 8) & word0) | ((((1U << 1) - 1) & value) << 8); - return *this; - } - volatile dma_status1_r &set_ib0_ai_valid_c1(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 8) & word0) | ((((1U << 1) - 1) & value) << 8); - return *this; - } - CONSTEXPR uint32_t get_ib0_ai_ready_c1() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 9); - return value; - } - uint32_t get_ib0_ai_ready_c1() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 9); - return value; - } - CONSTEXPR dma_status1_r &set_ib0_ai_ready_c1(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 9) & word0) | ((((1U << 1) - 1) & value) << 9); - return *this; - } - volatile dma_status1_r &set_ib0_ai_ready_c1(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 9) & word0) | ((((1U << 1) - 1) & value) << 9); - return *this; - } - CONSTEXPR uint32_t get_ib1_ai_valid_c1() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 10); - return value; - } - uint32_t get_ib1_ai_valid_c1() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 10); - return value; - } - CONSTEXPR dma_status1_r &set_ib1_ai_valid_c1(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 10) & word0) | ((((1U << 1) - 1) & value) << 10); - return *this; - } - volatile dma_status1_r &set_ib1_ai_valid_c1(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 10) & word0) | ((((1U << 1) - 1) & value) << 10); - return *this; - } - CONSTEXPR uint32_t get_ib1_ai_ready_c1() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 11); - return value; - } - uint32_t get_ib1_ai_ready_c1() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 11); - return value; - } - CONSTEXPR dma_status1_r &set_ib1_ai_ready_c1(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 11) & word0) | ((((1U << 1) - 1) & value) << 11); - return *this; - } - volatile dma_status1_r &set_ib1_ai_ready_c1(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 11) & word0) | ((((1U << 1) - 1) & value) << 11); - return *this; - } - CONSTEXPR uint32_t get_ib0_ao_valid_c1() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 12); - return value; - } - uint32_t get_ib0_ao_valid_c1() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 12); - return value; - } - CONSTEXPR dma_status1_r &set_ib0_ao_valid_c1(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 12) & word0) | ((((1U << 1) - 1) & value) << 12); - return *this; - } - volatile dma_status1_r &set_ib0_ao_valid_c1(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 12) & word0) | ((((1U << 1) - 1) & value) << 12); - return *this; - } - CONSTEXPR uint32_t get_ib0_ao_ready_c1() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 13); - return value; - } - uint32_t get_ib0_ao_ready_c1() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 13); - return value; - } - CONSTEXPR dma_status1_r &set_ib0_ao_ready_c1(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 13) & word0) | ((((1U << 1) - 1) & value) << 13); - return *this; - } - volatile dma_status1_r &set_ib0_ao_ready_c1(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 13) & word0) | ((((1U << 1) - 1) & value) << 13); - return *this; - } - CONSTEXPR uint32_t get_ib1_ao_valid_c1() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 14); - return value; - } - uint32_t get_ib1_ao_valid_c1() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 14); - return value; - } - CONSTEXPR dma_status1_r &set_ib1_ao_valid_c1(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 14) & word0) | ((((1U << 1) - 1) & value) << 14); - return *this; - } - volatile dma_status1_r &set_ib1_ao_valid_c1(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 14) & word0) | ((((1U << 1) - 1) & value) << 14); - return *this; - } - CONSTEXPR uint32_t get_ib1_ao_ready_c1() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 15); - return value; - } - uint32_t get_ib1_ao_ready_c1() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 15); - return value; - } - CONSTEXPR dma_status1_r &set_ib1_ao_ready_c1(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 15) & word0) | ((((1U << 1) - 1) & value) << 15); - return *this; - } - volatile dma_status1_r &set_ib1_ao_ready_c1(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 15) & word0) | ((((1U << 1) - 1) & value) << 15); - return *this; - } - CONSTEXPR uint32_t get_ob0_valid_c1() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 16); - return value; - } - uint32_t get_ob0_valid_c1() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 16); - return value; - } - CONSTEXPR dma_status1_r &set_ob0_valid_c1(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 16) & word0) | ((((1U << 1) - 1) & value) << 16); - return *this; - } - volatile dma_status1_r &set_ob0_valid_c1(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 16) & word0) | ((((1U << 1) - 1) & value) << 16); - return *this; - } - CONSTEXPR uint32_t get_ob0_ready_c1() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 17); - return value; - } - uint32_t get_ob0_ready_c1() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 17); - return value; - } - CONSTEXPR dma_status1_r &set_ob0_ready_c1(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 17) & word0) | ((((1U << 1) - 1) & value) << 17); - return *this; - } - volatile dma_status1_r &set_ob0_ready_c1(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 17) & word0) | ((((1U << 1) - 1) & value) << 17); - return *this; - } - CONSTEXPR uint32_t get_ob1_valid_c1() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 18); - return value; - } - uint32_t get_ob1_valid_c1() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 18); - return value; - } - CONSTEXPR dma_status1_r &set_ob1_valid_c1(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 18) & word0) | ((((1U << 1) - 1) & value) << 18); - return *this; - } - volatile dma_status1_r &set_ob1_valid_c1(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 18) & word0) | ((((1U << 1) - 1) & value) << 18); - return *this; - } - CONSTEXPR uint32_t get_ob1_ready_c1() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 19); - return value; - } - uint32_t get_ob1_ready_c1() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 19); - return value; - } - CONSTEXPR dma_status1_r &set_ob1_ready_c1(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 19) & word0) | ((((1U << 1) - 1) & value) << 19); - return *this; - } - volatile dma_status1_r &set_ob1_ready_c1(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 19) & word0) | ((((1U << 1) - 1) & value) << 19); - return *this; - } - CONSTEXPR uint32_t get_wd_bitstream_valid_c1() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 20); - return value; - } - uint32_t get_wd_bitstream_valid_c1() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 20); - return value; - } - CONSTEXPR dma_status1_r &set_wd_bitstream_valid_c1(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 20) & word0) | ((((1U << 1) - 1) & value) << 20); - return *this; - } - volatile dma_status1_r &set_wd_bitstream_valid_c1(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 20) & word0) | ((((1U << 1) - 1) & value) << 20); - return *this; - } - CONSTEXPR uint32_t get_wd_bitstream_ready_c1() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 21); - return value; - } - uint32_t get_wd_bitstream_ready_c1() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 21); - return value; - } - CONSTEXPR dma_status1_r &set_wd_bitstream_ready_c1(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 21) & word0) | ((((1U << 1) - 1) & value) << 21); - return *this; - } - volatile dma_status1_r &set_wd_bitstream_ready_c1(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 21) & word0) | ((((1U << 1) - 1) & value) << 21); - return *this; - } - CONSTEXPR uint32_t get_bs_bitstream_valid_c1() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 22); - return value; - } - uint32_t get_bs_bitstream_valid_c1() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 22); - return value; - } - CONSTEXPR dma_status1_r &set_bs_bitstream_valid_c1(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 22) & word0) | ((((1U << 1) - 1) & value) << 22); - return *this; - } - volatile dma_status1_r &set_bs_bitstream_valid_c1(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 22) & word0) | ((((1U << 1) - 1) & value) << 22); - return *this; - } - CONSTEXPR uint32_t get_bs_bitstream_ready_c1() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 23); - return value; - } - uint32_t get_bs_bitstream_ready_c1() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 23); - return value; - } - CONSTEXPR dma_status1_r &set_bs_bitstream_ready_c1(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 23) & word0) | ((((1U << 1) - 1) & value) << 23); - return *this; - } - volatile dma_status1_r &set_bs_bitstream_ready_c1(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 23) & word0) | ((((1U << 1) - 1) & value) << 23); - return *this; - } -#endif -}; - -// clkforce_r - Force clocks on for clock gating -struct clkforce_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t top_level_clk : 1; // set to 1 to force on TOP level clock - uint32_t cc_clk : 1; // set to 1 to force on CC clock - uint32_t dma_clk : 1; // set to 1 to force on DMA clock - uint32_t mac_clk : 1; // set to 1 to force on MAC clock - uint32_t ao_clk : 1; // set to 1 to force on AO clock - uint32_t wd_clk : 1; // set to 1 to force on WD clock - uint32_t reserved0 : 26; - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR clkforce_r() : word0(0) {} - CONSTEXPR clkforce_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - clkforce_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_top_level_clk() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 0); - return value; - } - uint32_t get_top_level_clk() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 0); - return value; - } - CONSTEXPR clkforce_r &set_top_level_clk(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - volatile clkforce_r &set_top_level_clk(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - CONSTEXPR uint32_t get_cc_clk() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 1); - return value; - } - uint32_t get_cc_clk() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 1); - return value; - } - CONSTEXPR clkforce_r &set_cc_clk(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - volatile clkforce_r &set_cc_clk(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - CONSTEXPR uint32_t get_dma_clk() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 2); - return value; - } - uint32_t get_dma_clk() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 2); - return value; - } - CONSTEXPR clkforce_r &set_dma_clk(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - volatile clkforce_r &set_dma_clk(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - CONSTEXPR uint32_t get_mac_clk() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 3); - return value; - } - uint32_t get_mac_clk() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 3); - return value; - } - CONSTEXPR clkforce_r &set_mac_clk(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - volatile clkforce_r &set_mac_clk(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - CONSTEXPR uint32_t get_ao_clk() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 4); - return value; - } - uint32_t get_ao_clk() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 4); - return value; - } - CONSTEXPR clkforce_r &set_ao_clk(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 4) & word0) | ((((1U << 1) - 1) & value) << 4); - return *this; - } - volatile clkforce_r &set_ao_clk(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 4) & word0) | ((((1U << 1) - 1) & value) << 4); - return *this; - } - CONSTEXPR uint32_t get_wd_clk() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 5); - return value; - } - uint32_t get_wd_clk() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 5); - return value; - } - CONSTEXPR clkforce_r &set_wd_clk(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 5) & word0) | ((((1U << 1) - 1) & value) << 5); - return *this; - } - volatile clkforce_r &set_wd_clk(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 5) & word0) | ((((1U << 1) - 1) & value) << 5); - return *this; - } -#endif -}; - -// debug_address_r - Set debug address for register reads 0x400-0x7FF. The address must be 1KB aligned -struct debug_address_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t addr : 32; // Register address - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR debug_address_r() : word0(0) {} - CONSTEXPR debug_address_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - debug_address_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_addr() const - { - uint32_t value = word0; - return value; - } - uint32_t get_addr() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR debug_address_r &set_addr(uint32_t value) - { - word0 = value; - return *this; - } - volatile debug_address_r &set_addr(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// debug_misc_r - 32-bit read/write register for driver debug use. This does not affect NPU function -struct debug_misc_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t misc : 32; // Debug misc - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR debug_misc_r() : word0(0) {} - CONSTEXPR debug_misc_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - debug_misc_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_misc() const - { - uint32_t value = word0; - return value; - } - uint32_t get_misc() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR debug_misc_r &set_misc(uint32_t value) - { - word0 = value; - return *this; - } - volatile debug_misc_r &set_misc(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// debug_block_r - Set from which of four block banks the TSU registers are read. 0 = read from the current bank 256+n = -// force to read from bank n where n is in the range 0 to 3 -struct debug_block_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t block : 32; // Debug block - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR debug_block_r() : word0(0) {} - CONSTEXPR debug_block_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - debug_block_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_block() const - { - uint32_t value = word0; - return value; - } - uint32_t get_block() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR debug_block_r &set_block(uint32_t value) - { - word0 = value; - return *this; - } - volatile debug_block_r &set_block(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// pmcr_r - PMU Register control -struct pmcr_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t cnt_en : 1; // Enable counter - uint32_t event_cnt_rst : 1; // Reset event counter - uint32_t cycle_cnt_rst : 1; // Reset cycle counter - uint32_t mask_en : 1; // PMU can be enabled/disabled by command stream operation NPU_OP_PMU_MASK - uint32_t reserved0 : 7; - uint32_t num_event_cnt : 5; // Number of event counters - uint32_t reserved1 : 16; - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR pmcr_r() : word0(8192) {} - CONSTEXPR pmcr_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - pmcr_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_cnt_en() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 0); - return value; - } - uint32_t get_cnt_en() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 0); - return value; - } - CONSTEXPR pmcr_r &set_cnt_en(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - volatile pmcr_r &set_cnt_en(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - CONSTEXPR uint32_t get_event_cnt_rst() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 1); - return value; - } - uint32_t get_event_cnt_rst() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 1); - return value; - } - CONSTEXPR pmcr_r &set_event_cnt_rst(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - volatile pmcr_r &set_event_cnt_rst(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - CONSTEXPR uint32_t get_cycle_cnt_rst() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 2); - return value; - } - uint32_t get_cycle_cnt_rst() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 2); - return value; - } - CONSTEXPR pmcr_r &set_cycle_cnt_rst(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - volatile pmcr_r &set_cycle_cnt_rst(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - CONSTEXPR uint32_t get_mask_en() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 3); - return value; - } - uint32_t get_mask_en() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 3); - return value; - } - CONSTEXPR pmcr_r &set_mask_en(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - volatile pmcr_r &set_mask_en(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - CONSTEXPR uint32_t get_num_event_cnt() const - { - uint32_t value = ((1U << 5) - 1) & (word0 >> 11); - return value; - } - uint32_t get_num_event_cnt() const volatile - { - uint32_t value = ((1U << 5) - 1) & (word0 >> 11); - return value; - } - CONSTEXPR pmcr_r &set_num_event_cnt(uint32_t value) - { - word0 = (((~((1U << 5) - 1)) << 11) & word0) | ((((1U << 5) - 1) & value) << 11); - return *this; - } - volatile pmcr_r &set_num_event_cnt(uint32_t value) volatile - { - word0 = (((~((1U << 5) - 1)) << 11) & word0) | ((((1U << 5) - 1) & value) << 11); - return *this; - } -#endif -}; - -// pmcntenset_r - Count enable set register -struct pmcntenset_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t EVENT_CNT_0 : 1; // Event counter enable bit for PMEVCNTR0 - uint32_t EVENT_CNT_1 : 1; // Event counter enable bit for PMEVCNTR1 - uint32_t EVENT_CNT_2 : 1; // Event counter enable bit for PMEVCNTR2 - uint32_t EVENT_CNT_3 : 1; // Event counter enable bit for PMEVCNTR3 - uint32_t reserved0 : 27; - uint32_t CYCLE_CNT : 1; // PMCCNTR enable bit - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR pmcntenset_r() : word0(0) {} - CONSTEXPR pmcntenset_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - pmcntenset_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_0() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 0); - return value; - } - uint32_t get_EVENT_CNT_0() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 0); - return value; - } - CONSTEXPR pmcntenset_r &set_EVENT_CNT_0(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - volatile pmcntenset_r &set_EVENT_CNT_0(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_1() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 1); - return value; - } - uint32_t get_EVENT_CNT_1() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 1); - return value; - } - CONSTEXPR pmcntenset_r &set_EVENT_CNT_1(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - volatile pmcntenset_r &set_EVENT_CNT_1(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_2() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 2); - return value; - } - uint32_t get_EVENT_CNT_2() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 2); - return value; - } - CONSTEXPR pmcntenset_r &set_EVENT_CNT_2(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - volatile pmcntenset_r &set_EVENT_CNT_2(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_3() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 3); - return value; - } - uint32_t get_EVENT_CNT_3() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 3); - return value; - } - CONSTEXPR pmcntenset_r &set_EVENT_CNT_3(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - volatile pmcntenset_r &set_EVENT_CNT_3(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - CONSTEXPR uint32_t get_CYCLE_CNT() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 31); - return value; - } - uint32_t get_CYCLE_CNT() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 31); - return value; - } - CONSTEXPR pmcntenset_r &set_CYCLE_CNT(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 31) & word0) | ((((1U << 1) - 1) & value) << 31); - return *this; - } - volatile pmcntenset_r &set_CYCLE_CNT(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 31) & word0) | ((((1U << 1) - 1) & value) << 31); - return *this; - } -#endif -}; - -// pmcntenclr_r - Count enable clear register -struct pmcntenclr_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t EVENT_CNT_0 : 1; // Event counter disable bit for PMEVCNTR0 - uint32_t EVENT_CNT_1 : 1; // Event counter disable bit for PMEVCNTR1 - uint32_t EVENT_CNT_2 : 1; // Event counter disable bit for PMEVCNTR2 - uint32_t EVENT_CNT_3 : 1; // Event counter disable bit for PMEVCNTR3 - uint32_t reserved0 : 27; - uint32_t CYCLE_CNT : 1; // PMCCNTR disable bit - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR pmcntenclr_r() : word0(0) {} - CONSTEXPR pmcntenclr_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - pmcntenclr_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_0() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 0); - return value; - } - uint32_t get_EVENT_CNT_0() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 0); - return value; - } - CONSTEXPR pmcntenclr_r &set_EVENT_CNT_0(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - volatile pmcntenclr_r &set_EVENT_CNT_0(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_1() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 1); - return value; - } - uint32_t get_EVENT_CNT_1() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 1); - return value; - } - CONSTEXPR pmcntenclr_r &set_EVENT_CNT_1(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - volatile pmcntenclr_r &set_EVENT_CNT_1(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_2() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 2); - return value; - } - uint32_t get_EVENT_CNT_2() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 2); - return value; - } - CONSTEXPR pmcntenclr_r &set_EVENT_CNT_2(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - volatile pmcntenclr_r &set_EVENT_CNT_2(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_3() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 3); - return value; - } - uint32_t get_EVENT_CNT_3() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 3); - return value; - } - CONSTEXPR pmcntenclr_r &set_EVENT_CNT_3(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - volatile pmcntenclr_r &set_EVENT_CNT_3(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - CONSTEXPR uint32_t get_CYCLE_CNT() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 31); - return value; - } - uint32_t get_CYCLE_CNT() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 31); - return value; - } - CONSTEXPR pmcntenclr_r &set_CYCLE_CNT(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 31) & word0) | ((((1U << 1) - 1) & value) << 31); - return *this; - } - volatile pmcntenclr_r &set_CYCLE_CNT(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 31) & word0) | ((((1U << 1) - 1) & value) << 31); - return *this; - } -#endif -}; - -// pmovsset_r - Overflow flag status set register -struct pmovsset_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t EVENT_CNT_0_OVF : 1; // Event counter overflow set bit for PMEVCNTR0 - uint32_t EVENT_CNT_1_OVF : 1; // Event counter overflow set bit for PMEVCNTR1 - uint32_t EVENT_CNT_2_OVF : 1; // Event counter overflow set bit for PMEVCNTR2 - uint32_t EVENT_CNT_3_OVF : 1; // Event counter overflow set bit for PMEVCNTR3 - uint32_t reserved0 : 27; - uint32_t CYCLE_CNT_OVF : 1; // PMCCNTR overflow set bit - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR pmovsset_r() : word0(0) {} - CONSTEXPR pmovsset_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - pmovsset_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_0_OVF() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 0); - return value; - } - uint32_t get_EVENT_CNT_0_OVF() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 0); - return value; - } - CONSTEXPR pmovsset_r &set_EVENT_CNT_0_OVF(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - volatile pmovsset_r &set_EVENT_CNT_0_OVF(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_1_OVF() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 1); - return value; - } - uint32_t get_EVENT_CNT_1_OVF() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 1); - return value; - } - CONSTEXPR pmovsset_r &set_EVENT_CNT_1_OVF(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - volatile pmovsset_r &set_EVENT_CNT_1_OVF(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_2_OVF() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 2); - return value; - } - uint32_t get_EVENT_CNT_2_OVF() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 2); - return value; - } - CONSTEXPR pmovsset_r &set_EVENT_CNT_2_OVF(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - volatile pmovsset_r &set_EVENT_CNT_2_OVF(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_3_OVF() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 3); - return value; - } - uint32_t get_EVENT_CNT_3_OVF() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 3); - return value; - } - CONSTEXPR pmovsset_r &set_EVENT_CNT_3_OVF(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - volatile pmovsset_r &set_EVENT_CNT_3_OVF(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - CONSTEXPR uint32_t get_CYCLE_CNT_OVF() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 31); - return value; - } - uint32_t get_CYCLE_CNT_OVF() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 31); - return value; - } - CONSTEXPR pmovsset_r &set_CYCLE_CNT_OVF(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 31) & word0) | ((((1U << 1) - 1) & value) << 31); - return *this; - } - volatile pmovsset_r &set_CYCLE_CNT_OVF(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 31) & word0) | ((((1U << 1) - 1) & value) << 31); - return *this; - } -#endif -}; - -// pmovsclr_r - Overflow flag status clear register -struct pmovsclr_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t EVENT_CNT_0_OVF : 1; // Event counter overflow clear bit for PMEVCNTR0 - uint32_t EVENT_CNT_1_OVF : 1; // Event counter overflow clear bit for PMEVCNTR1 - uint32_t EVENT_CNT_2_OVF : 1; // Event counter overflow clear bit for PMEVCNTR2 - uint32_t EVENT_CNT_3_OVF : 1; // Event counter overflow clear bit for PMEVCNTR3 - uint32_t reserved0 : 27; - uint32_t CYCLE_CNT_OVF : 1; // PMCCNTR overflow clear bit - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR pmovsclr_r() : word0(0) {} - CONSTEXPR pmovsclr_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - pmovsclr_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_0_OVF() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 0); - return value; - } - uint32_t get_EVENT_CNT_0_OVF() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 0); - return value; - } - CONSTEXPR pmovsclr_r &set_EVENT_CNT_0_OVF(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - volatile pmovsclr_r &set_EVENT_CNT_0_OVF(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_1_OVF() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 1); - return value; - } - uint32_t get_EVENT_CNT_1_OVF() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 1); - return value; - } - CONSTEXPR pmovsclr_r &set_EVENT_CNT_1_OVF(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - volatile pmovsclr_r &set_EVENT_CNT_1_OVF(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_2_OVF() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 2); - return value; - } - uint32_t get_EVENT_CNT_2_OVF() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 2); - return value; - } - CONSTEXPR pmovsclr_r &set_EVENT_CNT_2_OVF(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - volatile pmovsclr_r &set_EVENT_CNT_2_OVF(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_3_OVF() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 3); - return value; - } - uint32_t get_EVENT_CNT_3_OVF() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 3); - return value; - } - CONSTEXPR pmovsclr_r &set_EVENT_CNT_3_OVF(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - volatile pmovsclr_r &set_EVENT_CNT_3_OVF(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - CONSTEXPR uint32_t get_CYCLE_CNT_OVF() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 31); - return value; - } - uint32_t get_CYCLE_CNT_OVF() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 31); - return value; - } - CONSTEXPR pmovsclr_r &set_CYCLE_CNT_OVF(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 31) & word0) | ((((1U << 1) - 1) & value) << 31); - return *this; - } - volatile pmovsclr_r &set_CYCLE_CNT_OVF(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 31) & word0) | ((((1U << 1) - 1) & value) << 31); - return *this; - } -#endif -}; - -// pmintset_r - Interrupt enable set register -struct pmintset_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t EVENT_CNT_0_INT : 1; // Event counter overflow interrupt request enable bit for PMEVCNTR0 - uint32_t EVENT_CNT_1_INT : 1; // Event counter overflow interrupt request enable bit for PMEVCNTR1 - uint32_t EVENT_CNT_2_INT : 1; // Event counter overflow interrupt request enable bit for PMEVCNTR2 - uint32_t EVENT_CNT_3_INT : 1; // Event counter overflow interrupt request enable bit for PMEVCNTR3 - uint32_t reserved0 : 27; - uint32_t CYCLE_CNT_INT : 1; // PMCCNTR overflow interrupt request enable bit - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR pmintset_r() : word0(0) {} - CONSTEXPR pmintset_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - pmintset_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_0_INT() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 0); - return value; - } - uint32_t get_EVENT_CNT_0_INT() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 0); - return value; - } - CONSTEXPR pmintset_r &set_EVENT_CNT_0_INT(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - volatile pmintset_r &set_EVENT_CNT_0_INT(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_1_INT() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 1); - return value; - } - uint32_t get_EVENT_CNT_1_INT() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 1); - return value; - } - CONSTEXPR pmintset_r &set_EVENT_CNT_1_INT(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - volatile pmintset_r &set_EVENT_CNT_1_INT(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_2_INT() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 2); - return value; - } - uint32_t get_EVENT_CNT_2_INT() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 2); - return value; - } - CONSTEXPR pmintset_r &set_EVENT_CNT_2_INT(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - volatile pmintset_r &set_EVENT_CNT_2_INT(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_3_INT() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 3); - return value; - } - uint32_t get_EVENT_CNT_3_INT() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 3); - return value; - } - CONSTEXPR pmintset_r &set_EVENT_CNT_3_INT(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - volatile pmintset_r &set_EVENT_CNT_3_INT(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - CONSTEXPR uint32_t get_CYCLE_CNT_INT() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 31); - return value; - } - uint32_t get_CYCLE_CNT_INT() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 31); - return value; - } - CONSTEXPR pmintset_r &set_CYCLE_CNT_INT(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 31) & word0) | ((((1U << 1) - 1) & value) << 31); - return *this; - } - volatile pmintset_r &set_CYCLE_CNT_INT(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 31) & word0) | ((((1U << 1) - 1) & value) << 31); - return *this; - } -#endif -}; - -// pmintclr_r - Interrupt enable clear register -struct pmintclr_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t EVENT_CNT_0_INT : 1; // Event counter overflow interrupt request disable bit for PMEVCNTR0 - uint32_t EVENT_CNT_1_INT : 1; // Event counter overflow interrupt request disable bit for PMEVCNTR1 - uint32_t EVENT_CNT_2_INT : 1; // Event counter overflow interrupt request disable bit for PMEVCNTR2 - uint32_t EVENT_CNT_3_INT : 1; // Event counter overflow interrupt request disable bit for PMEVCNTR3 - uint32_t reserved0 : 27; - uint32_t CYCLE_CNT_INT : 1; // PMCCNTR overflow interrupt request disable bit - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR pmintclr_r() : word0(0) {} - CONSTEXPR pmintclr_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - pmintclr_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_0_INT() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 0); - return value; - } - uint32_t get_EVENT_CNT_0_INT() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 0); - return value; - } - CONSTEXPR pmintclr_r &set_EVENT_CNT_0_INT(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - volatile pmintclr_r &set_EVENT_CNT_0_INT(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_1_INT() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 1); - return value; - } - uint32_t get_EVENT_CNT_1_INT() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 1); - return value; - } - CONSTEXPR pmintclr_r &set_EVENT_CNT_1_INT(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - volatile pmintclr_r &set_EVENT_CNT_1_INT(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_2_INT() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 2); - return value; - } - uint32_t get_EVENT_CNT_2_INT() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 2); - return value; - } - CONSTEXPR pmintclr_r &set_EVENT_CNT_2_INT(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - volatile pmintclr_r &set_EVENT_CNT_2_INT(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_3_INT() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 3); - return value; - } - uint32_t get_EVENT_CNT_3_INT() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 3); - return value; - } - CONSTEXPR pmintclr_r &set_EVENT_CNT_3_INT(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - volatile pmintclr_r &set_EVENT_CNT_3_INT(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - CONSTEXPR uint32_t get_CYCLE_CNT_INT() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 31); - return value; - } - uint32_t get_CYCLE_CNT_INT() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 31); - return value; - } - CONSTEXPR pmintclr_r &set_CYCLE_CNT_INT(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 31) & word0) | ((((1U << 1) - 1) & value) << 31); - return *this; - } - volatile pmintclr_r &set_CYCLE_CNT_INT(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 31) & word0) | ((((1U << 1) - 1) & value) << 31); - return *this; - } -#endif -}; - -// pmccntr_r - Performance monitor cycle count register -struct pmccntr_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t CYCLE_CNT_LO : 32; // Cycle count - LSB - uint32_t CYCLE_CNT_HI : 16; // Cycle count - MSB - uint32_t reserved0 : 16; - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR pmccntr_r() : word0(0), word1(0) {} - CONSTEXPR pmccntr_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - pmccntr_r copy() volatile - { - return *this; - } -#endif -}; - -// pmccntr_cfg_r - Set start/stop event on the cycle counter -struct pmccntr_cfg_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t CYCLE_CNT_CFG_START : 10; // Cycle counter start event - uint32_t reserved0 : 6; - uint32_t CYCLE_CNT_CFG_STOP : 10; // Cycle counter stop event - uint32_t reserved1 : 6; - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR pmccntr_cfg_r() : word0(0) {} - CONSTEXPR pmccntr_cfg_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - pmccntr_cfg_r copy() volatile - { - return *this; - } - CONSTEXPR NPU_NAMESPACE::pmu_event get_CYCLE_CNT_CFG_START() const - { - NPU_NAMESPACE::pmu_event value = static_cast(((1U << 10) - 1) & (word0 >> 0)); - return value; - } - NPU_NAMESPACE::pmu_event get_CYCLE_CNT_CFG_START() const volatile - { - NPU_NAMESPACE::pmu_event value = static_cast(((1U << 10) - 1) & (word0 >> 0)); - return value; - } - CONSTEXPR pmccntr_cfg_r &set_CYCLE_CNT_CFG_START(NPU_NAMESPACE::pmu_event value) - { - word0 = (((~((1U << 10) - 1)) << 0) & word0) | ((((1U << 10) - 1) & static_cast(value)) << 0); - return *this; - } - volatile pmccntr_cfg_r &set_CYCLE_CNT_CFG_START(NPU_NAMESPACE::pmu_event value) volatile - { - word0 = (((~((1U << 10) - 1)) << 0) & word0) | ((((1U << 10) - 1) & static_cast(value)) << 0); - return *this; - } - CONSTEXPR NPU_NAMESPACE::pmu_event get_CYCLE_CNT_CFG_STOP() const - { - NPU_NAMESPACE::pmu_event value = static_cast(((1U << 10) - 1) & (word0 >> 16)); - return value; - } - NPU_NAMESPACE::pmu_event get_CYCLE_CNT_CFG_STOP() const volatile - { - NPU_NAMESPACE::pmu_event value = static_cast(((1U << 10) - 1) & (word0 >> 16)); - return value; - } - CONSTEXPR pmccntr_cfg_r &set_CYCLE_CNT_CFG_STOP(NPU_NAMESPACE::pmu_event value) - { - word0 = (((~((1U << 10) - 1)) << 16) & word0) | ((((1U << 10) - 1) & static_cast(value)) << 16); - return *this; - } - volatile pmccntr_cfg_r &set_CYCLE_CNT_CFG_STOP(NPU_NAMESPACE::pmu_event value) volatile - { - word0 = (((~((1U << 10) - 1)) << 16) & word0) | ((((1U << 10) - 1) & static_cast(value)) << 16); - return *this; - } -#endif -}; - -// pmcaxi_chan_r - Set which AXI channel to monitor for latency measurements in PMU -struct pmcaxi_chan_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t CH_SEL : 4; // Channel select for latency measurements - uint32_t reserved0 : 4; - uint32_t AXI_CNT_SEL : 2; // AXI counter to monitor for latency measurements - uint32_t BW_CH_SEL_EN : 1; // Bandwidth channel selector - uint32_t reserved1 : 21; - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR pmcaxi_chan_r() : word0(0) {} - CONSTEXPR pmcaxi_chan_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - pmcaxi_chan_r copy() volatile - { - return *this; - } - CONSTEXPR NPU_NAMESPACE::pmu_axi_channel get_CH_SEL() const - { - NPU_NAMESPACE::pmu_axi_channel value = - static_cast(((1U << 4) - 1) & (word0 >> 0)); - return value; - } - NPU_NAMESPACE::pmu_axi_channel get_CH_SEL() const volatile - { - NPU_NAMESPACE::pmu_axi_channel value = - static_cast(((1U << 4) - 1) & (word0 >> 0)); - return value; - } - CONSTEXPR pmcaxi_chan_r &set_CH_SEL(NPU_NAMESPACE::pmu_axi_channel value) - { - word0 = (((~((1U << 4) - 1)) << 0) & word0) | ((((1U << 4) - 1) & static_cast(value)) << 0); - return *this; - } - volatile pmcaxi_chan_r &set_CH_SEL(NPU_NAMESPACE::pmu_axi_channel value) volatile - { - word0 = (((~((1U << 4) - 1)) << 0) & word0) | ((((1U << 4) - 1) & static_cast(value)) << 0); - return *this; - } - CONSTEXPR uint32_t get_AXI_CNT_SEL() const - { - uint32_t value = ((1U << 2) - 1) & (word0 >> 8); - return value; - } - uint32_t get_AXI_CNT_SEL() const volatile - { - uint32_t value = ((1U << 2) - 1) & (word0 >> 8); - return value; - } - CONSTEXPR pmcaxi_chan_r &set_AXI_CNT_SEL(uint32_t value) - { - word0 = (((~((1U << 2) - 1)) << 8) & word0) | ((((1U << 2) - 1) & value) << 8); - return *this; - } - volatile pmcaxi_chan_r &set_AXI_CNT_SEL(uint32_t value) volatile - { - word0 = (((~((1U << 2) - 1)) << 8) & word0) | ((((1U << 2) - 1) & value) << 8); - return *this; - } - CONSTEXPR uint32_t get_BW_CH_SEL_EN() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 10); - return value; - } - uint32_t get_BW_CH_SEL_EN() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 10); - return value; - } - CONSTEXPR pmcaxi_chan_r &set_BW_CH_SEL_EN(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 10) & word0) | ((((1U << 1) - 1) & value) << 10); - return *this; - } - volatile pmcaxi_chan_r &set_BW_CH_SEL_EN(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 10) & word0) | ((((1U << 1) - 1) & value) << 10); - return *this; - } -#endif -}; - -// kernel_x_r - Kernel X offset of in kernel decomposition -struct kernel_x_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR kernel_x_r() : word0(0) {} - CONSTEXPR kernel_x_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - kernel_x_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR kernel_x_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile kernel_x_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// kernel_y_r - Kernel Y offset of in kernel decomposition -struct kernel_y_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR kernel_y_r() : word0(0) {} - CONSTEXPR kernel_y_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - kernel_y_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR kernel_y_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile kernel_y_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// kernel_w_m1_r - Kernel (width-1) of current block -struct kernel_w_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR kernel_w_m1_r() : word0(0) {} - CONSTEXPR kernel_w_m1_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - kernel_w_m1_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR kernel_w_m1_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile kernel_w_m1_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// kernel_h_m1_r - Kernel (height-1) of current block -struct kernel_h_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR kernel_h_m1_r() : word0(0) {} - CONSTEXPR kernel_h_m1_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - kernel_h_m1_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR kernel_h_m1_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile kernel_h_m1_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ofm_cblk_width_m1_r - OFM current block (width-1) -struct ofm_cblk_width_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ofm_cblk_width_m1_r() : word0(0) {} - CONSTEXPR ofm_cblk_width_m1_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ofm_cblk_width_m1_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ofm_cblk_width_m1_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ofm_cblk_width_m1_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ofm_cblk_height_m1_r - OFM current block (height-1) -struct ofm_cblk_height_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ofm_cblk_height_m1_r() : word0(0) {} - CONSTEXPR ofm_cblk_height_m1_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ofm_cblk_height_m1_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ofm_cblk_height_m1_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ofm_cblk_height_m1_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ofm_cblk_depth_m1_r - OFM current block (depth-1) -struct ofm_cblk_depth_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ofm_cblk_depth_m1_r() : word0(0) {} - CONSTEXPR ofm_cblk_depth_m1_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ofm_cblk_depth_m1_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ofm_cblk_depth_m1_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ofm_cblk_depth_m1_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ifm_cblk_depth_m1_r - IFM current block (depth-1) -struct ifm_cblk_depth_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ifm_cblk_depth_m1_r() : word0(0) {} - CONSTEXPR ifm_cblk_depth_m1_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ifm_cblk_depth_m1_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ifm_cblk_depth_m1_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ifm_cblk_depth_m1_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ofm_x_r - Block X coordinate in OFM -struct ofm_x_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ofm_x_r() : word0(0) {} - CONSTEXPR ofm_x_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ofm_x_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ofm_x_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ofm_x_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ofm_y_r - Block Y coordinate in OFM -struct ofm_y_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ofm_y_r() : word0(0) {} - CONSTEXPR ofm_y_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ofm_y_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ofm_y_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ofm_y_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ofm_z_r - Block Z (channel) coordinate in OFM -struct ofm_z_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ofm_z_r() : word0(0) {} - CONSTEXPR ofm_z_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ofm_z_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ofm_z_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ofm_z_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ifm_z_r - Block Z (channel) coordinate in IFM -struct ifm_z_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ifm_z_r() : word0(0) {} - CONSTEXPR ifm_z_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ifm_z_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ifm_z_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ifm_z_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// pad_top_r - Block top pad -struct pad_top_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR pad_top_r() : word0(0) {} - CONSTEXPR pad_top_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - pad_top_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR pad_top_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile pad_top_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// pad_left_r - Block left pad -struct pad_left_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR pad_left_r() : word0(0) {} - CONSTEXPR pad_left_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - pad_left_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR pad_left_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile pad_left_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ifm_cblk_width_r - IFM current block derived width -struct ifm_cblk_width_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ifm_cblk_width_r() : word0(0) {} - CONSTEXPR ifm_cblk_width_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ifm_cblk_width_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ifm_cblk_width_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ifm_cblk_width_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ifm_cblk_height_r - IFM current block derived height -struct ifm_cblk_height_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ifm_cblk_height_r() : word0(0) {} - CONSTEXPR ifm_cblk_height_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ifm_cblk_height_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ifm_cblk_height_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ifm_cblk_height_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// dma_ifm_src_r - DMA IFM channel source position on AXI -struct dma_ifm_src_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t offset : 32; // Offset - uint32_t reserved0 : 32; - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR dma_ifm_src_r() : word0(0), word1(0) {} - CONSTEXPR dma_ifm_src_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - dma_ifm_src_r copy() volatile - { - return *this; - } -#endif -}; - -// dma_ifm_dst_r - DMA IFM channel destination position in SHRAM -struct dma_ifm_dst_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR dma_ifm_dst_r() : word0(0) {} - CONSTEXPR dma_ifm_dst_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - dma_ifm_dst_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR dma_ifm_dst_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile dma_ifm_dst_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// dma_ofm_src_r - DMA OFM channel source position in SHRAM -struct dma_ofm_src_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR dma_ofm_src_r() : word0(0) {} - CONSTEXPR dma_ofm_src_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - dma_ofm_src_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR dma_ofm_src_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile dma_ofm_src_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// dma_ofm_dst_r - DMA OFM channel destination position on AXI -struct dma_ofm_dst_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t offset : 32; // Offset - uint32_t reserved0 : 32; - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR dma_ofm_dst_r() : word0(0), word1(0) {} - CONSTEXPR dma_ofm_dst_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - dma_ofm_dst_r copy() volatile - { - return *this; - } -#endif -}; - -// dma_weight_src_r - DMA weight channel source position on AXI -struct dma_weight_src_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t offset : 32; // Offset - uint32_t reserved0 : 32; - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR dma_weight_src_r() : word0(0), word1(0) {} - CONSTEXPR dma_weight_src_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - dma_weight_src_r copy() volatile - { - return *this; - } -#endif -}; - -// dma_cmd_src_r - DMA command channel source position on AXI -struct dma_cmd_src_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t offset : 32; // Offset - uint32_t reserved0 : 32; - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR dma_cmd_src_r() : word0(0), word1(0) {} - CONSTEXPR dma_cmd_src_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - dma_cmd_src_r copy() volatile - { - return *this; - } -#endif -}; - -// dma_cmd_size_r - DMA command channel number of bytes buffered -struct dma_cmd_size_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR dma_cmd_size_r() : word0(0) {} - CONSTEXPR dma_cmd_size_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - dma_cmd_size_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR dma_cmd_size_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile dma_cmd_size_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// dma_m2m_src_r - DMA memory to memory source position on AXI -struct dma_m2m_src_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t offset : 32; // Offset - uint32_t reserved0 : 32; - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR dma_m2m_src_r() : word0(0), word1(0) {} - CONSTEXPR dma_m2m_src_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - dma_m2m_src_r copy() volatile - { - return *this; - } -#endif -}; - -// dma_m2m_dst_r - DMA memory to memory destination position on AXI -struct dma_m2m_dst_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t offset : 32; // Offset - uint32_t reserved0 : 32; - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR dma_m2m_dst_r() : word0(0), word1(0) {} - CONSTEXPR dma_m2m_dst_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - dma_m2m_dst_r copy() volatile - { - return *this; - } -#endif -}; - -// current_qread_r - QREAD position being issued (rather than completed) -struct current_qread_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR current_qread_r() : word0(0) {} - CONSTEXPR current_qread_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - current_qread_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR current_qread_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile current_qread_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// dma_scale_src_r - DMA scale and bias channel source position on AXI -struct dma_scale_src_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t offset : 32; // Offset - uint32_t reserved0 : 32; - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR dma_scale_src_r() : word0(0), word1(0) {} - CONSTEXPR dma_scale_src_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - dma_scale_src_r copy() volatile - { - return *this; - } -#endif -}; - -// current_block_r - 0-3. Current block bank being executed by the TSU or last one executed if TSU is stopped -struct current_block_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR current_block_r() : word0(0) {} - CONSTEXPR current_block_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - current_block_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR current_block_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile current_block_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// current_op_r - Current NPU OP command being executed by the TSU -struct current_op_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR current_op_r() : word0(0) {} - CONSTEXPR current_op_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - current_op_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR current_op_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile current_op_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// current_cmd_r - Current 32-bit command being parsed by the command stream parser -struct current_cmd_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR current_cmd_r() : word0(0) {} - CONSTEXPR current_cmd_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - current_cmd_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR current_cmd_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile current_cmd_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// pmevcntr_r - Performance monitor event 0 count register -struct pmevcntr_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t count : 32; // Count word - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR pmevcntr_r() : word0(0) {} - CONSTEXPR pmevcntr_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - pmevcntr_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_count() const - { - uint32_t value = word0; - return value; - } - uint32_t get_count() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR pmevcntr_r &set_count(uint32_t value) - { - word0 = value; - return *this; - } - volatile pmevcntr_r &set_count(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// pmevtyper_r - Performance monitor event type register 0 -struct pmevtyper_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t EV_TYPE : 10; // Event Type - uint32_t reserved0 : 22; - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR pmevtyper_r() : word0(0) {} - CONSTEXPR pmevtyper_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - pmevtyper_r copy() volatile - { - return *this; - } - CONSTEXPR NPU_NAMESPACE::pmu_event get_EV_TYPE() const - { - NPU_NAMESPACE::pmu_event value = static_cast(((1U << 10) - 1) & (word0 >> 0)); - return value; - } - NPU_NAMESPACE::pmu_event get_EV_TYPE() const volatile - { - NPU_NAMESPACE::pmu_event value = static_cast(((1U << 10) - 1) & (word0 >> 0)); - return value; - } - CONSTEXPR pmevtyper_r &set_EV_TYPE(NPU_NAMESPACE::pmu_event value) - { - word0 = (((~((1U << 10) - 1)) << 0) & word0) | ((((1U << 10) - 1) & static_cast(value)) << 0); - return *this; - } - volatile pmevtyper_r &set_EV_TYPE(NPU_NAMESPACE::pmu_event value) volatile - { - word0 = (((~((1U << 10) - 1)) << 0) & word0) | ((((1U << 10) - 1) & static_cast(value)) << 0); - return *this; - } -#endif -}; - -// shared_buffer_r - Shared buffer debug access. Only valid in STOPPED state -struct shared_buffer_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t mem_word : 32; // Memory word - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR shared_buffer_r() : word0(0) {} - CONSTEXPR shared_buffer_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - shared_buffer_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_mem_word() const - { - uint32_t value = word0; - return value; - } - uint32_t get_mem_word() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR shared_buffer_r &set_mem_word(uint32_t value) - { - word0 = value; - return *this; - } - volatile shared_buffer_r &set_mem_word(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ifm_pad_top_r - None -struct ifm_pad_top_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ifm_pad_top_r() : word0(0) {} - CONSTEXPR ifm_pad_top_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ifm_pad_top_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ifm_pad_top_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ifm_pad_top_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ifm_pad_left_r - None -struct ifm_pad_left_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ifm_pad_left_r() : word0(0) {} - CONSTEXPR ifm_pad_left_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ifm_pad_left_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ifm_pad_left_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ifm_pad_left_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ifm_pad_right_r - None -struct ifm_pad_right_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ifm_pad_right_r() : word0(0) {} - CONSTEXPR ifm_pad_right_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ifm_pad_right_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ifm_pad_right_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ifm_pad_right_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ifm_pad_bottom_r - None -struct ifm_pad_bottom_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ifm_pad_bottom_r() : word0(0) {} - CONSTEXPR ifm_pad_bottom_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ifm_pad_bottom_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ifm_pad_bottom_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ifm_pad_bottom_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ifm_depth_m1_r - None -struct ifm_depth_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ifm_depth_m1_r() : word0(0) {} - CONSTEXPR ifm_depth_m1_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ifm_depth_m1_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ifm_depth_m1_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ifm_depth_m1_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ifm_precision_r - None -struct ifm_precision_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ifm_precision_r() : word0(0) {} - CONSTEXPR ifm_precision_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ifm_precision_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ifm_precision_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ifm_precision_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ifm_upscale_r - None -struct ifm_upscale_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ifm_upscale_r() : word0(0) {} - CONSTEXPR ifm_upscale_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ifm_upscale_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ifm_upscale_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ifm_upscale_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ifm_zero_point_r - None -struct ifm_zero_point_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ifm_zero_point_r() : word0(0) {} - CONSTEXPR ifm_zero_point_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ifm_zero_point_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ifm_zero_point_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ifm_zero_point_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ifm_width0_m1_r - None -struct ifm_width0_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ifm_width0_m1_r() : word0(0) {} - CONSTEXPR ifm_width0_m1_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ifm_width0_m1_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ifm_width0_m1_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ifm_width0_m1_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ifm_height0_m1_r - None -struct ifm_height0_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ifm_height0_m1_r() : word0(0) {} - CONSTEXPR ifm_height0_m1_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ifm_height0_m1_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ifm_height0_m1_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ifm_height0_m1_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ifm_height1_m1_r - None -struct ifm_height1_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ifm_height1_m1_r() : word0(0) {} - CONSTEXPR ifm_height1_m1_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ifm_height1_m1_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ifm_height1_m1_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ifm_height1_m1_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ifm_ib_end_r - None -struct ifm_ib_end_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ifm_ib_end_r() : word0(0) {} - CONSTEXPR ifm_ib_end_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ifm_ib_end_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ifm_ib_end_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ifm_ib_end_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ifm_region_r - None -struct ifm_region_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ifm_region_r() : word0(0) {} - CONSTEXPR ifm_region_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ifm_region_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ifm_region_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ifm_region_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ofm_width_m1_r - None -struct ofm_width_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ofm_width_m1_r() : word0(0) {} - CONSTEXPR ofm_width_m1_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ofm_width_m1_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ofm_width_m1_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ofm_width_m1_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ofm_height_m1_r - None -struct ofm_height_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ofm_height_m1_r() : word0(0) {} - CONSTEXPR ofm_height_m1_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ofm_height_m1_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ofm_height_m1_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ofm_height_m1_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ofm_depth_m1_r - None -struct ofm_depth_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ofm_depth_m1_r() : word0(0) {} - CONSTEXPR ofm_depth_m1_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ofm_depth_m1_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ofm_depth_m1_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ofm_depth_m1_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ofm_precision_r - None -struct ofm_precision_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ofm_precision_r() : word0(0) {} - CONSTEXPR ofm_precision_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ofm_precision_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ofm_precision_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ofm_precision_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ofm_blk_width_m1_r - None -struct ofm_blk_width_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ofm_blk_width_m1_r() : word0(0) {} - CONSTEXPR ofm_blk_width_m1_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ofm_blk_width_m1_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ofm_blk_width_m1_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ofm_blk_width_m1_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ofm_blk_height_m1_r - None -struct ofm_blk_height_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ofm_blk_height_m1_r() : word0(0) {} - CONSTEXPR ofm_blk_height_m1_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ofm_blk_height_m1_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ofm_blk_height_m1_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ofm_blk_height_m1_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ofm_blk_depth_m1_r - None -struct ofm_blk_depth_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ofm_blk_depth_m1_r() : word0(0) {} - CONSTEXPR ofm_blk_depth_m1_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ofm_blk_depth_m1_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ofm_blk_depth_m1_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ofm_blk_depth_m1_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ofm_zero_point_r - None -struct ofm_zero_point_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ofm_zero_point_r() : word0(0) {} - CONSTEXPR ofm_zero_point_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ofm_zero_point_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ofm_zero_point_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ofm_zero_point_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ofm_width0_m1_r - None -struct ofm_width0_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ofm_width0_m1_r() : word0(0) {} - CONSTEXPR ofm_width0_m1_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ofm_width0_m1_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ofm_width0_m1_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ofm_width0_m1_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ofm_height0_m1_r - None -struct ofm_height0_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ofm_height0_m1_r() : word0(0) {} - CONSTEXPR ofm_height0_m1_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ofm_height0_m1_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ofm_height0_m1_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ofm_height0_m1_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ofm_height1_m1_r - None -struct ofm_height1_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ofm_height1_m1_r() : word0(0) {} - CONSTEXPR ofm_height1_m1_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ofm_height1_m1_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ofm_height1_m1_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ofm_height1_m1_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ofm_region_r - None -struct ofm_region_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ofm_region_r() : word0(0) {} - CONSTEXPR ofm_region_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ofm_region_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ofm_region_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ofm_region_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// kernel_width_m1_r - None -struct kernel_width_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR kernel_width_m1_r() : word0(0) {} - CONSTEXPR kernel_width_m1_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - kernel_width_m1_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR kernel_width_m1_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile kernel_width_m1_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// kernel_height_m1_r - None -struct kernel_height_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR kernel_height_m1_r() : word0(0) {} - CONSTEXPR kernel_height_m1_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - kernel_height_m1_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR kernel_height_m1_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile kernel_height_m1_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// kernel_stride_r - None -struct kernel_stride_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR kernel_stride_r() : word0(0) {} - CONSTEXPR kernel_stride_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - kernel_stride_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR kernel_stride_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile kernel_stride_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// acc_format_r - None -struct acc_format_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR acc_format_r() : word0(0) {} - CONSTEXPR acc_format_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - acc_format_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR acc_format_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile acc_format_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// activation_r - None -struct activation_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR activation_r() : word0(0) {} - CONSTEXPR activation_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - activation_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR activation_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile activation_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// activation_min_r - None -struct activation_min_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR activation_min_r() : word0(0) {} - CONSTEXPR activation_min_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - activation_min_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR activation_min_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile activation_min_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// activation_max_r - None -struct activation_max_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR activation_max_r() : word0(0) {} - CONSTEXPR activation_max_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - activation_max_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR activation_max_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile activation_max_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// weight_region_r - None -struct weight_region_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR weight_region_r() : word0(0) {} - CONSTEXPR weight_region_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - weight_region_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR weight_region_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile weight_region_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// scale_region_r - None -struct scale_region_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR scale_region_r() : word0(0) {} - CONSTEXPR scale_region_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - scale_region_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR scale_region_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile scale_region_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ab_start_r - None -struct ab_start_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ab_start_r() : word0(0) {} - CONSTEXPR ab_start_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ab_start_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ab_start_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ab_start_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// blockdep_r - None -struct blockdep_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR blockdep_r() : word0(0) {} - CONSTEXPR blockdep_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - blockdep_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR blockdep_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile blockdep_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// dma0_src_region_r - None -struct dma0_src_region_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR dma0_src_region_r() : word0(0) {} - CONSTEXPR dma0_src_region_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - dma0_src_region_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR dma0_src_region_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile dma0_src_region_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// dma0_dst_region_r - None -struct dma0_dst_region_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR dma0_dst_region_r() : word0(0) {} - CONSTEXPR dma0_dst_region_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - dma0_dst_region_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR dma0_dst_region_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile dma0_dst_region_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// dma0_size0_r - None -struct dma0_size0_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR dma0_size0_r() : word0(0) {} - CONSTEXPR dma0_size0_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - dma0_size0_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR dma0_size0_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile dma0_size0_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// dma0_size1_r - None -struct dma0_size1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR dma0_size1_r() : word0(0) {} - CONSTEXPR dma0_size1_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - dma0_size1_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR dma0_size1_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile dma0_size1_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ifm2_broadcast_r - None -struct ifm2_broadcast_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ifm2_broadcast_r() : word0(0) {} - CONSTEXPR ifm2_broadcast_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ifm2_broadcast_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ifm2_broadcast_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ifm2_broadcast_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ifm2_scalar_r - None -struct ifm2_scalar_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ifm2_scalar_r() : word0(0) {} - CONSTEXPR ifm2_scalar_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ifm2_scalar_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ifm2_scalar_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ifm2_scalar_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ifm2_precision_r - None -struct ifm2_precision_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ifm2_precision_r() : word0(0) {} - CONSTEXPR ifm2_precision_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ifm2_precision_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ifm2_precision_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ifm2_precision_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ifm2_zero_point_r - None -struct ifm2_zero_point_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ifm2_zero_point_r() : word0(0) {} - CONSTEXPR ifm2_zero_point_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ifm2_zero_point_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ifm2_zero_point_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ifm2_zero_point_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ifm2_width0_m1_r - None -struct ifm2_width0_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ifm2_width0_m1_r() : word0(0) {} - CONSTEXPR ifm2_width0_m1_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ifm2_width0_m1_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ifm2_width0_m1_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ifm2_width0_m1_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ifm2_height0_m1_r - None -struct ifm2_height0_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ifm2_height0_m1_r() : word0(0) {} - CONSTEXPR ifm2_height0_m1_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ifm2_height0_m1_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ifm2_height0_m1_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ifm2_height0_m1_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ifm2_height1_m1_r - None -struct ifm2_height1_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ifm2_height1_m1_r() : word0(0) {} - CONSTEXPR ifm2_height1_m1_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ifm2_height1_m1_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ifm2_height1_m1_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ifm2_height1_m1_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ifm2_ib_start_r - None -struct ifm2_ib_start_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ifm2_ib_start_r() : word0(0) {} - CONSTEXPR ifm2_ib_start_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ifm2_ib_start_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ifm2_ib_start_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ifm2_ib_start_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ifm2_region_r - None -struct ifm2_region_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ifm2_region_r() : word0(0) {} - CONSTEXPR ifm2_region_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ifm2_region_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ifm2_region_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ifm2_region_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ifm_base0_r - None -struct ifm_base0_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR ifm_base0_r() : word0(0), word1(0) {} - CONSTEXPR ifm_base0_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - ifm_base0_r copy() volatile - { - return *this; - } -#endif -}; - -// ifm_base1_r - None -struct ifm_base1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR ifm_base1_r() : word0(0), word1(0) {} - CONSTEXPR ifm_base1_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - ifm_base1_r copy() volatile - { - return *this; - } -#endif -}; - -// ifm_base2_r - None -struct ifm_base2_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR ifm_base2_r() : word0(0), word1(0) {} - CONSTEXPR ifm_base2_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - ifm_base2_r copy() volatile - { - return *this; - } -#endif -}; - -// ifm_base3_r - None -struct ifm_base3_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR ifm_base3_r() : word0(0), word1(0) {} - CONSTEXPR ifm_base3_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - ifm_base3_r copy() volatile - { - return *this; - } -#endif -}; - -// ifm_stride_x_r - None -struct ifm_stride_x_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR ifm_stride_x_r() : word0(0), word1(0) {} - CONSTEXPR ifm_stride_x_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - ifm_stride_x_r copy() volatile - { - return *this; - } -#endif -}; - -// ifm_stride_y_r - None -struct ifm_stride_y_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR ifm_stride_y_r() : word0(0), word1(0) {} - CONSTEXPR ifm_stride_y_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - ifm_stride_y_r copy() volatile - { - return *this; - } -#endif -}; - -// ifm_stride_c_r - None -struct ifm_stride_c_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR ifm_stride_c_r() : word0(0), word1(0) {} - CONSTEXPR ifm_stride_c_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - ifm_stride_c_r copy() volatile - { - return *this; - } -#endif -}; - -// ofm_base0_r - None -struct ofm_base0_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR ofm_base0_r() : word0(0), word1(0) {} - CONSTEXPR ofm_base0_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - ofm_base0_r copy() volatile - { - return *this; - } -#endif -}; - -// ofm_base1_r - None -struct ofm_base1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR ofm_base1_r() : word0(0), word1(0) {} - CONSTEXPR ofm_base1_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - ofm_base1_r copy() volatile - { - return *this; - } -#endif -}; - -// ofm_base2_r - None -struct ofm_base2_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR ofm_base2_r() : word0(0), word1(0) {} - CONSTEXPR ofm_base2_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - ofm_base2_r copy() volatile - { - return *this; - } -#endif -}; - -// ofm_base3_r - None -struct ofm_base3_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR ofm_base3_r() : word0(0), word1(0) {} - CONSTEXPR ofm_base3_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - ofm_base3_r copy() volatile - { - return *this; - } -#endif -}; - -// ofm_stride_x_r - None -struct ofm_stride_x_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR ofm_stride_x_r() : word0(0), word1(0) {} - CONSTEXPR ofm_stride_x_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - ofm_stride_x_r copy() volatile - { - return *this; - } -#endif -}; - -// ofm_stride_y_r - None -struct ofm_stride_y_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR ofm_stride_y_r() : word0(0), word1(0) {} - CONSTEXPR ofm_stride_y_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - ofm_stride_y_r copy() volatile - { - return *this; - } -#endif -}; - -// ofm_stride_c_r - None -struct ofm_stride_c_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR ofm_stride_c_r() : word0(0), word1(0) {} - CONSTEXPR ofm_stride_c_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - ofm_stride_c_r copy() volatile - { - return *this; - } -#endif -}; - -// weight_base_r - None -struct weight_base_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR weight_base_r() : word0(0), word1(0) {} - CONSTEXPR weight_base_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - weight_base_r copy() volatile - { - return *this; - } -#endif -}; - -// weight_length_r - None -struct weight_length_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR weight_length_r() : word0(0), word1(0) {} - CONSTEXPR weight_length_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - weight_length_r copy() volatile - { - return *this; - } -#endif -}; - -// scale_base_r - None -struct scale_base_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR scale_base_r() : word0(0), word1(0) {} - CONSTEXPR scale_base_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - scale_base_r copy() volatile - { - return *this; - } -#endif -}; - -// scale_length_r - None -struct scale_length_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR scale_length_r() : word0(0), word1(0) {} - CONSTEXPR scale_length_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - scale_length_r copy() volatile - { - return *this; - } -#endif -}; - -// ofm_scale_r - None -struct ofm_scale_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ofm_scale_r() : word0(0) {} - CONSTEXPR ofm_scale_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ofm_scale_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ofm_scale_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ofm_scale_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ofm_scale_shift_r - None -struct ofm_scale_shift_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ofm_scale_shift_r() : word0(0) {} - CONSTEXPR ofm_scale_shift_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ofm_scale_shift_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ofm_scale_shift_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ofm_scale_shift_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// opa_scale_r - None -struct opa_scale_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR opa_scale_r() : word0(0) {} - CONSTEXPR opa_scale_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - opa_scale_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR opa_scale_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile opa_scale_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// opa_scale_shift_r - None -struct opa_scale_shift_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR opa_scale_shift_r() : word0(0) {} - CONSTEXPR opa_scale_shift_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - opa_scale_shift_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR opa_scale_shift_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile opa_scale_shift_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// opb_scale_r - None -struct opb_scale_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR opb_scale_r() : word0(0) {} - CONSTEXPR opb_scale_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - opb_scale_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR opb_scale_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile opb_scale_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// dma0_src_r - None -struct dma0_src_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR dma0_src_r() : word0(0), word1(0) {} - CONSTEXPR dma0_src_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - dma0_src_r copy() volatile - { - return *this; - } -#endif -}; - -// dma0_dst_r - None -struct dma0_dst_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR dma0_dst_r() : word0(0), word1(0) {} - CONSTEXPR dma0_dst_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - dma0_dst_r copy() volatile - { - return *this; - } -#endif -}; - -// dma0_len_r - None -struct dma0_len_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR dma0_len_r() : word0(0), word1(0) {} - CONSTEXPR dma0_len_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - dma0_len_r copy() volatile - { - return *this; - } -#endif -}; - -// ifm2_base0_r - None -struct ifm2_base0_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR ifm2_base0_r() : word0(0), word1(0) {} - CONSTEXPR ifm2_base0_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - ifm2_base0_r copy() volatile - { - return *this; - } -#endif -}; - -// ifm2_base1_r - None -struct ifm2_base1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR ifm2_base1_r() : word0(0), word1(0) {} - CONSTEXPR ifm2_base1_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - ifm2_base1_r copy() volatile - { - return *this; - } -#endif -}; - -// ifm2_base2_r - None -struct ifm2_base2_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR ifm2_base2_r() : word0(0), word1(0) {} - CONSTEXPR ifm2_base2_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - ifm2_base2_r copy() volatile - { - return *this; - } -#endif -}; - -// ifm2_base3_r - None -struct ifm2_base3_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR ifm2_base3_r() : word0(0), word1(0) {} - CONSTEXPR ifm2_base3_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - ifm2_base3_r copy() volatile - { - return *this; - } -#endif -}; - -// ifm2_stride_x_r - None -struct ifm2_stride_x_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR ifm2_stride_x_r() : word0(0), word1(0) {} - CONSTEXPR ifm2_stride_x_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - ifm2_stride_x_r copy() volatile - { - return *this; - } -#endif -}; - -// ifm2_stride_y_r - None -struct ifm2_stride_y_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR ifm2_stride_y_r() : word0(0), word1(0) {} - CONSTEXPR ifm2_stride_y_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - ifm2_stride_y_r copy() volatile - { - return *this; - } -#endif -}; - -// ifm2_stride_c_r - None -struct ifm2_stride_c_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR ifm2_stride_c_r() : word0(0), word1(0) {} - CONSTEXPR ifm2_stride_c_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - ifm2_stride_c_r copy() volatile - { - return *this; - } -#endif -}; - -// revision_r - Internal FPGA build revision: first 32-bits of the Ultan Git hash used for the build -struct revision_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR revision_r() : word0(0) {} - CONSTEXPR revision_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - revision_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR revision_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile revision_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// pid4_r - Peripheral ID byte 4 (Arm=code 4) -struct pid4_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t PID4 : 32; // Byte 4 of Peripheral ID (Lower 8 bits valid) - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR pid4_r() : word0(4) {} - CONSTEXPR pid4_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - pid4_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_PID4() const - { - uint32_t value = word0; - return value; - } - uint32_t get_PID4() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR pid4_r &set_PID4(uint32_t value) - { - word0 = value; - return *this; - } - volatile pid4_r &set_PID4(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// pid5_r - Peripheral ID byte 5 (reserved) -struct pid5_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t PID5 : 32; // Byte 5 of Peripheral ID (Lower 8 bits valid) - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR pid5_r() : word0(0) {} - CONSTEXPR pid5_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - pid5_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_PID5() const - { - uint32_t value = word0; - return value; - } - uint32_t get_PID5() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR pid5_r &set_PID5(uint32_t value) - { - word0 = value; - return *this; - } - volatile pid5_r &set_PID5(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// pid6_r - Peripheral ID byte 6 (reserved) -struct pid6_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t PID6 : 32; // Byte 6 of Peripheral ID (Lower 8 bits valid) - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR pid6_r() : word0(0) {} - CONSTEXPR pid6_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - pid6_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_PID6() const - { - uint32_t value = word0; - return value; - } - uint32_t get_PID6() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR pid6_r &set_PID6(uint32_t value) - { - word0 = value; - return *this; - } - volatile pid6_r &set_PID6(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// pid7_r - Peripheral ID byte 7 (reserved) -struct pid7_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t PID7 : 32; // Byte 7 of Peripheral ID (Lower 8 bits valid) - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR pid7_r() : word0(0) {} - CONSTEXPR pid7_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - pid7_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_PID7() const - { - uint32_t value = word0; - return value; - } - uint32_t get_PID7() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR pid7_r &set_PID7(uint32_t value) - { - word0 = value; - return *this; - } - volatile pid7_r &set_PID7(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// pid0_r - Peripheral ID byte 0. This is bits[7:0] of the part number -struct pid0_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t PID0 : 32; // Byte 0 of Peripheral ID (Lower 8 bits valid) - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR pid0_r() : word0(128) {} - CONSTEXPR pid0_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - pid0_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_PID0() const - { - uint32_t value = word0; - return value; - } - uint32_t get_PID0() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR pid0_r &set_PID0(uint32_t value) - { - word0 = value; - return *this; - } - volatile pid0_r &set_PID0(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// pid1_r - Peripheral ID byte 1. This is bits[11:8] of the part number in bits[3:0], and bits[3:0] of the Arm ID in -// bits[7:4] -struct pid1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t PID1 : 32; // Byte 1 of Peripheral ID (Lower 8 bits valid) - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR pid1_r() : word0(181) {} - CONSTEXPR pid1_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - pid1_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_PID1() const - { - uint32_t value = word0; - return value; - } - uint32_t get_PID1() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR pid1_r &set_PID1(uint32_t value) - { - word0 = value; - return *this; - } - volatile pid1_r &set_PID1(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// pid2_r - Peripheral ID byte 2. This is bits[6:4] of the Arm ID in bits[2:0], and bit 3 indicates format B -struct pid2_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t PID2 : 32; // Byte 2 of Peripheral ID (Lower 8 bits valid) - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR pid2_r() : word0(11) {} - CONSTEXPR pid2_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - pid2_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_PID2() const - { - uint32_t value = word0; - return value; - } - uint32_t get_PID2() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR pid2_r &set_PID2(uint32_t value) - { - word0 = value; - return *this; - } - volatile pid2_r &set_PID2(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// pid3_r - Peripheral ID byte 3 -struct pid3_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t PID3 : 32; // Byte 1 of Peripheral ID (Lower 8 bits valid) - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR pid3_r() : word0(0) {} - CONSTEXPR pid3_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - pid3_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_PID3() const - { - uint32_t value = word0; - return value; - } - uint32_t get_PID3() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR pid3_r &set_PID3(uint32_t value) - { - word0 = value; - return *this; - } - volatile pid3_r &set_PID3(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// cid0_r - Component ID byte 0 -struct cid0_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t CID0 : 32; // Byte 0 of Component ID (Lower 8 bits valid) - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR cid0_r() : word0(13) {} - CONSTEXPR cid0_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - cid0_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_CID0() const - { - uint32_t value = word0; - return value; - } - uint32_t get_CID0() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR cid0_r &set_CID0(uint32_t value) - { - word0 = value; - return *this; - } - volatile cid0_r &set_CID0(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// cid1_r - Component ID byte 1 -struct cid1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t CID1 : 32; // Byte 1 of Component ID (Lower 8 bits valid) - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR cid1_r() : word0(240) {} - CONSTEXPR cid1_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - cid1_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_CID1() const - { - uint32_t value = word0; - return value; - } - uint32_t get_CID1() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR cid1_r &set_CID1(uint32_t value) - { - word0 = value; - return *this; - } - volatile cid1_r &set_CID1(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// cid2_r - Component ID byte 2 -struct cid2_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t CID2 : 32; // Byte 2 of Component ID (Lower 8 bits valid) - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR cid2_r() : word0(5) {} - CONSTEXPR cid2_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - cid2_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_CID2() const - { - uint32_t value = word0; - return value; - } - uint32_t get_CID2() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR cid2_r &set_CID2(uint32_t value) - { - word0 = value; - return *this; - } - volatile cid2_r &set_CID2(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// cid3_r - Component ID byte 3 -struct cid3_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t CID3 : 32; // Byte 3 of Component ID (Lower 8 bits valid) - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR cid3_r() : word0(177) {} - CONSTEXPR cid3_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - cid3_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_CID3() const - { - uint32_t value = word0; - return value; - } - uint32_t get_CID3() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR cid3_r &set_CID3(uint32_t value) - { - word0 = value; - return *this; - } - volatile cid3_r &set_CID3(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -struct NPU_REG -{ - STRUCT id_r ID; // 0x0000 - STRUCT status_r STATUS; // 0x0004 - STRUCT cmd_r CMD; // 0x0008 - STRUCT reset_r RESET; // 0x000C - STRUCT qbase_r QBASE; // 0x0010 - STRUCT qread_r QREAD; // 0x0018 - STRUCT qconfig_r QCONFIG; // 0x001C - STRUCT qsize_r QSIZE; // 0x0020 - STRUCT prot_r PROT; // 0x0024 - STRUCT config_r CONFIG; // 0x0028 - STRUCT lock_r LOCK; // 0x002C - uint32_t unused0[3]; - STRUCT regioncfg_r REGIONCFG; // 0x003C - STRUCT axi_limit0_r AXI_LIMIT0; // 0x0040 - STRUCT axi_limit1_r AXI_LIMIT1; // 0x0044 - STRUCT axi_limit2_r AXI_LIMIT2; // 0x0048 - STRUCT axi_limit3_r AXI_LIMIT3; // 0x004C - uint32_t unused1[12]; - STRUCT basep_r BASEP[8]; // 0x0080 - uint32_t unused2[16]; - STRUCT wd_status_r WD_STATUS; // 0x0100 - STRUCT mac_status_r MAC_STATUS; // 0x0104 - STRUCT ao_status_r AO_STATUS; // 0x0108 - uint32_t unused3[1]; - STRUCT dma_status0_r DMA_STATUS0; // 0x0110 - STRUCT dma_status1_r DMA_STATUS1; // 0x0114 - uint32_t unused4[10]; - STRUCT clkforce_r CLKFORCE; // 0x0140 - STRUCT debug_address_r DEBUG_ADDRESS; // 0x0144 - STRUCT debug_misc_r DEBUG_MISC; // 0x0148 - uint32_t unused5[1]; - STRUCT debug_block_r DEBUG_BLOCK; // 0x0150 - uint32_t unused6[11]; - STRUCT pmcr_r PMCR; // 0x0180 - STRUCT pmcntenset_r PMCNTENSET; // 0x0184 - STRUCT pmcntenclr_r PMCNTENCLR; // 0x0188 - STRUCT pmovsset_r PMOVSSET; // 0x018C - STRUCT pmovsclr_r PMOVSCLR; // 0x0190 - STRUCT pmintset_r PMINTSET; // 0x0194 - STRUCT pmintclr_r PMINTCLR; // 0x0198 - uint32_t unused7[1]; - STRUCT pmccntr_r PMCCNTR; // 0x01A0 - STRUCT pmccntr_cfg_r PMCCNTR_CFG; // 0x01A8 - STRUCT pmcaxi_chan_r PMCAXI_CHAN; // 0x01AC - uint32_t unused8[20]; - STRUCT kernel_x_r KERNEL_X; // 0x0200 - STRUCT kernel_y_r KERNEL_Y; // 0x0204 - STRUCT kernel_w_m1_r KERNEL_W_M1; // 0x0208 - STRUCT kernel_h_m1_r KERNEL_H_M1; // 0x020C - STRUCT ofm_cblk_width_m1_r OFM_CBLK_WIDTH_M1; // 0x0210 - STRUCT ofm_cblk_height_m1_r OFM_CBLK_HEIGHT_M1; // 0x0214 - STRUCT ofm_cblk_depth_m1_r OFM_CBLK_DEPTH_M1; // 0x0218 - STRUCT ifm_cblk_depth_m1_r IFM_CBLK_DEPTH_M1; // 0x021C - STRUCT ofm_x_r OFM_X; // 0x0220 - STRUCT ofm_y_r OFM_Y; // 0x0224 - STRUCT ofm_z_r OFM_Z; // 0x0228 - STRUCT ifm_z_r IFM_Z; // 0x022C - STRUCT pad_top_r PAD_TOP; // 0x0230 - STRUCT pad_left_r PAD_LEFT; // 0x0234 - STRUCT ifm_cblk_width_r IFM_CBLK_WIDTH; // 0x0238 - STRUCT ifm_cblk_height_r IFM_CBLK_HEIGHT; // 0x023C - STRUCT dma_ifm_src_r DMA_IFM_SRC; // 0x0240 - STRUCT dma_ifm_dst_r DMA_IFM_DST; // 0x0248 - STRUCT dma_ofm_src_r DMA_OFM_SRC; // 0x024C - STRUCT dma_ofm_dst_r DMA_OFM_DST; // 0x0250 - STRUCT dma_weight_src_r DMA_WEIGHT_SRC; // 0x0258 - STRUCT dma_cmd_src_r DMA_CMD_SRC; // 0x0260 - STRUCT dma_cmd_size_r DMA_CMD_SIZE; // 0x0268 - STRUCT dma_m2m_src_r DMA_M2M_SRC; // 0x026C - STRUCT dma_m2m_dst_r DMA_M2M_DST; // 0x0274 - STRUCT current_qread_r CURRENT_QREAD; // 0x027C - STRUCT dma_scale_src_r DMA_SCALE_SRC; // 0x0280 - uint32_t unused9[11]; - STRUCT current_block_r CURRENT_BLOCK; // 0x02B4 - STRUCT current_op_r CURRENT_OP; // 0x02B8 - STRUCT current_cmd_r CURRENT_CMD; // 0x02BC - uint32_t unused10[16]; - STRUCT pmevcntr_r PMEVCNTR[4]; // 0x0300 - uint32_t unused11[28]; - STRUCT pmevtyper_r PMEVTYPER[4]; // 0x0380 - uint32_t unused12[28]; - STRUCT shared_buffer_r SHARED_BUFFER[256]; // 0x0400 - STRUCT ifm_pad_top_r IFM_PAD_TOP; // 0x0800 - STRUCT ifm_pad_left_r IFM_PAD_LEFT; // 0x0804 - STRUCT ifm_pad_right_r IFM_PAD_RIGHT; // 0x0808 - STRUCT ifm_pad_bottom_r IFM_PAD_BOTTOM; // 0x080C - STRUCT ifm_depth_m1_r IFM_DEPTH_M1; // 0x0810 - STRUCT ifm_precision_r IFM_PRECISION; // 0x0814 - uint32_t unused13[1]; - STRUCT ifm_upscale_r IFM_UPSCALE; // 0x081C - uint32_t unused14[1]; - STRUCT ifm_zero_point_r IFM_ZERO_POINT; // 0x0824 - STRUCT ifm_width0_m1_r IFM_WIDTH0_M1; // 0x0828 - STRUCT ifm_height0_m1_r IFM_HEIGHT0_M1; // 0x082C - STRUCT ifm_height1_m1_r IFM_HEIGHT1_M1; // 0x0830 - STRUCT ifm_ib_end_r IFM_IB_END; // 0x0834 - uint32_t unused15[1]; - STRUCT ifm_region_r IFM_REGION; // 0x083C - uint32_t unused16[1]; - STRUCT ofm_width_m1_r OFM_WIDTH_M1; // 0x0844 - STRUCT ofm_height_m1_r OFM_HEIGHT_M1; // 0x0848 - STRUCT ofm_depth_m1_r OFM_DEPTH_M1; // 0x084C - STRUCT ofm_precision_r OFM_PRECISION; // 0x0850 - STRUCT ofm_blk_width_m1_r OFM_BLK_WIDTH_M1; // 0x0854 - STRUCT ofm_blk_height_m1_r OFM_BLK_HEIGHT_M1; // 0x0858 - STRUCT ofm_blk_depth_m1_r OFM_BLK_DEPTH_M1; // 0x085C - STRUCT ofm_zero_point_r OFM_ZERO_POINT; // 0x0860 - uint32_t unused17[1]; - STRUCT ofm_width0_m1_r OFM_WIDTH0_M1; // 0x0868 - STRUCT ofm_height0_m1_r OFM_HEIGHT0_M1; // 0x086C - STRUCT ofm_height1_m1_r OFM_HEIGHT1_M1; // 0x0870 - uint32_t unused18[2]; - STRUCT ofm_region_r OFM_REGION; // 0x087C - STRUCT kernel_width_m1_r KERNEL_WIDTH_M1; // 0x0880 - STRUCT kernel_height_m1_r KERNEL_HEIGHT_M1; // 0x0884 - STRUCT kernel_stride_r KERNEL_STRIDE; // 0x0888 - uint32_t unused19[1]; - STRUCT acc_format_r ACC_FORMAT; // 0x0890 - STRUCT activation_r ACTIVATION; // 0x0894 - STRUCT activation_min_r ACTIVATION_MIN; // 0x0898 - STRUCT activation_max_r ACTIVATION_MAX; // 0x089C - STRUCT weight_region_r WEIGHT_REGION; // 0x08A0 - STRUCT scale_region_r SCALE_REGION; // 0x08A4 - uint32_t unused20[3]; - STRUCT ab_start_r AB_START; // 0x08B4 - uint32_t unused21[1]; - STRUCT blockdep_r BLOCKDEP; // 0x08BC - STRUCT dma0_src_region_r DMA0_SRC_REGION; // 0x08C0 - STRUCT dma0_dst_region_r DMA0_DST_REGION; // 0x08C4 - STRUCT dma0_size0_r DMA0_SIZE0; // 0x08C8 - STRUCT dma0_size1_r DMA0_SIZE1; // 0x08CC - uint32_t unused22[12]; - STRUCT ifm2_broadcast_r IFM2_BROADCAST; // 0x0900 - STRUCT ifm2_scalar_r IFM2_SCALAR; // 0x0904 - uint32_t unused23[3]; - STRUCT ifm2_precision_r IFM2_PRECISION; // 0x0914 - uint32_t unused24[3]; - STRUCT ifm2_zero_point_r IFM2_ZERO_POINT; // 0x0924 - STRUCT ifm2_width0_m1_r IFM2_WIDTH0_M1; // 0x0928 - STRUCT ifm2_height0_m1_r IFM2_HEIGHT0_M1; // 0x092C - STRUCT ifm2_height1_m1_r IFM2_HEIGHT1_M1; // 0x0930 - STRUCT ifm2_ib_start_r IFM2_IB_START; // 0x0934 - uint32_t unused25[1]; - STRUCT ifm2_region_r IFM2_REGION; // 0x093C - uint32_t unused26[48]; - STRUCT ifm_base0_r IFM_BASE0; // 0x0A00 - STRUCT ifm_base1_r IFM_BASE1; // 0x0A08 - STRUCT ifm_base2_r IFM_BASE2; // 0x0A10 - STRUCT ifm_base3_r IFM_BASE3; // 0x0A18 - STRUCT ifm_stride_x_r IFM_STRIDE_X; // 0x0A20 - STRUCT ifm_stride_y_r IFM_STRIDE_Y; // 0x0A28 - STRUCT ifm_stride_c_r IFM_STRIDE_C; // 0x0A30 - uint32_t unused27[2]; - STRUCT ofm_base0_r OFM_BASE0; // 0x0A40 - STRUCT ofm_base1_r OFM_BASE1; // 0x0A48 - STRUCT ofm_base2_r OFM_BASE2; // 0x0A50 - STRUCT ofm_base3_r OFM_BASE3; // 0x0A58 - STRUCT ofm_stride_x_r OFM_STRIDE_X; // 0x0A60 - STRUCT ofm_stride_y_r OFM_STRIDE_Y; // 0x0A68 - STRUCT ofm_stride_c_r OFM_STRIDE_C; // 0x0A70 - uint32_t unused28[2]; - STRUCT weight_base_r WEIGHT_BASE; // 0x0A80 - STRUCT weight_length_r WEIGHT_LENGTH; // 0x0A88 - STRUCT scale_base_r SCALE_BASE; // 0x0A90 - STRUCT scale_length_r SCALE_LENGTH; // 0x0A98 - STRUCT ofm_scale_r OFM_SCALE; // 0x0AA0 - STRUCT ofm_scale_shift_r OFM_SCALE_SHIFT; // 0x0AA4 - STRUCT opa_scale_r OPA_SCALE; // 0x0AA8 - STRUCT opa_scale_shift_r OPA_SCALE_SHIFT; // 0x0AAC - STRUCT opb_scale_r OPB_SCALE; // 0x0AB0 - uint32_t unused29[3]; - STRUCT dma0_src_r DMA0_SRC; // 0x0AC0 - STRUCT dma0_dst_r DMA0_DST; // 0x0AC8 - STRUCT dma0_len_r DMA0_LEN; // 0x0AD0 - uint32_t unused30[10]; - STRUCT ifm2_base0_r IFM2_BASE0; // 0x0B00 - STRUCT ifm2_base1_r IFM2_BASE1; // 0x0B08 - STRUCT ifm2_base2_r IFM2_BASE2; // 0x0B10 - STRUCT ifm2_base3_r IFM2_BASE3; // 0x0B18 - STRUCT ifm2_stride_x_r IFM2_STRIDE_X; // 0x0B20 - STRUCT ifm2_stride_y_r IFM2_STRIDE_Y; // 0x0B28 - STRUCT ifm2_stride_c_r IFM2_STRIDE_C; // 0x0B30 - uint32_t unused31[18]; - uint32_t USER_DEFINED[16]; // 0x0B80 - uint32_t unused32[256]; - STRUCT revision_r REVISION; // 0x0FC0 - uint32_t unused33[3]; - STRUCT pid4_r PID4; // 0x0FD0 - STRUCT pid5_r PID5; // 0x0FD4 - STRUCT pid6_r PID6; // 0x0FD8 - STRUCT pid7_r PID7; // 0x0FDC - STRUCT pid0_r PID0; // 0x0FE0 - STRUCT pid1_r PID1; // 0x0FE4 - STRUCT pid2_r PID2; // 0x0FE8 - STRUCT pid3_r PID3; // 0x0FEC - STRUCT cid0_r CID0; // 0x0FF0 - STRUCT cid1_r CID1; // 0x0FF4 - STRUCT cid2_r CID2; // 0x0FF8 - STRUCT cid3_r CID3; // 0x0FFC - -#ifdef __cplusplus - enum class access_type_t : uint8_t - { - RW, - RO, - WO - }; - NPU_REG() - { - reset(); - } - void reset() - { - ID = 269500929; - STATUS = 8; - CMD = 12; - RESET = 0; - QBASE = 0; - QREAD = 0; - QCONFIG = 0; - QSIZE = 0; - PROT = 0; - CONFIG = 0; - LOCK = 0; - REGIONCFG = 0; - AXI_LIMIT0 = 0; - AXI_LIMIT1 = 0; - AXI_LIMIT2 = 0; - AXI_LIMIT3 = 0; - for (size_t i = 0; i < (sizeof(BASEP) / sizeof(BASEP[0])); ++i) - BASEP[i] = 0; - WD_STATUS = 0; - MAC_STATUS = 0; - AO_STATUS = 0; - DMA_STATUS0 = 0; - DMA_STATUS1 = 0; - CLKFORCE = 0; - DEBUG_ADDRESS = 0; - DEBUG_MISC = 0; - DEBUG_BLOCK = 0; - PMCR = 8192; - PMCNTENSET = 0; - PMCNTENCLR = 0; - PMOVSSET = 0; - PMOVSCLR = 0; - PMINTSET = 0; - PMINTCLR = 0; - PMCCNTR = 0; - PMCCNTR_CFG = 0; - PMCAXI_CHAN = 0; - KERNEL_X = 0; - KERNEL_Y = 0; - KERNEL_W_M1 = 0; - KERNEL_H_M1 = 0; - OFM_CBLK_WIDTH_M1 = 0; - OFM_CBLK_HEIGHT_M1 = 0; - OFM_CBLK_DEPTH_M1 = 0; - IFM_CBLK_DEPTH_M1 = 0; - OFM_X = 0; - OFM_Y = 0; - OFM_Z = 0; - IFM_Z = 0; - PAD_TOP = 0; - PAD_LEFT = 0; - IFM_CBLK_WIDTH = 0; - IFM_CBLK_HEIGHT = 0; - DMA_IFM_SRC = 0; - DMA_IFM_DST = 0; - DMA_OFM_SRC = 0; - DMA_OFM_DST = 0; - DMA_WEIGHT_SRC = 0; - DMA_CMD_SRC = 0; - DMA_CMD_SIZE = 0; - DMA_M2M_SRC = 0; - DMA_M2M_DST = 0; - CURRENT_QREAD = 0; - DMA_SCALE_SRC = 0; - CURRENT_BLOCK = 0; - CURRENT_OP = 0; - CURRENT_CMD = 0; - for (size_t i = 0; i < (sizeof(PMEVCNTR) / sizeof(PMEVCNTR[0])); ++i) - PMEVCNTR[i] = 0; - for (size_t i = 0; i < (sizeof(PMEVTYPER) / sizeof(PMEVTYPER[0])); ++i) - PMEVTYPER[i] = 0; - for (size_t i = 0; i < (sizeof(SHARED_BUFFER) / sizeof(SHARED_BUFFER[0])); ++i) - SHARED_BUFFER[i] = 0; - IFM_PAD_TOP = 0; - IFM_PAD_LEFT = 0; - IFM_PAD_RIGHT = 0; - IFM_PAD_BOTTOM = 0; - IFM_DEPTH_M1 = 0; - IFM_PRECISION = 0; - IFM_UPSCALE = 0; - IFM_ZERO_POINT = 0; - IFM_WIDTH0_M1 = 0; - IFM_HEIGHT0_M1 = 0; - IFM_HEIGHT1_M1 = 0; - IFM_IB_END = 0; - IFM_REGION = 0; - OFM_WIDTH_M1 = 0; - OFM_HEIGHT_M1 = 0; - OFM_DEPTH_M1 = 0; - OFM_PRECISION = 0; - OFM_BLK_WIDTH_M1 = 0; - OFM_BLK_HEIGHT_M1 = 0; - OFM_BLK_DEPTH_M1 = 0; - OFM_ZERO_POINT = 0; - OFM_WIDTH0_M1 = 0; - OFM_HEIGHT0_M1 = 0; - OFM_HEIGHT1_M1 = 0; - OFM_REGION = 0; - KERNEL_WIDTH_M1 = 0; - KERNEL_HEIGHT_M1 = 0; - KERNEL_STRIDE = 0; - ACC_FORMAT = 0; - ACTIVATION = 0; - ACTIVATION_MIN = 0; - ACTIVATION_MAX = 0; - WEIGHT_REGION = 0; - SCALE_REGION = 0; - AB_START = 0; - BLOCKDEP = 0; - DMA0_SRC_REGION = 0; - DMA0_DST_REGION = 0; - DMA0_SIZE0 = 0; - DMA0_SIZE1 = 0; - IFM2_BROADCAST = 0; - IFM2_SCALAR = 0; - IFM2_PRECISION = 0; - IFM2_ZERO_POINT = 0; - IFM2_WIDTH0_M1 = 0; - IFM2_HEIGHT0_M1 = 0; - IFM2_HEIGHT1_M1 = 0; - IFM2_IB_START = 0; - IFM2_REGION = 0; - IFM_BASE0 = 0; - IFM_BASE1 = 0; - IFM_BASE2 = 0; - IFM_BASE3 = 0; - IFM_STRIDE_X = 0; - IFM_STRIDE_Y = 0; - IFM_STRIDE_C = 0; - OFM_BASE0 = 0; - OFM_BASE1 = 0; - OFM_BASE2 = 0; - OFM_BASE3 = 0; - OFM_STRIDE_X = 0; - OFM_STRIDE_Y = 0; - OFM_STRIDE_C = 0; - WEIGHT_BASE = 0; - WEIGHT_LENGTH = 0; - SCALE_BASE = 0; - SCALE_LENGTH = 0; - OFM_SCALE = 0; - OFM_SCALE_SHIFT = 0; - OPA_SCALE = 0; - OPA_SCALE_SHIFT = 0; - OPB_SCALE = 0; - DMA0_SRC = 0; - DMA0_DST = 0; - DMA0_LEN = 0; - IFM2_BASE0 = 0; - IFM2_BASE1 = 0; - IFM2_BASE2 = 0; - IFM2_BASE3 = 0; - IFM2_STRIDE_X = 0; - IFM2_STRIDE_Y = 0; - IFM2_STRIDE_C = 0; - for (size_t i = 0; i < (sizeof(USER_DEFINED) / sizeof(USER_DEFINED[0])); ++i) - USER_DEFINED[i] = 0; - REVISION = 0; - PID4 = 4; - PID5 = 0; - PID6 = 0; - PID7 = 0; - PID0 = 128; - PID1 = 181; - PID2 = 11; - PID3 = 0; - CID0 = 13; - CID1 = 240; - CID2 = 5; - CID3 = 177; - } - uint32_t &operator[](const int addr_offset) - { - return reinterpret_cast(this)[addr_offset / 4]; - } - access_type_t get_access_type(uint32_t offset) - { - switch (offset) - { - case 0: - return access_type_t::RO; - case 4: - return access_type_t::RO; - case 8: - return access_type_t::RW; - case 12: - return access_type_t::RW; - case 16: - return access_type_t::RW; - case 24: - return access_type_t::RO; - case 28: - return access_type_t::RW; - case 32: - return access_type_t::RW; - case 36: - return access_type_t::RO; - case 40: - return access_type_t::RO; - case 44: - return access_type_t::RW; - case 60: - return access_type_t::RW; - case 64: - return access_type_t::RW; - case 68: - return access_type_t::RW; - case 72: - return access_type_t::RW; - case 76: - return access_type_t::RW; - case 128: - return access_type_t::RW; - case 136: - return access_type_t::RW; - case 144: - return access_type_t::RW; - case 152: - return access_type_t::RW; - case 160: - return access_type_t::RW; - case 168: - return access_type_t::RW; - case 176: - return access_type_t::RW; - case 184: - return access_type_t::RW; - case 256: - return access_type_t::RO; - case 260: - return access_type_t::RO; - case 264: - return access_type_t::RO; - case 272: - return access_type_t::RO; - case 276: - return access_type_t::RO; - case 320: - return access_type_t::RW; - case 324: - return access_type_t::RW; - case 328: - return access_type_t::RW; - case 336: - return access_type_t::RW; - case 384: - return access_type_t::RW; - case 388: - return access_type_t::RW; - case 392: - return access_type_t::RW; - case 396: - return access_type_t::RW; - case 400: - return access_type_t::RW; - case 404: - return access_type_t::RW; - case 408: - return access_type_t::RW; - case 416: - return access_type_t::RW; - case 424: - return access_type_t::RW; - case 428: - return access_type_t::RW; - case 512: - return access_type_t::RO; - case 516: - return access_type_t::RO; - case 520: - return access_type_t::RO; - case 524: - return access_type_t::RO; - case 528: - return access_type_t::RO; - case 532: - return access_type_t::RO; - case 536: - return access_type_t::RO; - case 540: - return access_type_t::RO; - case 544: - return access_type_t::RO; - case 548: - return access_type_t::RO; - case 552: - return access_type_t::RO; - case 556: - return access_type_t::RO; - case 560: - return access_type_t::RO; - case 564: - return access_type_t::RO; - case 568: - return access_type_t::RO; - case 572: - return access_type_t::RO; - case 576: - return access_type_t::RO; - case 584: - return access_type_t::RO; - case 588: - return access_type_t::RO; - case 592: - return access_type_t::RO; - case 600: - return access_type_t::RO; - case 608: - return access_type_t::RO; - case 616: - return access_type_t::RO; - case 620: - return access_type_t::RO; - case 628: - return access_type_t::RO; - case 636: - return access_type_t::RO; - case 640: - return access_type_t::RO; - case 692: - return access_type_t::RO; - case 696: - return access_type_t::RO; - case 700: - return access_type_t::RO; - case 768: - return access_type_t::RW; - case 772: - return access_type_t::RW; - case 776: - return access_type_t::RW; - case 780: - return access_type_t::RW; - case 896: - return access_type_t::RW; - case 900: - return access_type_t::RW; - case 904: - return access_type_t::RW; - case 908: - return access_type_t::RW; - case 1024: - return access_type_t::RW; - case 1028: - return access_type_t::RW; - case 1032: - return access_type_t::RW; - case 1036: - return access_type_t::RW; - case 1040: - return access_type_t::RW; - case 1044: - return access_type_t::RW; - case 1048: - return access_type_t::RW; - case 1052: - return access_type_t::RW; - case 1056: - return access_type_t::RW; - case 1060: - return access_type_t::RW; - case 1064: - return access_type_t::RW; - case 1068: - return access_type_t::RW; - case 1072: - return access_type_t::RW; - case 1076: - return access_type_t::RW; - case 1080: - return access_type_t::RW; - case 1084: - return access_type_t::RW; - case 1088: - return access_type_t::RW; - case 1092: - return access_type_t::RW; - case 1096: - return access_type_t::RW; - case 1100: - return access_type_t::RW; - case 1104: - return access_type_t::RW; - case 1108: - return access_type_t::RW; - case 1112: - return access_type_t::RW; - case 1116: - return access_type_t::RW; - case 1120: - return access_type_t::RW; - case 1124: - return access_type_t::RW; - case 1128: - return access_type_t::RW; - case 1132: - return access_type_t::RW; - case 1136: - return access_type_t::RW; - case 1140: - return access_type_t::RW; - case 1144: - return access_type_t::RW; - case 1148: - return access_type_t::RW; - case 1152: - return access_type_t::RW; - case 1156: - return access_type_t::RW; - case 1160: - return access_type_t::RW; - case 1164: - return access_type_t::RW; - case 1168: - return access_type_t::RW; - case 1172: - return access_type_t::RW; - case 1176: - return access_type_t::RW; - case 1180: - return access_type_t::RW; - case 1184: - return access_type_t::RW; - case 1188: - return access_type_t::RW; - case 1192: - return access_type_t::RW; - case 1196: - return access_type_t::RW; - case 1200: - return access_type_t::RW; - case 1204: - return access_type_t::RW; - case 1208: - return access_type_t::RW; - case 1212: - return access_type_t::RW; - case 1216: - return access_type_t::RW; - case 1220: - return access_type_t::RW; - case 1224: - return access_type_t::RW; - case 1228: - return access_type_t::RW; - case 1232: - return access_type_t::RW; - case 1236: - return access_type_t::RW; - case 1240: - return access_type_t::RW; - case 1244: - return access_type_t::RW; - case 1248: - return access_type_t::RW; - case 1252: - return access_type_t::RW; - case 1256: - return access_type_t::RW; - case 1260: - return access_type_t::RW; - case 1264: - return access_type_t::RW; - case 1268: - return access_type_t::RW; - case 1272: - return access_type_t::RW; - case 1276: - return access_type_t::RW; - case 1280: - return access_type_t::RW; - case 1284: - return access_type_t::RW; - case 1288: - return access_type_t::RW; - case 1292: - return access_type_t::RW; - case 1296: - return access_type_t::RW; - case 1300: - return access_type_t::RW; - case 1304: - return access_type_t::RW; - case 1308: - return access_type_t::RW; - case 1312: - return access_type_t::RW; - case 1316: - return access_type_t::RW; - case 1320: - return access_type_t::RW; - case 1324: - return access_type_t::RW; - case 1328: - return access_type_t::RW; - case 1332: - return access_type_t::RW; - case 1336: - return access_type_t::RW; - case 1340: - return access_type_t::RW; - case 1344: - return access_type_t::RW; - case 1348: - return access_type_t::RW; - case 1352: - return access_type_t::RW; - case 1356: - return access_type_t::RW; - case 1360: - return access_type_t::RW; - case 1364: - return access_type_t::RW; - case 1368: - return access_type_t::RW; - case 1372: - return access_type_t::RW; - case 1376: - return access_type_t::RW; - case 1380: - return access_type_t::RW; - case 1384: - return access_type_t::RW; - case 1388: - return access_type_t::RW; - case 1392: - return access_type_t::RW; - case 1396: - return access_type_t::RW; - case 1400: - return access_type_t::RW; - case 1404: - return access_type_t::RW; - case 1408: - return access_type_t::RW; - case 1412: - return access_type_t::RW; - case 1416: - return access_type_t::RW; - case 1420: - return access_type_t::RW; - case 1424: - return access_type_t::RW; - case 1428: - return access_type_t::RW; - case 1432: - return access_type_t::RW; - case 1436: - return access_type_t::RW; - case 1440: - return access_type_t::RW; - case 1444: - return access_type_t::RW; - case 1448: - return access_type_t::RW; - case 1452: - return access_type_t::RW; - case 1456: - return access_type_t::RW; - case 1460: - return access_type_t::RW; - case 1464: - return access_type_t::RW; - case 1468: - return access_type_t::RW; - case 1472: - return access_type_t::RW; - case 1476: - return access_type_t::RW; - case 1480: - return access_type_t::RW; - case 1484: - return access_type_t::RW; - case 1488: - return access_type_t::RW; - case 1492: - return access_type_t::RW; - case 1496: - return access_type_t::RW; - case 1500: - return access_type_t::RW; - case 1504: - return access_type_t::RW; - case 1508: - return access_type_t::RW; - case 1512: - return access_type_t::RW; - case 1516: - return access_type_t::RW; - case 1520: - return access_type_t::RW; - case 1524: - return access_type_t::RW; - case 1528: - return access_type_t::RW; - case 1532: - return access_type_t::RW; - case 1536: - return access_type_t::RW; - case 1540: - return access_type_t::RW; - case 1544: - return access_type_t::RW; - case 1548: - return access_type_t::RW; - case 1552: - return access_type_t::RW; - case 1556: - return access_type_t::RW; - case 1560: - return access_type_t::RW; - case 1564: - return access_type_t::RW; - case 1568: - return access_type_t::RW; - case 1572: - return access_type_t::RW; - case 1576: - return access_type_t::RW; - case 1580: - return access_type_t::RW; - case 1584: - return access_type_t::RW; - case 1588: - return access_type_t::RW; - case 1592: - return access_type_t::RW; - case 1596: - return access_type_t::RW; - case 1600: - return access_type_t::RW; - case 1604: - return access_type_t::RW; - case 1608: - return access_type_t::RW; - case 1612: - return access_type_t::RW; - case 1616: - return access_type_t::RW; - case 1620: - return access_type_t::RW; - case 1624: - return access_type_t::RW; - case 1628: - return access_type_t::RW; - case 1632: - return access_type_t::RW; - case 1636: - return access_type_t::RW; - case 1640: - return access_type_t::RW; - case 1644: - return access_type_t::RW; - case 1648: - return access_type_t::RW; - case 1652: - return access_type_t::RW; - case 1656: - return access_type_t::RW; - case 1660: - return access_type_t::RW; - case 1664: - return access_type_t::RW; - case 1668: - return access_type_t::RW; - case 1672: - return access_type_t::RW; - case 1676: - return access_type_t::RW; - case 1680: - return access_type_t::RW; - case 1684: - return access_type_t::RW; - case 1688: - return access_type_t::RW; - case 1692: - return access_type_t::RW; - case 1696: - return access_type_t::RW; - case 1700: - return access_type_t::RW; - case 1704: - return access_type_t::RW; - case 1708: - return access_type_t::RW; - case 1712: - return access_type_t::RW; - case 1716: - return access_type_t::RW; - case 1720: - return access_type_t::RW; - case 1724: - return access_type_t::RW; - case 1728: - return access_type_t::RW; - case 1732: - return access_type_t::RW; - case 1736: - return access_type_t::RW; - case 1740: - return access_type_t::RW; - case 1744: - return access_type_t::RW; - case 1748: - return access_type_t::RW; - case 1752: - return access_type_t::RW; - case 1756: - return access_type_t::RW; - case 1760: - return access_type_t::RW; - case 1764: - return access_type_t::RW; - case 1768: - return access_type_t::RW; - case 1772: - return access_type_t::RW; - case 1776: - return access_type_t::RW; - case 1780: - return access_type_t::RW; - case 1784: - return access_type_t::RW; - case 1788: - return access_type_t::RW; - case 1792: - return access_type_t::RW; - case 1796: - return access_type_t::RW; - case 1800: - return access_type_t::RW; - case 1804: - return access_type_t::RW; - case 1808: - return access_type_t::RW; - case 1812: - return access_type_t::RW; - case 1816: - return access_type_t::RW; - case 1820: - return access_type_t::RW; - case 1824: - return access_type_t::RW; - case 1828: - return access_type_t::RW; - case 1832: - return access_type_t::RW; - case 1836: - return access_type_t::RW; - case 1840: - return access_type_t::RW; - case 1844: - return access_type_t::RW; - case 1848: - return access_type_t::RW; - case 1852: - return access_type_t::RW; - case 1856: - return access_type_t::RW; - case 1860: - return access_type_t::RW; - case 1864: - return access_type_t::RW; - case 1868: - return access_type_t::RW; - case 1872: - return access_type_t::RW; - case 1876: - return access_type_t::RW; - case 1880: - return access_type_t::RW; - case 1884: - return access_type_t::RW; - case 1888: - return access_type_t::RW; - case 1892: - return access_type_t::RW; - case 1896: - return access_type_t::RW; - case 1900: - return access_type_t::RW; - case 1904: - return access_type_t::RW; - case 1908: - return access_type_t::RW; - case 1912: - return access_type_t::RW; - case 1916: - return access_type_t::RW; - case 1920: - return access_type_t::RW; - case 1924: - return access_type_t::RW; - case 1928: - return access_type_t::RW; - case 1932: - return access_type_t::RW; - case 1936: - return access_type_t::RW; - case 1940: - return access_type_t::RW; - case 1944: - return access_type_t::RW; - case 1948: - return access_type_t::RW; - case 1952: - return access_type_t::RW; - case 1956: - return access_type_t::RW; - case 1960: - return access_type_t::RW; - case 1964: - return access_type_t::RW; - case 1968: - return access_type_t::RW; - case 1972: - return access_type_t::RW; - case 1976: - return access_type_t::RW; - case 1980: - return access_type_t::RW; - case 1984: - return access_type_t::RW; - case 1988: - return access_type_t::RW; - case 1992: - return access_type_t::RW; - case 1996: - return access_type_t::RW; - case 2000: - return access_type_t::RW; - case 2004: - return access_type_t::RW; - case 2008: - return access_type_t::RW; - case 2012: - return access_type_t::RW; - case 2016: - return access_type_t::RW; - case 2020: - return access_type_t::RW; - case 2024: - return access_type_t::RW; - case 2028: - return access_type_t::RW; - case 2032: - return access_type_t::RW; - case 2036: - return access_type_t::RW; - case 2040: - return access_type_t::RW; - case 2044: - return access_type_t::RW; - case 2048: - return access_type_t::RW; - case 2052: - return access_type_t::RW; - case 2056: - return access_type_t::RW; - case 2060: - return access_type_t::RW; - case 2064: - return access_type_t::RW; - case 2068: - return access_type_t::RW; - case 2076: - return access_type_t::RW; - case 2084: - return access_type_t::RW; - case 2088: - return access_type_t::RW; - case 2092: - return access_type_t::RW; - case 2096: - return access_type_t::RW; - case 2100: - return access_type_t::RW; - case 2108: - return access_type_t::RW; - case 2116: - return access_type_t::RW; - case 2120: - return access_type_t::RW; - case 2124: - return access_type_t::RW; - case 2128: - return access_type_t::RW; - case 2132: - return access_type_t::RW; - case 2136: - return access_type_t::RW; - case 2140: - return access_type_t::RW; - case 2144: - return access_type_t::RW; - case 2152: - return access_type_t::RW; - case 2156: - return access_type_t::RW; - case 2160: - return access_type_t::RW; - case 2172: - return access_type_t::RW; - case 2176: - return access_type_t::RW; - case 2180: - return access_type_t::RW; - case 2184: - return access_type_t::RW; - case 2192: - return access_type_t::RW; - case 2196: - return access_type_t::RW; - case 2200: - return access_type_t::RW; - case 2204: - return access_type_t::RW; - case 2208: - return access_type_t::RW; - case 2212: - return access_type_t::RW; - case 2228: - return access_type_t::RW; - case 2236: - return access_type_t::RW; - case 2240: - return access_type_t::RW; - case 2244: - return access_type_t::RW; - case 2248: - return access_type_t::RW; - case 2252: - return access_type_t::RW; - case 2304: - return access_type_t::RW; - case 2308: - return access_type_t::RW; - case 2324: - return access_type_t::RW; - case 2340: - return access_type_t::RW; - case 2344: - return access_type_t::RW; - case 2348: - return access_type_t::RW; - case 2352: - return access_type_t::RW; - case 2356: - return access_type_t::RW; - case 2364: - return access_type_t::RW; - case 2560: - return access_type_t::RW; - case 2568: - return access_type_t::RW; - case 2576: - return access_type_t::RW; - case 2584: - return access_type_t::RW; - case 2592: - return access_type_t::RW; - case 2600: - return access_type_t::RW; - case 2608: - return access_type_t::RW; - case 2624: - return access_type_t::RW; - case 2632: - return access_type_t::RW; - case 2640: - return access_type_t::RW; - case 2648: - return access_type_t::RW; - case 2656: - return access_type_t::RW; - case 2664: - return access_type_t::RW; - case 2672: - return access_type_t::RW; - case 2688: - return access_type_t::RW; - case 2696: - return access_type_t::RW; - case 2704: - return access_type_t::RW; - case 2712: - return access_type_t::RW; - case 2720: - return access_type_t::RW; - case 2724: - return access_type_t::RW; - case 2728: - return access_type_t::RW; - case 2732: - return access_type_t::RW; - case 2736: - return access_type_t::RW; - case 2752: - return access_type_t::RW; - case 2760: - return access_type_t::RW; - case 2768: - return access_type_t::RW; - case 2816: - return access_type_t::RW; - case 2824: - return access_type_t::RW; - case 2832: - return access_type_t::RW; - case 2840: - return access_type_t::RW; - case 2848: - return access_type_t::RW; - case 2856: - return access_type_t::RW; - case 2864: - return access_type_t::RW; - case 2944: - return access_type_t::RW; - case 2952: - return access_type_t::RW; - case 2960: - return access_type_t::RW; - case 2968: - return access_type_t::RW; - case 2976: - return access_type_t::RW; - case 2984: - return access_type_t::RW; - case 2992: - return access_type_t::RW; - case 3000: - return access_type_t::RW; - case 4032: - return access_type_t::RO; - case 4048: - return access_type_t::RO; - case 4052: - return access_type_t::RO; - case 4056: - return access_type_t::RO; - case 4060: - return access_type_t::RO; - case 4064: - return access_type_t::RO; - case 4068: - return access_type_t::RO; - case 4072: - return access_type_t::RO; - case 4076: - return access_type_t::RO; - case 4080: - return access_type_t::RO; - case 4084: - return access_type_t::RO; - case 4088: - return access_type_t::RO; - case 4092: - return access_type_t::RO; - default: - return access_type_t::RO; - } - } -#endif -}; - -#ifdef __cplusplus -struct isa -{ -#ifdef NPU_DISASSEMBLE - static int disassemble(const uint32_t *in, - std::string &op, - std::vector> &fields) - { - switch (*in & 0xffff) - { - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_STOP): - { - const npu_op_stop_t &v = *reinterpret_cast(in); - op = "NPU_OP_STOP"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_IRQ): - { - const npu_op_irq_t &v = *reinterpret_cast(in); - op = "NPU_OP_IRQ"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_CONV): - { - const npu_op_conv_t &v = *reinterpret_cast(in); - op = "NPU_OP_CONV"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_DEPTHWISE): - { - const npu_op_depthwise_t &v = *reinterpret_cast(in); - op = "NPU_OP_DEPTHWISE"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_POOL): - { - const npu_op_pool_t &v = *reinterpret_cast(in); - op = "NPU_OP_POOL"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_ELEMENTWISE): - { - const npu_op_elementwise_t &v = *reinterpret_cast(in); - op = "NPU_OP_ELEMENTWISE"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_DMA_START): - { - const npu_op_dma_start_t &v = *reinterpret_cast(in); - op = "NPU_OP_DMA_START"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_DMA_WAIT): - { - const npu_op_dma_wait_t &v = *reinterpret_cast(in); - op = "NPU_OP_DMA_WAIT"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_KERNEL_WAIT): - { - const npu_op_kernel_wait_t &v = *reinterpret_cast(in); - op = "NPU_OP_KERNEL_WAIT"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_PMU_MASK): - { - const npu_op_pmu_mask_t &v = *reinterpret_cast(in); - op = "NPU_OP_PMU_MASK"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PAD_TOP): - { - const npu_set_ifm_pad_top_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM_PAD_TOP"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PAD_LEFT): - { - const npu_set_ifm_pad_left_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM_PAD_LEFT"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PAD_RIGHT): - { - const npu_set_ifm_pad_right_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM_PAD_RIGHT"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PAD_BOTTOM): - { - const npu_set_ifm_pad_bottom_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM_PAD_BOTTOM"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_DEPTH_M1): - { - const npu_set_ifm_depth_m1_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM_DEPTH_M1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PRECISION): - { - const npu_set_ifm_precision_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM_PRECISION"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_UPSCALE): - { - const npu_set_ifm_upscale_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM_UPSCALE"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_ZERO_POINT): - { - const npu_set_ifm_zero_point_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM_ZERO_POINT"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_WIDTH0_M1): - { - const npu_set_ifm_width0_m1_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM_WIDTH0_M1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_HEIGHT0_M1): - { - const npu_set_ifm_height0_m1_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM_HEIGHT0_M1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_HEIGHT1_M1): - { - const npu_set_ifm_height1_m1_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM_HEIGHT1_M1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_IB_END): - { - const npu_set_ifm_ib_end_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM_IB_END"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_REGION): - { - const npu_set_ifm_region_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM_REGION"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_WIDTH_M1): - { - const npu_set_ofm_width_m1_t &v = *reinterpret_cast(in); - op = "NPU_SET_OFM_WIDTH_M1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_HEIGHT_M1): - { - const npu_set_ofm_height_m1_t &v = *reinterpret_cast(in); - op = "NPU_SET_OFM_HEIGHT_M1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_DEPTH_M1): - { - const npu_set_ofm_depth_m1_t &v = *reinterpret_cast(in); - op = "NPU_SET_OFM_DEPTH_M1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_PRECISION): - { - const npu_set_ofm_precision_t &v = *reinterpret_cast(in); - op = "NPU_SET_OFM_PRECISION"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_BLK_WIDTH_M1): - { - const npu_set_ofm_blk_width_m1_t &v = *reinterpret_cast(in); - op = "NPU_SET_OFM_BLK_WIDTH_M1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_BLK_HEIGHT_M1): - { - const npu_set_ofm_blk_height_m1_t &v = *reinterpret_cast(in); - op = "NPU_SET_OFM_BLK_HEIGHT_M1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_BLK_DEPTH_M1): - { - const npu_set_ofm_blk_depth_m1_t &v = *reinterpret_cast(in); - op = "NPU_SET_OFM_BLK_DEPTH_M1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_ZERO_POINT): - { - const npu_set_ofm_zero_point_t &v = *reinterpret_cast(in); - op = "NPU_SET_OFM_ZERO_POINT"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_WIDTH0_M1): - { - const npu_set_ofm_width0_m1_t &v = *reinterpret_cast(in); - op = "NPU_SET_OFM_WIDTH0_M1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_HEIGHT0_M1): - { - const npu_set_ofm_height0_m1_t &v = *reinterpret_cast(in); - op = "NPU_SET_OFM_HEIGHT0_M1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_HEIGHT1_M1): - { - const npu_set_ofm_height1_m1_t &v = *reinterpret_cast(in); - op = "NPU_SET_OFM_HEIGHT1_M1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_REGION): - { - const npu_set_ofm_region_t &v = *reinterpret_cast(in); - op = "NPU_SET_OFM_REGION"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_KERNEL_WIDTH_M1): - { - const npu_set_kernel_width_m1_t &v = *reinterpret_cast(in); - op = "NPU_SET_KERNEL_WIDTH_M1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_KERNEL_HEIGHT_M1): - { - const npu_set_kernel_height_m1_t &v = *reinterpret_cast(in); - op = "NPU_SET_KERNEL_HEIGHT_M1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_KERNEL_STRIDE): - { - const npu_set_kernel_stride_t &v = *reinterpret_cast(in); - op = "NPU_SET_KERNEL_STRIDE"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_ACC_FORMAT): - { - const npu_set_acc_format_t &v = *reinterpret_cast(in); - op = "NPU_SET_ACC_FORMAT"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_ACTIVATION): - { - const npu_set_activation_t &v = *reinterpret_cast(in); - op = "NPU_SET_ACTIVATION"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_ACTIVATION_MIN): - { - const npu_set_activation_min_t &v = *reinterpret_cast(in); - op = "NPU_SET_ACTIVATION_MIN"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_ACTIVATION_MAX): - { - const npu_set_activation_max_t &v = *reinterpret_cast(in); - op = "NPU_SET_ACTIVATION_MAX"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_WEIGHT_REGION): - { - const npu_set_weight_region_t &v = *reinterpret_cast(in); - op = "NPU_SET_WEIGHT_REGION"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_SCALE_REGION): - { - const npu_set_scale_region_t &v = *reinterpret_cast(in); - op = "NPU_SET_SCALE_REGION"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_AB_START): - { - const npu_set_ab_start_t &v = *reinterpret_cast(in); - op = "NPU_SET_AB_START"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_BLOCKDEP): - { - const npu_set_blockdep_t &v = *reinterpret_cast(in); - op = "NPU_SET_BLOCKDEP"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_SRC_REGION): - { - const npu_set_dma0_src_region_t &v = *reinterpret_cast(in); - op = "NPU_SET_DMA0_SRC_REGION"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_DST_REGION): - { - const npu_set_dma0_dst_region_t &v = *reinterpret_cast(in); - op = "NPU_SET_DMA0_DST_REGION"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_SIZE0): - { - const npu_set_dma0_size0_t &v = *reinterpret_cast(in); - op = "NPU_SET_DMA0_SIZE0"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_SIZE1): - { - const npu_set_dma0_size1_t &v = *reinterpret_cast(in); - op = "NPU_SET_DMA0_SIZE1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_BROADCAST): - { - const npu_set_ifm2_broadcast_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM2_BROADCAST"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_SCALAR): - { - const npu_set_ifm2_scalar_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM2_SCALAR"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_PRECISION): - { - const npu_set_ifm2_precision_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM2_PRECISION"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_ZERO_POINT): - { - const npu_set_ifm2_zero_point_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM2_ZERO_POINT"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_WIDTH0_M1): - { - const npu_set_ifm2_width0_m1_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM2_WIDTH0_M1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_HEIGHT0_M1): - { - const npu_set_ifm2_height0_m1_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM2_HEIGHT0_M1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_HEIGHT1_M1): - { - const npu_set_ifm2_height1_m1_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM2_HEIGHT1_M1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_IB_START): - { - const npu_set_ifm2_ib_start_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM2_IB_START"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_REGION): - { - const npu_set_ifm2_region_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM2_REGION"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_BASE0): - { - const npu_set_ifm_base0_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM_BASE0"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_BASE1): - { - const npu_set_ifm_base1_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM_BASE1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_BASE2): - { - const npu_set_ifm_base2_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM_BASE2"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_BASE3): - { - const npu_set_ifm_base3_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM_BASE3"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_STRIDE_X): - { - const npu_set_ifm_stride_x_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM_STRIDE_X"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_STRIDE_Y): - { - const npu_set_ifm_stride_y_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM_STRIDE_Y"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_STRIDE_C): - { - const npu_set_ifm_stride_c_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM_STRIDE_C"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_BASE0): - { - const npu_set_ofm_base0_t &v = *reinterpret_cast(in); - op = "NPU_SET_OFM_BASE0"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_BASE1): - { - const npu_set_ofm_base1_t &v = *reinterpret_cast(in); - op = "NPU_SET_OFM_BASE1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_BASE2): - { - const npu_set_ofm_base2_t &v = *reinterpret_cast(in); - op = "NPU_SET_OFM_BASE2"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_BASE3): - { - const npu_set_ofm_base3_t &v = *reinterpret_cast(in); - op = "NPU_SET_OFM_BASE3"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_STRIDE_X): - { - const npu_set_ofm_stride_x_t &v = *reinterpret_cast(in); - op = "NPU_SET_OFM_STRIDE_X"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_STRIDE_Y): - { - const npu_set_ofm_stride_y_t &v = *reinterpret_cast(in); - op = "NPU_SET_OFM_STRIDE_Y"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_STRIDE_C): - { - const npu_set_ofm_stride_c_t &v = *reinterpret_cast(in); - op = "NPU_SET_OFM_STRIDE_C"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT_BASE): - { - const npu_set_weight_base_t &v = *reinterpret_cast(in); - op = "NPU_SET_WEIGHT_BASE"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT_LENGTH): - { - const npu_set_weight_length_t &v = *reinterpret_cast(in); - op = "NPU_SET_WEIGHT_LENGTH"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_SCALE_BASE): - { - const npu_set_scale_base_t &v = *reinterpret_cast(in); - op = "NPU_SET_SCALE_BASE"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_SCALE_LENGTH): - { - const npu_set_scale_length_t &v = *reinterpret_cast(in); - op = "NPU_SET_SCALE_LENGTH"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_SCALE): - { - const npu_set_ofm_scale_t &v = *reinterpret_cast(in); - op = "NPU_SET_OFM_SCALE"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OPA_SCALE): - { - const npu_set_opa_scale_t &v = *reinterpret_cast(in); - op = "NPU_SET_OPA_SCALE"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OPB_SCALE): - { - const npu_set_opb_scale_t &v = *reinterpret_cast(in); - op = "NPU_SET_OPB_SCALE"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_SRC): - { - const npu_set_dma0_src_t &v = *reinterpret_cast(in); - op = "NPU_SET_DMA0_SRC"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_DST): - { - const npu_set_dma0_dst_t &v = *reinterpret_cast(in); - op = "NPU_SET_DMA0_DST"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_LEN): - { - const npu_set_dma0_len_t &v = *reinterpret_cast(in); - op = "NPU_SET_DMA0_LEN"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_BASE0): - { - const npu_set_ifm2_base0_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM2_BASE0"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_BASE1): - { - const npu_set_ifm2_base1_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM2_BASE1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_BASE2): - { - const npu_set_ifm2_base2_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM2_BASE2"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_BASE3): - { - const npu_set_ifm2_base3_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM2_BASE3"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_STRIDE_X): - { - const npu_set_ifm2_stride_x_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM2_STRIDE_X"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_STRIDE_Y): - { - const npu_set_ifm2_stride_y_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM2_STRIDE_Y"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_STRIDE_C): - { - const npu_set_ifm2_stride_c_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM2_STRIDE_C"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_USER_DEFINED0): - { - const npu_set_user_defined0_t &v = *reinterpret_cast(in); - op = "NPU_SET_USER_DEFINED0"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_USER_DEFINED1): - { - const npu_set_user_defined1_t &v = *reinterpret_cast(in); - op = "NPU_SET_USER_DEFINED1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_USER_DEFINED2): - { - const npu_set_user_defined2_t &v = *reinterpret_cast(in); - op = "NPU_SET_USER_DEFINED2"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_USER_DEFINED3): - { - const npu_set_user_defined3_t &v = *reinterpret_cast(in); - op = "NPU_SET_USER_DEFINED3"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_USER_DEFINED4): - { - const npu_set_user_defined4_t &v = *reinterpret_cast(in); - op = "NPU_SET_USER_DEFINED4"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_USER_DEFINED5): - { - const npu_set_user_defined5_t &v = *reinterpret_cast(in); - op = "NPU_SET_USER_DEFINED5"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_USER_DEFINED6): - { - const npu_set_user_defined6_t &v = *reinterpret_cast(in); - op = "NPU_SET_USER_DEFINED6"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_USER_DEFINED7): - { - const npu_set_user_defined7_t &v = *reinterpret_cast(in); - op = "NPU_SET_USER_DEFINED7"; - v.disassemble(fields); - break; - } - } - return (*in & (3 << 14)) != 0 ? 2 : 1; - } -#endif -#endif - // Signal the end of command stream - struct npu_op_stop_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t mask : 16; // Encoding for 16-bit mask value -#ifdef __cplusplus - public: - npu_op_stop_t(uint32_t _mask) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_STOP)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), mask(_mask & ((1U << 16) - 1)) - { - } - CONSTEXPR npu_op_stop_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_STOP)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), mask(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_STOP) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_STOP); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_op_stop_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_op_stop_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_mask() const - { - return static_cast(mask); - } - CONSTEXPR npu_op_stop_t &set_mask(uint32_t value) - { - mask = static_cast(value) & ((1U << 16) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("mask", std::to_string(mask))); - } -#endif -#endif - }; - // Raises an IRQ to the host - struct npu_op_irq_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t mask : 16; // Encoding for 16-bit mask value -#ifdef __cplusplus - public: - npu_op_irq_t(uint32_t _mask) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_IRQ)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), mask(_mask & ((1U << 16) - 1)) - { - } - CONSTEXPR npu_op_irq_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_IRQ)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), mask(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_IRQ) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_IRQ); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_op_irq_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_op_irq_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_mask() const - { - return static_cast(mask); - } - CONSTEXPR npu_op_irq_t &set_mask(uint32_t value) - { - mask = static_cast(value) & ((1U << 16) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("mask", std::to_string(mask))); - } -#endif -#endif - }; - // 2D convolution - struct npu_op_conv_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t reserved1 : 16; -#ifdef __cplusplus - public: - CONSTEXPR npu_op_conv_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_CONV)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), reserved1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_CONV) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_CONV); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_op_conv_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_op_conv_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const {} -#endif -#endif - }; - // Depth-wise 2D convolution - struct npu_op_depthwise_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t reserved1 : 16; -#ifdef __cplusplus - public: - CONSTEXPR npu_op_depthwise_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_DEPTHWISE)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), reserved1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_DEPTHWISE) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_DEPTHWISE); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_op_depthwise_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_op_depthwise_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const {} -#endif -#endif - }; - // Pooling - struct npu_op_pool_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t pooling_mode : 3; // Pooling mode - uint32_t reserved1 : 13; -#ifdef __cplusplus - public: - npu_op_pool_t(NPU_NAMESPACE::pooling_mode _pooling_mode) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_POOL)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - pooling_mode(static_cast(_pooling_mode) & ((1U << 3) - 1)), reserved1(0) - { - } - CONSTEXPR npu_op_pool_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_POOL)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), pooling_mode(0), reserved1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_POOL) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_POOL); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_op_pool_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_op_pool_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::pooling_mode get_pooling_mode() const - { - return static_cast(pooling_mode); - } - CONSTEXPR npu_op_pool_t &set_pooling_mode(NPU_NAMESPACE::pooling_mode value) - { - pooling_mode = static_cast(value) & ((1U << 3) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair( - "pooling_mode", - (pooling_mode < (sizeof(pooling_mode_str) / sizeof(pooling_mode_str[0])) ? - pooling_mode_str[pooling_mode] : - "****"))); - } -#endif -#endif - }; - // Elementwise operation - struct npu_op_elementwise_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t elementwise_mode : 6; // Elementwise mode - uint32_t reserved1 : 10; -#ifdef __cplusplus - public: - npu_op_elementwise_t(NPU_NAMESPACE::elementwise_mode _elementwise_mode) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_ELEMENTWISE)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - elementwise_mode(static_cast(_elementwise_mode) & ((1U << 6) - 1)), reserved1(0) - { - } - CONSTEXPR npu_op_elementwise_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_ELEMENTWISE)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), elementwise_mode(0), reserved1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_ELEMENTWISE) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_ELEMENTWISE); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_op_elementwise_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_op_elementwise_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::elementwise_mode get_elementwise_mode() const - { - return static_cast(elementwise_mode); - } - CONSTEXPR npu_op_elementwise_t &set_elementwise_mode(NPU_NAMESPACE::elementwise_mode value) - { - elementwise_mode = static_cast(value) & ((1U << 6) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair( - "elementwise_mode", - (elementwise_mode < (sizeof(elementwise_mode_str) / sizeof(elementwise_mode_str[0])) ? - elementwise_mode_str[elementwise_mode] : - "****"))); - } -#endif -#endif - }; - // Queue new DMA for the given channel - struct npu_op_dma_start_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t reserved1 : 16; -#ifdef __cplusplus - public: - CONSTEXPR npu_op_dma_start_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_DMA_START)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), reserved1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_DMA_START) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_DMA_START); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_op_dma_start_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_op_dma_start_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const {} -#endif -#endif - }; - // Wait for the DMA channel to have k or fewer active descriptors outstanding - struct npu_op_dma_wait_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t k : 4; // Number of outstanding descriptors - uint32_t reserved1 : 12; -#ifdef __cplusplus - public: - npu_op_dma_wait_t(uint32_t _k) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_DMA_WAIT)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), k(_k & ((1U << 4) - 1)), reserved1(0) - { - } - CONSTEXPR npu_op_dma_wait_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_DMA_WAIT)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), k(0), reserved1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_DMA_WAIT) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_DMA_WAIT); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_op_dma_wait_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_op_dma_wait_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_k() const - { - return static_cast(k); - } - CONSTEXPR npu_op_dma_wait_t &set_k(uint32_t value) - { - k = static_cast(value) & ((1U << 4) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("k", std::to_string(k))); - } -#endif -#endif - }; - // Wait for n or fewer kernel operations to be remaining - struct npu_op_kernel_wait_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t n : 2; // Number of kernel operations in range 0-3 - uint32_t reserved1 : 14; -#ifdef __cplusplus - public: - npu_op_kernel_wait_t(uint32_t _n) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_KERNEL_WAIT)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), n(_n & ((1U << 2) - 1)), reserved1(0) - { - } - CONSTEXPR npu_op_kernel_wait_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_KERNEL_WAIT)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), n(0), reserved1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_KERNEL_WAIT) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_KERNEL_WAIT); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_op_kernel_wait_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_op_kernel_wait_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_n() const - { - return static_cast(n); - } - CONSTEXPR npu_op_kernel_wait_t &set_n(uint32_t value) - { - n = static_cast(value) & ((1U << 2) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("n", std::to_string(n))); - } -#endif -#endif - }; - // Enable or disable PMU counting (debug feature only) - struct npu_op_pmu_mask_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t enable : 1; // Enable or disable PMU mask - uint32_t reserved1 : 15; -#ifdef __cplusplus - public: - npu_op_pmu_mask_t(uint32_t _enable) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_PMU_MASK)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), enable(_enable & ((1U << 1) - 1)), - reserved1(0) - { - } - CONSTEXPR npu_op_pmu_mask_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_PMU_MASK)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), enable(0), reserved1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_PMU_MASK) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_PMU_MASK); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_op_pmu_mask_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_op_pmu_mask_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_enable() const - { - return static_cast(enable); - } - CONSTEXPR npu_op_pmu_mask_t &set_enable(uint32_t value) - { - enable = static_cast(value) & ((1U << 1) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("enable", std::to_string(enable))); - } -#endif -#endif - }; - // IFM top pad - struct npu_set_ifm_pad_top_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t pad : 7; // IFM top pad - uint32_t reserved1 : 9; -#ifdef __cplusplus - public: - npu_set_ifm_pad_top_t(uint32_t _pad) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PAD_TOP)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), pad(_pad & ((1U << 7) - 1)), reserved1(0) - { - } - CONSTEXPR npu_set_ifm_pad_top_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PAD_TOP)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), pad(0), reserved1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PAD_TOP) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PAD_TOP); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm_pad_top_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm_pad_top_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_pad() const - { - return static_cast(pad); - } - CONSTEXPR npu_set_ifm_pad_top_t &set_pad(uint32_t value) - { - pad = static_cast(value) & ((1U << 7) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("pad", std::to_string(pad))); - } -#endif -#endif - }; - // IFM left pad - struct npu_set_ifm_pad_left_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t pad : 7; // IFM left pad - uint32_t reserved1 : 9; -#ifdef __cplusplus - public: - npu_set_ifm_pad_left_t(uint32_t _pad) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PAD_LEFT)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), pad(_pad & ((1U << 7) - 1)), reserved1(0) - { - } - CONSTEXPR npu_set_ifm_pad_left_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PAD_LEFT)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), pad(0), reserved1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PAD_LEFT) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PAD_LEFT); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm_pad_left_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm_pad_left_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_pad() const - { - return static_cast(pad); - } - CONSTEXPR npu_set_ifm_pad_left_t &set_pad(uint32_t value) - { - pad = static_cast(value) & ((1U << 7) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("pad", std::to_string(pad))); - } -#endif -#endif - }; - // IFM right pad - struct npu_set_ifm_pad_right_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t pad : 8; // IFM right pad. Max value is 128 - uint32_t reserved1 : 8; -#ifdef __cplusplus - public: - npu_set_ifm_pad_right_t(uint32_t _pad) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PAD_RIGHT)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), pad(_pad & ((1U << 8) - 1)), reserved1(0) - { - } - CONSTEXPR npu_set_ifm_pad_right_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PAD_RIGHT)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), pad(0), reserved1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PAD_RIGHT) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PAD_RIGHT); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm_pad_right_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm_pad_right_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_pad() const - { - return static_cast(pad); - } - CONSTEXPR npu_set_ifm_pad_right_t &set_pad(uint32_t value) - { - pad = static_cast(value) & ((1U << 8) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("pad", std::to_string(pad))); - } -#endif -#endif - }; - // IFM bottom pad - struct npu_set_ifm_pad_bottom_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t pad : 8; // IFM bottom pad. Max value is 128 - uint32_t reserved1 : 8; -#ifdef __cplusplus - public: - npu_set_ifm_pad_bottom_t(uint32_t _pad) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PAD_BOTTOM)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), pad(_pad & ((1U << 8) - 1)), reserved1(0) - { - } - CONSTEXPR npu_set_ifm_pad_bottom_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PAD_BOTTOM)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), pad(0), reserved1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PAD_BOTTOM) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PAD_BOTTOM); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm_pad_bottom_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm_pad_bottom_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_pad() const - { - return static_cast(pad); - } - CONSTEXPR npu_set_ifm_pad_bottom_t &set_pad(uint32_t value) - { - pad = static_cast(value) & ((1U << 8) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("pad", std::to_string(pad))); - } -#endif -#endif - }; - // Number of input channels for convolution - struct npu_set_ifm_depth_m1_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t depth_m1 : 16; // Number of input channels for convolution -#ifdef __cplusplus - public: - npu_set_ifm_depth_m1_t(uint32_t _depth_m1) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_DEPTH_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), depth_m1(_depth_m1 & ((1U << 16) - 1)) - { - } - CONSTEXPR npu_set_ifm_depth_m1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_DEPTH_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), depth_m1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_DEPTH_M1) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_DEPTH_M1); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm_depth_m1_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm_depth_m1_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_depth_m1() const - { - return static_cast(depth_m1); - } - CONSTEXPR npu_set_ifm_depth_m1_t &set_depth_m1(uint32_t value) - { - depth_m1 = static_cast(value) & ((1U << 16) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("depth_m1", std::to_string(depth_m1))); - } -#endif -#endif - }; - // IFM Precision - struct npu_set_ifm_precision_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t activation_type : 1; // IFM type - uint32_t reserved1 : 1; - uint32_t activation_precision : 2; // IFM precision - uint32_t reserved2 : 2; - uint32_t activation_format : 2; // IFM format - uint32_t scale_mode : 2; // IFM scale mode - uint32_t reserved3 : 4; - uint32_t round_mode : 2; // IFM round mode -#ifdef __cplusplus - public: - npu_set_ifm_precision_t(NPU_NAMESPACE::activation_type _activation_type, - NPU_NAMESPACE::activation_precision _activation_precision, - NPU_NAMESPACE::activation_format _activation_format, - NPU_NAMESPACE::ifm_scale_mode _scale_mode, - NPU_NAMESPACE::round_mode _round_mode) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PRECISION)), - reserved0(0), control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - activation_type(static_cast(_activation_type) & ((1U << 1) - 1)), reserved1(0), - activation_precision(static_cast(_activation_precision) & ((1U << 2) - 1)), reserved2(0), - activation_format(static_cast(_activation_format) & ((1U << 2) - 1)), - scale_mode(static_cast(_scale_mode) & ((1U << 2) - 1)), reserved3(0), - round_mode(static_cast(_round_mode) & ((1U << 2) - 1)) - { - } - CONSTEXPR npu_set_ifm_precision_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PRECISION)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), activation_type(0), reserved1(0), - activation_precision(0), reserved2(0), activation_format(0), scale_mode(0), reserved3(0), round_mode(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PRECISION) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PRECISION); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm_precision_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm_precision_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::activation_type get_activation_type() const - { - return static_cast(activation_type); - } - CONSTEXPR npu_set_ifm_precision_t &set_activation_type(NPU_NAMESPACE::activation_type value) - { - activation_type = static_cast(value) & ((1U << 1) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::activation_precision get_activation_precision() const - { - return static_cast(activation_precision); - } - CONSTEXPR npu_set_ifm_precision_t &set_activation_precision(NPU_NAMESPACE::activation_precision value) - { - activation_precision = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::activation_format get_activation_format() const - { - return static_cast(activation_format); - } - CONSTEXPR npu_set_ifm_precision_t &set_activation_format(NPU_NAMESPACE::activation_format value) - { - activation_format = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::ifm_scale_mode get_scale_mode() const - { - return static_cast(scale_mode); - } - CONSTEXPR npu_set_ifm_precision_t &set_scale_mode(NPU_NAMESPACE::ifm_scale_mode value) - { - scale_mode = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::round_mode get_round_mode() const - { - return static_cast(round_mode); - } - CONSTEXPR npu_set_ifm_precision_t &set_round_mode(NPU_NAMESPACE::round_mode value) - { - round_mode = static_cast(value) & ((1U << 2) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair( - "activation_type", - (activation_type < (sizeof(activation_type_str) / sizeof(activation_type_str[0])) ? - activation_type_str[activation_type] : - "****"))); - fields.push_back(std::make_pair( - "activation_precision", - (activation_precision < (sizeof(activation_precision_str) / sizeof(activation_precision_str[0])) ? - activation_precision_str[activation_precision] : - "****"))); - fields.push_back(std::make_pair( - "activation_format", - (activation_format < (sizeof(activation_format_str) / sizeof(activation_format_str[0])) ? - activation_format_str[activation_format] : - "****"))); - fields.push_back(std::make_pair( - "scale_mode", - (scale_mode < (sizeof(ifm_scale_mode_str) / sizeof(ifm_scale_mode_str[0])) ? - ifm_scale_mode_str[scale_mode] : - "****"))); - fields.push_back(std::make_pair( - "round_mode", - (round_mode < (sizeof(round_mode_str) / sizeof(round_mode_str[0])) ? round_mode_str[round_mode] : - "****"))); - } -#endif -#endif - }; - // IFM upscale mode - struct npu_set_ifm_upscale_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t mode : 2; // IFM upscale mode - uint32_t reserved1 : 14; -#ifdef __cplusplus - public: - npu_set_ifm_upscale_t(NPU_NAMESPACE::ifm_upscale_mode _mode) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_UPSCALE)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - mode(static_cast(_mode) & ((1U << 2) - 1)), reserved1(0) - { - } - CONSTEXPR npu_set_ifm_upscale_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_UPSCALE)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), mode(0), reserved1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_UPSCALE) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_UPSCALE); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm_upscale_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm_upscale_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::ifm_upscale_mode get_mode() const - { - return static_cast(mode); - } - CONSTEXPR npu_set_ifm_upscale_t &set_mode(NPU_NAMESPACE::ifm_upscale_mode value) - { - mode = static_cast(value) & ((1U << 2) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair( - "mode", - (mode < (sizeof(ifm_upscale_mode_str) / sizeof(ifm_upscale_mode_str[0])) ? ifm_upscale_mode_str[mode] : - "****"))); - } -#endif -#endif - }; - // IFM zero point - struct npu_set_ifm_zero_point_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t zero_point : 16; // Zero point offset -#ifdef __cplusplus - public: - npu_set_ifm_zero_point_t(uint32_t _zero_point) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_ZERO_POINT)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - zero_point(_zero_point & ((1U << 16) - 1)) - { - } - CONSTEXPR npu_set_ifm_zero_point_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_ZERO_POINT)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), zero_point(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_ZERO_POINT) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_ZERO_POINT); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm_zero_point_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm_zero_point_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_zero_point() const - { - return static_cast(zero_point); - } - CONSTEXPR npu_set_ifm_zero_point_t &set_zero_point(uint32_t value) - { - zero_point = static_cast(value) & ((1U << 16) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("zero_point", std::to_string(zero_point))); - } -#endif -#endif - }; - // IFM Tile 0 and tile 2 width - struct npu_set_ifm_width0_m1_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t width_m1 : 16; // IFM Tile 0 and tile 2 width -#ifdef __cplusplus - public: - npu_set_ifm_width0_m1_t(uint32_t _width_m1) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_WIDTH0_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), width_m1(_width_m1 & ((1U << 16) - 1)) - { - } - CONSTEXPR npu_set_ifm_width0_m1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_WIDTH0_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), width_m1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_WIDTH0_M1) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_WIDTH0_M1); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm_width0_m1_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm_width0_m1_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_width_m1() const - { - return static_cast(width_m1); - } - CONSTEXPR npu_set_ifm_width0_m1_t &set_width_m1(uint32_t value) - { - width_m1 = static_cast(value) & ((1U << 16) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("width_m1", std::to_string(width_m1))); - } -#endif -#endif - }; - // IFM Tile 0 height - struct npu_set_ifm_height0_m1_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t height_m1 : 16; // IFM Tile 0 height -#ifdef __cplusplus - public: - npu_set_ifm_height0_m1_t(uint32_t _height_m1) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_HEIGHT0_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), height_m1(_height_m1 & ((1U << 16) - 1)) - { - } - CONSTEXPR npu_set_ifm_height0_m1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_HEIGHT0_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), height_m1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_HEIGHT0_M1) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_HEIGHT0_M1); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm_height0_m1_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm_height0_m1_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_height_m1() const - { - return static_cast(height_m1); - } - CONSTEXPR npu_set_ifm_height0_m1_t &set_height_m1(uint32_t value) - { - height_m1 = static_cast(value) & ((1U << 16) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("height_m1", std::to_string(height_m1))); - } -#endif -#endif - }; - // IFM Tile 1 height - struct npu_set_ifm_height1_m1_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t height_m1 : 16; // IFM Tile 1 height -#ifdef __cplusplus - public: - npu_set_ifm_height1_m1_t(uint32_t _height_m1) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_HEIGHT1_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), height_m1(_height_m1 & ((1U << 16) - 1)) - { - } - CONSTEXPR npu_set_ifm_height1_m1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_HEIGHT1_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), height_m1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_HEIGHT1_M1) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_HEIGHT1_M1); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm_height1_m1_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm_height1_m1_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_height_m1() const - { - return static_cast(height_m1); - } - CONSTEXPR npu_set_ifm_height1_m1_t &set_height_m1(uint32_t value) - { - height_m1 = static_cast(value) & ((1U << 16) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("height_m1", std::to_string(height_m1))); - } -#endif -#endif - }; - // End of IB0,IB1 buffers - struct npu_set_ifm_ib_end_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t ib_end : 6; // End of IB0,IB1 buffers in the SHRAM in KB units. Multiple of 2 - uint32_t reserved1 : 10; -#ifdef __cplusplus - public: - npu_set_ifm_ib_end_t(uint32_t _ib_end) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_IB_END)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), ib_end(_ib_end & ((1U << 6) - 1)), - reserved1(0) - { - } - CONSTEXPR npu_set_ifm_ib_end_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_IB_END)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), ib_end(0), reserved1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_IB_END) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_IB_END); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm_ib_end_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm_ib_end_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_ib_end() const - { - return static_cast(ib_end); - } - CONSTEXPR npu_set_ifm_ib_end_t &set_ib_end(uint32_t value) - { - ib_end = static_cast(value) & ((1U << 6) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("ib_end", std::to_string(ib_end))); - } -#endif -#endif - }; - // Index n for IFM access - struct npu_set_ifm_region_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t region : 3; // Region number n - uint32_t reserved1 : 12; - uint32_t custom_dma_cs : 1; // Custom DMA select -#ifdef __cplusplus - public: - npu_set_ifm_region_t(uint32_t _region, NPU_NAMESPACE::custom_dma_cs _custom_dma_cs) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_REGION)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), region(_region & ((1U << 3) - 1)), - reserved1(0), custom_dma_cs(static_cast(_custom_dma_cs) & ((1U << 1) - 1)) - { - } - CONSTEXPR npu_set_ifm_region_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_REGION)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), region(0), reserved1(0), custom_dma_cs(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_REGION) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_REGION); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm_region_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm_region_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_region() const - { - return static_cast(region); - } - CONSTEXPR npu_set_ifm_region_t &set_region(uint32_t value) - { - region = static_cast(value) & ((1U << 3) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::custom_dma_cs get_custom_dma_cs() const - { - return static_cast(custom_dma_cs); - } - CONSTEXPR npu_set_ifm_region_t &set_custom_dma_cs(NPU_NAMESPACE::custom_dma_cs value) - { - custom_dma_cs = static_cast(value) & ((1U << 1) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("region", std::to_string(region))); - fields.push_back(std::make_pair( - "custom_dma_cs", - (custom_dma_cs < (sizeof(custom_dma_cs_str) / sizeof(custom_dma_cs_str[0])) ? - custom_dma_cs_str[custom_dma_cs] : - "****"))); - } -#endif -#endif - }; - // Output feature map width - struct npu_set_ofm_width_m1_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t width_m1 : 16; // Output feature map width -#ifdef __cplusplus - public: - npu_set_ofm_width_m1_t(uint32_t _width_m1) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_WIDTH_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), width_m1(_width_m1 & ((1U << 16) - 1)) - { - } - CONSTEXPR npu_set_ofm_width_m1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_WIDTH_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), width_m1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_WIDTH_M1) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_WIDTH_M1); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ofm_width_m1_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ofm_width_m1_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_width_m1() const - { - return static_cast(width_m1); - } - CONSTEXPR npu_set_ofm_width_m1_t &set_width_m1(uint32_t value) - { - width_m1 = static_cast(value) & ((1U << 16) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("width_m1", std::to_string(width_m1))); - } -#endif -#endif - }; - // Output feature map height - struct npu_set_ofm_height_m1_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t height_m1 : 16; // Output feature map height -#ifdef __cplusplus - public: - npu_set_ofm_height_m1_t(uint32_t _height_m1) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_HEIGHT_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), height_m1(_height_m1 & ((1U << 16) - 1)) - { - } - CONSTEXPR npu_set_ofm_height_m1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_HEIGHT_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), height_m1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_HEIGHT_M1) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_HEIGHT_M1); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ofm_height_m1_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ofm_height_m1_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_height_m1() const - { - return static_cast(height_m1); - } - CONSTEXPR npu_set_ofm_height_m1_t &set_height_m1(uint32_t value) - { - height_m1 = static_cast(value) & ((1U << 16) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("height_m1", std::to_string(height_m1))); - } -#endif -#endif - }; - // Output feature map depth - struct npu_set_ofm_depth_m1_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t depth_m1 : 16; // Output feature map depth -#ifdef __cplusplus - public: - npu_set_ofm_depth_m1_t(uint32_t _depth_m1) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_DEPTH_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), depth_m1(_depth_m1 & ((1U << 16) - 1)) - { - } - CONSTEXPR npu_set_ofm_depth_m1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_DEPTH_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), depth_m1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_DEPTH_M1) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_DEPTH_M1); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ofm_depth_m1_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ofm_depth_m1_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_depth_m1() const - { - return static_cast(depth_m1); - } - CONSTEXPR npu_set_ofm_depth_m1_t &set_depth_m1(uint32_t value) - { - depth_m1 = static_cast(value) & ((1U << 16) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("depth_m1", std::to_string(depth_m1))); - } -#endif -#endif - }; - // OFM Precision - struct npu_set_ofm_precision_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t activation_type : 1; // OFM type - uint32_t activation_precision : 2; // OFM precision - uint32_t reserved1 : 3; - uint32_t activation_format : 2; // OFM format - uint32_t scale_mode : 1; // OFM scale mode - uint32_t reserved2 : 5; - uint32_t round_mode : 2; // OFM round mode -#ifdef __cplusplus - public: - npu_set_ofm_precision_t(NPU_NAMESPACE::activation_type _activation_type, - NPU_NAMESPACE::activation_precision _activation_precision, - NPU_NAMESPACE::activation_format _activation_format, - NPU_NAMESPACE::ofm_scale_mode _scale_mode, - NPU_NAMESPACE::round_mode _round_mode) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_PRECISION)), - reserved0(0), control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - activation_type(static_cast(_activation_type) & ((1U << 1) - 1)), - activation_precision(static_cast(_activation_precision) & ((1U << 2) - 1)), reserved1(0), - activation_format(static_cast(_activation_format) & ((1U << 2) - 1)), - scale_mode(static_cast(_scale_mode) & ((1U << 1) - 1)), reserved2(0), - round_mode(static_cast(_round_mode) & ((1U << 2) - 1)) - { - } - CONSTEXPR npu_set_ofm_precision_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_PRECISION)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), activation_type(0), - activation_precision(0), reserved1(0), activation_format(0), scale_mode(0), reserved2(0), round_mode(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_PRECISION) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_PRECISION); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ofm_precision_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ofm_precision_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::activation_type get_activation_type() const - { - return static_cast(activation_type); - } - CONSTEXPR npu_set_ofm_precision_t &set_activation_type(NPU_NAMESPACE::activation_type value) - { - activation_type = static_cast(value) & ((1U << 1) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::activation_precision get_activation_precision() const - { - return static_cast(activation_precision); - } - CONSTEXPR npu_set_ofm_precision_t &set_activation_precision(NPU_NAMESPACE::activation_precision value) - { - activation_precision = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::activation_format get_activation_format() const - { - return static_cast(activation_format); - } - CONSTEXPR npu_set_ofm_precision_t &set_activation_format(NPU_NAMESPACE::activation_format value) - { - activation_format = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::ofm_scale_mode get_scale_mode() const - { - return static_cast(scale_mode); - } - CONSTEXPR npu_set_ofm_precision_t &set_scale_mode(NPU_NAMESPACE::ofm_scale_mode value) - { - scale_mode = static_cast(value) & ((1U << 1) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::round_mode get_round_mode() const - { - return static_cast(round_mode); - } - CONSTEXPR npu_set_ofm_precision_t &set_round_mode(NPU_NAMESPACE::round_mode value) - { - round_mode = static_cast(value) & ((1U << 2) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair( - "activation_type", - (activation_type < (sizeof(activation_type_str) / sizeof(activation_type_str[0])) ? - activation_type_str[activation_type] : - "****"))); - fields.push_back(std::make_pair( - "activation_precision", - (activation_precision < (sizeof(activation_precision_str) / sizeof(activation_precision_str[0])) ? - activation_precision_str[activation_precision] : - "****"))); - fields.push_back(std::make_pair( - "activation_format", - (activation_format < (sizeof(activation_format_str) / sizeof(activation_format_str[0])) ? - activation_format_str[activation_format] : - "****"))); - fields.push_back(std::make_pair( - "scale_mode", - (scale_mode < (sizeof(ofm_scale_mode_str) / sizeof(ofm_scale_mode_str[0])) ? - ofm_scale_mode_str[scale_mode] : - "****"))); - fields.push_back(std::make_pair( - "round_mode", - (round_mode < (sizeof(round_mode_str) / sizeof(round_mode_str[0])) ? round_mode_str[round_mode] : - "****"))); - } -#endif -#endif - }; - // OFM block width - struct npu_set_ofm_blk_width_m1_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t width_m1 : 6; // OFM block width - uint32_t reserved1 : 10; -#ifdef __cplusplus - public: - npu_set_ofm_blk_width_m1_t(uint32_t _width_m1) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_BLK_WIDTH_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), width_m1(_width_m1 & ((1U << 6) - 1)), - reserved1(0) - { - } - CONSTEXPR npu_set_ofm_blk_width_m1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_BLK_WIDTH_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), width_m1(0), reserved1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_BLK_WIDTH_M1) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_BLK_WIDTH_M1); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ofm_blk_width_m1_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ofm_blk_width_m1_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_width_m1() const - { - return static_cast(width_m1); - } - CONSTEXPR npu_set_ofm_blk_width_m1_t &set_width_m1(uint32_t value) - { - width_m1 = static_cast(value) & ((1U << 6) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("width_m1", std::to_string(width_m1))); - } -#endif -#endif - }; - // OFM block height - struct npu_set_ofm_blk_height_m1_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t height_m1 : 5; // OFM block height - uint32_t reserved1 : 11; -#ifdef __cplusplus - public: - npu_set_ofm_blk_height_m1_t(uint32_t _height_m1) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_BLK_HEIGHT_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), height_m1(_height_m1 & ((1U << 5) - 1)), - reserved1(0) - { - } - CONSTEXPR npu_set_ofm_blk_height_m1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_BLK_HEIGHT_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), height_m1(0), reserved1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_BLK_HEIGHT_M1) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_BLK_HEIGHT_M1); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ofm_blk_height_m1_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ofm_blk_height_m1_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_height_m1() const - { - return static_cast(height_m1); - } - CONSTEXPR npu_set_ofm_blk_height_m1_t &set_height_m1(uint32_t value) - { - height_m1 = static_cast(value) & ((1U << 5) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("height_m1", std::to_string(height_m1))); - } -#endif -#endif - }; - // OFM block depth - struct npu_set_ofm_blk_depth_m1_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t depth_m1 : 7; // OFM block depth - uint32_t reserved1 : 9; -#ifdef __cplusplus - public: - npu_set_ofm_blk_depth_m1_t(uint32_t _depth_m1) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_BLK_DEPTH_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), depth_m1(_depth_m1 & ((1U << 7) - 1)), - reserved1(0) - { - } - CONSTEXPR npu_set_ofm_blk_depth_m1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_BLK_DEPTH_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), depth_m1(0), reserved1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_BLK_DEPTH_M1) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_BLK_DEPTH_M1); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ofm_blk_depth_m1_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ofm_blk_depth_m1_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_depth_m1() const - { - return static_cast(depth_m1); - } - CONSTEXPR npu_set_ofm_blk_depth_m1_t &set_depth_m1(uint32_t value) - { - depth_m1 = static_cast(value) & ((1U << 7) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("depth_m1", std::to_string(depth_m1))); - } -#endif -#endif - }; - // OFM zero point - struct npu_set_ofm_zero_point_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t zero_point : 16; // Zero point offset -#ifdef __cplusplus - public: - npu_set_ofm_zero_point_t(uint32_t _zero_point) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_ZERO_POINT)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - zero_point(_zero_point & ((1U << 16) - 1)) - { - } - CONSTEXPR npu_set_ofm_zero_point_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_ZERO_POINT)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), zero_point(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_ZERO_POINT) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_ZERO_POINT); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ofm_zero_point_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ofm_zero_point_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_zero_point() const - { - return static_cast(zero_point); - } - CONSTEXPR npu_set_ofm_zero_point_t &set_zero_point(uint32_t value) - { - zero_point = static_cast(value) & ((1U << 16) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("zero_point", std::to_string(zero_point))); - } -#endif -#endif - }; - // OFM Tile 0 and tile 2 width - struct npu_set_ofm_width0_m1_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t width_m1 : 16; // OFM Tile 0 and tile 2 width -#ifdef __cplusplus - public: - npu_set_ofm_width0_m1_t(uint32_t _width_m1) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_WIDTH0_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), width_m1(_width_m1 & ((1U << 16) - 1)) - { - } - CONSTEXPR npu_set_ofm_width0_m1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_WIDTH0_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), width_m1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_WIDTH0_M1) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_WIDTH0_M1); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ofm_width0_m1_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ofm_width0_m1_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_width_m1() const - { - return static_cast(width_m1); - } - CONSTEXPR npu_set_ofm_width0_m1_t &set_width_m1(uint32_t value) - { - width_m1 = static_cast(value) & ((1U << 16) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("width_m1", std::to_string(width_m1))); - } -#endif -#endif - }; - // OFM Tile 0 height - struct npu_set_ofm_height0_m1_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t height_m1 : 16; // OFM Tile 0 height -#ifdef __cplusplus - public: - npu_set_ofm_height0_m1_t(uint32_t _height_m1) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_HEIGHT0_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), height_m1(_height_m1 & ((1U << 16) - 1)) - { - } - CONSTEXPR npu_set_ofm_height0_m1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_HEIGHT0_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), height_m1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_HEIGHT0_M1) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_HEIGHT0_M1); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ofm_height0_m1_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ofm_height0_m1_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_height_m1() const - { - return static_cast(height_m1); - } - CONSTEXPR npu_set_ofm_height0_m1_t &set_height_m1(uint32_t value) - { - height_m1 = static_cast(value) & ((1U << 16) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("height_m1", std::to_string(height_m1))); - } -#endif -#endif - }; - // OFM Tile 1 height - struct npu_set_ofm_height1_m1_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t height_m1 : 16; // OFM Tile 1 height -#ifdef __cplusplus - public: - npu_set_ofm_height1_m1_t(uint32_t _height_m1) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_HEIGHT1_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), height_m1(_height_m1 & ((1U << 16) - 1)) - { - } - CONSTEXPR npu_set_ofm_height1_m1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_HEIGHT1_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), height_m1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_HEIGHT1_M1) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_HEIGHT1_M1); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ofm_height1_m1_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ofm_height1_m1_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_height_m1() const - { - return static_cast(height_m1); - } - CONSTEXPR npu_set_ofm_height1_m1_t &set_height_m1(uint32_t value) - { - height_m1 = static_cast(value) & ((1U << 16) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("height_m1", std::to_string(height_m1))); - } -#endif -#endif - }; - // Index n for OFM access - struct npu_set_ofm_region_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t region : 3; // Index n for OFM access - uint32_t reserved1 : 12; - uint32_t custom_dma_cs : 1; // Custom DMA select -#ifdef __cplusplus - public: - npu_set_ofm_region_t(uint32_t _region, NPU_NAMESPACE::custom_dma_cs _custom_dma_cs) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_REGION)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), region(_region & ((1U << 3) - 1)), - reserved1(0), custom_dma_cs(static_cast(_custom_dma_cs) & ((1U << 1) - 1)) - { - } - CONSTEXPR npu_set_ofm_region_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_REGION)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), region(0), reserved1(0), custom_dma_cs(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_REGION) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_REGION); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ofm_region_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ofm_region_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_region() const - { - return static_cast(region); - } - CONSTEXPR npu_set_ofm_region_t &set_region(uint32_t value) - { - region = static_cast(value) & ((1U << 3) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::custom_dma_cs get_custom_dma_cs() const - { - return static_cast(custom_dma_cs); - } - CONSTEXPR npu_set_ofm_region_t &set_custom_dma_cs(NPU_NAMESPACE::custom_dma_cs value) - { - custom_dma_cs = static_cast(value) & ((1U << 1) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("region", std::to_string(region))); - fields.push_back(std::make_pair( - "custom_dma_cs", - (custom_dma_cs < (sizeof(custom_dma_cs_str) / sizeof(custom_dma_cs_str[0])) ? - custom_dma_cs_str[custom_dma_cs] : - "****"))); - } -#endif -#endif - }; - // Kernel width - struct npu_set_kernel_width_m1_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t width_m1 : 16; // Kernel width -#ifdef __cplusplus - public: - npu_set_kernel_width_m1_t(uint32_t _width_m1) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_KERNEL_WIDTH_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), width_m1(_width_m1 & ((1U << 16) - 1)) - { - } - CONSTEXPR npu_set_kernel_width_m1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_KERNEL_WIDTH_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), width_m1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_KERNEL_WIDTH_M1) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_KERNEL_WIDTH_M1); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_kernel_width_m1_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_kernel_width_m1_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_width_m1() const - { - return static_cast(width_m1); - } - CONSTEXPR npu_set_kernel_width_m1_t &set_width_m1(uint32_t value) - { - width_m1 = static_cast(value) & ((1U << 16) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("width_m1", std::to_string(width_m1))); - } -#endif -#endif - }; - // Kernel height - struct npu_set_kernel_height_m1_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t height_m1 : 16; // Kernel height -#ifdef __cplusplus - public: - npu_set_kernel_height_m1_t(uint32_t _height_m1) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_KERNEL_HEIGHT_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), height_m1(_height_m1 & ((1U << 16) - 1)) - { - } - CONSTEXPR npu_set_kernel_height_m1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_KERNEL_HEIGHT_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), height_m1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_KERNEL_HEIGHT_M1) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_KERNEL_HEIGHT_M1); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_kernel_height_m1_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_kernel_height_m1_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_height_m1() const - { - return static_cast(height_m1); - } - CONSTEXPR npu_set_kernel_height_m1_t &set_height_m1(uint32_t value) - { - height_m1 = static_cast(value) & ((1U << 16) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("height_m1", std::to_string(height_m1))); - } -#endif -#endif - }; - // Kernel stride - struct npu_set_kernel_stride_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t stride_x_lsb : 1; // Stride x LSB. (kernel_x_stride - 1)[0] - uint32_t stride_y_lsb : 1; // Stride y LSB. (kernel_y_stride - 1)[0] - uint32_t weight_order : 1; // Weight ordering mode - uint32_t dilation_x : 1; // Kernel x dilation - uint32_t dilation_y : 1; // Kernel y dilation - uint32_t decomposition : 1; // Kernel decomposition - uint32_t stride_x_msb : 1; // Stride x MSB. (kernel_x_stride - 1) >> 1 - uint32_t reserved1 : 2; - uint32_t stride_y_msb : 1; // Stride y MSB. (kernel_y_stride - 1) >> 1 - uint32_t reserved2 : 6; -#ifdef __cplusplus - public: - npu_set_kernel_stride_t(uint32_t _stride_x_lsb, - uint32_t _stride_y_lsb, - NPU_NAMESPACE::weight_order _weight_order, - NPU_NAMESPACE::kernel_dilation _dilation_x, - NPU_NAMESPACE::kernel_dilation _dilation_y, - NPU_NAMESPACE::kernel_decomposition _decomposition, - uint32_t _stride_x_msb, - uint32_t _stride_y_msb) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_KERNEL_STRIDE)), - reserved0(0), control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - stride_x_lsb(_stride_x_lsb & ((1U << 1) - 1)), stride_y_lsb(_stride_y_lsb & ((1U << 1) - 1)), - weight_order(static_cast(_weight_order) & ((1U << 1) - 1)), - dilation_x(static_cast(_dilation_x) & ((1U << 1) - 1)), - dilation_y(static_cast(_dilation_y) & ((1U << 1) - 1)), - decomposition(static_cast(_decomposition) & ((1U << 1) - 1)), - stride_x_msb(_stride_x_msb & ((1U << 1) - 1)), reserved1(0), stride_y_msb(_stride_y_msb & ((1U << 1) - 1)), - reserved2(0) - { - } - CONSTEXPR npu_set_kernel_stride_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_KERNEL_STRIDE)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), stride_x_lsb(0), stride_y_lsb(0), - weight_order(0), dilation_x(0), dilation_y(0), decomposition(0), stride_x_msb(0), reserved1(0), - stride_y_msb(0), reserved2(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_KERNEL_STRIDE) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_KERNEL_STRIDE); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_kernel_stride_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_kernel_stride_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_stride_x_lsb() const - { - return static_cast(stride_x_lsb); - } - CONSTEXPR npu_set_kernel_stride_t &set_stride_x_lsb(uint32_t value) - { - stride_x_lsb = static_cast(value) & ((1U << 1) - 1); - return *this; - } - CONSTEXPR uint32_t get_stride_y_lsb() const - { - return static_cast(stride_y_lsb); - } - CONSTEXPR npu_set_kernel_stride_t &set_stride_y_lsb(uint32_t value) - { - stride_y_lsb = static_cast(value) & ((1U << 1) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::weight_order get_weight_order() const - { - return static_cast(weight_order); - } - CONSTEXPR npu_set_kernel_stride_t &set_weight_order(NPU_NAMESPACE::weight_order value) - { - weight_order = static_cast(value) & ((1U << 1) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::kernel_dilation get_dilation_x() const - { - return static_cast(dilation_x); - } - CONSTEXPR npu_set_kernel_stride_t &set_dilation_x(NPU_NAMESPACE::kernel_dilation value) - { - dilation_x = static_cast(value) & ((1U << 1) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::kernel_dilation get_dilation_y() const - { - return static_cast(dilation_y); - } - CONSTEXPR npu_set_kernel_stride_t &set_dilation_y(NPU_NAMESPACE::kernel_dilation value) - { - dilation_y = static_cast(value) & ((1U << 1) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::kernel_decomposition get_decomposition() const - { - return static_cast(decomposition); - } - CONSTEXPR npu_set_kernel_stride_t &set_decomposition(NPU_NAMESPACE::kernel_decomposition value) - { - decomposition = static_cast(value) & ((1U << 1) - 1); - return *this; - } - CONSTEXPR uint32_t get_stride_x_msb() const - { - return static_cast(stride_x_msb); - } - CONSTEXPR npu_set_kernel_stride_t &set_stride_x_msb(uint32_t value) - { - stride_x_msb = static_cast(value) & ((1U << 1) - 1); - return *this; - } - CONSTEXPR uint32_t get_stride_y_msb() const - { - return static_cast(stride_y_msb); - } - CONSTEXPR npu_set_kernel_stride_t &set_stride_y_msb(uint32_t value) - { - stride_y_msb = static_cast(value) & ((1U << 1) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("stride_x_lsb", std::to_string(stride_x_lsb))); - fields.push_back(std::make_pair("stride_y_lsb", std::to_string(stride_y_lsb))); - fields.push_back(std::make_pair( - "weight_order", - (weight_order < (sizeof(weight_order_str) / sizeof(weight_order_str[0])) ? - weight_order_str[weight_order] : - "****"))); - fields.push_back(std::make_pair( - "dilation_x", - (dilation_x < (sizeof(kernel_dilation_str) / sizeof(kernel_dilation_str[0])) ? - kernel_dilation_str[dilation_x] : - "****"))); - fields.push_back(std::make_pair( - "dilation_y", - (dilation_y < (sizeof(kernel_dilation_str) / sizeof(kernel_dilation_str[0])) ? - kernel_dilation_str[dilation_y] : - "****"))); - fields.push_back(std::make_pair( - "decomposition", - (decomposition < (sizeof(kernel_decomposition_str) / sizeof(kernel_decomposition_str[0])) ? - kernel_decomposition_str[decomposition] : - "****"))); - fields.push_back(std::make_pair("stride_x_msb", std::to_string(stride_x_msb))); - fields.push_back(std::make_pair("stride_y_msb", std::to_string(stride_y_msb))); - } -#endif -#endif - }; - // Accumulator format - struct npu_set_acc_format_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t acc_format : 2; // Accumulator format - uint32_t reserved1 : 14; -#ifdef __cplusplus - public: - npu_set_acc_format_t(NPU_NAMESPACE::acc_format _acc_format) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_ACC_FORMAT)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - acc_format(static_cast(_acc_format) & ((1U << 2) - 1)), reserved1(0) - { - } - CONSTEXPR npu_set_acc_format_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_ACC_FORMAT)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), acc_format(0), reserved1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_ACC_FORMAT) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_ACC_FORMAT); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_acc_format_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_acc_format_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::acc_format get_acc_format() const - { - return static_cast(acc_format); - } - CONSTEXPR npu_set_acc_format_t &set_acc_format(NPU_NAMESPACE::acc_format value) - { - acc_format = static_cast(value) & ((1U << 2) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair( - "acc_format", - (acc_format < (sizeof(acc_format_str) / sizeof(acc_format_str[0])) ? acc_format_str[acc_format] : - "****"))); - } -#endif -#endif - }; - // Activation function and clip range - struct npu_set_activation_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t activation_function : 5; // Activation function (before table lookup) - uint32_t reserved1 : 7; - uint32_t activation_clip_range : 3; // Activation clip range. This must be set to 0 if table lookup is not used - uint32_t reserved2 : 1; -#ifdef __cplusplus - public: - npu_set_activation_t(NPU_NAMESPACE::activation_function _activation_function, - NPU_NAMESPACE::activation_clip_range _activation_clip_range) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_ACTIVATION)), - reserved0(0), control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - activation_function(static_cast(_activation_function) & ((1U << 5) - 1)), reserved1(0), - activation_clip_range(static_cast(_activation_clip_range) & ((1U << 3) - 1)), reserved2(0) - { - } - CONSTEXPR npu_set_activation_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_ACTIVATION)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), activation_function(0), reserved1(0), - activation_clip_range(0), reserved2(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_ACTIVATION) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_ACTIVATION); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_activation_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_activation_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::activation_function get_activation_function() const - { - return static_cast(activation_function); - } - CONSTEXPR npu_set_activation_t &set_activation_function(NPU_NAMESPACE::activation_function value) - { - activation_function = static_cast(value) & ((1U << 5) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::activation_clip_range get_activation_clip_range() const - { - return static_cast(activation_clip_range); - } - CONSTEXPR npu_set_activation_t &set_activation_clip_range(NPU_NAMESPACE::activation_clip_range value) - { - activation_clip_range = static_cast(value) & ((1U << 3) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair( - "activation_function", - (activation_function < (sizeof(activation_function_str) / sizeof(activation_function_str[0])) ? - activation_function_str[activation_function] : - "****"))); - fields.push_back(std::make_pair( - "activation_clip_range", - (activation_clip_range < (sizeof(activation_clip_range_str) / sizeof(activation_clip_range_str[0])) ? - activation_clip_range_str[activation_clip_range] : - "****"))); - } -#endif -#endif - }; - // Lower bound clip - struct npu_set_activation_min_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t clip_boundary : 16; // Clip boundary for OFM activations -#ifdef __cplusplus - public: - npu_set_activation_min_t(uint32_t _clip_boundary) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_ACTIVATION_MIN)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - clip_boundary(_clip_boundary & ((1U << 16) - 1)) - { - } - CONSTEXPR npu_set_activation_min_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_ACTIVATION_MIN)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), clip_boundary(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_ACTIVATION_MIN) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_ACTIVATION_MIN); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_activation_min_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_activation_min_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_clip_boundary() const - { - return static_cast(clip_boundary); - } - CONSTEXPR npu_set_activation_min_t &set_clip_boundary(uint32_t value) - { - clip_boundary = static_cast(value) & ((1U << 16) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("clip_boundary", std::to_string(clip_boundary))); - } -#endif -#endif - }; - // Upper bound clip - struct npu_set_activation_max_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t clip_boundary : 16; // Clip boundary for OFM activations -#ifdef __cplusplus - public: - npu_set_activation_max_t(uint32_t _clip_boundary) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_ACTIVATION_MAX)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - clip_boundary(_clip_boundary & ((1U << 16) - 1)) - { - } - CONSTEXPR npu_set_activation_max_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_ACTIVATION_MAX)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), clip_boundary(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_ACTIVATION_MAX) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_ACTIVATION_MAX); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_activation_max_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_activation_max_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_clip_boundary() const - { - return static_cast(clip_boundary); - } - CONSTEXPR npu_set_activation_max_t &set_clip_boundary(uint32_t value) - { - clip_boundary = static_cast(value) & ((1U << 16) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("clip_boundary", std::to_string(clip_boundary))); - } -#endif -#endif - }; - // Index n for weight stream access - struct npu_set_weight_region_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t region : 3; // Index n for weight stream access - uint32_t reserved1 : 12; - uint32_t custom_dma_cs : 1; // Custom DMA select -#ifdef __cplusplus - public: - npu_set_weight_region_t(uint32_t _region, NPU_NAMESPACE::custom_dma_cs _custom_dma_cs) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_WEIGHT_REGION)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), region(_region & ((1U << 3) - 1)), - reserved1(0), custom_dma_cs(static_cast(_custom_dma_cs) & ((1U << 1) - 1)) - { - } - CONSTEXPR npu_set_weight_region_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_WEIGHT_REGION)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), region(0), reserved1(0), custom_dma_cs(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_WEIGHT_REGION) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_WEIGHT_REGION); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_weight_region_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_weight_region_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_region() const - { - return static_cast(region); - } - CONSTEXPR npu_set_weight_region_t &set_region(uint32_t value) - { - region = static_cast(value) & ((1U << 3) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::custom_dma_cs get_custom_dma_cs() const - { - return static_cast(custom_dma_cs); - } - CONSTEXPR npu_set_weight_region_t &set_custom_dma_cs(NPU_NAMESPACE::custom_dma_cs value) - { - custom_dma_cs = static_cast(value) & ((1U << 1) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("region", std::to_string(region))); - fields.push_back(std::make_pair( - "custom_dma_cs", - (custom_dma_cs < (sizeof(custom_dma_cs_str) / sizeof(custom_dma_cs_str[0])) ? - custom_dma_cs_str[custom_dma_cs] : - "****"))); - } -#endif -#endif - }; - // Index n for scale stream access - struct npu_set_scale_region_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t region : 3; // Index n for scale stream access - uint32_t reserved1 : 12; - uint32_t custom_dma_cs : 1; // Custom DMA select -#ifdef __cplusplus - public: - npu_set_scale_region_t(uint32_t _region, NPU_NAMESPACE::custom_dma_cs _custom_dma_cs) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_SCALE_REGION)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), region(_region & ((1U << 3) - 1)), - reserved1(0), custom_dma_cs(static_cast(_custom_dma_cs) & ((1U << 1) - 1)) - { - } - CONSTEXPR npu_set_scale_region_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_SCALE_REGION)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), region(0), reserved1(0), custom_dma_cs(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_SCALE_REGION) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_SCALE_REGION); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_scale_region_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_scale_region_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_region() const - { - return static_cast(region); - } - CONSTEXPR npu_set_scale_region_t &set_region(uint32_t value) - { - region = static_cast(value) & ((1U << 3) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::custom_dma_cs get_custom_dma_cs() const - { - return static_cast(custom_dma_cs); - } - CONSTEXPR npu_set_scale_region_t &set_custom_dma_cs(NPU_NAMESPACE::custom_dma_cs value) - { - custom_dma_cs = static_cast(value) & ((1U << 1) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("region", std::to_string(region))); - fields.push_back(std::make_pair( - "custom_dma_cs", - (custom_dma_cs < (sizeof(custom_dma_cs_str) / sizeof(custom_dma_cs_str[0])) ? - custom_dma_cs_str[custom_dma_cs] : - "****"))); - } -#endif -#endif - }; - // Start of ACC0,ACC1 buffers - struct npu_set_ab_start_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t ab_start : 6; // Start of ACC0,ACC1 buffers in the SHRAM in KB units. Multiple of 2 - uint32_t reserved1 : 10; -#ifdef __cplusplus - public: - npu_set_ab_start_t(uint32_t _ab_start) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_AB_START)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), ab_start(_ab_start & ((1U << 6) - 1)), - reserved1(0) - { - } - CONSTEXPR npu_set_ab_start_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_AB_START)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), ab_start(0), reserved1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_AB_START) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_AB_START); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ab_start_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ab_start_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_ab_start() const - { - return static_cast(ab_start); - } - CONSTEXPR npu_set_ab_start_t &set_ab_start(uint32_t value) - { - ab_start = static_cast(value) & ((1U << 6) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("ab_start", std::to_string(ab_start))); - } -#endif -#endif - }; - // Block number of blocks dependency - struct npu_set_blockdep_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t blockdep : 2; // Block number of blocks dependency between kernel operations - uint32_t reserved1 : 14; -#ifdef __cplusplus - public: - npu_set_blockdep_t(uint32_t _blockdep) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_BLOCKDEP)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), blockdep(_blockdep & ((1U << 2) - 1)), - reserved1(0) - { - } - CONSTEXPR npu_set_blockdep_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_BLOCKDEP)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), blockdep(0), reserved1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_BLOCKDEP) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_BLOCKDEP); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_blockdep_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_blockdep_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_blockdep() const - { - return static_cast(blockdep); - } - CONSTEXPR npu_set_blockdep_t &set_blockdep(uint32_t value) - { - blockdep = static_cast(value) & ((1U << 2) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("blockdep", std::to_string(blockdep))); - } -#endif -#endif - }; - // DMA0 source region - struct npu_set_dma0_src_region_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t region : 3; // Region number - uint32_t reserved1 : 5; - uint32_t region_mode : 1; // Region mode - uint32_t stride_mode : 2; // Stride mode - uint32_t reserved2 : 4; - uint32_t custom_dma_cs : 1; // Custom DMA select -#ifdef __cplusplus - public: - npu_set_dma0_src_region_t(uint32_t _region, - NPU_NAMESPACE::dma_region_mode _region_mode, - NPU_NAMESPACE::dma_stride_mode _stride_mode, - NPU_NAMESPACE::custom_dma_cs _custom_dma_cs) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_SRC_REGION)), - reserved0(0), control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - region(_region & ((1U << 3) - 1)), reserved1(0), - region_mode(static_cast(_region_mode) & ((1U << 1) - 1)), - stride_mode(static_cast(_stride_mode) & ((1U << 2) - 1)), reserved2(0), - custom_dma_cs(static_cast(_custom_dma_cs) & ((1U << 1) - 1)) - { - } - CONSTEXPR npu_set_dma0_src_region_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_SRC_REGION)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), region(0), reserved1(0), region_mode(0), - stride_mode(0), reserved2(0), custom_dma_cs(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_SRC_REGION) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_SRC_REGION); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_dma0_src_region_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_dma0_src_region_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_region() const - { - return static_cast(region); - } - CONSTEXPR npu_set_dma0_src_region_t &set_region(uint32_t value) - { - region = static_cast(value) & ((1U << 3) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::dma_region_mode get_region_mode() const - { - return static_cast(region_mode); - } - CONSTEXPR npu_set_dma0_src_region_t &set_region_mode(NPU_NAMESPACE::dma_region_mode value) - { - region_mode = static_cast(value) & ((1U << 1) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::dma_stride_mode get_stride_mode() const - { - return static_cast(stride_mode); - } - CONSTEXPR npu_set_dma0_src_region_t &set_stride_mode(NPU_NAMESPACE::dma_stride_mode value) - { - stride_mode = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::custom_dma_cs get_custom_dma_cs() const - { - return static_cast(custom_dma_cs); - } - CONSTEXPR npu_set_dma0_src_region_t &set_custom_dma_cs(NPU_NAMESPACE::custom_dma_cs value) - { - custom_dma_cs = static_cast(value) & ((1U << 1) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("region", std::to_string(region))); - fields.push_back(std::make_pair( - "region_mode", - (region_mode < (sizeof(dma_region_mode_str) / sizeof(dma_region_mode_str[0])) ? - dma_region_mode_str[region_mode] : - "****"))); - fields.push_back(std::make_pair( - "stride_mode", - (stride_mode < (sizeof(dma_stride_mode_str) / sizeof(dma_stride_mode_str[0])) ? - dma_stride_mode_str[stride_mode] : - "****"))); - fields.push_back(std::make_pair( - "custom_dma_cs", - (custom_dma_cs < (sizeof(custom_dma_cs_str) / sizeof(custom_dma_cs_str[0])) ? - custom_dma_cs_str[custom_dma_cs] : - "****"))); - } -#endif -#endif - }; - // DMA0 destination region - struct npu_set_dma0_dst_region_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t region : 3; // Region number if region_mode is region_mode_external. Else core mask to write to (bit k - // set for core k=0,1) - uint32_t reserved1 : 5; - uint32_t region_mode : 1; // Region mode - uint32_t stride_mode : 2; // Stride mode - uint32_t reserved2 : 4; - uint32_t custom_dma_cs : 1; // Custom DMA select -#ifdef __cplusplus - public: - npu_set_dma0_dst_region_t(uint32_t _region, - NPU_NAMESPACE::dma_region_mode _region_mode, - NPU_NAMESPACE::dma_stride_mode _stride_mode, - NPU_NAMESPACE::custom_dma_cs _custom_dma_cs) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_DST_REGION)), - reserved0(0), control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - region(_region & ((1U << 3) - 1)), reserved1(0), - region_mode(static_cast(_region_mode) & ((1U << 1) - 1)), - stride_mode(static_cast(_stride_mode) & ((1U << 2) - 1)), reserved2(0), - custom_dma_cs(static_cast(_custom_dma_cs) & ((1U << 1) - 1)) - { - } - CONSTEXPR npu_set_dma0_dst_region_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_DST_REGION)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), region(0), reserved1(0), region_mode(0), - stride_mode(0), reserved2(0), custom_dma_cs(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_DST_REGION) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_DST_REGION); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_dma0_dst_region_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_dma0_dst_region_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_region() const - { - return static_cast(region); - } - CONSTEXPR npu_set_dma0_dst_region_t &set_region(uint32_t value) - { - region = static_cast(value) & ((1U << 3) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::dma_region_mode get_region_mode() const - { - return static_cast(region_mode); - } - CONSTEXPR npu_set_dma0_dst_region_t &set_region_mode(NPU_NAMESPACE::dma_region_mode value) - { - region_mode = static_cast(value) & ((1U << 1) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::dma_stride_mode get_stride_mode() const - { - return static_cast(stride_mode); - } - CONSTEXPR npu_set_dma0_dst_region_t &set_stride_mode(NPU_NAMESPACE::dma_stride_mode value) - { - stride_mode = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::custom_dma_cs get_custom_dma_cs() const - { - return static_cast(custom_dma_cs); - } - CONSTEXPR npu_set_dma0_dst_region_t &set_custom_dma_cs(NPU_NAMESPACE::custom_dma_cs value) - { - custom_dma_cs = static_cast(value) & ((1U << 1) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("region", std::to_string(region))); - fields.push_back(std::make_pair( - "region_mode", - (region_mode < (sizeof(dma_region_mode_str) / sizeof(dma_region_mode_str[0])) ? - dma_region_mode_str[region_mode] : - "****"))); - fields.push_back(std::make_pair( - "stride_mode", - (stride_mode < (sizeof(dma_stride_mode_str) / sizeof(dma_stride_mode_str[0])) ? - dma_stride_mode_str[stride_mode] : - "****"))); - fields.push_back(std::make_pair( - "custom_dma_cs", - (custom_dma_cs < (sizeof(custom_dma_cs_str) / sizeof(custom_dma_cs_str[0])) ? - custom_dma_cs_str[custom_dma_cs] : - "****"))); - } -#endif -#endif - }; - // Size of second dimension for 2D/3D transfers - struct npu_set_dma0_size0_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t size : 16; // Size of second dimension for 2D/3D transfers -#ifdef __cplusplus - public: - npu_set_dma0_size0_t(uint32_t _size) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_SIZE0)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), size(_size & ((1U << 16) - 1)) - { - } - CONSTEXPR npu_set_dma0_size0_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_SIZE0)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), size(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_SIZE0) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_SIZE0); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_dma0_size0_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_dma0_size0_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_size() const - { - return static_cast(size); - } - CONSTEXPR npu_set_dma0_size0_t &set_size(uint32_t value) - { - size = static_cast(value) & ((1U << 16) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("size", std::to_string(size))); - } -#endif -#endif - }; - // Size of third dimension for 3D transfers - struct npu_set_dma0_size1_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t size : 16; // Size of third dimension for 3D transfers -#ifdef __cplusplus - public: - npu_set_dma0_size1_t(uint32_t _size) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_SIZE1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), size(_size & ((1U << 16) - 1)) - { - } - CONSTEXPR npu_set_dma0_size1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_SIZE1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), size(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_SIZE1) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_SIZE1); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_dma0_size1_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_dma0_size1_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_size() const - { - return static_cast(size); - } - CONSTEXPR npu_set_dma0_size1_t &set_size(uint32_t value) - { - size = static_cast(value) & ((1U << 16) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("size", std::to_string(size))); - } -#endif -#endif - }; - // IFM2 broadcast configuration - struct npu_set_ifm2_broadcast_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t - broadcast_h : 1; // Broadcast H dimension (if set then any accesses to IFM2 sets y=0 and IFM2 height=1) - uint32_t broadcast_w : 1; // Broadcast W dimension (if set then any accesses to IFM2 sets x=0 and IFM2 width=1) - uint32_t broadcast_c : 1; // Broadcast C dimension (if set then any accesses to IFM2 sets c=0 and IFM2 depth=1) - uint32_t reserved1 : 3; - uint32_t operand_order : 1; // Operand order - uint32_t broadcast_constant : 1; // Broadcast constant given by NPU_SET_IFM2_SCALAR and so ignore BH, BW and BC - uint32_t reserved2 : 8; -#ifdef __cplusplus - public: - npu_set_ifm2_broadcast_t(NPU_NAMESPACE::broadcast_mode _broadcast_h, - NPU_NAMESPACE::broadcast_mode _broadcast_w, - NPU_NAMESPACE::broadcast_mode _broadcast_c, - NPU_NAMESPACE::ifm2_operand_order _operand_order, - NPU_NAMESPACE::broadcast_mode _broadcast_constant) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_BROADCAST)), - reserved0(0), control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - broadcast_h(static_cast(_broadcast_h) & ((1U << 1) - 1)), - broadcast_w(static_cast(_broadcast_w) & ((1U << 1) - 1)), - broadcast_c(static_cast(_broadcast_c) & ((1U << 1) - 1)), reserved1(0), - operand_order(static_cast(_operand_order) & ((1U << 1) - 1)), - broadcast_constant(static_cast(_broadcast_constant) & ((1U << 1) - 1)), reserved2(0) - { - } - CONSTEXPR npu_set_ifm2_broadcast_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_BROADCAST)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), broadcast_h(0), broadcast_w(0), - broadcast_c(0), reserved1(0), operand_order(0), broadcast_constant(0), reserved2(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_BROADCAST) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_BROADCAST); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm2_broadcast_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm2_broadcast_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::broadcast_mode get_broadcast_h() const - { - return static_cast(broadcast_h); - } - CONSTEXPR npu_set_ifm2_broadcast_t &set_broadcast_h(NPU_NAMESPACE::broadcast_mode value) - { - broadcast_h = static_cast(value) & ((1U << 1) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::broadcast_mode get_broadcast_w() const - { - return static_cast(broadcast_w); - } - CONSTEXPR npu_set_ifm2_broadcast_t &set_broadcast_w(NPU_NAMESPACE::broadcast_mode value) - { - broadcast_w = static_cast(value) & ((1U << 1) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::broadcast_mode get_broadcast_c() const - { - return static_cast(broadcast_c); - } - CONSTEXPR npu_set_ifm2_broadcast_t &set_broadcast_c(NPU_NAMESPACE::broadcast_mode value) - { - broadcast_c = static_cast(value) & ((1U << 1) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::ifm2_operand_order get_operand_order() const - { - return static_cast(operand_order); - } - CONSTEXPR npu_set_ifm2_broadcast_t &set_operand_order(NPU_NAMESPACE::ifm2_operand_order value) - { - operand_order = static_cast(value) & ((1U << 1) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::broadcast_mode get_broadcast_constant() const - { - return static_cast(broadcast_constant); - } - CONSTEXPR npu_set_ifm2_broadcast_t &set_broadcast_constant(NPU_NAMESPACE::broadcast_mode value) - { - broadcast_constant = static_cast(value) & ((1U << 1) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair( - "broadcast_h", - (broadcast_h < (sizeof(broadcast_mode_str) / sizeof(broadcast_mode_str[0])) ? - broadcast_mode_str[broadcast_h] : - "****"))); - fields.push_back(std::make_pair( - "broadcast_w", - (broadcast_w < (sizeof(broadcast_mode_str) / sizeof(broadcast_mode_str[0])) ? - broadcast_mode_str[broadcast_w] : - "****"))); - fields.push_back(std::make_pair( - "broadcast_c", - (broadcast_c < (sizeof(broadcast_mode_str) / sizeof(broadcast_mode_str[0])) ? - broadcast_mode_str[broadcast_c] : - "****"))); - fields.push_back(std::make_pair( - "operand_order", - (operand_order < (sizeof(ifm2_operand_order_str) / sizeof(ifm2_operand_order_str[0])) ? - ifm2_operand_order_str[operand_order] : - "****"))); - fields.push_back(std::make_pair( - "broadcast_constant", - (broadcast_constant < (sizeof(broadcast_mode_str) / sizeof(broadcast_mode_str[0])) ? - broadcast_mode_str[broadcast_constant] : - "****"))); - } -#endif -#endif - }; - // IFM2 scalar value - struct npu_set_ifm2_scalar_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t scalar : 16; // int16 or uint16 depending on ifm2_precision.type -#ifdef __cplusplus - public: - npu_set_ifm2_scalar_t(uint32_t _scalar) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_SCALAR)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), scalar(_scalar & ((1U << 16) - 1)) - { - } - CONSTEXPR npu_set_ifm2_scalar_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_SCALAR)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), scalar(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_SCALAR) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_SCALAR); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm2_scalar_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm2_scalar_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_scalar() const - { - return static_cast(scalar); - } - CONSTEXPR npu_set_ifm2_scalar_t &set_scalar(uint32_t value) - { - scalar = static_cast(value) & ((1U << 16) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("scalar", std::to_string(scalar))); - } -#endif -#endif - }; - // IFM2 Precision - struct npu_set_ifm2_precision_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t activation_type : 1; // IFM type - MUST MATCH IFM - uint32_t reserved1 : 1; - uint32_t activation_precision : 2; // IFM precision - MUST MATCH IFM - uint32_t reserved2 : 2; - uint32_t activation_format : 2; // IFM format - uint32_t reserved3 : 8; -#ifdef __cplusplus - public: - npu_set_ifm2_precision_t(NPU_NAMESPACE::activation_type _activation_type, - NPU_NAMESPACE::activation_precision _activation_precision, - NPU_NAMESPACE::activation_format _activation_format) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_PRECISION)), - reserved0(0), control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - activation_type(static_cast(_activation_type) & ((1U << 1) - 1)), reserved1(0), - activation_precision(static_cast(_activation_precision) & ((1U << 2) - 1)), reserved2(0), - activation_format(static_cast(_activation_format) & ((1U << 2) - 1)), reserved3(0) - { - } - CONSTEXPR npu_set_ifm2_precision_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_PRECISION)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), activation_type(0), reserved1(0), - activation_precision(0), reserved2(0), activation_format(0), reserved3(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_PRECISION) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_PRECISION); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm2_precision_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm2_precision_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::activation_type get_activation_type() const - { - return static_cast(activation_type); - } - CONSTEXPR npu_set_ifm2_precision_t &set_activation_type(NPU_NAMESPACE::activation_type value) - { - activation_type = static_cast(value) & ((1U << 1) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::activation_precision get_activation_precision() const - { - return static_cast(activation_precision); - } - CONSTEXPR npu_set_ifm2_precision_t &set_activation_precision(NPU_NAMESPACE::activation_precision value) - { - activation_precision = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::activation_format get_activation_format() const - { - return static_cast(activation_format); - } - CONSTEXPR npu_set_ifm2_precision_t &set_activation_format(NPU_NAMESPACE::activation_format value) - { - activation_format = static_cast(value) & ((1U << 2) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair( - "activation_type", - (activation_type < (sizeof(activation_type_str) / sizeof(activation_type_str[0])) ? - activation_type_str[activation_type] : - "****"))); - fields.push_back(std::make_pair( - "activation_precision", - (activation_precision < (sizeof(activation_precision_str) / sizeof(activation_precision_str[0])) ? - activation_precision_str[activation_precision] : - "****"))); - fields.push_back(std::make_pair( - "activation_format", - (activation_format < (sizeof(activation_format_str) / sizeof(activation_format_str[0])) ? - activation_format_str[activation_format] : - "****"))); - } -#endif -#endif - }; - // IFM2 zero point - struct npu_set_ifm2_zero_point_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t zero_point : 16; // Zero point offset -#ifdef __cplusplus - public: - npu_set_ifm2_zero_point_t(uint32_t _zero_point) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_ZERO_POINT)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - zero_point(_zero_point & ((1U << 16) - 1)) - { - } - CONSTEXPR npu_set_ifm2_zero_point_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_ZERO_POINT)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), zero_point(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_ZERO_POINT) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_ZERO_POINT); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm2_zero_point_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm2_zero_point_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_zero_point() const - { - return static_cast(zero_point); - } - CONSTEXPR npu_set_ifm2_zero_point_t &set_zero_point(uint32_t value) - { - zero_point = static_cast(value) & ((1U << 16) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("zero_point", std::to_string(zero_point))); - } -#endif -#endif - }; - // IFM2 Tile 0 and tile 2 width - struct npu_set_ifm2_width0_m1_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t width_m1 : 16; // IFM2 Tile 0 and tile 2 width -#ifdef __cplusplus - public: - npu_set_ifm2_width0_m1_t(uint32_t _width_m1) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_WIDTH0_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), width_m1(_width_m1 & ((1U << 16) - 1)) - { - } - CONSTEXPR npu_set_ifm2_width0_m1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_WIDTH0_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), width_m1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_WIDTH0_M1) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_WIDTH0_M1); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm2_width0_m1_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm2_width0_m1_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_width_m1() const - { - return static_cast(width_m1); - } - CONSTEXPR npu_set_ifm2_width0_m1_t &set_width_m1(uint32_t value) - { - width_m1 = static_cast(value) & ((1U << 16) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("width_m1", std::to_string(width_m1))); - } -#endif -#endif - }; - // IFM2 Tile 0 height - struct npu_set_ifm2_height0_m1_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t height_m1 : 16; // IFM2 Tile 0 height -#ifdef __cplusplus - public: - npu_set_ifm2_height0_m1_t(uint32_t _height_m1) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_HEIGHT0_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), height_m1(_height_m1 & ((1U << 16) - 1)) - { - } - CONSTEXPR npu_set_ifm2_height0_m1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_HEIGHT0_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), height_m1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_HEIGHT0_M1) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_HEIGHT0_M1); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm2_height0_m1_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm2_height0_m1_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_height_m1() const - { - return static_cast(height_m1); - } - CONSTEXPR npu_set_ifm2_height0_m1_t &set_height_m1(uint32_t value) - { - height_m1 = static_cast(value) & ((1U << 16) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("height_m1", std::to_string(height_m1))); - } -#endif -#endif - }; - // IFM2 Tile 1 height - struct npu_set_ifm2_height1_m1_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t height_m1 : 16; // IFM2 Tile 1 height -#ifdef __cplusplus - public: - npu_set_ifm2_height1_m1_t(uint32_t _height_m1) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_HEIGHT1_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), height_m1(_height_m1 & ((1U << 16) - 1)) - { - } - CONSTEXPR npu_set_ifm2_height1_m1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_HEIGHT1_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), height_m1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_HEIGHT1_M1) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_HEIGHT1_M1); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm2_height1_m1_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm2_height1_m1_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_height_m1() const - { - return static_cast(height_m1); - } - CONSTEXPR npu_set_ifm2_height1_m1_t &set_height_m1(uint32_t value) - { - height_m1 = static_cast(value) & ((1U << 16) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("height_m1", std::to_string(height_m1))); - } -#endif -#endif - }; - // Start of IB0,IB1 buffers for IFM2 - struct npu_set_ifm2_ib_start_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t ib_start : 6; // Start of IB0,IB1 buffers for IFM2 in the SHRAM in KB units. Multiple of 2 - uint32_t reserved1 : 10; -#ifdef __cplusplus - public: - npu_set_ifm2_ib_start_t(uint32_t _ib_start) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_IB_START)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), ib_start(_ib_start & ((1U << 6) - 1)), - reserved1(0) - { - } - CONSTEXPR npu_set_ifm2_ib_start_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_IB_START)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), ib_start(0), reserved1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_IB_START) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_IB_START); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm2_ib_start_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm2_ib_start_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_ib_start() const - { - return static_cast(ib_start); - } - CONSTEXPR npu_set_ifm2_ib_start_t &set_ib_start(uint32_t value) - { - ib_start = static_cast(value) & ((1U << 6) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("ib_start", std::to_string(ib_start))); - } -#endif -#endif - }; - // Index n for IFM2 access - struct npu_set_ifm2_region_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t region : 3; // Index n for IFM2 access - uint32_t reserved1 : 13; -#ifdef __cplusplus - public: - npu_set_ifm2_region_t(uint32_t _region) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_REGION)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), region(_region & ((1U << 3) - 1)), - reserved1(0) - { - } - CONSTEXPR npu_set_ifm2_region_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_REGION)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), region(0), reserved1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_REGION) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_REGION); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm2_region_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm2_region_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_region() const - { - return static_cast(region); - } - CONSTEXPR npu_set_ifm2_region_t &set_region(uint32_t value) - { - region = static_cast(value) & ((1U << 3) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("region", std::to_string(region))); - } -#endif -#endif - }; - // IFM Tile 0 address - struct npu_set_ifm_base0_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t reserved1 : 16; - uint32_t addr : 32; // address offset -#ifdef __cplusplus - public: - npu_set_ifm_base0_t(uint32_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_BASE0)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), addr(_addr) - { - } - CONSTEXPR npu_set_ifm_base0_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_BASE0)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), addr(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_BASE0) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_BASE0); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd1_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm_base0_t &set_opcode(NPU_NAMESPACE::cmd1_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm_base0_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_addr() const - { - return static_cast(addr); - } - CONSTEXPR npu_set_ifm_base0_t &set_addr(uint32_t value) - { - addr = value; - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - std::stringstream saddr; - saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif - }; - // IFM Tile 1 address - struct npu_set_ifm_base1_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t reserved1 : 16; - uint32_t addr : 32; // address offset -#ifdef __cplusplus - public: - npu_set_ifm_base1_t(uint32_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_BASE1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), addr(_addr) - { - } - CONSTEXPR npu_set_ifm_base1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_BASE1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), addr(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_BASE1) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_BASE1); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd1_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm_base1_t &set_opcode(NPU_NAMESPACE::cmd1_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm_base1_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_addr() const - { - return static_cast(addr); - } - CONSTEXPR npu_set_ifm_base1_t &set_addr(uint32_t value) - { - addr = value; - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - std::stringstream saddr; - saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif - }; - // IFM Tile 2 address - struct npu_set_ifm_base2_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t reserved1 : 16; - uint32_t addr : 32; // address offset -#ifdef __cplusplus - public: - npu_set_ifm_base2_t(uint32_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_BASE2)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), addr(_addr) - { - } - CONSTEXPR npu_set_ifm_base2_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_BASE2)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), addr(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_BASE2) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_BASE2); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd1_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm_base2_t &set_opcode(NPU_NAMESPACE::cmd1_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm_base2_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_addr() const - { - return static_cast(addr); - } - CONSTEXPR npu_set_ifm_base2_t &set_addr(uint32_t value) - { - addr = value; - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - std::stringstream saddr; - saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif - }; - // IFM Tile 3 address - struct npu_set_ifm_base3_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t reserved1 : 16; - uint32_t addr : 32; // address offset -#ifdef __cplusplus - public: - npu_set_ifm_base3_t(uint32_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_BASE3)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), addr(_addr) - { - } - CONSTEXPR npu_set_ifm_base3_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_BASE3)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), addr(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_BASE3) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_BASE3); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd1_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm_base3_t &set_opcode(NPU_NAMESPACE::cmd1_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm_base3_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_addr() const - { - return static_cast(addr); - } - CONSTEXPR npu_set_ifm_base3_t &set_addr(uint32_t value) - { - addr = value; - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - std::stringstream saddr; - saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif - }; - // IFM byte stride between horizontal values - struct npu_set_ifm_stride_x_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t reserved1 : 16; - uint32_t addr : 32; // address offset -#ifdef __cplusplus - public: - npu_set_ifm_stride_x_t(uint32_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_STRIDE_X)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), addr(_addr) - { - } - CONSTEXPR npu_set_ifm_stride_x_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_STRIDE_X)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), addr(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_STRIDE_X) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_STRIDE_X); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd1_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm_stride_x_t &set_opcode(NPU_NAMESPACE::cmd1_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm_stride_x_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_addr() const - { - return static_cast(addr); - } - CONSTEXPR npu_set_ifm_stride_x_t &set_addr(uint32_t value) - { - addr = value; - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - std::stringstream saddr; - saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif - }; - // IFM byte stride between vertical values - struct npu_set_ifm_stride_y_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t reserved1 : 16; - uint32_t addr : 32; // address offset -#ifdef __cplusplus - public: - npu_set_ifm_stride_y_t(uint32_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_STRIDE_Y)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), addr(_addr) - { - } - CONSTEXPR npu_set_ifm_stride_y_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_STRIDE_Y)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), addr(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_STRIDE_Y) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_STRIDE_Y); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd1_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm_stride_y_t &set_opcode(NPU_NAMESPACE::cmd1_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm_stride_y_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_addr() const - { - return static_cast(addr); - } - CONSTEXPR npu_set_ifm_stride_y_t &set_addr(uint32_t value) - { - addr = value; - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - std::stringstream saddr; - saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif - }; - // IFM byte stride between channel blocks (of 16 bytes each block) - struct npu_set_ifm_stride_c_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t reserved1 : 16; - uint32_t addr : 32; // address offset -#ifdef __cplusplus - public: - npu_set_ifm_stride_c_t(uint32_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_STRIDE_C)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), addr(_addr) - { - } - CONSTEXPR npu_set_ifm_stride_c_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_STRIDE_C)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), addr(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_STRIDE_C) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_STRIDE_C); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd1_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm_stride_c_t &set_opcode(NPU_NAMESPACE::cmd1_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm_stride_c_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_addr() const - { - return static_cast(addr); - } - CONSTEXPR npu_set_ifm_stride_c_t &set_addr(uint32_t value) - { - addr = value; - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - std::stringstream saddr; - saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif - }; - // OFM Tile 0 address - struct npu_set_ofm_base0_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t reserved1 : 16; - uint32_t addr : 32; // address offset -#ifdef __cplusplus - public: - npu_set_ofm_base0_t(uint32_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_BASE0)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), addr(_addr) - { - } - CONSTEXPR npu_set_ofm_base0_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_BASE0)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), addr(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_BASE0) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_BASE0); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd1_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ofm_base0_t &set_opcode(NPU_NAMESPACE::cmd1_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ofm_base0_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_addr() const - { - return static_cast(addr); - } - CONSTEXPR npu_set_ofm_base0_t &set_addr(uint32_t value) - { - addr = value; - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - std::stringstream saddr; - saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif - }; - // OFM Tile 1 address - struct npu_set_ofm_base1_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t reserved1 : 16; - uint32_t addr : 32; // address offset -#ifdef __cplusplus - public: - npu_set_ofm_base1_t(uint32_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_BASE1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), addr(_addr) - { - } - CONSTEXPR npu_set_ofm_base1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_BASE1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), addr(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_BASE1) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_BASE1); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd1_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ofm_base1_t &set_opcode(NPU_NAMESPACE::cmd1_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ofm_base1_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_addr() const - { - return static_cast(addr); - } - CONSTEXPR npu_set_ofm_base1_t &set_addr(uint32_t value) - { - addr = value; - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - std::stringstream saddr; - saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif - }; - // OFM Tile 2 address - struct npu_set_ofm_base2_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t reserved1 : 16; - uint32_t addr : 32; // address offset -#ifdef __cplusplus - public: - npu_set_ofm_base2_t(uint32_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_BASE2)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), addr(_addr) - { - } - CONSTEXPR npu_set_ofm_base2_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_BASE2)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), addr(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_BASE2) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_BASE2); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd1_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ofm_base2_t &set_opcode(NPU_NAMESPACE::cmd1_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ofm_base2_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_addr() const - { - return static_cast(addr); - } - CONSTEXPR npu_set_ofm_base2_t &set_addr(uint32_t value) - { - addr = value; - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - std::stringstream saddr; - saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif - }; - // OFM Tile 3 address - struct npu_set_ofm_base3_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t reserved1 : 16; - uint32_t addr : 32; // address offset -#ifdef __cplusplus - public: - npu_set_ofm_base3_t(uint32_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_BASE3)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), addr(_addr) - { - } - CONSTEXPR npu_set_ofm_base3_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_BASE3)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), addr(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_BASE3) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_BASE3); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd1_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ofm_base3_t &set_opcode(NPU_NAMESPACE::cmd1_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ofm_base3_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_addr() const - { - return static_cast(addr); - } - CONSTEXPR npu_set_ofm_base3_t &set_addr(uint32_t value) - { - addr = value; - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - std::stringstream saddr; - saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif - }; - // OFM byte stride between horizontal values - struct npu_set_ofm_stride_x_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t reserved1 : 16; - uint32_t addr : 32; // address offset -#ifdef __cplusplus - public: - npu_set_ofm_stride_x_t(uint32_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_STRIDE_X)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), addr(_addr) - { - } - CONSTEXPR npu_set_ofm_stride_x_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_STRIDE_X)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), addr(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_STRIDE_X) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_STRIDE_X); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd1_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ofm_stride_x_t &set_opcode(NPU_NAMESPACE::cmd1_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ofm_stride_x_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_addr() const - { - return static_cast(addr); - } - CONSTEXPR npu_set_ofm_stride_x_t &set_addr(uint32_t value) - { - addr = value; - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - std::stringstream saddr; - saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif - }; - // OFM byte stride between vertical values - struct npu_set_ofm_stride_y_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t reserved1 : 16; - uint32_t addr : 32; // address offset -#ifdef __cplusplus - public: - npu_set_ofm_stride_y_t(uint32_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_STRIDE_Y)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), addr(_addr) - { - } - CONSTEXPR npu_set_ofm_stride_y_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_STRIDE_Y)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), addr(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_STRIDE_Y) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_STRIDE_Y); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd1_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ofm_stride_y_t &set_opcode(NPU_NAMESPACE::cmd1_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ofm_stride_y_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_addr() const - { - return static_cast(addr); - } - CONSTEXPR npu_set_ofm_stride_y_t &set_addr(uint32_t value) - { - addr = value; - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - std::stringstream saddr; - saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif - }; - // OFM byte stride between channel blocks (of 16 bytes each block) - struct npu_set_ofm_stride_c_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t reserved1 : 16; - uint32_t addr : 32; // address offset -#ifdef __cplusplus - public: - npu_set_ofm_stride_c_t(uint32_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_STRIDE_C)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), addr(_addr) - { - } - CONSTEXPR npu_set_ofm_stride_c_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_STRIDE_C)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), addr(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_STRIDE_C) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_STRIDE_C); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd1_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ofm_stride_c_t &set_opcode(NPU_NAMESPACE::cmd1_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ofm_stride_c_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_addr() const - { - return static_cast(addr); - } - CONSTEXPR npu_set_ofm_stride_c_t &set_addr(uint32_t value) - { - addr = value; - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - std::stringstream saddr; - saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif - }; - // Weight stream byte offset in WEIGHT_REGION - struct npu_set_weight_base_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t reserved1 : 16; - uint32_t addr : 32; // address offset -#ifdef __cplusplus - public: - npu_set_weight_base_t(uint32_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT_BASE)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), addr(_addr) - { - } - CONSTEXPR npu_set_weight_base_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT_BASE)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), addr(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT_BASE) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT_BASE); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd1_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_weight_base_t &set_opcode(NPU_NAMESPACE::cmd1_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_weight_base_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_addr() const - { - return static_cast(addr); - } - CONSTEXPR npu_set_weight_base_t &set_addr(uint32_t value) - { - addr = value; - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - std::stringstream saddr; - saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif - }; - // Weight stream byte length - struct npu_set_weight_length_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t reserved1 : 16; - uint32_t length : 32; // Weight stream byte length -#ifdef __cplusplus - public: - npu_set_weight_length_t(uint32_t _length) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT_LENGTH)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), length(_length) - { - } - CONSTEXPR npu_set_weight_length_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT_LENGTH)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), length(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT_LENGTH) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT_LENGTH); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd1_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_weight_length_t &set_opcode(NPU_NAMESPACE::cmd1_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_weight_length_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_length() const - { - return static_cast(length); - } - CONSTEXPR npu_set_weight_length_t &set_length(uint32_t value) - { - length = value; - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("length", std::to_string(length))); - } -#endif -#endif - }; - // Scale and bias stream input byte offset from SCALE_REGION - struct npu_set_scale_base_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t reserved1 : 16; - uint32_t addr : 32; // address offset -#ifdef __cplusplus - public: - npu_set_scale_base_t(uint32_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_SCALE_BASE)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), addr(_addr) - { - } - CONSTEXPR npu_set_scale_base_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_SCALE_BASE)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), addr(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_SCALE_BASE) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_SCALE_BASE); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd1_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_scale_base_t &set_opcode(NPU_NAMESPACE::cmd1_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_scale_base_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_addr() const - { - return static_cast(addr); - } - CONSTEXPR npu_set_scale_base_t &set_addr(uint32_t value) - { - addr = value; - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - std::stringstream saddr; - saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif - }; - // Scale and bias stream input byte length - struct npu_set_scale_length_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t reserved1 : 16; - uint32_t length : 20; // Scale and bias stream byte length - uint32_t reserved2 : 12; -#ifdef __cplusplus - public: - npu_set_scale_length_t(uint32_t _length) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_SCALE_LENGTH)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), - length(_length & ((1U << 20) - 1)), reserved2(0) - { - } - CONSTEXPR npu_set_scale_length_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_SCALE_LENGTH)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), length(0), reserved2(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_SCALE_LENGTH) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_SCALE_LENGTH); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd1_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_scale_length_t &set_opcode(NPU_NAMESPACE::cmd1_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_scale_length_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_length() const - { - return static_cast(length); - } - CONSTEXPR npu_set_scale_length_t &set_length(uint32_t value) - { - length = value & ((1U << 20) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("length", std::to_string(length))); - } -#endif -#endif - }; - // OFM scale - struct npu_set_ofm_scale_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t shift : 6; // Shift - uint32_t reserved1 : 10; - uint32_t scale : 32; // Scale. Not applied for 32-bit operations -#ifdef __cplusplus - public: - npu_set_ofm_scale_t(uint32_t _shift, uint32_t _scale) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_SCALE)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), shift(_shift & ((1U << 6) - 1)), - reserved1(0), scale(_scale) - { - } - CONSTEXPR npu_set_ofm_scale_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_SCALE)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), shift(0), reserved1(0), scale(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_SCALE) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_SCALE); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd1_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ofm_scale_t &set_opcode(NPU_NAMESPACE::cmd1_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ofm_scale_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_shift() const - { - return static_cast(shift); - } - CONSTEXPR npu_set_ofm_scale_t &set_shift(uint32_t value) - { - shift = static_cast(value) & ((1U << 6) - 1); - return *this; - } - CONSTEXPR uint32_t get_scale() const - { - return static_cast(scale); - } - CONSTEXPR npu_set_ofm_scale_t &set_scale(uint32_t value) - { - scale = value; - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("shift", std::to_string(shift))); - fields.push_back(std::make_pair("scale", std::to_string(scale))); - } -#endif -#endif - }; - // Input operand A scale - struct npu_set_opa_scale_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t shift : 6; // Shift. Ignored if IFM scale mode is 0 - uint32_t reserved1 : 10; - uint32_t scale : 32; // Scale. 16-bit if IFM scale mode is 0 -#ifdef __cplusplus - public: - npu_set_opa_scale_t(uint32_t _shift, uint32_t _scale) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OPA_SCALE)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), shift(_shift & ((1U << 6) - 1)), - reserved1(0), scale(_scale) - { - } - CONSTEXPR npu_set_opa_scale_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OPA_SCALE)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), shift(0), reserved1(0), scale(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OPA_SCALE) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OPA_SCALE); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd1_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_opa_scale_t &set_opcode(NPU_NAMESPACE::cmd1_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_opa_scale_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_shift() const - { - return static_cast(shift); - } - CONSTEXPR npu_set_opa_scale_t &set_shift(uint32_t value) - { - shift = static_cast(value) & ((1U << 6) - 1); - return *this; - } - CONSTEXPR uint32_t get_scale() const - { - return static_cast(scale); - } - CONSTEXPR npu_set_opa_scale_t &set_scale(uint32_t value) - { - scale = value; - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("shift", std::to_string(shift))); - fields.push_back(std::make_pair("scale", std::to_string(scale))); - } -#endif -#endif - }; - // Input operand B scale - struct npu_set_opb_scale_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t reserved1 : 16; - uint32_t scale : 16; // Scale. Not used if IFM scale mode is 1 or 2 - uint32_t reserved2 : 16; -#ifdef __cplusplus - public: - npu_set_opb_scale_t(uint32_t _scale) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OPB_SCALE)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), - scale(_scale & ((1U << 16) - 1)), reserved2(0) - { - } - CONSTEXPR npu_set_opb_scale_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OPB_SCALE)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), scale(0), reserved2(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OPB_SCALE) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OPB_SCALE); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd1_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_opb_scale_t &set_opcode(NPU_NAMESPACE::cmd1_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_opb_scale_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_scale() const - { - return static_cast(scale); - } - CONSTEXPR npu_set_opb_scale_t &set_scale(uint32_t value) - { - scale = static_cast(value) & ((1U << 16) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("scale", std::to_string(scale))); - } -#endif -#endif - }; - // DMA user channel 0 source byte offset from DMA0_SRC_REGION - struct npu_set_dma0_src_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t reserved1 : 16; - uint32_t addr : 32; // address offset -#ifdef __cplusplus - public: - npu_set_dma0_src_t(uint32_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_SRC)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), addr(_addr) - { - } - CONSTEXPR npu_set_dma0_src_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_SRC)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), addr(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_SRC) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_SRC); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd1_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_dma0_src_t &set_opcode(NPU_NAMESPACE::cmd1_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_dma0_src_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_addr() const - { - return static_cast(addr); - } - CONSTEXPR npu_set_dma0_src_t &set_addr(uint32_t value) - { - addr = value; - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - std::stringstream saddr; - saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif - }; - // DMA user channel 0 destination byte offset from DMA0_DST_REGION - struct npu_set_dma0_dst_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t reserved1 : 16; - uint32_t addr : 32; // address offset -#ifdef __cplusplus - public: - npu_set_dma0_dst_t(uint32_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_DST)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), addr(_addr) - { - } - CONSTEXPR npu_set_dma0_dst_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_DST)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), addr(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_DST) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_DST); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd1_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_dma0_dst_t &set_opcode(NPU_NAMESPACE::cmd1_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_dma0_dst_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_addr() const - { - return static_cast(addr); - } - CONSTEXPR npu_set_dma0_dst_t &set_addr(uint32_t value) - { - addr = value; - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - std::stringstream saddr; - saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif - }; - // DMA user channel 0 transfer length in bytes for each 1D transfer - struct npu_set_dma0_len_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t reserved1 : 16; - uint32_t addr : 32; // address offset -#ifdef __cplusplus - public: - npu_set_dma0_len_t(uint32_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_LEN)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), addr(_addr) - { - } - CONSTEXPR npu_set_dma0_len_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_LEN)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), addr(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_LEN) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_LEN); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd1_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_dma0_len_t &set_opcode(NPU_NAMESPACE::cmd1_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_dma0_len_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_addr() const - { - return static_cast(addr); - } - CONSTEXPR npu_set_dma0_len_t &set_addr(uint32_t value) - { - addr = value; - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - std::stringstream saddr; - saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif - }; - // IFM2 Tile 0 address - struct npu_set_ifm2_base0_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t reserved1 : 16; - uint32_t addr : 32; // address offset -#ifdef __cplusplus - public: - npu_set_ifm2_base0_t(uint32_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_BASE0)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), addr(_addr) - { - } - CONSTEXPR npu_set_ifm2_base0_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_BASE0)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), addr(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_BASE0) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_BASE0); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd1_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm2_base0_t &set_opcode(NPU_NAMESPACE::cmd1_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm2_base0_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_addr() const - { - return static_cast(addr); - } - CONSTEXPR npu_set_ifm2_base0_t &set_addr(uint32_t value) - { - addr = value; - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - std::stringstream saddr; - saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif - }; - // IFM2 Tile 1 address - struct npu_set_ifm2_base1_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t reserved1 : 16; - uint32_t addr : 32; // address offset -#ifdef __cplusplus - public: - npu_set_ifm2_base1_t(uint32_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_BASE1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), addr(_addr) - { - } - CONSTEXPR npu_set_ifm2_base1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_BASE1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), addr(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_BASE1) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_BASE1); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd1_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm2_base1_t &set_opcode(NPU_NAMESPACE::cmd1_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm2_base1_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_addr() const - { - return static_cast(addr); - } - CONSTEXPR npu_set_ifm2_base1_t &set_addr(uint32_t value) - { - addr = value; - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - std::stringstream saddr; - saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif - }; - // IFM2 Tile 2 address - struct npu_set_ifm2_base2_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t reserved1 : 16; - uint32_t addr : 32; // address offset -#ifdef __cplusplus - public: - npu_set_ifm2_base2_t(uint32_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_BASE2)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), addr(_addr) - { - } - CONSTEXPR npu_set_ifm2_base2_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_BASE2)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), addr(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_BASE2) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_BASE2); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd1_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm2_base2_t &set_opcode(NPU_NAMESPACE::cmd1_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm2_base2_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_addr() const - { - return static_cast(addr); - } - CONSTEXPR npu_set_ifm2_base2_t &set_addr(uint32_t value) - { - addr = value; - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - std::stringstream saddr; - saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif - }; - // IFM2 Tile 3 address - struct npu_set_ifm2_base3_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t reserved1 : 16; - uint32_t addr : 32; // address offset -#ifdef __cplusplus - public: - npu_set_ifm2_base3_t(uint32_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_BASE3)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), addr(_addr) - { - } - CONSTEXPR npu_set_ifm2_base3_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_BASE3)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), addr(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_BASE3) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_BASE3); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd1_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm2_base3_t &set_opcode(NPU_NAMESPACE::cmd1_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm2_base3_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_addr() const - { - return static_cast(addr); - } - CONSTEXPR npu_set_ifm2_base3_t &set_addr(uint32_t value) - { - addr = value; - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - std::stringstream saddr; - saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif - }; - // IFM2 byte stride between horizontal values - struct npu_set_ifm2_stride_x_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t reserved1 : 16; - uint32_t addr : 32; // address offset -#ifdef __cplusplus - public: - npu_set_ifm2_stride_x_t(uint32_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_STRIDE_X)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), addr(_addr) - { - } - CONSTEXPR npu_set_ifm2_stride_x_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_STRIDE_X)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), addr(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_STRIDE_X) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_STRIDE_X); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd1_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm2_stride_x_t &set_opcode(NPU_NAMESPACE::cmd1_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm2_stride_x_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_addr() const - { - return static_cast(addr); - } - CONSTEXPR npu_set_ifm2_stride_x_t &set_addr(uint32_t value) - { - addr = value; - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - std::stringstream saddr; - saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif - }; - // IFM2 byte stride between vertical values - struct npu_set_ifm2_stride_y_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t reserved1 : 16; - uint32_t addr : 32; // address offset -#ifdef __cplusplus - public: - npu_set_ifm2_stride_y_t(uint32_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_STRIDE_Y)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), addr(_addr) - { - } - CONSTEXPR npu_set_ifm2_stride_y_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_STRIDE_Y)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), addr(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_STRIDE_Y) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_STRIDE_Y); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd1_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm2_stride_y_t &set_opcode(NPU_NAMESPACE::cmd1_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm2_stride_y_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_addr() const - { - return static_cast(addr); - } - CONSTEXPR npu_set_ifm2_stride_y_t &set_addr(uint32_t value) - { - addr = value; - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - std::stringstream saddr; - saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif - }; - // IFM2 byte stride between channel blocks (of 16 bytes each block) - struct npu_set_ifm2_stride_c_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t reserved1 : 16; - uint32_t addr : 32; // address offset -#ifdef __cplusplus - public: - npu_set_ifm2_stride_c_t(uint32_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_STRIDE_C)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), addr(_addr) - { - } - CONSTEXPR npu_set_ifm2_stride_c_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_STRIDE_C)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), addr(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_STRIDE_C) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_STRIDE_C); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd1_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm2_stride_c_t &set_opcode(NPU_NAMESPACE::cmd1_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm2_stride_c_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_addr() const - { - return static_cast(addr); - } - CONSTEXPR npu_set_ifm2_stride_c_t &set_addr(uint32_t value) - { - addr = value; - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - std::stringstream saddr; - saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif - }; - // User defined register 0 - struct npu_set_user_defined0_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t reserved1 : 16; - uint32_t user_reg : 32; // User defined register -#ifdef __cplusplus - public: - npu_set_user_defined0_t(uint32_t _user_reg) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_USER_DEFINED0)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), user_reg(_user_reg) - { - } - CONSTEXPR npu_set_user_defined0_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_USER_DEFINED0)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), user_reg(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_USER_DEFINED0) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_USER_DEFINED0); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd1_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_user_defined0_t &set_opcode(NPU_NAMESPACE::cmd1_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_user_defined0_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_user_reg() const - { - return static_cast(user_reg); - } - CONSTEXPR npu_set_user_defined0_t &set_user_reg(uint32_t value) - { - user_reg = value; - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("user_reg", std::to_string(user_reg))); - } -#endif -#endif - }; - // User defined register 1 - struct npu_set_user_defined1_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t reserved1 : 16; - uint32_t user_reg : 32; // User defined register -#ifdef __cplusplus - public: - npu_set_user_defined1_t(uint32_t _user_reg) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_USER_DEFINED1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), user_reg(_user_reg) - { - } - CONSTEXPR npu_set_user_defined1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_USER_DEFINED1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), user_reg(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_USER_DEFINED1) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_USER_DEFINED1); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd1_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_user_defined1_t &set_opcode(NPU_NAMESPACE::cmd1_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_user_defined1_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_user_reg() const - { - return static_cast(user_reg); - } - CONSTEXPR npu_set_user_defined1_t &set_user_reg(uint32_t value) - { - user_reg = value; - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("user_reg", std::to_string(user_reg))); - } -#endif -#endif - }; - // User defined register 2 - struct npu_set_user_defined2_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t reserved1 : 16; - uint32_t user_reg : 32; // User defined register -#ifdef __cplusplus - public: - npu_set_user_defined2_t(uint32_t _user_reg) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_USER_DEFINED2)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), user_reg(_user_reg) - { - } - CONSTEXPR npu_set_user_defined2_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_USER_DEFINED2)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), user_reg(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_USER_DEFINED2) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_USER_DEFINED2); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd1_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_user_defined2_t &set_opcode(NPU_NAMESPACE::cmd1_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_user_defined2_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_user_reg() const - { - return static_cast(user_reg); - } - CONSTEXPR npu_set_user_defined2_t &set_user_reg(uint32_t value) - { - user_reg = value; - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("user_reg", std::to_string(user_reg))); - } -#endif -#endif - }; - // User defined register 3 - struct npu_set_user_defined3_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t reserved1 : 16; - uint32_t user_reg : 32; // User defined register -#ifdef __cplusplus - public: - npu_set_user_defined3_t(uint32_t _user_reg) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_USER_DEFINED3)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), user_reg(_user_reg) - { - } - CONSTEXPR npu_set_user_defined3_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_USER_DEFINED3)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), user_reg(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_USER_DEFINED3) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_USER_DEFINED3); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd1_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_user_defined3_t &set_opcode(NPU_NAMESPACE::cmd1_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_user_defined3_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_user_reg() const - { - return static_cast(user_reg); - } - CONSTEXPR npu_set_user_defined3_t &set_user_reg(uint32_t value) - { - user_reg = value; - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("user_reg", std::to_string(user_reg))); - } -#endif -#endif - }; - // User defined register 4 - struct npu_set_user_defined4_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t reserved1 : 16; - uint32_t user_reg : 32; // User defined register -#ifdef __cplusplus - public: - npu_set_user_defined4_t(uint32_t _user_reg) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_USER_DEFINED4)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), user_reg(_user_reg) - { - } - CONSTEXPR npu_set_user_defined4_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_USER_DEFINED4)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), user_reg(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_USER_DEFINED4) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_USER_DEFINED4); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd1_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_user_defined4_t &set_opcode(NPU_NAMESPACE::cmd1_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_user_defined4_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_user_reg() const - { - return static_cast(user_reg); - } - CONSTEXPR npu_set_user_defined4_t &set_user_reg(uint32_t value) - { - user_reg = value; - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("user_reg", std::to_string(user_reg))); - } -#endif -#endif - }; - // User defined register 5 - struct npu_set_user_defined5_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t reserved1 : 16; - uint32_t user_reg : 32; // User defined register -#ifdef __cplusplus - public: - npu_set_user_defined5_t(uint32_t _user_reg) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_USER_DEFINED5)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), user_reg(_user_reg) - { - } - CONSTEXPR npu_set_user_defined5_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_USER_DEFINED5)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), user_reg(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_USER_DEFINED5) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_USER_DEFINED5); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd1_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_user_defined5_t &set_opcode(NPU_NAMESPACE::cmd1_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_user_defined5_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_user_reg() const - { - return static_cast(user_reg); - } - CONSTEXPR npu_set_user_defined5_t &set_user_reg(uint32_t value) - { - user_reg = value; - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("user_reg", std::to_string(user_reg))); - } -#endif -#endif - }; - // User defined register 6 - struct npu_set_user_defined6_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t reserved1 : 16; - uint32_t user_reg : 32; // User defined register -#ifdef __cplusplus - public: - npu_set_user_defined6_t(uint32_t _user_reg) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_USER_DEFINED6)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), user_reg(_user_reg) - { - } - CONSTEXPR npu_set_user_defined6_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_USER_DEFINED6)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), user_reg(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_USER_DEFINED6) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_USER_DEFINED6); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd1_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_user_defined6_t &set_opcode(NPU_NAMESPACE::cmd1_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_user_defined6_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_user_reg() const - { - return static_cast(user_reg); - } - CONSTEXPR npu_set_user_defined6_t &set_user_reg(uint32_t value) - { - user_reg = value; - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("user_reg", std::to_string(user_reg))); - } -#endif -#endif - }; - // User defined register 7 - struct npu_set_user_defined7_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t reserved1 : 16; - uint32_t user_reg : 32; // User defined register -#ifdef __cplusplus - public: - npu_set_user_defined7_t(uint32_t _user_reg) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_USER_DEFINED7)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), user_reg(_user_reg) - { - } - CONSTEXPR npu_set_user_defined7_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_USER_DEFINED7)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), user_reg(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_USER_DEFINED7) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_USER_DEFINED7); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd1_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_user_defined7_t &set_opcode(NPU_NAMESPACE::cmd1_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_user_defined7_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_user_reg() const - { - return static_cast(user_reg); - } - CONSTEXPR npu_set_user_defined7_t &set_user_reg(uint32_t value) - { - user_reg = value; - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("user_reg", std::to_string(user_reg))); - } -#endif -#endif - }; -#ifdef __cplusplus -}; -#endif -#define NPU_OP_STRUCTS \ - NPU_OP_(stop) \ - NPU_OP_(irq) \ - NPU_OP_(conv) \ - NPU_OP_(depthwise) \ - NPU_OP_(pool) \ - NPU_OP_(elementwise) \ - NPU_OP_(dma_start) \ - NPU_OP_(dma_wait) \ - NPU_OP_(kernel_wait) \ - NPU_OP_(pmu_mask) - -#define NPU_SET_STRUCTS \ - NPU_SET_(ifm_pad_top) \ - NPU_SET_(ifm_pad_left) \ - NPU_SET_(ifm_pad_right) \ - NPU_SET_(ifm_pad_bottom) \ - NPU_SET_(ifm_depth_m1) \ - NPU_SET_(ifm_precision) \ - NPU_SET_(ifm_upscale) \ - NPU_SET_(ifm_zero_point) \ - NPU_SET_(ifm_width0_m1) \ - NPU_SET_(ifm_height0_m1) \ - NPU_SET_(ifm_height1_m1) \ - NPU_SET_(ifm_ib_end) \ - NPU_SET_(ifm_region) \ - NPU_SET_(ofm_width_m1) \ - NPU_SET_(ofm_height_m1) \ - NPU_SET_(ofm_depth_m1) \ - NPU_SET_(ofm_precision) \ - NPU_SET_(ofm_blk_width_m1) \ - NPU_SET_(ofm_blk_height_m1) \ - NPU_SET_(ofm_blk_depth_m1) \ - NPU_SET_(ofm_zero_point) \ - NPU_SET_(ofm_width0_m1) \ - NPU_SET_(ofm_height0_m1) \ - NPU_SET_(ofm_height1_m1) \ - NPU_SET_(ofm_region) \ - NPU_SET_(kernel_width_m1) \ - NPU_SET_(kernel_height_m1) \ - NPU_SET_(kernel_stride) \ - NPU_SET_(acc_format) \ - NPU_SET_(activation) \ - NPU_SET_(activation_min) \ - NPU_SET_(activation_max) \ - NPU_SET_(weight_region) \ - NPU_SET_(scale_region) \ - NPU_SET_(ab_start) \ - NPU_SET_(blockdep) \ - NPU_SET_(dma0_src_region) \ - NPU_SET_(dma0_dst_region) \ - NPU_SET_(dma0_size0) \ - NPU_SET_(dma0_size1) \ - NPU_SET_(ifm2_broadcast) \ - NPU_SET_(ifm2_scalar) \ - NPU_SET_(ifm2_precision) \ - NPU_SET_(ifm2_zero_point) \ - NPU_SET_(ifm2_width0_m1) \ - NPU_SET_(ifm2_height0_m1) \ - NPU_SET_(ifm2_height1_m1) \ - NPU_SET_(ifm2_ib_start) \ - NPU_SET_(ifm2_region) \ - NPU_SET_(ifm_base0) \ - NPU_SET_(ifm_base1) \ - NPU_SET_(ifm_base2) \ - NPU_SET_(ifm_base3) \ - NPU_SET_(ifm_stride_x) \ - NPU_SET_(ifm_stride_y) \ - NPU_SET_(ifm_stride_c) \ - NPU_SET_(ofm_base0) \ - NPU_SET_(ofm_base1) \ - NPU_SET_(ofm_base2) \ - NPU_SET_(ofm_base3) \ - NPU_SET_(ofm_stride_x) \ - NPU_SET_(ofm_stride_y) \ - NPU_SET_(ofm_stride_c) \ - NPU_SET_(weight_base) \ - NPU_SET_(weight_length) \ - NPU_SET_(scale_base) \ - NPU_SET_(scale_length) \ - NPU_SET_(ofm_scale) \ - NPU_SET_(opa_scale) \ - NPU_SET_(opb_scale) \ - NPU_SET_(dma0_src) \ - NPU_SET_(dma0_dst) \ - NPU_SET_(dma0_len) \ - NPU_SET_(ifm2_base0) \ - NPU_SET_(ifm2_base1) \ - NPU_SET_(ifm2_base2) \ - NPU_SET_(ifm2_base3) \ - NPU_SET_(ifm2_stride_x) \ - NPU_SET_(ifm2_stride_y) \ - NPU_SET_(ifm2_stride_c) \ - NPU_SET_(user_defined0) \ - NPU_SET_(user_defined1) \ - NPU_SET_(user_defined2) \ - NPU_SET_(user_defined3) \ - NPU_SET_(user_defined4) \ - NPU_SET_(user_defined5) \ - NPU_SET_(user_defined6) \ - NPU_SET_(user_defined7) - -#define EXPAND_ACC_FORMAT(FUNC, SEP) FUNC(acc_format, I32) SEP FUNC(acc_format, I40) SEP FUNC(acc_format, F16) - -#define EXPAND_ACTIVATION_CLIP_RANGE(FUNC, SEP) \ - FUNC(activation_clip_range, OFM_PRECISION) \ - SEP FUNC(activation_clip_range, FORCE_UINT8) SEP FUNC(activation_clip_range, FORCE_INT8) \ - SEP FUNC(activation_clip_range, FORCE_INT16) - -#define EXPAND_ACTIVATION_FORMAT(FUNC, SEP) FUNC(activation_format, NHWC) SEP FUNC(activation_format, NHCWB16) - -#define EXPAND_ACTIVATION_FUNCTION(FUNC, SEP) \ - FUNC(activation_function, RELU) \ - SEP FUNC(activation_function, TANH) SEP FUNC(activation_function, SIGMOID) SEP FUNC(activation_function, TABLE_0) \ - SEP FUNC(activation_function, TABLE_1) SEP FUNC(activation_function, TABLE_2) \ - SEP FUNC(activation_function, TABLE_3) SEP FUNC(activation_function, TABLE_4) \ - SEP FUNC(activation_function, TABLE_5) SEP FUNC(activation_function, TABLE_6) \ - SEP FUNC(activation_function, TABLE_7) - -#define EXPAND_ACTIVATION_PRECISION(FUNC, SEP) \ - FUNC(activation_precision, B8) \ - SEP FUNC(activation_precision, B16) SEP FUNC(activation_precision, B32) SEP FUNC(activation_precision, B64) - -#define EXPAND_ACTIVATION_TYPE(FUNC, SEP) FUNC(activation_type, UNSIGNED) SEP FUNC(activation_type, SIGNED) - -#define EXPAND_AXI_MEM_ENCODING(FUNC, SEP) \ - FUNC(axi_mem_encoding, DEVICE_NON_BUFFERABLE) \ - SEP FUNC(axi_mem_encoding, DEVICE_BUFFERABLE) SEP FUNC(axi_mem_encoding, NORMAL_NON_CACHEABLE_NON_BUFFERABLE) \ - SEP FUNC(axi_mem_encoding, NORMAL_NON_CACHEABLE_BUFFERABLE) \ - SEP FUNC(axi_mem_encoding, WRITE_THROUGH_NO_ALLOCATE) \ - SEP FUNC(axi_mem_encoding, WRITE_THROUGH_READ_ALLOCATE) \ - SEP FUNC(axi_mem_encoding, WRITE_THROUGH_WRITE_ALLOCATE) \ - SEP FUNC(axi_mem_encoding, WRITE_THROUGH_READ_AND_WRITE_ALLOCATE) \ - SEP FUNC(axi_mem_encoding, WRITE_BACK_NO_ALLOCATE) \ - SEP FUNC(axi_mem_encoding, WRITE_BACK_READ_ALLOCATE) \ - SEP FUNC(axi_mem_encoding, WRITE_BACK_WRITE_ALLOCATE) \ - SEP FUNC(axi_mem_encoding, WRITE_BACK_READ_AND_WRITE_ALLOCATE) - -#define EXPAND_BROADCAST_MODE(FUNC, SEP) FUNC(broadcast_mode, DISABLE) SEP FUNC(broadcast_mode, ENABLE) - -#define EXPAND_CMD0_OPCODE(FUNC, SEP) \ - FUNC(cmd0_opcode, NPU_OP_STOP) \ - SEP FUNC(cmd0_opcode, NPU_OP_IRQ) SEP FUNC(cmd0_opcode, NPU_OP_CONV) SEP FUNC( \ - cmd0_opcode, NPU_OP_DEPTHWISE) SEP FUNC(cmd0_opcode, NPU_OP_POOL) SEP FUNC(cmd0_opcode, NPU_OP_ELEMENTWISE) \ - SEP FUNC(cmd0_opcode, NPU_OP_DMA_START) SEP FUNC(cmd0_opcode, NPU_OP_DMA_WAIT) SEP FUNC( \ - cmd0_opcode, NPU_OP_KERNEL_WAIT) SEP FUNC(cmd0_opcode, NPU_OP_PMU_MASK) SEP FUNC(cmd0_opcode, \ - NPU_SET_IFM_PAD_TOP) \ - SEP FUNC(cmd0_opcode, NPU_SET_IFM_PAD_LEFT) SEP FUNC(cmd0_opcode, NPU_SET_IFM_PAD_RIGHT) SEP FUNC( \ - cmd0_opcode, NPU_SET_IFM_PAD_BOTTOM) SEP FUNC(cmd0_opcode, \ - NPU_SET_IFM_DEPTH_M1) SEP FUNC(cmd0_opcode, \ - NPU_SET_IFM_PRECISION) \ - SEP FUNC(cmd0_opcode, NPU_SET_IFM_UPSCALE) SEP FUNC(cmd0_opcode, NPU_SET_IFM_ZERO_POINT) SEP FUNC( \ - cmd0_opcode, NPU_SET_IFM_WIDTH0_M1) SEP FUNC(cmd0_opcode, NPU_SET_IFM_HEIGHT0_M1) \ - SEP FUNC(cmd0_opcode, NPU_SET_IFM_HEIGHT1_M1) SEP FUNC(cmd0_opcode, NPU_SET_IFM_IB_END) SEP FUNC( \ - cmd0_opcode, NPU_SET_IFM_REGION) SEP FUNC(cmd0_opcode, NPU_SET_OFM_WIDTH_M1) \ - SEP FUNC(cmd0_opcode, NPU_SET_OFM_HEIGHT_M1) SEP FUNC(cmd0_opcode, NPU_SET_OFM_DEPTH_M1) \ - SEP FUNC(cmd0_opcode, NPU_SET_OFM_PRECISION) SEP FUNC( \ - cmd0_opcode, NPU_SET_OFM_BLK_WIDTH_M1) SEP FUNC(cmd0_opcode, \ - NPU_SET_OFM_BLK_HEIGHT_M1) \ - SEP FUNC(cmd0_opcode, NPU_SET_OFM_BLK_DEPTH_M1) SEP FUNC( \ - cmd0_opcode, NPU_SET_OFM_ZERO_POINT) SEP FUNC(cmd0_opcode, NPU_SET_OFM_WIDTH0_M1) \ - SEP FUNC(cmd0_opcode, NPU_SET_OFM_HEIGHT0_M1) SEP FUNC( \ - cmd0_opcode, \ - NPU_SET_OFM_HEIGHT1_M1) SEP FUNC(cmd0_opcode, NPU_SET_OFM_REGION) \ - SEP FUNC(cmd0_opcode, NPU_SET_KERNEL_WIDTH_M1) SEP FUNC( \ - cmd0_opcode, \ - NPU_SET_KERNEL_HEIGHT_M1) SEP FUNC(cmd0_opcode, NPU_SET_KERNEL_STRIDE) \ - SEP FUNC(cmd0_opcode, NPU_SET_ACC_FORMAT) SEP FUNC( \ - cmd0_opcode, \ - NPU_SET_ACTIVATION) SEP FUNC(cmd0_opcode, NPU_SET_ACTIVATION_MIN) \ - SEP FUNC(cmd0_opcode, NPU_SET_ACTIVATION_MAX) SEP FUNC( \ - cmd0_opcode, \ - NPU_SET_WEIGHT_REGION) SEP FUNC(cmd0_opcode, NPU_SET_SCALE_REGION) \ - SEP FUNC(cmd0_opcode, \ - NPU_SET_AB_START) SEP FUNC(cmd0_opcode, NPU_SET_BLOCKDEP) \ - SEP FUNC(cmd0_opcode, NPU_SET_DMA0_SRC_REGION) SEP FUNC( \ - cmd0_opcode, \ - NPU_SET_DMA0_DST_REGION) SEP FUNC(cmd0_opcode, \ - NPU_SET_DMA0_SIZE0) \ - SEP FUNC(cmd0_opcode, NPU_SET_DMA0_SIZE1) SEP FUNC( \ - cmd0_opcode, \ - NPU_SET_IFM2_BROADCAST) \ - SEP FUNC(cmd0_opcode, NPU_SET_IFM2_SCALAR) SEP FUNC( \ - cmd0_opcode, \ - NPU_SET_IFM2_PRECISION) \ - SEP FUNC(cmd0_opcode, NPU_SET_IFM2_ZERO_POINT) \ - SEP FUNC(cmd0_opcode, NPU_SET_IFM2_WIDTH0_M1) \ - SEP FUNC(cmd0_opcode, \ - NPU_SET_IFM2_HEIGHT0_M1) \ - SEP FUNC(cmd0_opcode, \ - NPU_SET_IFM2_HEIGHT1_M1) \ - SEP FUNC(cmd0_opcode, \ - NPU_SET_IFM2_IB_START) \ - SEP FUNC(cmd0_opcode, \ - NPU_SET_IFM2_REGION) - -#define EXPAND_CMD1_OPCODE(FUNC, SEP) \ - FUNC(cmd1_opcode, NPU_SET_IFM_BASE0) \ - SEP FUNC(cmd1_opcode, NPU_SET_IFM_BASE1) SEP FUNC(cmd1_opcode, NPU_SET_IFM_BASE2) SEP FUNC( \ - cmd1_opcode, NPU_SET_IFM_BASE3) SEP FUNC(cmd1_opcode, NPU_SET_IFM_STRIDE_X) \ - SEP FUNC(cmd1_opcode, NPU_SET_IFM_STRIDE_Y) SEP FUNC(cmd1_opcode, NPU_SET_IFM_STRIDE_C) SEP FUNC( \ - cmd1_opcode, NPU_SET_OFM_BASE0) SEP FUNC(cmd1_opcode, NPU_SET_OFM_BASE1) \ - SEP FUNC(cmd1_opcode, NPU_SET_OFM_BASE2) SEP FUNC(cmd1_opcode, NPU_SET_OFM_BASE3) SEP FUNC( \ - cmd1_opcode, NPU_SET_OFM_STRIDE_X) SEP FUNC(cmd1_opcode, NPU_SET_OFM_STRIDE_Y) \ - SEP FUNC(cmd1_opcode, NPU_SET_OFM_STRIDE_C) SEP FUNC(cmd1_opcode, NPU_SET_WEIGHT_BASE) SEP FUNC( \ - cmd1_opcode, NPU_SET_WEIGHT_LENGTH) SEP FUNC(cmd1_opcode, NPU_SET_SCALE_BASE) \ - SEP FUNC(cmd1_opcode, NPU_SET_SCALE_LENGTH) SEP FUNC(cmd1_opcode, NPU_SET_OFM_SCALE) SEP FUNC( \ - cmd1_opcode, NPU_SET_OPA_SCALE) SEP FUNC(cmd1_opcode, NPU_SET_OPB_SCALE) \ - SEP FUNC(cmd1_opcode, NPU_SET_DMA0_SRC) SEP FUNC(cmd1_opcode, NPU_SET_DMA0_DST) SEP FUNC( \ - cmd1_opcode, NPU_SET_DMA0_LEN) SEP FUNC(cmd1_opcode, NPU_SET_IFM2_BASE0) \ - SEP FUNC(cmd1_opcode, NPU_SET_IFM2_BASE1) SEP FUNC(cmd1_opcode, NPU_SET_IFM2_BASE2) \ - SEP FUNC(cmd1_opcode, NPU_SET_IFM2_BASE3) SEP FUNC(cmd1_opcode, NPU_SET_IFM2_STRIDE_X) \ - SEP FUNC(cmd1_opcode, NPU_SET_IFM2_STRIDE_Y) \ - SEP FUNC(cmd1_opcode, NPU_SET_IFM2_STRIDE_C) \ - SEP FUNC(cmd1_opcode, NPU_SET_USER_DEFINED0) \ - SEP FUNC(cmd1_opcode, NPU_SET_USER_DEFINED1) \ - SEP FUNC(cmd1_opcode, NPU_SET_USER_DEFINED2) \ - SEP FUNC(cmd1_opcode, NPU_SET_USER_DEFINED3) \ - SEP FUNC(cmd1_opcode, NPU_SET_USER_DEFINED4) \ - SEP FUNC(cmd1_opcode, NPU_SET_USER_DEFINED5) \ - SEP FUNC(cmd1_opcode, NPU_SET_USER_DEFINED6) \ - SEP FUNC(cmd1_opcode, NPU_SET_USER_DEFINED7) - -#define EXPAND_CMD_CTRL(FUNC, SEP) FUNC(cmd_ctrl, CMD0_CTRL) SEP FUNC(cmd_ctrl, CMD1_CTRL) - -#define EXPAND_CUSTOM_DMA_CS(FUNC, SEP) FUNC(custom_dma_cs, DISABLE) SEP FUNC(custom_dma_cs, ENABLE) - -#define EXPAND_CUSTOM_DMA(FUNC, SEP) FUNC(custom_dma, NOT_IMPLEMENTED) SEP FUNC(custom_dma, IMPLEMENTED) - -#define EXPAND_DMA_FAULT_SRC(FUNC, SEP) FUNC(dma_fault_src, AXI_M0) SEP FUNC(dma_fault_src, AXI_M1) - -#define EXPAND_DMA_REGION_MODE(FUNC, SEP) FUNC(dma_region_mode, EXTERNAL) SEP FUNC(dma_region_mode, INTERNAL) - -#define EXPAND_DMA_STRIDE_MODE(FUNC, SEP) FUNC(dma_stride_mode, D1) - -#define EXPAND_ELEMENTWISE_MODE(FUNC, SEP) \ - FUNC(elementwise_mode, MUL) \ - SEP FUNC(elementwise_mode, ADD) SEP FUNC(elementwise_mode, SUB) SEP FUNC(elementwise_mode, MIN) \ - SEP FUNC(elementwise_mode, MAX) SEP FUNC(elementwise_mode, LRELU) SEP FUNC(elementwise_mode, ABS) \ - SEP FUNC(elementwise_mode, CLZ) SEP FUNC(elementwise_mode, SHR) SEP FUNC(elementwise_mode, SHL) - -#define EXPAND_FUNCTIONAL_SAFETY(FUNC, SEP) \ - FUNC(functional_safety, NOT_IMPLEMENTED) SEP FUNC(functional_safety, IMPLEMENTED) - -#define EXPAND_IFM2_OPERAND_ORDER(FUNC, SEP) FUNC(ifm2_operand_order, ORDER_B) SEP FUNC(ifm2_operand_order, ORDER_A) - -#define EXPAND_IFM_SCALE_MODE(FUNC, SEP) \ - FUNC(ifm_scale_mode, OPA_OPB_16) SEP FUNC(ifm_scale_mode, OPA_32) SEP FUNC(ifm_scale_mode, OPB_32) - -#define EXPAND_IFM_UPSCALE_MODE(FUNC, SEP) \ - FUNC(ifm_upscale_mode, NONE) SEP FUNC(ifm_upscale_mode, NEAREST) SEP FUNC(ifm_upscale_mode, ZEROS) - -#define EXPAND_KERNEL_DECOMPOSITION(FUNC, SEP) FUNC(kernel_decomposition, D8X8) SEP FUNC(kernel_decomposition, D4X4) - -#define EXPAND_KERNEL_DILATION(FUNC, SEP) FUNC(kernel_dilation, NONE) SEP FUNC(kernel_dilation, X2) - -#define EXPAND_MAX_BEATS(FUNC, SEP) FUNC(max_beats, B64) SEP FUNC(max_beats, B128) SEP FUNC(max_beats, B256) - -#define EXPAND_MEM_ATTR(FUNC, SEP) \ - FUNC(mem_attr, AXI0_OUTSTANDING_COUNTER0) \ - SEP FUNC(mem_attr, AXI0_OUTSTANDING_COUNTER1) SEP FUNC(mem_attr, AXI1_OUTSTANDING_COUNTER2) \ - SEP FUNC(mem_attr, AXI1_OUTSTANDING_COUNTER3) - -#define EXPAND_OFM_SCALE_MODE(FUNC, SEP) FUNC(ofm_scale_mode, PER_CHANNEL) SEP FUNC(ofm_scale_mode, GLOBAL) - -#define EXPAND_PMU_AXI_CHANNEL(FUNC, SEP) \ - FUNC(pmu_axi_channel, RD_CMD) \ - SEP FUNC(pmu_axi_channel, RD_IFM) SEP FUNC(pmu_axi_channel, RD_WEIGHTS) SEP FUNC(pmu_axi_channel, RD_SCALE_BIAS) \ - SEP FUNC(pmu_axi_channel, RD_MEM2MEM) SEP FUNC(pmu_axi_channel, WR_OFM) SEP FUNC(pmu_axi_channel, WR_MEM2MEM) - -#define EXPAND_PMU_EVENT(FUNC, SEP) \ - FUNC(pmu_event, NO_EVENT) \ - SEP FUNC(pmu_event, CYCLE) SEP FUNC(pmu_event, NPU_IDLE) SEP FUNC(pmu_event, CC_STALLED_ON_BLOCKDEP) SEP FUNC( \ - pmu_event, CC_STALLED_ON_SHRAM_RECONFIG) SEP FUNC(pmu_event, NPU_ACTIVE) SEP FUNC(pmu_event, MAC_ACTIVE) \ - SEP FUNC(pmu_event, MAC_ACTIVE_8BIT) SEP FUNC(pmu_event, MAC_ACTIVE_16BIT) SEP FUNC( \ - pmu_event, MAC_DPU_ACTIVE) SEP FUNC(pmu_event, MAC_STALLED_BY_WD_ACC) SEP FUNC(pmu_event, \ - MAC_STALLED_BY_WD) \ - SEP FUNC(pmu_event, MAC_STALLED_BY_ACC) SEP FUNC(pmu_event, MAC_STALLED_BY_IB) SEP FUNC( \ - pmu_event, \ - MAC_ACTIVE_32BIT) SEP FUNC(pmu_event, \ - MAC_STALLED_BY_INT_W) SEP FUNC(pmu_event, \ - MAC_STALLED_BY_INT_ACC) SEP FUNC(pmu_event, \ - AO_ACTIVE) \ - SEP FUNC(pmu_event, AO_ACTIVE_8BIT) SEP FUNC(pmu_event, AO_ACTIVE_16BIT) SEP FUNC( \ - pmu_event, AO_STALLED_BY_OFMP_OB) SEP FUNC(pmu_event, AO_STALLED_BY_OFMP) SEP \ - FUNC(pmu_event, AO_STALLED_BY_OB) SEP FUNC(pmu_event, AO_STALLED_BY_ACC_IB) SEP FUNC( \ - pmu_event, AO_STALLED_BY_ACC) SEP FUNC(pmu_event, AO_STALLED_BY_IB) SEP \ - FUNC(pmu_event, WD_ACTIVE) SEP FUNC(pmu_event, WD_STALLED) SEP FUNC(pmu_event, WD_STALLED_BY_WS) SEP FUNC( \ - pmu_event, WD_STALLED_BY_WD_BUF) SEP FUNC(pmu_event, \ - WD_PARSE_ACTIVE) SEP \ - FUNC(pmu_event, WD_PARSE_STALLED) SEP FUNC(pmu_event, WD_PARSE_STALLED_IN) SEP FUNC( \ - pmu_event, WD_PARSE_STALLED_OUT) SEP FUNC(pmu_event, \ - WD_TRANS_WS) SEP \ - FUNC(pmu_event, WD_TRANS_WB) SEP FUNC(pmu_event, WD_TRANS_DW0) SEP FUNC( \ - pmu_event, WD_TRANS_DW1) SEP FUNC(pmu_event, \ - AXI0_RD_TRANS_ACCEPTED) SEP \ - FUNC(pmu_event, AXI0_RD_TRANS_COMPLETED) SEP FUNC(pmu_event, AXI0_RD_DATA_BEAT_RECEIVED) SEP FUNC( \ - pmu_event, AXI0_RD_TRAN_REQ_STALLED) SEP FUNC(pmu_event, \ - AXI0_WR_TRANS_ACCEPTED) SEP \ - FUNC(pmu_event, AXI0_WR_TRANS_COMPLETED_M) SEP FUNC( \ - pmu_event, AXI0_WR_TRANS_COMPLETED_S) SEP \ - FUNC(pmu_event, AXI0_WR_DATA_BEAT_WRITTEN) SEP FUNC( \ - pmu_event, AXI0_WR_TRAN_REQ_STALLED) SEP \ - FUNC(pmu_event, AXI0_WR_DATA_BEAT_STALLED) SEP FUNC( \ - pmu_event, \ - AXI0_ENABLED_CYCLES) SEP FUNC(pmu_event, \ - AXI0_RD_STALL_LIMIT) SEP \ - FUNC(pmu_event, AXI0_WR_STALL_LIMIT) SEP FUNC( \ - pmu_event, \ - AXI_LATENCY_ANY) SEP FUNC(pmu_event, \ - AXI_LATENCY_32) SEP \ - FUNC(pmu_event, \ - AXI_LATENCY_64) SEP FUNC(pmu_event, \ - AXI_LATENCY_128) SEP \ - FUNC(pmu_event, AXI_LATENCY_256) SEP FUNC( \ - pmu_event, \ - AXI_LATENCY_512) SEP FUNC(pmu_event, \ - AXI_LATENCY_1024) SEP \ - FUNC(pmu_event, ECC_DMA) SEP FUNC( \ - pmu_event, \ - ECC_SB0) SEP FUNC(pmu_event, \ - AXI1_RD_TRANS_ACCEPTED) SEP \ - FUNC(pmu_event, AXI1_RD_TRANS_COMPLETED) SEP FUNC( \ - pmu_event, AXI1_RD_DATA_BEAT_RECEIVED) SEP \ - FUNC(pmu_event, AXI1_RD_TRAN_REQ_STALLED) SEP FUNC( \ - pmu_event, AXI1_WR_TRANS_ACCEPTED) SEP \ - FUNC(pmu_event, AXI1_WR_TRANS_COMPLETED_M) SEP FUNC( \ - pmu_event, \ - AXI1_WR_TRANS_COMPLETED_S) SEP \ - FUNC(pmu_event, \ - AXI1_WR_DATA_BEAT_WRITTEN) SEP \ - FUNC(pmu_event, \ - AXI1_WR_TRAN_REQ_STALLED) SEP \ - FUNC( \ - pmu_event, \ - AXI1_WR_DATA_BEAT_STALLED) SEP \ - FUNC( \ - pmu_event, \ - AXI1_ENABLED_CYCLES) SEP \ - FUNC( \ - pmu_event, \ - AXI1_RD_STALL_LIMIT) SEP \ - FUNC( \ - pmu_event, \ - AXI1_WR_STALL_LIMIT) \ - SEP FUNC( \ - pmu_event, \ - ECC_SB1) - -#define EXPAND_POOLING_MODE(FUNC, SEP) \ - FUNC(pooling_mode, MAX) SEP FUNC(pooling_mode, AVERAGE) SEP FUNC(pooling_mode, REDUCE_SUM) - -#define EXPAND_PRIVILEGE_LEVEL(FUNC, SEP) FUNC(privilege_level, USER) SEP FUNC(privilege_level, PRIVILEGED) - -#define EXPAND_ROUND_MODE(FUNC, SEP) FUNC(round_mode, DBL) SEP FUNC(round_mode, TRUNCATE) SEP FUNC(round_mode, NATURAL) - -#define EXPAND_SECURITY_LEVEL(FUNC, SEP) FUNC(security_level, SECURE) SEP FUNC(security_level, NON_SECURE) - -#define EXPAND_STATE(FUNC, SEP) FUNC(state, STOPPED) SEP FUNC(state, RUNNING) - -#define EXPAND_WD_CORE_SLICE_STATE(FUNC, SEP) \ - FUNC(wd_core_slice_state, HEADER) SEP FUNC(wd_core_slice_state, PALETTE) SEP FUNC(wd_core_slice_state, WEIGHTS) - -#define EXPAND_WD_CTRL_STATE(FUNC, SEP) \ - FUNC(wd_ctrl_state, IDLE) \ - SEP FUNC(wd_ctrl_state, DRAIN) SEP FUNC(wd_ctrl_state, OFD_INIT) SEP FUNC(wd_ctrl_state, OFD_RUN) - -#define EXPAND_WEIGHT_ORDER(FUNC, SEP) FUNC(weight_order, DEPTH_FIRST) SEP FUNC(weight_order, PART_KERNEL_FIRST) - -#ifdef __cplusplus -} -#endif -#endif diff --git a/ai_layer/engine/include/executorch/backends/arm/third-party/ethos-u-core-driver/src/ethosu65_interface.h b/ai_layer/engine/include/executorch/backends/arm/third-party/ethos-u-core-driver/src/ethosu65_interface.h deleted file mode 100644 index c4e3d2e0..00000000 --- a/ai_layer/engine/include/executorch/backends/arm/third-party/ethos-u-core-driver/src/ethosu65_interface.h +++ /dev/null @@ -1,26060 +0,0 @@ -/* - * Copyright (c) 2020-2021 Arm Limited. All rights reserved. - * - * SPDX-License-Identifier: Apache-2.0 - * - * Licensed under the Apache License, Version 2.0 (the License); you may - * not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an AS IS BASIS, WITHOUT - * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef ETHOSU65_INTERFACE_H -#define ETHOSU65_INTERFACE_H - -#ifdef __KERNEL__ -#include -#else -#include -#endif - -#if !defined(__cplusplus) || __cplusplus < 201402L -#define CONSTEXPR -#else -#define CONSTEXPR constexpr -#endif - -#ifndef __cplusplus -#define STRUCT struct -#else -#define STRUCT -#endif - -#if defined(__cplusplus) && defined(NPU_DISASSEMBLE) -#include -#include -#include -#endif - -#if defined(__cplusplus) && !defined(NPU_NAMESPACE) -#define NPU_NAMESPACE npu -#endif - -#ifdef __cplusplus -#include -#include -#endif - -#ifdef __cplusplus -namespace NPU_NAMESPACE -{ -#endif -#define NNX_ARCH_VERSION_MAJOR 1 -#define NNX_ARCH_VERSION_MINOR 0 -#define NNX_ARCH_VERSION_PATCH 6 - -// Register offsets -// -// Register subpage BASE -// -#define NPU_REG_ID 0x0000 -#define NPU_REG_STATUS 0x0004 -#define NPU_REG_CMD 0x0008 -#define NPU_REG_RESET 0x000C -#define NPU_REG_QBASE 0x0010 -#define NPU_REG_QBASE_HI 0x0014 -#define NPU_REG_QREAD 0x0018 -#define NPU_REG_QCONFIG 0x001C -#define NPU_REG_QSIZE 0x0020 -#define NPU_REG_PROT 0x0024 -#define NPU_REG_CONFIG 0x0028 -#define NPU_REG_LOCK 0x002C -#define NPU_REG_REGIONCFG 0x003C -#define NPU_REG_AXI_LIMIT0 0x0040 -#define NPU_REG_AXI_LIMIT1 0x0044 -#define NPU_REG_AXI_LIMIT2 0x0048 -#define NPU_REG_AXI_LIMIT3 0x004C -#define BASE_REGISTERS_SIZE 0x0080 - -// -// Register subpage BASE_POINTERS -// -#define NPU_REG_BASEP_BASE 0x0080 -#define NPU_REG_BASEP_ARRLEN 0x0008 -#define BASE_POINTERS_REGISTERS_SIZE 0x0100 - -// -// Register subpage DEBUG -// -#define NPU_REG_WD_STATUS 0x0100 -#define NPU_REG_MAC_STATUS 0x0104 -#define NPU_REG_AO_STATUS 0x0108 -#define NPU_REG_DMA_STATUS0 0x0110 -#define NPU_REG_DMA_STATUS1 0x0114 -#define NPU_REG_CLKFORCE 0x0140 -#define NPU_REG_DEBUG_ADDRESS 0x0144 -#define NPU_REG_DEBUG_MISC 0x0148 -#define NPU_REG_DEBUGCORE 0x014C -#define NPU_REG_DEBUG_BLOCK 0x0150 -#define DEBUG_REGISTERS_SIZE 0x0180 - -// -// Register subpage PMU -// -#define NPU_REG_PMCR 0x0180 -#define NPU_REG_PMCNTENSET 0x0184 -#define NPU_REG_PMCNTENCLR 0x0188 -#define NPU_REG_PMOVSSET 0x018C -#define NPU_REG_PMOVSCLR 0x0190 -#define NPU_REG_PMINTSET 0x0194 -#define NPU_REG_PMINTCLR 0x0198 -#define NPU_REG_PMCCNTR 0x01A0 -#define NPU_REG_PMCCNTR_HI 0x01A4 -#define NPU_REG_PMCCNTR_CFG 0x01A8 -#define NPU_REG_PMCAXI_CHAN 0x01AC -#define PMU_REGISTERS_SIZE 0x0200 - -// -// Register subpage TSU_DEBUG -// -#define NPU_REG_KERNEL_X 0x0200 -#define NPU_REG_KERNEL_Y 0x0204 -#define NPU_REG_KERNEL_W_M1 0x0208 -#define NPU_REG_KERNEL_H_M1 0x020C -#define NPU_REG_OFM_CBLK_WIDTH_M1 0x0210 -#define NPU_REG_OFM_CBLK_HEIGHT_M1 0x0214 -#define NPU_REG_OFM_CBLK_DEPTH_M1 0x0218 -#define NPU_REG_IFM_CBLK_DEPTH_M1 0x021C -#define NPU_REG_OFM_X 0x0220 -#define NPU_REG_OFM_Y 0x0224 -#define NPU_REG_OFM_Z 0x0228 -#define NPU_REG_IFM_Z 0x022C -#define NPU_REG_PAD_TOP 0x0230 -#define NPU_REG_PAD_LEFT 0x0234 -#define NPU_REG_IFM_CBLK_WIDTH 0x0238 -#define NPU_REG_IFM_CBLK_HEIGHT 0x023C -#define NPU_REG_DMA_IFM_SRC 0x0240 -#define NPU_REG_DMA_IFM_SRC_HI 0x0244 -#define NPU_REG_DMA_IFM_DST 0x0248 -#define NPU_REG_DMA_OFM_SRC 0x024C -#define NPU_REG_DMA_OFM_DST 0x0250 -#define NPU_REG_DMA_OFM_DST_HI 0x0254 -#define NPU_REG_DMA_WEIGHT_SRC 0x0258 -#define NPU_REG_DMA_WEIGHT_SRC_HI 0x025C -#define NPU_REG_DMA_CMD_SRC 0x0260 -#define NPU_REG_DMA_CMD_SRC_HI 0x0264 -#define NPU_REG_DMA_CMD_SIZE 0x0268 -#define NPU_REG_DMA_M2M_SRC 0x026C -#define NPU_REG_DMA_M2M_SRC_HI 0x0270 -#define NPU_REG_DMA_M2M_DST 0x0274 -#define NPU_REG_DMA_M2M_DST_HI 0x0278 -#define NPU_REG_CURRENT_QREAD 0x027C -#define NPU_REG_DMA_SCALE_SRC 0x0280 -#define NPU_REG_DMA_SCALE_SRC_HI 0x0284 -#define NPU_REG_CURRENT_BLOCK 0x02B4 -#define NPU_REG_CURRENT_OP 0x02B8 -#define NPU_REG_CURRENT_CMD 0x02BC -#define TSU_DEBUG_REGISTERS_SIZE 0x02C0 - -// -// Register subpage PMU_COUNTERS -// -#define NPU_REG_PMEVCNTR_BASE 0x0300 -#define NPU_REG_PMEVCNTR_ARRLEN 0x0004 -#define NPU_REG_PMEVTYPER_BASE 0x0380 -#define NPU_REG_PMEVTYPER_ARRLEN 0x0004 -#define PMU_COUNTERS_REGISTERS_SIZE 0x0400 - -// -// Register subpage SHARED_BUFFER -// -#define NPU_REG_SHARED_BUFFER_BASE 0x0400 -#define NPU_REG_SHARED_BUFFER_ARRLEN 0x0100 -#define SHARED_BUFFER_REGISTERS_SIZE 0x0800 - -// -// Register subpage TSU_IFM -// -#define NPU_REG_IFM_PAD_TOP 0x0800 -#define NPU_REG_IFM_PAD_LEFT 0x0804 -#define NPU_REG_IFM_PAD_RIGHT 0x0808 -#define NPU_REG_IFM_PAD_BOTTOM 0x080C -#define NPU_REG_IFM_DEPTH_M1 0x0810 -#define NPU_REG_IFM_PRECISION 0x0814 -#define NPU_REG_IFM_UPSCALE 0x081C -#define NPU_REG_IFM_ZERO_POINT 0x0824 -#define NPU_REG_IFM_WIDTH0_M1 0x0828 -#define NPU_REG_IFM_HEIGHT0_M1 0x082C -#define NPU_REG_IFM_HEIGHT1_M1 0x0830 -#define NPU_REG_IFM_IB_END 0x0834 -#define NPU_REG_IFM_REGION 0x083C -#define TSU_IFM_REGISTERS_SIZE 0x0840 - -// -// Register subpage TSU_OFM -// -#define NPU_REG_OFM_WIDTH_M1 0x0844 -#define NPU_REG_OFM_HEIGHT_M1 0x0848 -#define NPU_REG_OFM_DEPTH_M1 0x084C -#define NPU_REG_OFM_PRECISION 0x0850 -#define NPU_REG_OFM_BLK_WIDTH_M1 0x0854 -#define NPU_REG_OFM_BLK_HEIGHT_M1 0x0858 -#define NPU_REG_OFM_BLK_DEPTH_M1 0x085C -#define NPU_REG_OFM_ZERO_POINT 0x0860 -#define NPU_REG_OFM_WIDTH0_M1 0x0868 -#define NPU_REG_OFM_HEIGHT0_M1 0x086C -#define NPU_REG_OFM_HEIGHT1_M1 0x0870 -#define NPU_REG_OFM_REGION 0x087C -#define TSU_OFM_REGISTERS_SIZE 0x0880 - -// -// Register subpage TSU_KERNEL -// -#define NPU_REG_KERNEL_WIDTH_M1 0x0880 -#define NPU_REG_KERNEL_HEIGHT_M1 0x0884 -#define NPU_REG_KERNEL_STRIDE 0x0888 -#define NPU_REG_PARALLEL_MODE 0x088C -#define NPU_REG_ACC_FORMAT 0x0890 -#define NPU_REG_ACTIVATION 0x0894 -#define NPU_REG_ACTIVATION_MIN 0x0898 -#define NPU_REG_ACTIVATION_MAX 0x089C -#define NPU_REG_WEIGHT_REGION 0x08A0 -#define NPU_REG_SCALE_REGION 0x08A4 -#define NPU_REG_AB_START 0x08B4 -#define NPU_REG_BLOCKDEP 0x08BC -#define TSU_KERNEL_REGISTERS_SIZE 0x08C0 - -// -// Register subpage TSU_DMA -// -#define NPU_REG_DMA0_SRC_REGION 0x08C0 -#define NPU_REG_DMA0_DST_REGION 0x08C4 -#define NPU_REG_DMA0_SIZE0 0x08C8 -#define NPU_REG_DMA0_SIZE1 0x08CC -#define TSU_DMA_REGISTERS_SIZE 0x0900 - -// -// Register subpage TSU_IFM2 -// -#define NPU_REG_IFM2_BROADCAST 0x0900 -#define NPU_REG_IFM2_SCALAR 0x0904 -#define NPU_REG_IFM2_PRECISION 0x0914 -#define NPU_REG_IFM2_ZERO_POINT 0x0924 -#define NPU_REG_IFM2_WIDTH0_M1 0x0928 -#define NPU_REG_IFM2_HEIGHT0_M1 0x092C -#define NPU_REG_IFM2_HEIGHT1_M1 0x0930 -#define NPU_REG_IFM2_IB_START 0x0934 -#define NPU_REG_IFM2_REGION 0x093C -#define TSU_IFM2_REGISTERS_SIZE 0x0940 - -// -// Register subpage TSU_IFM_BASE -// -#define NPU_REG_IFM_BASE0 0x0A00 -#define NPU_REG_IFM_BASE0_HI 0x0A04 -#define NPU_REG_IFM_BASE1 0x0A08 -#define NPU_REG_IFM_BASE1_HI 0x0A0C -#define NPU_REG_IFM_BASE2 0x0A10 -#define NPU_REG_IFM_BASE2_HI 0x0A14 -#define NPU_REG_IFM_BASE3 0x0A18 -#define NPU_REG_IFM_BASE3_HI 0x0A1C -#define NPU_REG_IFM_STRIDE_X 0x0A20 -#define NPU_REG_IFM_STRIDE_X_HI 0x0A24 -#define NPU_REG_IFM_STRIDE_Y 0x0A28 -#define NPU_REG_IFM_STRIDE_Y_HI 0x0A2C -#define NPU_REG_IFM_STRIDE_C 0x0A30 -#define NPU_REG_IFM_STRIDE_C_HI 0x0A34 -#define TSU_IFM_BASE_REGISTERS_SIZE 0x0A40 - -// -// Register subpage TSU_OFM_BASE -// -#define NPU_REG_OFM_BASE0 0x0A40 -#define NPU_REG_OFM_BASE0_HI 0x0A44 -#define NPU_REG_OFM_BASE1 0x0A48 -#define NPU_REG_OFM_BASE1_HI 0x0A4C -#define NPU_REG_OFM_BASE2 0x0A50 -#define NPU_REG_OFM_BASE2_HI 0x0A54 -#define NPU_REG_OFM_BASE3 0x0A58 -#define NPU_REG_OFM_BASE3_HI 0x0A5C -#define NPU_REG_OFM_STRIDE_X 0x0A60 -#define NPU_REG_OFM_STRIDE_X_HI 0x0A64 -#define NPU_REG_OFM_STRIDE_Y 0x0A68 -#define NPU_REG_OFM_STRIDE_Y_HI 0x0A6C -#define NPU_REG_OFM_STRIDE_C 0x0A70 -#define NPU_REG_OFM_STRIDE_C_HI 0x0A74 -#define TSU_OFM_BASE_REGISTERS_SIZE 0x0A80 - -// -// Register subpage TSU_WS_BASE -// -#define NPU_REG_WEIGHT_BASE 0x0A80 -#define NPU_REG_WEIGHT_BASE_HI 0x0A84 -#define NPU_REG_WEIGHT_LENGTH 0x0A88 -#define NPU_REG_WEIGHT_LENGTH_HI 0x0A8C -#define NPU_REG_SCALE_BASE 0x0A90 -#define NPU_REG_SCALE_BASE_HI 0x0A94 -#define NPU_REG_SCALE_LENGTH 0x0A98 -#define NPU_REG_SCALE_LENGTH_HI 0x0A9C -#define NPU_REG_OFM_SCALE 0x0AA0 -#define NPU_REG_OFM_SCALE_SHIFT 0x0AA4 -#define NPU_REG_OPA_SCALE 0x0AA8 -#define NPU_REG_OPA_SCALE_SHIFT 0x0AAC -#define NPU_REG_OPB_SCALE 0x0AB0 -#define TSU_WS_BASE_REGISTERS_SIZE 0x0AC0 - -// -// Register subpage TSU_DMA_BASE -// -#define NPU_REG_DMA0_SRC 0x0AC0 -#define NPU_REG_DMA0_SRC_HI 0x0AC4 -#define NPU_REG_DMA0_DST 0x0AC8 -#define NPU_REG_DMA0_DST_HI 0x0ACC -#define NPU_REG_DMA0_LEN 0x0AD0 -#define NPU_REG_DMA0_LEN_HI 0x0AD4 -#define NPU_REG_DMA0_SKIP0 0x0AD8 -#define NPU_REG_DMA0_SKIP0_HI 0x0ADC -#define NPU_REG_DMA0_SKIP1 0x0AE0 -#define NPU_REG_DMA0_SKIP1_HI 0x0AE4 -#define TSU_DMA_BASE_REGISTERS_SIZE 0x0B00 - -// -// Register subpage TSU_IFM2_BASE -// -#define NPU_REG_IFM2_BASE0 0x0B00 -#define NPU_REG_IFM2_BASE0_HI 0x0B04 -#define NPU_REG_IFM2_BASE1 0x0B08 -#define NPU_REG_IFM2_BASE1_HI 0x0B0C -#define NPU_REG_IFM2_BASE2 0x0B10 -#define NPU_REG_IFM2_BASE2_HI 0x0B14 -#define NPU_REG_IFM2_BASE3 0x0B18 -#define NPU_REG_IFM2_BASE3_HI 0x0B1C -#define NPU_REG_IFM2_STRIDE_X 0x0B20 -#define NPU_REG_IFM2_STRIDE_X_HI 0x0B24 -#define NPU_REG_IFM2_STRIDE_Y 0x0B28 -#define NPU_REG_IFM2_STRIDE_Y_HI 0x0B2C -#define NPU_REG_IFM2_STRIDE_C 0x0B30 -#define NPU_REG_IFM2_STRIDE_C_HI 0x0B34 -#define TSU_IFM2_BASE_REGISTERS_SIZE 0x0B40 - -// -// Register subpage TSU_WS1_BASE -// -#define NPU_REG_WEIGHT1_BASE 0x0B40 -#define NPU_REG_WEIGHT1_BASE_HI 0x0B44 -#define NPU_REG_WEIGHT1_LENGTH 0x0B48 -#define NPU_REG_WEIGHT1_LENGTH_HI 0x0B4C -#define NPU_REG_SCALE1_BASE 0x0B50 -#define NPU_REG_SCALE1_BASE_HI 0x0B54 -#define NPU_REG_SCALE1_LENGTH 0x0B58 -#define NPU_REG_SCALE1_LENGTH_HI 0x0B5C -#define TSU_WS1_BASE_REGISTERS_SIZE 0x0B80 - -// -// Register subpage TSU_USER_BASE -// -#define TSU_USER_BASE_REGISTERS_SIZE 0x0BC0 - -// -// Register subpage TSU_DMA_EBASE -// -#define TSU_DMA_EBASE_REGISTERS_SIZE 0x0C00 - -// -// Register subpage ID -// -#define NPU_REG_REVISION 0x0FC0 -#define NPU_REG_PID4 0x0FD0 -#define NPU_REG_PID5 0x0FD4 -#define NPU_REG_PID6 0x0FD8 -#define NPU_REG_PID7 0x0FDC -#define NPU_REG_PID0 0x0FE0 -#define NPU_REG_PID1 0x0FE4 -#define NPU_REG_PID2 0x0FE8 -#define NPU_REG_PID3 0x0FEC -#define NPU_REG_CID0 0x0FF0 -#define NPU_REG_CID1 0x0FF4 -#define NPU_REG_CID2 0x0FF8 -#define NPU_REG_CID3 0x0FFC -#define ID_REGISTERS_SIZE 0x1000 - -#ifdef __cplusplus -// Enum types -enum class acc_format : uint8_t -{ - I32 = 0, - I40 = 1, - F16 = 2, -}; - -enum class activation_clip_range : uint8_t -{ - OFM_PRECISION = 0, - FORCE_UINT8 = 2, - FORCE_INT8 = 3, - FORCE_INT16 = 5, -}; - -enum class activation_format : uint8_t -{ - NHWC = 0, - NHCWB16 = 1, -}; - -enum class activation_function : uint8_t -{ - RELU = 0, - TANH = 3, - SIGMOID = 4, - TABLE_0 = 16, - TABLE_1 = 17, - TABLE_2 = 18, - TABLE_3 = 19, - TABLE_4 = 20, - TABLE_5 = 21, - TABLE_6 = 22, - TABLE_7 = 23, -}; - -enum class activation_precision : uint8_t -{ - B8 = 0, - B16 = 1, - B32 = 2, - B64 = 3, -}; - -enum class activation_type : uint8_t -{ - UNSIGNED = 0, - SIGNED = 1, -}; - -enum class axi_mem_encoding : uint8_t -{ - DEVICE_NON_BUFFERABLE = 0, - DEVICE_BUFFERABLE = 1, - NORMAL_NON_CACHEABLE_NON_BUFFERABLE = 2, - NORMAL_NON_CACHEABLE_BUFFERABLE = 3, - WRITE_THROUGH_NO_ALLOCATE = 4, - WRITE_THROUGH_READ_ALLOCATE = 5, - WRITE_THROUGH_WRITE_ALLOCATE = 6, - WRITE_THROUGH_READ_AND_WRITE_ALLOCATE = 7, - WRITE_BACK_NO_ALLOCATE = 8, - WRITE_BACK_READ_ALLOCATE = 9, - WRITE_BACK_WRITE_ALLOCATE = 10, - WRITE_BACK_READ_AND_WRITE_ALLOCATE = 11, -}; - -enum class broadcast_mode : uint8_t -{ - DISABLE = 0, - ENABLE = 1, -}; - -enum class cmd0_opcode : uint16_t -{ - NPU_OP_STOP = 0, - NPU_OP_IRQ = 1, - NPU_OP_CONV = 2, - NPU_OP_DEPTHWISE = 3, - NPU_OP_POOL = 5, - NPU_OP_ELEMENTWISE = 6, - NPU_OP_DMA_START = 16, - NPU_OP_DMA_WAIT = 17, - NPU_OP_KERNEL_WAIT = 18, - NPU_OP_PMU_MASK = 19, - NPU_SET_IFM_PAD_TOP = 256, - NPU_SET_IFM_PAD_LEFT = 257, - NPU_SET_IFM_PAD_RIGHT = 258, - NPU_SET_IFM_PAD_BOTTOM = 259, - NPU_SET_IFM_DEPTH_M1 = 260, - NPU_SET_IFM_PRECISION = 261, - NPU_SET_IFM_UPSCALE = 263, - NPU_SET_IFM_ZERO_POINT = 265, - NPU_SET_IFM_WIDTH0_M1 = 266, - NPU_SET_IFM_HEIGHT0_M1 = 267, - NPU_SET_IFM_HEIGHT1_M1 = 268, - NPU_SET_IFM_IB_END = 269, - NPU_SET_IFM_REGION = 271, - NPU_SET_OFM_WIDTH_M1 = 273, - NPU_SET_OFM_HEIGHT_M1 = 274, - NPU_SET_OFM_DEPTH_M1 = 275, - NPU_SET_OFM_PRECISION = 276, - NPU_SET_OFM_BLK_WIDTH_M1 = 277, - NPU_SET_OFM_BLK_HEIGHT_M1 = 278, - NPU_SET_OFM_BLK_DEPTH_M1 = 279, - NPU_SET_OFM_ZERO_POINT = 280, - NPU_SET_OFM_WIDTH0_M1 = 282, - NPU_SET_OFM_HEIGHT0_M1 = 283, - NPU_SET_OFM_HEIGHT1_M1 = 284, - NPU_SET_OFM_REGION = 287, - NPU_SET_KERNEL_WIDTH_M1 = 288, - NPU_SET_KERNEL_HEIGHT_M1 = 289, - NPU_SET_KERNEL_STRIDE = 290, - NPU_SET_PARALLEL_MODE = 291, - NPU_SET_ACC_FORMAT = 292, - NPU_SET_ACTIVATION = 293, - NPU_SET_ACTIVATION_MIN = 294, - NPU_SET_ACTIVATION_MAX = 295, - NPU_SET_WEIGHT_REGION = 296, - NPU_SET_SCALE_REGION = 297, - NPU_SET_AB_START = 301, - NPU_SET_BLOCKDEP = 303, - NPU_SET_DMA0_SRC_REGION = 304, - NPU_SET_DMA0_DST_REGION = 305, - NPU_SET_DMA0_SIZE0 = 306, - NPU_SET_DMA0_SIZE1 = 307, - NPU_SET_IFM2_BROADCAST = 384, - NPU_SET_IFM2_SCALAR = 385, - NPU_SET_IFM2_PRECISION = 389, - NPU_SET_IFM2_ZERO_POINT = 393, - NPU_SET_IFM2_WIDTH0_M1 = 394, - NPU_SET_IFM2_HEIGHT0_M1 = 395, - NPU_SET_IFM2_HEIGHT1_M1 = 396, - NPU_SET_IFM2_IB_START = 397, - NPU_SET_IFM2_REGION = 399, -}; - -enum class cmd1_opcode : uint16_t -{ - NPU_SET_IFM_BASE0 = 0, - NPU_SET_IFM_BASE1 = 1, - NPU_SET_IFM_BASE2 = 2, - NPU_SET_IFM_BASE3 = 3, - NPU_SET_IFM_STRIDE_X = 4, - NPU_SET_IFM_STRIDE_Y = 5, - NPU_SET_IFM_STRIDE_C = 6, - NPU_SET_OFM_BASE0 = 16, - NPU_SET_OFM_BASE1 = 17, - NPU_SET_OFM_BASE2 = 18, - NPU_SET_OFM_BASE3 = 19, - NPU_SET_OFM_STRIDE_X = 20, - NPU_SET_OFM_STRIDE_Y = 21, - NPU_SET_OFM_STRIDE_C = 22, - NPU_SET_WEIGHT_BASE = 32, - NPU_SET_WEIGHT_LENGTH = 33, - NPU_SET_SCALE_BASE = 34, - NPU_SET_SCALE_LENGTH = 35, - NPU_SET_OFM_SCALE = 36, - NPU_SET_OPA_SCALE = 37, - NPU_SET_OPB_SCALE = 38, - NPU_SET_DMA0_SRC = 48, - NPU_SET_DMA0_DST = 49, - NPU_SET_DMA0_LEN = 50, - NPU_SET_DMA0_SKIP0 = 51, - NPU_SET_DMA0_SKIP1 = 52, - NPU_SET_IFM2_BASE0 = 128, - NPU_SET_IFM2_BASE1 = 129, - NPU_SET_IFM2_BASE2 = 130, - NPU_SET_IFM2_BASE3 = 131, - NPU_SET_IFM2_STRIDE_X = 132, - NPU_SET_IFM2_STRIDE_Y = 133, - NPU_SET_IFM2_STRIDE_C = 134, - NPU_SET_WEIGHT1_BASE = 144, - NPU_SET_WEIGHT1_LENGTH = 145, - NPU_SET_SCALE1_BASE = 146, - NPU_SET_SCALE1_LENGTH = 147, -}; - -enum class cmd_ctrl : uint8_t -{ - CMD0_CTRL = 0, - CMD1_CTRL = 1, -}; - -enum class custom_dma : uint8_t -{ - NOT_IMPLEMENTED = 0, - IMPLEMENTED = 1, -}; - -enum class dma_fault_src : uint8_t -{ - AXI_M0 = 0, - AXI_M1 = 1, -}; - -enum class dma_region_mode : uint8_t -{ - EXTERNAL = 0, - INTERNAL = 1, -}; - -enum class dma_stride_mode : uint8_t -{ - D1 = 0, - D2 = 1, - D3 = 2, -}; - -enum class elementwise_mode : uint8_t -{ - MUL = 0, - ADD = 1, - SUB = 2, - MIN = 3, - MAX = 4, - LRELU = 5, - ABS = 6, - CLZ = 7, - SHR = 8, - SHL = 9, -}; - -enum class functional_safety : uint8_t -{ - NOT_IMPLEMENTED = 0, - IMPLEMENTED = 1, -}; - -enum class ifm2_operand_order : uint8_t -{ - ORDER_B = 0, - ORDER_A = 1, -}; - -enum class ifm_scale_mode : uint8_t -{ - OPA_OPB_16 = 0, - OPA_32 = 1, - OPB_32 = 2, -}; - -enum class ifm_upscale_mode : uint8_t -{ - NONE = 0, - NEAREST = 1, - ZEROS = 2, -}; - -enum class kernel_decomposition : uint8_t -{ - D8X8 = 0, - D4X4 = 1, -}; - -enum class kernel_dilation : uint8_t -{ - NONE = 0, - X2 = 1, -}; - -enum class max_beats : uint8_t -{ - B64 = 0, - B128 = 1, - B256 = 2, -}; - -enum class mem_attr : uint8_t -{ - AXI0_OUTSTANDING_COUNTER0 = 0, - AXI0_OUTSTANDING_COUNTER1 = 1, - AXI1_OUTSTANDING_COUNTER2 = 2, - AXI1_OUTSTANDING_COUNTER3 = 3, -}; - -enum class ofm_scale_mode : uint8_t -{ - PER_CHANNEL = 0, - GLOBAL = 1, -}; - -enum class parallel_mode : uint8_t -{ - SINGLE_CORE = 0, - DUAL_CORE_DEPTH = 1, -}; - -enum class pmu_axi_channel : uint8_t -{ - RD_CMD = 0, - RD_IFM = 1, - RD_WEIGHTS = 2, - RD_SCALE_BIAS = 3, - RD_MEM2MEM = 4, - WR_OFM = 8, - WR_MEM2MEM = 9, -}; - -enum class pmu_event : uint16_t -{ - NO_EVENT = 0, - CYCLE = 17, - NPU_IDLE = 32, - CC_STALLED_ON_BLOCKDEP = 33, - CC_STALLED_ON_SHRAM_RECONFIG = 34, - NPU_ACTIVE = 35, - MAC_ACTIVE = 48, - MAC_ACTIVE_8BIT = 49, - MAC_ACTIVE_16BIT = 50, - MAC_DPU_ACTIVE = 51, - MAC_STALLED_BY_WD_ACC = 52, - MAC_STALLED_BY_WD = 53, - MAC_STALLED_BY_ACC = 54, - MAC_STALLED_BY_IB = 55, - MAC_ACTIVE_32BIT = 56, - MAC_STALLED_BY_INT_W = 57, - MAC_STALLED_BY_INT_ACC = 58, - AO_ACTIVE = 64, - AO_ACTIVE_8BIT = 65, - AO_ACTIVE_16BIT = 66, - AO_STALLED_BY_OFMP_OB = 67, - AO_STALLED_BY_OFMP = 68, - AO_STALLED_BY_OB = 69, - AO_STALLED_BY_ACC_IB = 70, - AO_STALLED_BY_ACC = 71, - AO_STALLED_BY_IB = 72, - WD_ACTIVE = 80, - WD_STALLED = 81, - WD_STALLED_BY_WS = 82, - WD_STALLED_BY_WD_BUF = 83, - WD_PARSE_ACTIVE = 84, - WD_PARSE_STALLED = 85, - WD_PARSE_STALLED_IN = 86, - WD_PARSE_STALLED_OUT = 87, - WD_TRANS_WS = 88, - WD_TRANS_WB = 89, - WD_TRANS_DW0 = 90, - WD_TRANS_DW1 = 91, - AXI0_RD_TRANS_ACCEPTED = 128, - AXI0_RD_TRANS_COMPLETED = 129, - AXI0_RD_DATA_BEAT_RECEIVED = 130, - AXI0_RD_TRAN_REQ_STALLED = 131, - AXI0_WR_TRANS_ACCEPTED = 132, - AXI0_WR_TRANS_COMPLETED_M = 133, - AXI0_WR_TRANS_COMPLETED_S = 134, - AXI0_WR_DATA_BEAT_WRITTEN = 135, - AXI0_WR_TRAN_REQ_STALLED = 136, - AXI0_WR_DATA_BEAT_STALLED = 137, - AXI0_ENABLED_CYCLES = 140, - AXI0_RD_STALL_LIMIT = 142, - AXI0_WR_STALL_LIMIT = 143, - AXI_LATENCY_ANY = 160, - AXI_LATENCY_32 = 161, - AXI_LATENCY_64 = 162, - AXI_LATENCY_128 = 163, - AXI_LATENCY_256 = 164, - AXI_LATENCY_512 = 165, - AXI_LATENCY_1024 = 166, - ECC_DMA = 176, - ECC_SB0 = 177, - AXI1_RD_TRANS_ACCEPTED = 384, - AXI1_RD_TRANS_COMPLETED = 385, - AXI1_RD_DATA_BEAT_RECEIVED = 386, - AXI1_RD_TRAN_REQ_STALLED = 387, - AXI1_WR_TRANS_ACCEPTED = 388, - AXI1_WR_TRANS_COMPLETED_M = 389, - AXI1_WR_TRANS_COMPLETED_S = 390, - AXI1_WR_DATA_BEAT_WRITTEN = 391, - AXI1_WR_TRAN_REQ_STALLED = 392, - AXI1_WR_DATA_BEAT_STALLED = 393, - AXI1_ENABLED_CYCLES = 396, - AXI1_RD_STALL_LIMIT = 398, - AXI1_WR_STALL_LIMIT = 399, - ECC_SB1 = 433, -}; - -enum class pooling_mode : uint8_t -{ - MAX = 0, - AVERAGE = 1, - REDUCE_SUM = 2, -}; - -enum class privilege_level : uint8_t -{ - USER = 0, - PRIVILEGED = 1, -}; - -enum class round_mode : uint8_t -{ - DBL = 0, - TRUNCATE = 1, - NATURAL = 2, -}; - -enum class security_level : uint8_t -{ - SECURE = 0, - NON_SECURE = 1, -}; - -enum class state : uint8_t -{ - STOPPED = 0, - RUNNING = 1, -}; - -enum class wd_core_slice_state : uint8_t -{ - HEADER = 0, - PALETTE = 1, - WEIGHTS = 2, -}; - -enum class wd_ctrl_state : uint8_t -{ - IDLE = 0, - DRAIN = 1, - OFD_INIT = 2, - OFD_RUN = 3, -}; - -enum class weight_order : uint8_t -{ - DEPTH_FIRST = 0, - PART_KERNEL_FIRST = 1, -}; - -#else - -enum acc_format -{ - ACC_FORMAT_I32 = 0, - ACC_FORMAT_I40 = 1, - ACC_FORMAT_F16 = 2, -}; - -enum activation_clip_range -{ - ACTIVATION_CLIP_RANGE_OFM_PRECISION = 0, - ACTIVATION_CLIP_RANGE_FORCE_UINT8 = 2, - ACTIVATION_CLIP_RANGE_FORCE_INT8 = 3, - ACTIVATION_CLIP_RANGE_FORCE_INT16 = 5, -}; - -enum activation_format -{ - ACTIVATION_FORMAT_NHWC = 0, - ACTIVATION_FORMAT_NHCWB16 = 1, -}; - -enum activation_function -{ - ACTIVATION_FUNCTION_RELU = 0, - ACTIVATION_FUNCTION_TANH = 3, - ACTIVATION_FUNCTION_SIGMOID = 4, - ACTIVATION_FUNCTION_TABLE_0 = 16, - ACTIVATION_FUNCTION_TABLE_1 = 17, - ACTIVATION_FUNCTION_TABLE_2 = 18, - ACTIVATION_FUNCTION_TABLE_3 = 19, - ACTIVATION_FUNCTION_TABLE_4 = 20, - ACTIVATION_FUNCTION_TABLE_5 = 21, - ACTIVATION_FUNCTION_TABLE_6 = 22, - ACTIVATION_FUNCTION_TABLE_7 = 23, -}; - -enum activation_precision -{ - ACTIVATION_PRECISION_B8 = 0, - ACTIVATION_PRECISION_B16 = 1, - ACTIVATION_PRECISION_B32 = 2, - ACTIVATION_PRECISION_B64 = 3, -}; - -enum activation_type -{ - ACTIVATION_TYPE_UNSIGNED = 0, - ACTIVATION_TYPE_SIGNED = 1, -}; - -enum axi_mem_encoding -{ - AXI_MEM_ENCODING_DEVICE_NON_BUFFERABLE = 0, - AXI_MEM_ENCODING_DEVICE_BUFFERABLE = 1, - AXI_MEM_ENCODING_NORMAL_NON_CACHEABLE_NON_BUFFERABLE = 2, - AXI_MEM_ENCODING_NORMAL_NON_CACHEABLE_BUFFERABLE = 3, - AXI_MEM_ENCODING_WRITE_THROUGH_NO_ALLOCATE = 4, - AXI_MEM_ENCODING_WRITE_THROUGH_READ_ALLOCATE = 5, - AXI_MEM_ENCODING_WRITE_THROUGH_WRITE_ALLOCATE = 6, - AXI_MEM_ENCODING_WRITE_THROUGH_READ_AND_WRITE_ALLOCATE = 7, - AXI_MEM_ENCODING_WRITE_BACK_NO_ALLOCATE = 8, - AXI_MEM_ENCODING_WRITE_BACK_READ_ALLOCATE = 9, - AXI_MEM_ENCODING_WRITE_BACK_WRITE_ALLOCATE = 10, - AXI_MEM_ENCODING_WRITE_BACK_READ_AND_WRITE_ALLOCATE = 11, -}; - -enum broadcast_mode -{ - BROADCAST_MODE_DISABLE = 0, - BROADCAST_MODE_ENABLE = 1, -}; - -enum cmd0_opcode -{ - CMD0_OPCODE_NPU_OP_STOP = 0, - CMD0_OPCODE_NPU_OP_IRQ = 1, - CMD0_OPCODE_NPU_OP_CONV = 2, - CMD0_OPCODE_NPU_OP_DEPTHWISE = 3, - CMD0_OPCODE_NPU_OP_POOL = 5, - CMD0_OPCODE_NPU_OP_ELEMENTWISE = 6, - CMD0_OPCODE_NPU_OP_DMA_START = 16, - CMD0_OPCODE_NPU_OP_DMA_WAIT = 17, - CMD0_OPCODE_NPU_OP_KERNEL_WAIT = 18, - CMD0_OPCODE_NPU_OP_PMU_MASK = 19, - CMD0_OPCODE_NPU_SET_IFM_PAD_TOP = 256, - CMD0_OPCODE_NPU_SET_IFM_PAD_LEFT = 257, - CMD0_OPCODE_NPU_SET_IFM_PAD_RIGHT = 258, - CMD0_OPCODE_NPU_SET_IFM_PAD_BOTTOM = 259, - CMD0_OPCODE_NPU_SET_IFM_DEPTH_M1 = 260, - CMD0_OPCODE_NPU_SET_IFM_PRECISION = 261, - CMD0_OPCODE_NPU_SET_IFM_UPSCALE = 263, - CMD0_OPCODE_NPU_SET_IFM_ZERO_POINT = 265, - CMD0_OPCODE_NPU_SET_IFM_WIDTH0_M1 = 266, - CMD0_OPCODE_NPU_SET_IFM_HEIGHT0_M1 = 267, - CMD0_OPCODE_NPU_SET_IFM_HEIGHT1_M1 = 268, - CMD0_OPCODE_NPU_SET_IFM_IB_END = 269, - CMD0_OPCODE_NPU_SET_IFM_REGION = 271, - CMD0_OPCODE_NPU_SET_OFM_WIDTH_M1 = 273, - CMD0_OPCODE_NPU_SET_OFM_HEIGHT_M1 = 274, - CMD0_OPCODE_NPU_SET_OFM_DEPTH_M1 = 275, - CMD0_OPCODE_NPU_SET_OFM_PRECISION = 276, - CMD0_OPCODE_NPU_SET_OFM_BLK_WIDTH_M1 = 277, - CMD0_OPCODE_NPU_SET_OFM_BLK_HEIGHT_M1 = 278, - CMD0_OPCODE_NPU_SET_OFM_BLK_DEPTH_M1 = 279, - CMD0_OPCODE_NPU_SET_OFM_ZERO_POINT = 280, - CMD0_OPCODE_NPU_SET_OFM_WIDTH0_M1 = 282, - CMD0_OPCODE_NPU_SET_OFM_HEIGHT0_M1 = 283, - CMD0_OPCODE_NPU_SET_OFM_HEIGHT1_M1 = 284, - CMD0_OPCODE_NPU_SET_OFM_REGION = 287, - CMD0_OPCODE_NPU_SET_KERNEL_WIDTH_M1 = 288, - CMD0_OPCODE_NPU_SET_KERNEL_HEIGHT_M1 = 289, - CMD0_OPCODE_NPU_SET_KERNEL_STRIDE = 290, - CMD0_OPCODE_NPU_SET_PARALLEL_MODE = 291, - CMD0_OPCODE_NPU_SET_ACC_FORMAT = 292, - CMD0_OPCODE_NPU_SET_ACTIVATION = 293, - CMD0_OPCODE_NPU_SET_ACTIVATION_MIN = 294, - CMD0_OPCODE_NPU_SET_ACTIVATION_MAX = 295, - CMD0_OPCODE_NPU_SET_WEIGHT_REGION = 296, - CMD0_OPCODE_NPU_SET_SCALE_REGION = 297, - CMD0_OPCODE_NPU_SET_AB_START = 301, - CMD0_OPCODE_NPU_SET_BLOCKDEP = 303, - CMD0_OPCODE_NPU_SET_DMA0_SRC_REGION = 304, - CMD0_OPCODE_NPU_SET_DMA0_DST_REGION = 305, - CMD0_OPCODE_NPU_SET_DMA0_SIZE0 = 306, - CMD0_OPCODE_NPU_SET_DMA0_SIZE1 = 307, - CMD0_OPCODE_NPU_SET_IFM2_BROADCAST = 384, - CMD0_OPCODE_NPU_SET_IFM2_SCALAR = 385, - CMD0_OPCODE_NPU_SET_IFM2_PRECISION = 389, - CMD0_OPCODE_NPU_SET_IFM2_ZERO_POINT = 393, - CMD0_OPCODE_NPU_SET_IFM2_WIDTH0_M1 = 394, - CMD0_OPCODE_NPU_SET_IFM2_HEIGHT0_M1 = 395, - CMD0_OPCODE_NPU_SET_IFM2_HEIGHT1_M1 = 396, - CMD0_OPCODE_NPU_SET_IFM2_IB_START = 397, - CMD0_OPCODE_NPU_SET_IFM2_REGION = 399, -}; - -enum cmd1_opcode -{ - CMD1_OPCODE_NPU_SET_IFM_BASE0 = 0, - CMD1_OPCODE_NPU_SET_IFM_BASE1 = 1, - CMD1_OPCODE_NPU_SET_IFM_BASE2 = 2, - CMD1_OPCODE_NPU_SET_IFM_BASE3 = 3, - CMD1_OPCODE_NPU_SET_IFM_STRIDE_X = 4, - CMD1_OPCODE_NPU_SET_IFM_STRIDE_Y = 5, - CMD1_OPCODE_NPU_SET_IFM_STRIDE_C = 6, - CMD1_OPCODE_NPU_SET_OFM_BASE0 = 16, - CMD1_OPCODE_NPU_SET_OFM_BASE1 = 17, - CMD1_OPCODE_NPU_SET_OFM_BASE2 = 18, - CMD1_OPCODE_NPU_SET_OFM_BASE3 = 19, - CMD1_OPCODE_NPU_SET_OFM_STRIDE_X = 20, - CMD1_OPCODE_NPU_SET_OFM_STRIDE_Y = 21, - CMD1_OPCODE_NPU_SET_OFM_STRIDE_C = 22, - CMD1_OPCODE_NPU_SET_WEIGHT_BASE = 32, - CMD1_OPCODE_NPU_SET_WEIGHT_LENGTH = 33, - CMD1_OPCODE_NPU_SET_SCALE_BASE = 34, - CMD1_OPCODE_NPU_SET_SCALE_LENGTH = 35, - CMD1_OPCODE_NPU_SET_OFM_SCALE = 36, - CMD1_OPCODE_NPU_SET_OPA_SCALE = 37, - CMD1_OPCODE_NPU_SET_OPB_SCALE = 38, - CMD1_OPCODE_NPU_SET_DMA0_SRC = 48, - CMD1_OPCODE_NPU_SET_DMA0_DST = 49, - CMD1_OPCODE_NPU_SET_DMA0_LEN = 50, - CMD1_OPCODE_NPU_SET_DMA0_SKIP0 = 51, - CMD1_OPCODE_NPU_SET_DMA0_SKIP1 = 52, - CMD1_OPCODE_NPU_SET_IFM2_BASE0 = 128, - CMD1_OPCODE_NPU_SET_IFM2_BASE1 = 129, - CMD1_OPCODE_NPU_SET_IFM2_BASE2 = 130, - CMD1_OPCODE_NPU_SET_IFM2_BASE3 = 131, - CMD1_OPCODE_NPU_SET_IFM2_STRIDE_X = 132, - CMD1_OPCODE_NPU_SET_IFM2_STRIDE_Y = 133, - CMD1_OPCODE_NPU_SET_IFM2_STRIDE_C = 134, - CMD1_OPCODE_NPU_SET_WEIGHT1_BASE = 144, - CMD1_OPCODE_NPU_SET_WEIGHT1_LENGTH = 145, - CMD1_OPCODE_NPU_SET_SCALE1_BASE = 146, - CMD1_OPCODE_NPU_SET_SCALE1_LENGTH = 147, -}; - -enum cmd_ctrl -{ - CMD_CTRL_CMD0_CTRL = 0, - CMD_CTRL_CMD1_CTRL = 1, -}; - -enum custom_dma -{ - CUSTOM_DMA_NOT_IMPLEMENTED = 0, - CUSTOM_DMA_IMPLEMENTED = 1, -}; - -enum dma_fault_src -{ - DMA_FAULT_SRC_AXI_M0 = 0, - DMA_FAULT_SRC_AXI_M1 = 1, -}; - -enum dma_region_mode -{ - DMA_REGION_MODE_EXTERNAL = 0, - DMA_REGION_MODE_INTERNAL = 1, -}; - -enum dma_stride_mode -{ - DMA_STRIDE_MODE_D1 = 0, - DMA_STRIDE_MODE_D2 = 1, - DMA_STRIDE_MODE_D3 = 2, -}; - -enum elementwise_mode -{ - ELEMENTWISE_MODE_MUL = 0, - ELEMENTWISE_MODE_ADD = 1, - ELEMENTWISE_MODE_SUB = 2, - ELEMENTWISE_MODE_MIN = 3, - ELEMENTWISE_MODE_MAX = 4, - ELEMENTWISE_MODE_LRELU = 5, - ELEMENTWISE_MODE_ABS = 6, - ELEMENTWISE_MODE_CLZ = 7, - ELEMENTWISE_MODE_SHR = 8, - ELEMENTWISE_MODE_SHL = 9, -}; - -enum functional_safety -{ - FUNCTIONAL_SAFETY_NOT_IMPLEMENTED = 0, - FUNCTIONAL_SAFETY_IMPLEMENTED = 1, -}; - -enum ifm2_operand_order -{ - IFM2_OPERAND_ORDER_ORDER_B = 0, - IFM2_OPERAND_ORDER_ORDER_A = 1, -}; - -enum ifm_scale_mode -{ - IFM_SCALE_MODE_OPA_OPB_16 = 0, - IFM_SCALE_MODE_OPA_32 = 1, - IFM_SCALE_MODE_OPB_32 = 2, -}; - -enum ifm_upscale_mode -{ - IFM_UPSCALE_MODE_NONE = 0, - IFM_UPSCALE_MODE_NEAREST = 1, - IFM_UPSCALE_MODE_ZEROS = 2, -}; - -enum kernel_decomposition -{ - KERNEL_DECOMPOSITION_D8X8 = 0, - KERNEL_DECOMPOSITION_D4X4 = 1, -}; - -enum kernel_dilation -{ - KERNEL_DILATION_NONE = 0, - KERNEL_DILATION_X2 = 1, -}; - -enum max_beats -{ - MAX_BEATS_B64 = 0, - MAX_BEATS_B128 = 1, - MAX_BEATS_B256 = 2, -}; - -enum mem_attr -{ - MEM_ATTR_AXI0_OUTSTANDING_COUNTER0 = 0, - MEM_ATTR_AXI0_OUTSTANDING_COUNTER1 = 1, - MEM_ATTR_AXI1_OUTSTANDING_COUNTER2 = 2, - MEM_ATTR_AXI1_OUTSTANDING_COUNTER3 = 3, -}; - -enum ofm_scale_mode -{ - OFM_SCALE_MODE_PER_CHANNEL = 0, - OFM_SCALE_MODE_GLOBAL = 1, -}; - -enum parallel_mode -{ - PARALLEL_MODE_SINGLE_CORE = 0, - PARALLEL_MODE_DUAL_CORE_DEPTH = 1, -}; - -enum pmu_axi_channel -{ - PMU_AXI_CHANNEL_RD_CMD = 0, - PMU_AXI_CHANNEL_RD_IFM = 1, - PMU_AXI_CHANNEL_RD_WEIGHTS = 2, - PMU_AXI_CHANNEL_RD_SCALE_BIAS = 3, - PMU_AXI_CHANNEL_RD_MEM2MEM = 4, - PMU_AXI_CHANNEL_WR_OFM = 8, - PMU_AXI_CHANNEL_WR_MEM2MEM = 9, -}; - -enum pmu_event -{ - PMU_EVENT_NO_EVENT = 0, - PMU_EVENT_CYCLE = 17, - PMU_EVENT_NPU_IDLE = 32, - PMU_EVENT_CC_STALLED_ON_BLOCKDEP = 33, - PMU_EVENT_CC_STALLED_ON_SHRAM_RECONFIG = 34, - PMU_EVENT_NPU_ACTIVE = 35, - PMU_EVENT_MAC_ACTIVE = 48, - PMU_EVENT_MAC_ACTIVE_8BIT = 49, - PMU_EVENT_MAC_ACTIVE_16BIT = 50, - PMU_EVENT_MAC_DPU_ACTIVE = 51, - PMU_EVENT_MAC_STALLED_BY_WD_ACC = 52, - PMU_EVENT_MAC_STALLED_BY_WD = 53, - PMU_EVENT_MAC_STALLED_BY_ACC = 54, - PMU_EVENT_MAC_STALLED_BY_IB = 55, - PMU_EVENT_MAC_ACTIVE_32BIT = 56, - PMU_EVENT_MAC_STALLED_BY_INT_W = 57, - PMU_EVENT_MAC_STALLED_BY_INT_ACC = 58, - PMU_EVENT_AO_ACTIVE = 64, - PMU_EVENT_AO_ACTIVE_8BIT = 65, - PMU_EVENT_AO_ACTIVE_16BIT = 66, - PMU_EVENT_AO_STALLED_BY_OFMP_OB = 67, - PMU_EVENT_AO_STALLED_BY_OFMP = 68, - PMU_EVENT_AO_STALLED_BY_OB = 69, - PMU_EVENT_AO_STALLED_BY_ACC_IB = 70, - PMU_EVENT_AO_STALLED_BY_ACC = 71, - PMU_EVENT_AO_STALLED_BY_IB = 72, - PMU_EVENT_WD_ACTIVE = 80, - PMU_EVENT_WD_STALLED = 81, - PMU_EVENT_WD_STALLED_BY_WS = 82, - PMU_EVENT_WD_STALLED_BY_WD_BUF = 83, - PMU_EVENT_WD_PARSE_ACTIVE = 84, - PMU_EVENT_WD_PARSE_STALLED = 85, - PMU_EVENT_WD_PARSE_STALLED_IN = 86, - PMU_EVENT_WD_PARSE_STALLED_OUT = 87, - PMU_EVENT_WD_TRANS_WS = 88, - PMU_EVENT_WD_TRANS_WB = 89, - PMU_EVENT_WD_TRANS_DW0 = 90, - PMU_EVENT_WD_TRANS_DW1 = 91, - PMU_EVENT_AXI0_RD_TRANS_ACCEPTED = 128, - PMU_EVENT_AXI0_RD_TRANS_COMPLETED = 129, - PMU_EVENT_AXI0_RD_DATA_BEAT_RECEIVED = 130, - PMU_EVENT_AXI0_RD_TRAN_REQ_STALLED = 131, - PMU_EVENT_AXI0_WR_TRANS_ACCEPTED = 132, - PMU_EVENT_AXI0_WR_TRANS_COMPLETED_M = 133, - PMU_EVENT_AXI0_WR_TRANS_COMPLETED_S = 134, - PMU_EVENT_AXI0_WR_DATA_BEAT_WRITTEN = 135, - PMU_EVENT_AXI0_WR_TRAN_REQ_STALLED = 136, - PMU_EVENT_AXI0_WR_DATA_BEAT_STALLED = 137, - PMU_EVENT_AXI0_ENABLED_CYCLES = 140, - PMU_EVENT_AXI0_RD_STALL_LIMIT = 142, - PMU_EVENT_AXI0_WR_STALL_LIMIT = 143, - PMU_EVENT_AXI_LATENCY_ANY = 160, - PMU_EVENT_AXI_LATENCY_32 = 161, - PMU_EVENT_AXI_LATENCY_64 = 162, - PMU_EVENT_AXI_LATENCY_128 = 163, - PMU_EVENT_AXI_LATENCY_256 = 164, - PMU_EVENT_AXI_LATENCY_512 = 165, - PMU_EVENT_AXI_LATENCY_1024 = 166, - PMU_EVENT_ECC_DMA = 176, - PMU_EVENT_ECC_SB0 = 177, - PMU_EVENT_AXI1_RD_TRANS_ACCEPTED = 384, - PMU_EVENT_AXI1_RD_TRANS_COMPLETED = 385, - PMU_EVENT_AXI1_RD_DATA_BEAT_RECEIVED = 386, - PMU_EVENT_AXI1_RD_TRAN_REQ_STALLED = 387, - PMU_EVENT_AXI1_WR_TRANS_ACCEPTED = 388, - PMU_EVENT_AXI1_WR_TRANS_COMPLETED_M = 389, - PMU_EVENT_AXI1_WR_TRANS_COMPLETED_S = 390, - PMU_EVENT_AXI1_WR_DATA_BEAT_WRITTEN = 391, - PMU_EVENT_AXI1_WR_TRAN_REQ_STALLED = 392, - PMU_EVENT_AXI1_WR_DATA_BEAT_STALLED = 393, - PMU_EVENT_AXI1_ENABLED_CYCLES = 396, - PMU_EVENT_AXI1_RD_STALL_LIMIT = 398, - PMU_EVENT_AXI1_WR_STALL_LIMIT = 399, - PMU_EVENT_ECC_SB1 = 433, -}; - -enum pooling_mode -{ - POOLING_MODE_MAX = 0, - POOLING_MODE_AVERAGE = 1, - POOLING_MODE_REDUCE_SUM = 2, -}; - -enum privilege_level -{ - PRIVILEGE_LEVEL_USER = 0, - PRIVILEGE_LEVEL_PRIVILEGED = 1, -}; - -enum round_mode -{ - ROUND_MODE_DBL = 0, - ROUND_MODE_TRUNCATE = 1, - ROUND_MODE_NATURAL = 2, -}; - -enum security_level -{ - SECURITY_LEVEL_SECURE = 0, - SECURITY_LEVEL_NON_SECURE = 1, -}; - -enum state -{ - STATE_STOPPED = 0, - STATE_RUNNING = 1, -}; - -enum wd_core_slice_state -{ - WD_CORE_SLICE_STATE_HEADER = 0, - WD_CORE_SLICE_STATE_PALETTE = 1, - WD_CORE_SLICE_STATE_WEIGHTS = 2, -}; - -enum wd_ctrl_state -{ - WD_CTRL_STATE_IDLE = 0, - WD_CTRL_STATE_DRAIN = 1, - WD_CTRL_STATE_OFD_INIT = 2, - WD_CTRL_STATE_OFD_RUN = 3, -}; - -enum weight_order -{ - WEIGHT_ORDER_DEPTH_FIRST = 0, - WEIGHT_ORDER_PART_KERNEL_FIRST = 1, -}; - -#endif - -#ifdef NPU_DISASSEMBLE - -static const char *acc_format_str[] = { - "ACC_FORMAT_I32", - "ACC_FORMAT_I40", - "ACC_FORMAT_F16", -}; - -static const char *activation_clip_range_str[] = { - "ACTIVATION_CLIP_RANGE_OFM_PRECISION", - "****", - "ACTIVATION_CLIP_RANGE_FORCE_UINT8", - "ACTIVATION_CLIP_RANGE_FORCE_INT8", - "****", - "ACTIVATION_CLIP_RANGE_FORCE_INT16", -}; - -static const char *activation_format_str[] = { - "ACTIVATION_FORMAT_NHWC", - "ACTIVATION_FORMAT_NHCWB16", -}; - -static const char *activation_function_str[] = { - "ACTIVATION_FUNCTION_RELU", - "****", - "****", - "ACTIVATION_FUNCTION_TANH", - "ACTIVATION_FUNCTION_SIGMOID", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "ACTIVATION_FUNCTION_TABLE_0", - "ACTIVATION_FUNCTION_TABLE_1", - "ACTIVATION_FUNCTION_TABLE_2", - "ACTIVATION_FUNCTION_TABLE_3", - "ACTIVATION_FUNCTION_TABLE_4", - "ACTIVATION_FUNCTION_TABLE_5", - "ACTIVATION_FUNCTION_TABLE_6", - "ACTIVATION_FUNCTION_TABLE_7", -}; - -static const char *activation_precision_str[] = { - "ACTIVATION_PRECISION_B8", - "ACTIVATION_PRECISION_B16", - "ACTIVATION_PRECISION_B32", - "ACTIVATION_PRECISION_B64", -}; - -static const char *activation_type_str[] = { - "ACTIVATION_TYPE_UNSIGNED", - "ACTIVATION_TYPE_SIGNED", -}; - -static const char *axi_mem_encoding_str[] = { - "AXI_MEM_ENCODING_DEVICE_NON_BUFFERABLE", - "AXI_MEM_ENCODING_DEVICE_BUFFERABLE", - "AXI_MEM_ENCODING_NORMAL_NON_CACHEABLE_NON_BUFFERABLE", - "AXI_MEM_ENCODING_NORMAL_NON_CACHEABLE_BUFFERABLE", - "AXI_MEM_ENCODING_WRITE_THROUGH_NO_ALLOCATE", - "AXI_MEM_ENCODING_WRITE_THROUGH_READ_ALLOCATE", - "AXI_MEM_ENCODING_WRITE_THROUGH_WRITE_ALLOCATE", - "AXI_MEM_ENCODING_WRITE_THROUGH_READ_AND_WRITE_ALLOCATE", - "AXI_MEM_ENCODING_WRITE_BACK_NO_ALLOCATE", - "AXI_MEM_ENCODING_WRITE_BACK_READ_ALLOCATE", - "AXI_MEM_ENCODING_WRITE_BACK_WRITE_ALLOCATE", - "AXI_MEM_ENCODING_WRITE_BACK_READ_AND_WRITE_ALLOCATE", -}; - -static const char *broadcast_mode_str[] = { - "BROADCAST_MODE_DISABLE", - "BROADCAST_MODE_ENABLE", -}; - -static const char *cmd0_opcode_str[] = { - "CMD0_OPCODE_NPU_OP_STOP", - "CMD0_OPCODE_NPU_OP_IRQ", - "CMD0_OPCODE_NPU_OP_CONV", - "CMD0_OPCODE_NPU_OP_DEPTHWISE", - "****", - "CMD0_OPCODE_NPU_OP_POOL", - "CMD0_OPCODE_NPU_OP_ELEMENTWISE", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "CMD0_OPCODE_NPU_OP_DMA_START", - "CMD0_OPCODE_NPU_OP_DMA_WAIT", - "CMD0_OPCODE_NPU_OP_KERNEL_WAIT", - "CMD0_OPCODE_NPU_OP_PMU_MASK", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "CMD0_OPCODE_NPU_SET_IFM_PAD_TOP", - "CMD0_OPCODE_NPU_SET_IFM_PAD_LEFT", - "CMD0_OPCODE_NPU_SET_IFM_PAD_RIGHT", - "CMD0_OPCODE_NPU_SET_IFM_PAD_BOTTOM", - "CMD0_OPCODE_NPU_SET_IFM_DEPTH_M1", - "CMD0_OPCODE_NPU_SET_IFM_PRECISION", - "****", - "CMD0_OPCODE_NPU_SET_IFM_UPSCALE", - "****", - "CMD0_OPCODE_NPU_SET_IFM_ZERO_POINT", - "CMD0_OPCODE_NPU_SET_IFM_WIDTH0_M1", - "CMD0_OPCODE_NPU_SET_IFM_HEIGHT0_M1", - "CMD0_OPCODE_NPU_SET_IFM_HEIGHT1_M1", - "CMD0_OPCODE_NPU_SET_IFM_IB_END", - "****", - "CMD0_OPCODE_NPU_SET_IFM_REGION", - "****", - "CMD0_OPCODE_NPU_SET_OFM_WIDTH_M1", - "CMD0_OPCODE_NPU_SET_OFM_HEIGHT_M1", - "CMD0_OPCODE_NPU_SET_OFM_DEPTH_M1", - "CMD0_OPCODE_NPU_SET_OFM_PRECISION", - "CMD0_OPCODE_NPU_SET_OFM_BLK_WIDTH_M1", - "CMD0_OPCODE_NPU_SET_OFM_BLK_HEIGHT_M1", - "CMD0_OPCODE_NPU_SET_OFM_BLK_DEPTH_M1", - "CMD0_OPCODE_NPU_SET_OFM_ZERO_POINT", - "****", - "CMD0_OPCODE_NPU_SET_OFM_WIDTH0_M1", - "CMD0_OPCODE_NPU_SET_OFM_HEIGHT0_M1", - "CMD0_OPCODE_NPU_SET_OFM_HEIGHT1_M1", - "****", - "****", - "CMD0_OPCODE_NPU_SET_OFM_REGION", - "CMD0_OPCODE_NPU_SET_KERNEL_WIDTH_M1", - "CMD0_OPCODE_NPU_SET_KERNEL_HEIGHT_M1", - "CMD0_OPCODE_NPU_SET_KERNEL_STRIDE", - "CMD0_OPCODE_NPU_SET_PARALLEL_MODE", - "CMD0_OPCODE_NPU_SET_ACC_FORMAT", - "CMD0_OPCODE_NPU_SET_ACTIVATION", - "CMD0_OPCODE_NPU_SET_ACTIVATION_MIN", - "CMD0_OPCODE_NPU_SET_ACTIVATION_MAX", - "CMD0_OPCODE_NPU_SET_WEIGHT_REGION", - "CMD0_OPCODE_NPU_SET_SCALE_REGION", - "****", - "****", - "****", - "CMD0_OPCODE_NPU_SET_AB_START", - "****", - "CMD0_OPCODE_NPU_SET_BLOCKDEP", - "CMD0_OPCODE_NPU_SET_DMA0_SRC_REGION", - "CMD0_OPCODE_NPU_SET_DMA0_DST_REGION", - "CMD0_OPCODE_NPU_SET_DMA0_SIZE0", - "CMD0_OPCODE_NPU_SET_DMA0_SIZE1", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "CMD0_OPCODE_NPU_SET_IFM2_BROADCAST", - "CMD0_OPCODE_NPU_SET_IFM2_SCALAR", - "****", - "****", - "****", - "CMD0_OPCODE_NPU_SET_IFM2_PRECISION", - "****", - "****", - "****", - "CMD0_OPCODE_NPU_SET_IFM2_ZERO_POINT", - "CMD0_OPCODE_NPU_SET_IFM2_WIDTH0_M1", - "CMD0_OPCODE_NPU_SET_IFM2_HEIGHT0_M1", - "CMD0_OPCODE_NPU_SET_IFM2_HEIGHT1_M1", - "CMD0_OPCODE_NPU_SET_IFM2_IB_START", - "****", - "CMD0_OPCODE_NPU_SET_IFM2_REGION", -}; - -static const char *cmd1_opcode_str[] = { - "CMD1_OPCODE_NPU_SET_IFM_BASE0", - "CMD1_OPCODE_NPU_SET_IFM_BASE1", - "CMD1_OPCODE_NPU_SET_IFM_BASE2", - "CMD1_OPCODE_NPU_SET_IFM_BASE3", - "CMD1_OPCODE_NPU_SET_IFM_STRIDE_X", - "CMD1_OPCODE_NPU_SET_IFM_STRIDE_Y", - "CMD1_OPCODE_NPU_SET_IFM_STRIDE_C", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "CMD1_OPCODE_NPU_SET_OFM_BASE0", - "CMD1_OPCODE_NPU_SET_OFM_BASE1", - "CMD1_OPCODE_NPU_SET_OFM_BASE2", - "CMD1_OPCODE_NPU_SET_OFM_BASE3", - "CMD1_OPCODE_NPU_SET_OFM_STRIDE_X", - "CMD1_OPCODE_NPU_SET_OFM_STRIDE_Y", - "CMD1_OPCODE_NPU_SET_OFM_STRIDE_C", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "CMD1_OPCODE_NPU_SET_WEIGHT_BASE", - "CMD1_OPCODE_NPU_SET_WEIGHT_LENGTH", - "CMD1_OPCODE_NPU_SET_SCALE_BASE", - "CMD1_OPCODE_NPU_SET_SCALE_LENGTH", - "CMD1_OPCODE_NPU_SET_OFM_SCALE", - "CMD1_OPCODE_NPU_SET_OPA_SCALE", - "CMD1_OPCODE_NPU_SET_OPB_SCALE", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "CMD1_OPCODE_NPU_SET_DMA0_SRC", - "CMD1_OPCODE_NPU_SET_DMA0_DST", - "CMD1_OPCODE_NPU_SET_DMA0_LEN", - "CMD1_OPCODE_NPU_SET_DMA0_SKIP0", - "CMD1_OPCODE_NPU_SET_DMA0_SKIP1", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "CMD1_OPCODE_NPU_SET_IFM2_BASE0", - "CMD1_OPCODE_NPU_SET_IFM2_BASE1", - "CMD1_OPCODE_NPU_SET_IFM2_BASE2", - "CMD1_OPCODE_NPU_SET_IFM2_BASE3", - "CMD1_OPCODE_NPU_SET_IFM2_STRIDE_X", - "CMD1_OPCODE_NPU_SET_IFM2_STRIDE_Y", - "CMD1_OPCODE_NPU_SET_IFM2_STRIDE_C", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "CMD1_OPCODE_NPU_SET_WEIGHT1_BASE", - "CMD1_OPCODE_NPU_SET_WEIGHT1_LENGTH", - "CMD1_OPCODE_NPU_SET_SCALE1_BASE", - "CMD1_OPCODE_NPU_SET_SCALE1_LENGTH", -}; - -static const char *cmd_ctrl_str[] = { - "CMD_CTRL_CMD0_CTRL", - "CMD_CTRL_CMD1_CTRL", -}; - -static const char *custom_dma_str[] = { - "CUSTOM_DMA_NOT_IMPLEMENTED", - "CUSTOM_DMA_IMPLEMENTED", -}; - -static const char *dma_fault_src_str[] = { - "DMA_FAULT_SRC_AXI_M0", - "DMA_FAULT_SRC_AXI_M1", -}; - -static const char *dma_region_mode_str[] = { - "DMA_REGION_MODE_EXTERNAL", - "DMA_REGION_MODE_INTERNAL", -}; - -static const char *dma_stride_mode_str[] = { - "DMA_STRIDE_MODE_D1", - "DMA_STRIDE_MODE_D2", - "DMA_STRIDE_MODE_D3", -}; - -static const char *elementwise_mode_str[] = { - "ELEMENTWISE_MODE_MUL", - "ELEMENTWISE_MODE_ADD", - "ELEMENTWISE_MODE_SUB", - "ELEMENTWISE_MODE_MIN", - "ELEMENTWISE_MODE_MAX", - "ELEMENTWISE_MODE_LRELU", - "ELEMENTWISE_MODE_ABS", - "ELEMENTWISE_MODE_CLZ", - "ELEMENTWISE_MODE_SHR", - "ELEMENTWISE_MODE_SHL", -}; - -static const char *functional_safety_str[] = { - "FUNCTIONAL_SAFETY_NOT_IMPLEMENTED", - "FUNCTIONAL_SAFETY_IMPLEMENTED", -}; - -static const char *ifm2_operand_order_str[] = { - "IFM2_OPERAND_ORDER_ORDER_B", - "IFM2_OPERAND_ORDER_ORDER_A", -}; - -static const char *ifm_scale_mode_str[] = { - "IFM_SCALE_MODE_OPA_OPB_16", - "IFM_SCALE_MODE_OPA_32", - "IFM_SCALE_MODE_OPB_32", -}; - -static const char *ifm_upscale_mode_str[] = { - "IFM_UPSCALE_MODE_NONE", - "IFM_UPSCALE_MODE_NEAREST", - "IFM_UPSCALE_MODE_ZEROS", -}; - -static const char *kernel_decomposition_str[] = { - "KERNEL_DECOMPOSITION_D8X8", - "KERNEL_DECOMPOSITION_D4X4", -}; - -static const char *kernel_dilation_str[] = { - "KERNEL_DILATION_NONE", - "KERNEL_DILATION_X2", -}; - -static const char *max_beats_str[] = { - "MAX_BEATS_B64", - "MAX_BEATS_B128", - "MAX_BEATS_B256", -}; - -static const char *mem_attr_str[] = { - "MEM_ATTR_AXI0_OUTSTANDING_COUNTER0", - "MEM_ATTR_AXI0_OUTSTANDING_COUNTER1", - "MEM_ATTR_AXI1_OUTSTANDING_COUNTER2", - "MEM_ATTR_AXI1_OUTSTANDING_COUNTER3", -}; - -static const char *ofm_scale_mode_str[] = { - "OFM_SCALE_MODE_PER_CHANNEL", - "OFM_SCALE_MODE_GLOBAL", -}; - -static const char *parallel_mode_str[] = { - "PARALLEL_MODE_SINGLE_CORE", - "PARALLEL_MODE_DUAL_CORE_DEPTH", -}; - -static const char *pmu_axi_channel_str[] = { - "PMU_AXI_CHANNEL_RD_CMD", - "PMU_AXI_CHANNEL_RD_IFM", - "PMU_AXI_CHANNEL_RD_WEIGHTS", - "PMU_AXI_CHANNEL_RD_SCALE_BIAS", - "PMU_AXI_CHANNEL_RD_MEM2MEM", - "****", - "****", - "****", - "PMU_AXI_CHANNEL_WR_OFM", - "PMU_AXI_CHANNEL_WR_MEM2MEM", -}; - -static const char *pmu_event_str[] = { - "PMU_EVENT_NO_EVENT", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "PMU_EVENT_CYCLE", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "PMU_EVENT_NPU_IDLE", - "PMU_EVENT_CC_STALLED_ON_BLOCKDEP", - "PMU_EVENT_CC_STALLED_ON_SHRAM_RECONFIG", - "PMU_EVENT_NPU_ACTIVE", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "PMU_EVENT_MAC_ACTIVE", - "PMU_EVENT_MAC_ACTIVE_8BIT", - "PMU_EVENT_MAC_ACTIVE_16BIT", - "PMU_EVENT_MAC_DPU_ACTIVE", - "PMU_EVENT_MAC_STALLED_BY_WD_ACC", - "PMU_EVENT_MAC_STALLED_BY_WD", - "PMU_EVENT_MAC_STALLED_BY_ACC", - "PMU_EVENT_MAC_STALLED_BY_IB", - "PMU_EVENT_MAC_ACTIVE_32BIT", - "PMU_EVENT_MAC_STALLED_BY_INT_W", - "PMU_EVENT_MAC_STALLED_BY_INT_ACC", - "****", - "****", - "****", - "****", - "****", - "PMU_EVENT_AO_ACTIVE", - "PMU_EVENT_AO_ACTIVE_8BIT", - "PMU_EVENT_AO_ACTIVE_16BIT", - "PMU_EVENT_AO_STALLED_BY_OFMP_OB", - "PMU_EVENT_AO_STALLED_BY_OFMP", - "PMU_EVENT_AO_STALLED_BY_OB", - "PMU_EVENT_AO_STALLED_BY_ACC_IB", - "PMU_EVENT_AO_STALLED_BY_ACC", - "PMU_EVENT_AO_STALLED_BY_IB", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "PMU_EVENT_WD_ACTIVE", - "PMU_EVENT_WD_STALLED", - "PMU_EVENT_WD_STALLED_BY_WS", - "PMU_EVENT_WD_STALLED_BY_WD_BUF", - "PMU_EVENT_WD_PARSE_ACTIVE", - "PMU_EVENT_WD_PARSE_STALLED", - "PMU_EVENT_WD_PARSE_STALLED_IN", - "PMU_EVENT_WD_PARSE_STALLED_OUT", - "PMU_EVENT_WD_TRANS_WS", - "PMU_EVENT_WD_TRANS_WB", - "PMU_EVENT_WD_TRANS_DW0", - "PMU_EVENT_WD_TRANS_DW1", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "PMU_EVENT_AXI0_RD_TRANS_ACCEPTED", - "PMU_EVENT_AXI0_RD_TRANS_COMPLETED", - "PMU_EVENT_AXI0_RD_DATA_BEAT_RECEIVED", - "PMU_EVENT_AXI0_RD_TRAN_REQ_STALLED", - "PMU_EVENT_AXI0_WR_TRANS_ACCEPTED", - "PMU_EVENT_AXI0_WR_TRANS_COMPLETED_M", - "PMU_EVENT_AXI0_WR_TRANS_COMPLETED_S", - "PMU_EVENT_AXI0_WR_DATA_BEAT_WRITTEN", - "PMU_EVENT_AXI0_WR_TRAN_REQ_STALLED", - "PMU_EVENT_AXI0_WR_DATA_BEAT_STALLED", - "****", - "****", - "PMU_EVENT_AXI0_ENABLED_CYCLES", - "****", - "PMU_EVENT_AXI0_RD_STALL_LIMIT", - "PMU_EVENT_AXI0_WR_STALL_LIMIT", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "PMU_EVENT_AXI_LATENCY_ANY", - "PMU_EVENT_AXI_LATENCY_32", - "PMU_EVENT_AXI_LATENCY_64", - "PMU_EVENT_AXI_LATENCY_128", - "PMU_EVENT_AXI_LATENCY_256", - "PMU_EVENT_AXI_LATENCY_512", - "PMU_EVENT_AXI_LATENCY_1024", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "PMU_EVENT_ECC_DMA", - "PMU_EVENT_ECC_SB0", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "PMU_EVENT_AXI1_RD_TRANS_ACCEPTED", - "PMU_EVENT_AXI1_RD_TRANS_COMPLETED", - "PMU_EVENT_AXI1_RD_DATA_BEAT_RECEIVED", - "PMU_EVENT_AXI1_RD_TRAN_REQ_STALLED", - "PMU_EVENT_AXI1_WR_TRANS_ACCEPTED", - "PMU_EVENT_AXI1_WR_TRANS_COMPLETED_M", - "PMU_EVENT_AXI1_WR_TRANS_COMPLETED_S", - "PMU_EVENT_AXI1_WR_DATA_BEAT_WRITTEN", - "PMU_EVENT_AXI1_WR_TRAN_REQ_STALLED", - "PMU_EVENT_AXI1_WR_DATA_BEAT_STALLED", - "****", - "****", - "PMU_EVENT_AXI1_ENABLED_CYCLES", - "****", - "PMU_EVENT_AXI1_RD_STALL_LIMIT", - "PMU_EVENT_AXI1_WR_STALL_LIMIT", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "PMU_EVENT_ECC_SB1", -}; - -static const char *pooling_mode_str[] = { - "POOLING_MODE_MAX", - "POOLING_MODE_AVERAGE", - "POOLING_MODE_REDUCE_SUM", -}; - -static const char *privilege_level_str[] = { - "PRIVILEGE_LEVEL_USER", - "PRIVILEGE_LEVEL_PRIVILEGED", -}; - -static const char *round_mode_str[] = { - "ROUND_MODE_DBL", - "ROUND_MODE_TRUNCATE", - "ROUND_MODE_NATURAL", -}; - -static const char *security_level_str[] = { - "SECURITY_LEVEL_SECURE", - "SECURITY_LEVEL_NON_SECURE", -}; - -static const char *state_str[] = { - "STATE_STOPPED", - "STATE_RUNNING", -}; - -static const char *wd_core_slice_state_str[] = { - "WD_CORE_SLICE_STATE_HEADER", - "WD_CORE_SLICE_STATE_PALETTE", - "WD_CORE_SLICE_STATE_WEIGHTS", -}; - -static const char *wd_ctrl_state_str[] = { - "WD_CTRL_STATE_IDLE", - "WD_CTRL_STATE_DRAIN", - "WD_CTRL_STATE_OFD_INIT", - "WD_CTRL_STATE_OFD_RUN", -}; - -static const char *weight_order_str[] = { - "WEIGHT_ORDER_DEPTH_FIRST", - "WEIGHT_ORDER_PART_KERNEL_FIRST", -}; - -#endif - -// Register type structs -// id_r - ID register -struct id_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t version_status : 4; // This is the version of the product - uint32_t version_minor : 4; // This is the n for the P part of an RnPn release number - uint32_t version_major : 4; // This is the n for the R part of an RnPn release number - uint32_t product_major : 4; // Product major ID number (unique per base product) - uint32_t arch_patch_rev : 4; // This is the patch number of the architecture version a.b - uint32_t - arch_minor_rev : 8; // This is the minor architecture version number, b in the architecture version a.b - uint32_t - arch_major_rev : 4; // This is the major architecture version number, a in the architecture version a.b - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR id_r() : word0(268853249) {} - CONSTEXPR id_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - id_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_version_status() const - { - uint32_t value = ((1U << 4) - 1) & (word0 >> 0); - return value; - } - uint32_t get_version_status() const volatile - { - uint32_t value = ((1U << 4) - 1) & (word0 >> 0); - return value; - } - CONSTEXPR id_r &set_version_status(uint32_t value) - { - word0 = (((~((1U << 4) - 1)) << 0) & word0) | ((((1U << 4) - 1) & value) << 0); - return *this; - } - volatile id_r &set_version_status(uint32_t value) volatile - { - word0 = (((~((1U << 4) - 1)) << 0) & word0) | ((((1U << 4) - 1) & value) << 0); - return *this; - } - CONSTEXPR uint32_t get_version_minor() const - { - uint32_t value = ((1U << 4) - 1) & (word0 >> 4); - return value; - } - uint32_t get_version_minor() const volatile - { - uint32_t value = ((1U << 4) - 1) & (word0 >> 4); - return value; - } - CONSTEXPR id_r &set_version_minor(uint32_t value) - { - word0 = (((~((1U << 4) - 1)) << 4) & word0) | ((((1U << 4) - 1) & value) << 4); - return *this; - } - volatile id_r &set_version_minor(uint32_t value) volatile - { - word0 = (((~((1U << 4) - 1)) << 4) & word0) | ((((1U << 4) - 1) & value) << 4); - return *this; - } - CONSTEXPR uint32_t get_version_major() const - { - uint32_t value = ((1U << 4) - 1) & (word0 >> 8); - return value; - } - uint32_t get_version_major() const volatile - { - uint32_t value = ((1U << 4) - 1) & (word0 >> 8); - return value; - } - CONSTEXPR id_r &set_version_major(uint32_t value) - { - word0 = (((~((1U << 4) - 1)) << 8) & word0) | ((((1U << 4) - 1) & value) << 8); - return *this; - } - volatile id_r &set_version_major(uint32_t value) volatile - { - word0 = (((~((1U << 4) - 1)) << 8) & word0) | ((((1U << 4) - 1) & value) << 8); - return *this; - } - CONSTEXPR uint32_t get_product_major() const - { - uint32_t value = ((1U << 4) - 1) & (word0 >> 12); - return value; - } - uint32_t get_product_major() const volatile - { - uint32_t value = ((1U << 4) - 1) & (word0 >> 12); - return value; - } - CONSTEXPR id_r &set_product_major(uint32_t value) - { - word0 = (((~((1U << 4) - 1)) << 12) & word0) | ((((1U << 4) - 1) & value) << 12); - return *this; - } - volatile id_r &set_product_major(uint32_t value) volatile - { - word0 = (((~((1U << 4) - 1)) << 12) & word0) | ((((1U << 4) - 1) & value) << 12); - return *this; - } - CONSTEXPR uint32_t get_arch_patch_rev() const - { - uint32_t value = ((1U << 4) - 1) & (word0 >> 16); - return value; - } - uint32_t get_arch_patch_rev() const volatile - { - uint32_t value = ((1U << 4) - 1) & (word0 >> 16); - return value; - } - CONSTEXPR id_r &set_arch_patch_rev(uint32_t value) - { - word0 = (((~((1U << 4) - 1)) << 16) & word0) | ((((1U << 4) - 1) & value) << 16); - return *this; - } - volatile id_r &set_arch_patch_rev(uint32_t value) volatile - { - word0 = (((~((1U << 4) - 1)) << 16) & word0) | ((((1U << 4) - 1) & value) << 16); - return *this; - } - CONSTEXPR uint32_t get_arch_minor_rev() const - { - uint32_t value = ((1U << 8) - 1) & (word0 >> 20); - return value; - } - uint32_t get_arch_minor_rev() const volatile - { - uint32_t value = ((1U << 8) - 1) & (word0 >> 20); - return value; - } - CONSTEXPR id_r &set_arch_minor_rev(uint32_t value) - { - word0 = (((~((1U << 8) - 1)) << 20) & word0) | ((((1U << 8) - 1) & value) << 20); - return *this; - } - volatile id_r &set_arch_minor_rev(uint32_t value) volatile - { - word0 = (((~((1U << 8) - 1)) << 20) & word0) | ((((1U << 8) - 1) & value) << 20); - return *this; - } - CONSTEXPR uint32_t get_arch_major_rev() const - { - uint32_t value = ((1U << 4) - 1) & (word0 >> 28); - return value; - } - uint32_t get_arch_major_rev() const volatile - { - uint32_t value = ((1U << 4) - 1) & (word0 >> 28); - return value; - } - CONSTEXPR id_r &set_arch_major_rev(uint32_t value) - { - word0 = (((~((1U << 4) - 1)) << 28) & word0) | ((((1U << 4) - 1) & value) << 28); - return *this; - } - volatile id_r &set_arch_major_rev(uint32_t value) volatile - { - word0 = (((~((1U << 4) - 1)) << 28) & word0) | ((((1U << 4) - 1) & value) << 28); - return *this; - } -#endif -}; - -// status_r - Register describes the current operating status of the NPU -struct status_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t state : 1; // NPU state, 0 = Stopped, 1 = Running - uint32_t irq_raised : 1; // Raw IRQ status, 0 = IRQ not raised, 1 = IRQ raised. IRQ is cleared using command - // register bit 1 - uint32_t - bus_status : 1; // 0=OK, 1=Bus abort detected and processing halted (NPU will reach IDLE state and not - // to start process any more commands/AXI transactions). Can only be cleared by a reset - uint32_t reset_status : 1; // Reset is ongoing and only this register can be read (other registers read as 0 - // and writes are ignored.) A value of 0 means NPU is not being reset and can be - // accessed as normal - uint32_t - cmd_parse_error : 1; // 0=No error 1=Command stream parsing error detected. Can only be cleared by reset - uint32_t cmd_end_reached : 1; // 0=Not reached, 1=Reached. Cleared by writing QBASE or QSIZE when NPU is in - // stopped state - uint32_t pmu_irq_raised : 1; // 0=No PMU IRQ, 1=PMU IRQ raised. Cleared by using command register bit 1 - uint32_t wd_fault : 1; // Weight decoder state: 0=no fault 1=weight decoder decompression fault. Can only be - // cleared by reset - uint32_t ecc_fault : 1; // ECC state for internal RAMs: 0=no fault 1=ECC fault signalled. Can only be - // cleared by reset - uint32_t reserved0 : 2; - uint32_t faulting_interface : 1; // Faulting interface on bus abort - uint32_t faulting_channel : 4; // Faulting channel on a bus abort. Read: 0=Cmd 1=IFM 2=Weights 3=Scale+Bias - // 4=Mem2Mem; Write: 8=OFM 9=Mem2Mem - uint32_t irq_history_mask : 16; // IRQ History mask - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR status_r() : word0(8) {} - CONSTEXPR status_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - status_r copy() volatile - { - return *this; - } - CONSTEXPR NPU_NAMESPACE::state get_state() const - { - NPU_NAMESPACE::state value = static_cast(((1U << 1) - 1) & (word0 >> 0)); - return value; - } - NPU_NAMESPACE::state get_state() const volatile - { - NPU_NAMESPACE::state value = static_cast(((1U << 1) - 1) & (word0 >> 0)); - return value; - } - CONSTEXPR status_r &set_state(NPU_NAMESPACE::state value) - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & static_cast(value)) << 0); - return *this; - } - volatile status_r &set_state(NPU_NAMESPACE::state value) volatile - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & static_cast(value)) << 0); - return *this; - } - CONSTEXPR uint32_t get_irq_raised() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 1); - return value; - } - uint32_t get_irq_raised() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 1); - return value; - } - CONSTEXPR status_r &set_irq_raised(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - volatile status_r &set_irq_raised(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - CONSTEXPR uint32_t get_bus_status() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 2); - return value; - } - uint32_t get_bus_status() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 2); - return value; - } - CONSTEXPR status_r &set_bus_status(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - volatile status_r &set_bus_status(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - CONSTEXPR uint32_t get_reset_status() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 3); - return value; - } - uint32_t get_reset_status() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 3); - return value; - } - CONSTEXPR status_r &set_reset_status(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - volatile status_r &set_reset_status(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - CONSTEXPR uint32_t get_cmd_parse_error() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 4); - return value; - } - uint32_t get_cmd_parse_error() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 4); - return value; - } - CONSTEXPR status_r &set_cmd_parse_error(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 4) & word0) | ((((1U << 1) - 1) & value) << 4); - return *this; - } - volatile status_r &set_cmd_parse_error(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 4) & word0) | ((((1U << 1) - 1) & value) << 4); - return *this; - } - CONSTEXPR uint32_t get_cmd_end_reached() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 5); - return value; - } - uint32_t get_cmd_end_reached() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 5); - return value; - } - CONSTEXPR status_r &set_cmd_end_reached(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 5) & word0) | ((((1U << 1) - 1) & value) << 5); - return *this; - } - volatile status_r &set_cmd_end_reached(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 5) & word0) | ((((1U << 1) - 1) & value) << 5); - return *this; - } - CONSTEXPR uint32_t get_pmu_irq_raised() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 6); - return value; - } - uint32_t get_pmu_irq_raised() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 6); - return value; - } - CONSTEXPR status_r &set_pmu_irq_raised(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 6) & word0) | ((((1U << 1) - 1) & value) << 6); - return *this; - } - volatile status_r &set_pmu_irq_raised(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 6) & word0) | ((((1U << 1) - 1) & value) << 6); - return *this; - } - CONSTEXPR uint32_t get_wd_fault() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 7); - return value; - } - uint32_t get_wd_fault() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 7); - return value; - } - CONSTEXPR status_r &set_wd_fault(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 7) & word0) | ((((1U << 1) - 1) & value) << 7); - return *this; - } - volatile status_r &set_wd_fault(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 7) & word0) | ((((1U << 1) - 1) & value) << 7); - return *this; - } - CONSTEXPR uint32_t get_ecc_fault() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 8); - return value; - } - uint32_t get_ecc_fault() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 8); - return value; - } - CONSTEXPR status_r &set_ecc_fault(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 8) & word0) | ((((1U << 1) - 1) & value) << 8); - return *this; - } - volatile status_r &set_ecc_fault(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 8) & word0) | ((((1U << 1) - 1) & value) << 8); - return *this; - } - CONSTEXPR NPU_NAMESPACE::dma_fault_src get_faulting_interface() const - { - NPU_NAMESPACE::dma_fault_src value = static_cast(((1U << 1) - 1) & (word0 >> 11)); - return value; - } - NPU_NAMESPACE::dma_fault_src get_faulting_interface() const volatile - { - NPU_NAMESPACE::dma_fault_src value = static_cast(((1U << 1) - 1) & (word0 >> 11)); - return value; - } - CONSTEXPR status_r &set_faulting_interface(NPU_NAMESPACE::dma_fault_src value) - { - word0 = (((~((1U << 1) - 1)) << 11) & word0) | ((((1U << 1) - 1) & static_cast(value)) << 11); - return *this; - } - volatile status_r &set_faulting_interface(NPU_NAMESPACE::dma_fault_src value) volatile - { - word0 = (((~((1U << 1) - 1)) << 11) & word0) | ((((1U << 1) - 1) & static_cast(value)) << 11); - return *this; - } - CONSTEXPR uint32_t get_faulting_channel() const - { - uint32_t value = ((1U << 4) - 1) & (word0 >> 12); - return value; - } - uint32_t get_faulting_channel() const volatile - { - uint32_t value = ((1U << 4) - 1) & (word0 >> 12); - return value; - } - CONSTEXPR status_r &set_faulting_channel(uint32_t value) - { - word0 = (((~((1U << 4) - 1)) << 12) & word0) | ((((1U << 4) - 1) & value) << 12); - return *this; - } - volatile status_r &set_faulting_channel(uint32_t value) volatile - { - word0 = (((~((1U << 4) - 1)) << 12) & word0) | ((((1U << 4) - 1) & value) << 12); - return *this; - } - CONSTEXPR uint32_t get_irq_history_mask() const - { - uint32_t value = ((1U << 16) - 1) & (word0 >> 16); - return value; - } - uint32_t get_irq_history_mask() const volatile - { - uint32_t value = ((1U << 16) - 1) & (word0 >> 16); - return value; - } - CONSTEXPR status_r &set_irq_history_mask(uint32_t value) - { - word0 = (((~((1U << 16) - 1)) << 16) & word0) | ((((1U << 16) - 1) & value) << 16); - return *this; - } - volatile status_r &set_irq_history_mask(uint32_t value) volatile - { - word0 = (((~((1U << 16) - 1)) << 16) & word0) | ((((1U << 16) - 1) & value) << 16); - return *this; - } -#endif -}; - -// cmd_r - Command register, reads as last written command -struct cmd_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t transition_to_running_state : 1; // Write 1 to transition the NPU to running state. Writing 0 has - // no effect - uint32_t clear_irq : 1; // Write 1 to clear the IRQ status in the STATUS register. Writing 0 has no effect - uint32_t clock_q_enable : 1; // Write 1 to this bit to enable clock off using clock q-interface and enable - // the requester clock gate - uint32_t power_q_enable : 1; // Write 1 to this bit to enable power off using power q-interface - uint32_t - stop_request : 1; // Write 1 to this bit to request STOP after completing any already-started commands - uint32_t reserved0 : 11; - uint32_t clear_irq_history : 16; // Clears the IRQ history mask - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR cmd_r() : word0(12) {} - CONSTEXPR cmd_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - cmd_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_transition_to_running_state() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 0); - return value; - } - uint32_t get_transition_to_running_state() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 0); - return value; - } - CONSTEXPR cmd_r &set_transition_to_running_state(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - volatile cmd_r &set_transition_to_running_state(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - CONSTEXPR uint32_t get_clear_irq() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 1); - return value; - } - uint32_t get_clear_irq() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 1); - return value; - } - CONSTEXPR cmd_r &set_clear_irq(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - volatile cmd_r &set_clear_irq(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - CONSTEXPR uint32_t get_clock_q_enable() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 2); - return value; - } - uint32_t get_clock_q_enable() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 2); - return value; - } - CONSTEXPR cmd_r &set_clock_q_enable(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - volatile cmd_r &set_clock_q_enable(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - CONSTEXPR uint32_t get_power_q_enable() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 3); - return value; - } - uint32_t get_power_q_enable() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 3); - return value; - } - CONSTEXPR cmd_r &set_power_q_enable(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - volatile cmd_r &set_power_q_enable(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - CONSTEXPR uint32_t get_stop_request() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 4); - return value; - } - uint32_t get_stop_request() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 4); - return value; - } - CONSTEXPR cmd_r &set_stop_request(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 4) & word0) | ((((1U << 1) - 1) & value) << 4); - return *this; - } - volatile cmd_r &set_stop_request(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 4) & word0) | ((((1U << 1) - 1) & value) << 4); - return *this; - } - CONSTEXPR uint32_t get_clear_irq_history() const - { - uint32_t value = ((1U << 16) - 1) & (word0 >> 16); - return value; - } - uint32_t get_clear_irq_history() const volatile - { - uint32_t value = ((1U << 16) - 1) & (word0 >> 16); - return value; - } - CONSTEXPR cmd_r &set_clear_irq_history(uint32_t value) - { - word0 = (((~((1U << 16) - 1)) << 16) & word0) | ((((1U << 16) - 1) & value) << 16); - return *this; - } - volatile cmd_r &set_clear_irq_history(uint32_t value) volatile - { - word0 = (((~((1U << 16) - 1)) << 16) & word0) | ((((1U << 16) - 1) & value) << 16); - return *this; - } -#endif -}; - -// reset_r - Request Reset and new security mode -struct reset_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t pending_CPL : 1; // Current privilege level 0=User 1=Privileged - uint32_t pending_CSL : 1; // Current security level 0=Secure 1=Non secure - uint32_t reserved0 : 30; - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR reset_r() : word0(0) {} - CONSTEXPR reset_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - reset_r copy() volatile - { - return *this; - } - CONSTEXPR NPU_NAMESPACE::privilege_level get_pending_CPL() const - { - NPU_NAMESPACE::privilege_level value = - static_cast(((1U << 1) - 1) & (word0 >> 0)); - return value; - } - NPU_NAMESPACE::privilege_level get_pending_CPL() const volatile - { - NPU_NAMESPACE::privilege_level value = - static_cast(((1U << 1) - 1) & (word0 >> 0)); - return value; - } - CONSTEXPR reset_r &set_pending_CPL(NPU_NAMESPACE::privilege_level value) - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & static_cast(value)) << 0); - return *this; - } - volatile reset_r &set_pending_CPL(NPU_NAMESPACE::privilege_level value) volatile - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & static_cast(value)) << 0); - return *this; - } - CONSTEXPR NPU_NAMESPACE::security_level get_pending_CSL() const - { - NPU_NAMESPACE::security_level value = - static_cast(((1U << 1) - 1) & (word0 >> 1)); - return value; - } - NPU_NAMESPACE::security_level get_pending_CSL() const volatile - { - NPU_NAMESPACE::security_level value = - static_cast(((1U << 1) - 1) & (word0 >> 1)); - return value; - } - CONSTEXPR reset_r &set_pending_CSL(NPU_NAMESPACE::security_level value) - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & static_cast(value)) << 1); - return *this; - } - volatile reset_r &set_pending_CSL(NPU_NAMESPACE::security_level value) volatile - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & static_cast(value)) << 1); - return *this; - } -#endif -}; - -// qbase_r - Base address of the command stream in bytes -struct qbase_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t offset_LO : 32; // Offset - LSB - uint32_t offset_HI : 8; // Offset - MSB - uint32_t reserved0 : 24; - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR qbase_r() : word0(0), word1(0) {} - CONSTEXPR qbase_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - qbase_r copy() volatile - { - return *this; - } -#endif -}; - -// qread_r - Read offset in the command stream in bytes. Multiple of 4 in the range 0 to 16 MB -struct qread_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t QREAD : 32; // The read offset of the current command under execution - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR qread_r() : word0(0) {} - CONSTEXPR qread_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - qread_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_QREAD() const - { - uint32_t value = word0; - return value; - } - uint32_t get_QREAD() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR qread_r &set_QREAD(uint32_t value) - { - word0 = value; - return *this; - } - volatile qread_r &set_QREAD(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// qconfig_r - AXI configuration for the command stream in the range 0-3. Same encoding as for REGIONCFG -struct qconfig_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t cmd_region0 : 2; // Command region configuration - uint32_t reserved0 : 30; - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR qconfig_r() : word0(0) {} - CONSTEXPR qconfig_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - qconfig_r copy() volatile - { - return *this; - } - CONSTEXPR NPU_NAMESPACE::mem_attr get_cmd_region0() const - { - NPU_NAMESPACE::mem_attr value = static_cast(((1U << 2) - 1) & (word0 >> 0)); - return value; - } - NPU_NAMESPACE::mem_attr get_cmd_region0() const volatile - { - NPU_NAMESPACE::mem_attr value = static_cast(((1U << 2) - 1) & (word0 >> 0)); - return value; - } - CONSTEXPR qconfig_r &set_cmd_region0(NPU_NAMESPACE::mem_attr value) - { - word0 = (((~((1U << 2) - 1)) << 0) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 0); - return *this; - } - volatile qconfig_r &set_cmd_region0(NPU_NAMESPACE::mem_attr value) volatile - { - word0 = (((~((1U << 2) - 1)) << 0) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 0); - return *this; - } -#endif -}; - -// qsize_r - Size of the command stream in bytes. Multiple of 4 in the range 0 to 16 MB -struct qsize_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t QSIZE : 32; // Size of the next command stream to be executed by the NPU - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR qsize_r() : word0(0) {} - CONSTEXPR qsize_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - qsize_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_QSIZE() const - { - uint32_t value = word0; - return value; - } - uint32_t get_QSIZE() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR qsize_r &set_QSIZE(uint32_t value) - { - word0 = value; - return *this; - } - volatile qsize_r &set_QSIZE(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// prot_r - Protection level configured for the NPU when acting as an AXI requester -struct prot_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t active_CPL : 1; // Current privilege level 0=User 1=Privileged - uint32_t active_CSL : 1; // Current security level 0=Secure 1=Non secure - uint32_t reserved0 : 30; - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR prot_r() : word0(0) {} - CONSTEXPR prot_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - prot_r copy() volatile - { - return *this; - } - CONSTEXPR NPU_NAMESPACE::privilege_level get_active_CPL() const - { - NPU_NAMESPACE::privilege_level value = - static_cast(((1U << 1) - 1) & (word0 >> 0)); - return value; - } - NPU_NAMESPACE::privilege_level get_active_CPL() const volatile - { - NPU_NAMESPACE::privilege_level value = - static_cast(((1U << 1) - 1) & (word0 >> 0)); - return value; - } - CONSTEXPR prot_r &set_active_CPL(NPU_NAMESPACE::privilege_level value) - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & static_cast(value)) << 0); - return *this; - } - volatile prot_r &set_active_CPL(NPU_NAMESPACE::privilege_level value) volatile - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & static_cast(value)) << 0); - return *this; - } - CONSTEXPR NPU_NAMESPACE::security_level get_active_CSL() const - { - NPU_NAMESPACE::security_level value = - static_cast(((1U << 1) - 1) & (word0 >> 1)); - return value; - } - NPU_NAMESPACE::security_level get_active_CSL() const volatile - { - NPU_NAMESPACE::security_level value = - static_cast(((1U << 1) - 1) & (word0 >> 1)); - return value; - } - CONSTEXPR prot_r &set_active_CSL(NPU_NAMESPACE::security_level value) - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & static_cast(value)) << 1); - return *this; - } - volatile prot_r &set_active_CSL(NPU_NAMESPACE::security_level value) volatile - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & static_cast(value)) << 1); - return *this; - } -#endif -}; - -// config_r - RTL configuration -struct config_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t macs_per_cc : 4; // The log2(macs/clock cycle) - uint32_t cmd_stream_version : 4; // command stream version accepted by this NPU - uint32_t shram_size : 8; // Total size in KB of internal SHRAM - uint32_t reserved0 : 10; - uint32_t functional_safety : 1; // Functional safety configuration - uint32_t custom_dma : 1; // Custom DMA configuration - uint32_t product : 4; // Product configuration - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR config_r() : word0(268435456) {} - CONSTEXPR config_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - config_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_macs_per_cc() const - { - uint32_t value = ((1U << 4) - 1) & (word0 >> 0); - return value; - } - uint32_t get_macs_per_cc() const volatile - { - uint32_t value = ((1U << 4) - 1) & (word0 >> 0); - return value; - } - CONSTEXPR config_r &set_macs_per_cc(uint32_t value) - { - word0 = (((~((1U << 4) - 1)) << 0) & word0) | ((((1U << 4) - 1) & value) << 0); - return *this; - } - volatile config_r &set_macs_per_cc(uint32_t value) volatile - { - word0 = (((~((1U << 4) - 1)) << 0) & word0) | ((((1U << 4) - 1) & value) << 0); - return *this; - } - CONSTEXPR uint32_t get_cmd_stream_version() const - { - uint32_t value = ((1U << 4) - 1) & (word0 >> 4); - return value; - } - uint32_t get_cmd_stream_version() const volatile - { - uint32_t value = ((1U << 4) - 1) & (word0 >> 4); - return value; - } - CONSTEXPR config_r &set_cmd_stream_version(uint32_t value) - { - word0 = (((~((1U << 4) - 1)) << 4) & word0) | ((((1U << 4) - 1) & value) << 4); - return *this; - } - volatile config_r &set_cmd_stream_version(uint32_t value) volatile - { - word0 = (((~((1U << 4) - 1)) << 4) & word0) | ((((1U << 4) - 1) & value) << 4); - return *this; - } - CONSTEXPR uint32_t get_shram_size() const - { - uint32_t value = ((1U << 8) - 1) & (word0 >> 8); - return value; - } - uint32_t get_shram_size() const volatile - { - uint32_t value = ((1U << 8) - 1) & (word0 >> 8); - return value; - } - CONSTEXPR config_r &set_shram_size(uint32_t value) - { - word0 = (((~((1U << 8) - 1)) << 8) & word0) | ((((1U << 8) - 1) & value) << 8); - return *this; - } - volatile config_r &set_shram_size(uint32_t value) volatile - { - word0 = (((~((1U << 8) - 1)) << 8) & word0) | ((((1U << 8) - 1) & value) << 8); - return *this; - } - CONSTEXPR NPU_NAMESPACE::functional_safety get_functional_safety() const - { - NPU_NAMESPACE::functional_safety value = - static_cast(((1U << 1) - 1) & (word0 >> 26)); - return value; - } - NPU_NAMESPACE::functional_safety get_functional_safety() const volatile - { - NPU_NAMESPACE::functional_safety value = - static_cast(((1U << 1) - 1) & (word0 >> 26)); - return value; - } - CONSTEXPR config_r &set_functional_safety(NPU_NAMESPACE::functional_safety value) - { - word0 = (((~((1U << 1) - 1)) << 26) & word0) | ((((1U << 1) - 1) & static_cast(value)) << 26); - return *this; - } - volatile config_r &set_functional_safety(NPU_NAMESPACE::functional_safety value) volatile - { - word0 = (((~((1U << 1) - 1)) << 26) & word0) | ((((1U << 1) - 1) & static_cast(value)) << 26); - return *this; - } - CONSTEXPR NPU_NAMESPACE::custom_dma get_custom_dma() const - { - NPU_NAMESPACE::custom_dma value = static_cast(((1U << 1) - 1) & (word0 >> 27)); - return value; - } - NPU_NAMESPACE::custom_dma get_custom_dma() const volatile - { - NPU_NAMESPACE::custom_dma value = static_cast(((1U << 1) - 1) & (word0 >> 27)); - return value; - } - CONSTEXPR config_r &set_custom_dma(NPU_NAMESPACE::custom_dma value) - { - word0 = (((~((1U << 1) - 1)) << 27) & word0) | ((((1U << 1) - 1) & static_cast(value)) << 27); - return *this; - } - volatile config_r &set_custom_dma(NPU_NAMESPACE::custom_dma value) volatile - { - word0 = (((~((1U << 1) - 1)) << 27) & word0) | ((((1U << 1) - 1) & static_cast(value)) << 27); - return *this; - } - CONSTEXPR uint32_t get_product() const - { - uint32_t value = ((1U << 4) - 1) & (word0 >> 28); - return value; - } - uint32_t get_product() const volatile - { - uint32_t value = ((1U << 4) - 1) & (word0 >> 28); - return value; - } - CONSTEXPR config_r &set_product(uint32_t value) - { - word0 = (((~((1U << 4) - 1)) << 28) & word0) | ((((1U << 4) - 1) & value) << 28); - return *this; - } - volatile config_r &set_product(uint32_t value) volatile - { - word0 = (((~((1U << 4) - 1)) << 28) & word0) | ((((1U << 4) - 1) & value) << 28); - return *this; - } -#endif -}; - -// lock_r - Lock register. This register is designed for driver use and does not affect NPU functionality -struct lock_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t LOCK : 32; // 32 bit value for LOCK configuration - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR lock_r() : word0(0) {} - CONSTEXPR lock_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - lock_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_LOCK() const - { - uint32_t value = word0; - return value; - } - uint32_t get_LOCK() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR lock_r &set_LOCK(uint32_t value) - { - word0 = value; - return *this; - } - volatile lock_r &set_LOCK(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// regioncfg_r - Region memory type configuration. Bits[2*k+1:2*k] give the memory type for REGION[k] -struct regioncfg_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t region0 : 2; // Bits for Region0 Configuration - uint32_t region1 : 2; // Bits for Region1 Configuration - uint32_t region2 : 2; // Bits for Region2 Configuration - uint32_t region3 : 2; // Bits for Region3 Configuration - uint32_t region4 : 2; // Bits for Region4 Configuration - uint32_t region5 : 2; // Bits for Region5 Configuration - uint32_t region6 : 2; // Bits for Region6 Configuration - uint32_t region7 : 2; // Bits for Region7 Configuration - uint32_t reserved0 : 16; - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR regioncfg_r() : word0(0) {} - CONSTEXPR regioncfg_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - regioncfg_r copy() volatile - { - return *this; - } - CONSTEXPR NPU_NAMESPACE::mem_attr get_region0() const - { - NPU_NAMESPACE::mem_attr value = static_cast(((1U << 2) - 1) & (word0 >> 0)); - return value; - } - NPU_NAMESPACE::mem_attr get_region0() const volatile - { - NPU_NAMESPACE::mem_attr value = static_cast(((1U << 2) - 1) & (word0 >> 0)); - return value; - } - CONSTEXPR regioncfg_r &set_region0(NPU_NAMESPACE::mem_attr value) - { - word0 = (((~((1U << 2) - 1)) << 0) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 0); - return *this; - } - volatile regioncfg_r &set_region0(NPU_NAMESPACE::mem_attr value) volatile - { - word0 = (((~((1U << 2) - 1)) << 0) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 0); - return *this; - } - CONSTEXPR NPU_NAMESPACE::mem_attr get_region1() const - { - NPU_NAMESPACE::mem_attr value = static_cast(((1U << 2) - 1) & (word0 >> 2)); - return value; - } - NPU_NAMESPACE::mem_attr get_region1() const volatile - { - NPU_NAMESPACE::mem_attr value = static_cast(((1U << 2) - 1) & (word0 >> 2)); - return value; - } - CONSTEXPR regioncfg_r &set_region1(NPU_NAMESPACE::mem_attr value) - { - word0 = (((~((1U << 2) - 1)) << 2) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 2); - return *this; - } - volatile regioncfg_r &set_region1(NPU_NAMESPACE::mem_attr value) volatile - { - word0 = (((~((1U << 2) - 1)) << 2) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 2); - return *this; - } - CONSTEXPR NPU_NAMESPACE::mem_attr get_region2() const - { - NPU_NAMESPACE::mem_attr value = static_cast(((1U << 2) - 1) & (word0 >> 4)); - return value; - } - NPU_NAMESPACE::mem_attr get_region2() const volatile - { - NPU_NAMESPACE::mem_attr value = static_cast(((1U << 2) - 1) & (word0 >> 4)); - return value; - } - CONSTEXPR regioncfg_r &set_region2(NPU_NAMESPACE::mem_attr value) - { - word0 = (((~((1U << 2) - 1)) << 4) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 4); - return *this; - } - volatile regioncfg_r &set_region2(NPU_NAMESPACE::mem_attr value) volatile - { - word0 = (((~((1U << 2) - 1)) << 4) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 4); - return *this; - } - CONSTEXPR NPU_NAMESPACE::mem_attr get_region3() const - { - NPU_NAMESPACE::mem_attr value = static_cast(((1U << 2) - 1) & (word0 >> 6)); - return value; - } - NPU_NAMESPACE::mem_attr get_region3() const volatile - { - NPU_NAMESPACE::mem_attr value = static_cast(((1U << 2) - 1) & (word0 >> 6)); - return value; - } - CONSTEXPR regioncfg_r &set_region3(NPU_NAMESPACE::mem_attr value) - { - word0 = (((~((1U << 2) - 1)) << 6) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 6); - return *this; - } - volatile regioncfg_r &set_region3(NPU_NAMESPACE::mem_attr value) volatile - { - word0 = (((~((1U << 2) - 1)) << 6) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 6); - return *this; - } - CONSTEXPR NPU_NAMESPACE::mem_attr get_region4() const - { - NPU_NAMESPACE::mem_attr value = static_cast(((1U << 2) - 1) & (word0 >> 8)); - return value; - } - NPU_NAMESPACE::mem_attr get_region4() const volatile - { - NPU_NAMESPACE::mem_attr value = static_cast(((1U << 2) - 1) & (word0 >> 8)); - return value; - } - CONSTEXPR regioncfg_r &set_region4(NPU_NAMESPACE::mem_attr value) - { - word0 = (((~((1U << 2) - 1)) << 8) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 8); - return *this; - } - volatile regioncfg_r &set_region4(NPU_NAMESPACE::mem_attr value) volatile - { - word0 = (((~((1U << 2) - 1)) << 8) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 8); - return *this; - } - CONSTEXPR NPU_NAMESPACE::mem_attr get_region5() const - { - NPU_NAMESPACE::mem_attr value = static_cast(((1U << 2) - 1) & (word0 >> 10)); - return value; - } - NPU_NAMESPACE::mem_attr get_region5() const volatile - { - NPU_NAMESPACE::mem_attr value = static_cast(((1U << 2) - 1) & (word0 >> 10)); - return value; - } - CONSTEXPR regioncfg_r &set_region5(NPU_NAMESPACE::mem_attr value) - { - word0 = (((~((1U << 2) - 1)) << 10) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 10); - return *this; - } - volatile regioncfg_r &set_region5(NPU_NAMESPACE::mem_attr value) volatile - { - word0 = (((~((1U << 2) - 1)) << 10) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 10); - return *this; - } - CONSTEXPR NPU_NAMESPACE::mem_attr get_region6() const - { - NPU_NAMESPACE::mem_attr value = static_cast(((1U << 2) - 1) & (word0 >> 12)); - return value; - } - NPU_NAMESPACE::mem_attr get_region6() const volatile - { - NPU_NAMESPACE::mem_attr value = static_cast(((1U << 2) - 1) & (word0 >> 12)); - return value; - } - CONSTEXPR regioncfg_r &set_region6(NPU_NAMESPACE::mem_attr value) - { - word0 = (((~((1U << 2) - 1)) << 12) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 12); - return *this; - } - volatile regioncfg_r &set_region6(NPU_NAMESPACE::mem_attr value) volatile - { - word0 = (((~((1U << 2) - 1)) << 12) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 12); - return *this; - } - CONSTEXPR NPU_NAMESPACE::mem_attr get_region7() const - { - NPU_NAMESPACE::mem_attr value = static_cast(((1U << 2) - 1) & (word0 >> 14)); - return value; - } - NPU_NAMESPACE::mem_attr get_region7() const volatile - { - NPU_NAMESPACE::mem_attr value = static_cast(((1U << 2) - 1) & (word0 >> 14)); - return value; - } - CONSTEXPR regioncfg_r &set_region7(NPU_NAMESPACE::mem_attr value) - { - word0 = (((~((1U << 2) - 1)) << 14) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 14); - return *this; - } - volatile regioncfg_r &set_region7(NPU_NAMESPACE::mem_attr value) volatile - { - word0 = (((~((1U << 2) - 1)) << 14) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 14); - return *this; - } -#endif -}; - -// axi_limit0_r - AXI limits for port 0 counter 0 -struct axi_limit0_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t max_beats : 2; // Burst split alignment - uint32_t reserved0 : 2; - uint32_t memtype : 4; // Memtype to be used to encode AxCACHE signals - uint32_t reserved1 : 8; - uint32_t - max_outstanding_read_m1 : 6; // Maximum number of outstanding AXI read transactions - 1 in range 0 to 63 - uint32_t reserved2 : 2; - uint32_t max_outstanding_write_m1 : 5; // Maximum number of outstanding AXI write transactions - 1 in range - // 0 to 31 - uint32_t reserved3 : 3; - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR axi_limit0_r() : word0(0) {} - CONSTEXPR axi_limit0_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - axi_limit0_r copy() volatile - { - return *this; - } - CONSTEXPR NPU_NAMESPACE::max_beats get_max_beats() const - { - NPU_NAMESPACE::max_beats value = static_cast(((1U << 2) - 1) & (word0 >> 0)); - return value; - } - NPU_NAMESPACE::max_beats get_max_beats() const volatile - { - NPU_NAMESPACE::max_beats value = static_cast(((1U << 2) - 1) & (word0 >> 0)); - return value; - } - CONSTEXPR axi_limit0_r &set_max_beats(NPU_NAMESPACE::max_beats value) - { - word0 = (((~((1U << 2) - 1)) << 0) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 0); - return *this; - } - volatile axi_limit0_r &set_max_beats(NPU_NAMESPACE::max_beats value) volatile - { - word0 = (((~((1U << 2) - 1)) << 0) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 0); - return *this; - } - CONSTEXPR NPU_NAMESPACE::axi_mem_encoding get_memtype() const - { - NPU_NAMESPACE::axi_mem_encoding value = - static_cast(((1U << 4) - 1) & (word0 >> 4)); - return value; - } - NPU_NAMESPACE::axi_mem_encoding get_memtype() const volatile - { - NPU_NAMESPACE::axi_mem_encoding value = - static_cast(((1U << 4) - 1) & (word0 >> 4)); - return value; - } - CONSTEXPR axi_limit0_r &set_memtype(NPU_NAMESPACE::axi_mem_encoding value) - { - word0 = (((~((1U << 4) - 1)) << 4) & word0) | ((((1U << 4) - 1) & static_cast(value)) << 4); - return *this; - } - volatile axi_limit0_r &set_memtype(NPU_NAMESPACE::axi_mem_encoding value) volatile - { - word0 = (((~((1U << 4) - 1)) << 4) & word0) | ((((1U << 4) - 1) & static_cast(value)) << 4); - return *this; - } - CONSTEXPR uint32_t get_max_outstanding_read_m1() const - { - uint32_t value = ((1U << 6) - 1) & (word0 >> 16); - return value; - } - uint32_t get_max_outstanding_read_m1() const volatile - { - uint32_t value = ((1U << 6) - 1) & (word0 >> 16); - return value; - } - CONSTEXPR axi_limit0_r &set_max_outstanding_read_m1(uint32_t value) - { - word0 = (((~((1U << 6) - 1)) << 16) & word0) | ((((1U << 6) - 1) & value) << 16); - return *this; - } - volatile axi_limit0_r &set_max_outstanding_read_m1(uint32_t value) volatile - { - word0 = (((~((1U << 6) - 1)) << 16) & word0) | ((((1U << 6) - 1) & value) << 16); - return *this; - } - CONSTEXPR uint32_t get_max_outstanding_write_m1() const - { - uint32_t value = ((1U << 5) - 1) & (word0 >> 24); - return value; - } - uint32_t get_max_outstanding_write_m1() const volatile - { - uint32_t value = ((1U << 5) - 1) & (word0 >> 24); - return value; - } - CONSTEXPR axi_limit0_r &set_max_outstanding_write_m1(uint32_t value) - { - word0 = (((~((1U << 5) - 1)) << 24) & word0) | ((((1U << 5) - 1) & value) << 24); - return *this; - } - volatile axi_limit0_r &set_max_outstanding_write_m1(uint32_t value) volatile - { - word0 = (((~((1U << 5) - 1)) << 24) & word0) | ((((1U << 5) - 1) & value) << 24); - return *this; - } -#endif -}; - -// axi_limit1_r - AXI limits for port 0 counter 1 -struct axi_limit1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t max_beats : 2; // Burst split alignment - uint32_t reserved0 : 2; - uint32_t memtype : 4; // Memtype to be used to encode AxCACHE signals - uint32_t reserved1 : 8; - uint32_t - max_outstanding_read_m1 : 6; // Maximum number of outstanding AXI read transactions - 1 in range 0 to 63 - uint32_t reserved2 : 2; - uint32_t max_outstanding_write_m1 : 5; // Maximum number of outstanding AXI write transactions - 1 in range - // 0 to 31 - uint32_t reserved3 : 3; - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR axi_limit1_r() : word0(0) {} - CONSTEXPR axi_limit1_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - axi_limit1_r copy() volatile - { - return *this; - } - CONSTEXPR NPU_NAMESPACE::max_beats get_max_beats() const - { - NPU_NAMESPACE::max_beats value = static_cast(((1U << 2) - 1) & (word0 >> 0)); - return value; - } - NPU_NAMESPACE::max_beats get_max_beats() const volatile - { - NPU_NAMESPACE::max_beats value = static_cast(((1U << 2) - 1) & (word0 >> 0)); - return value; - } - CONSTEXPR axi_limit1_r &set_max_beats(NPU_NAMESPACE::max_beats value) - { - word0 = (((~((1U << 2) - 1)) << 0) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 0); - return *this; - } - volatile axi_limit1_r &set_max_beats(NPU_NAMESPACE::max_beats value) volatile - { - word0 = (((~((1U << 2) - 1)) << 0) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 0); - return *this; - } - CONSTEXPR NPU_NAMESPACE::axi_mem_encoding get_memtype() const - { - NPU_NAMESPACE::axi_mem_encoding value = - static_cast(((1U << 4) - 1) & (word0 >> 4)); - return value; - } - NPU_NAMESPACE::axi_mem_encoding get_memtype() const volatile - { - NPU_NAMESPACE::axi_mem_encoding value = - static_cast(((1U << 4) - 1) & (word0 >> 4)); - return value; - } - CONSTEXPR axi_limit1_r &set_memtype(NPU_NAMESPACE::axi_mem_encoding value) - { - word0 = (((~((1U << 4) - 1)) << 4) & word0) | ((((1U << 4) - 1) & static_cast(value)) << 4); - return *this; - } - volatile axi_limit1_r &set_memtype(NPU_NAMESPACE::axi_mem_encoding value) volatile - { - word0 = (((~((1U << 4) - 1)) << 4) & word0) | ((((1U << 4) - 1) & static_cast(value)) << 4); - return *this; - } - CONSTEXPR uint32_t get_max_outstanding_read_m1() const - { - uint32_t value = ((1U << 6) - 1) & (word0 >> 16); - return value; - } - uint32_t get_max_outstanding_read_m1() const volatile - { - uint32_t value = ((1U << 6) - 1) & (word0 >> 16); - return value; - } - CONSTEXPR axi_limit1_r &set_max_outstanding_read_m1(uint32_t value) - { - word0 = (((~((1U << 6) - 1)) << 16) & word0) | ((((1U << 6) - 1) & value) << 16); - return *this; - } - volatile axi_limit1_r &set_max_outstanding_read_m1(uint32_t value) volatile - { - word0 = (((~((1U << 6) - 1)) << 16) & word0) | ((((1U << 6) - 1) & value) << 16); - return *this; - } - CONSTEXPR uint32_t get_max_outstanding_write_m1() const - { - uint32_t value = ((1U << 5) - 1) & (word0 >> 24); - return value; - } - uint32_t get_max_outstanding_write_m1() const volatile - { - uint32_t value = ((1U << 5) - 1) & (word0 >> 24); - return value; - } - CONSTEXPR axi_limit1_r &set_max_outstanding_write_m1(uint32_t value) - { - word0 = (((~((1U << 5) - 1)) << 24) & word0) | ((((1U << 5) - 1) & value) << 24); - return *this; - } - volatile axi_limit1_r &set_max_outstanding_write_m1(uint32_t value) volatile - { - word0 = (((~((1U << 5) - 1)) << 24) & word0) | ((((1U << 5) - 1) & value) << 24); - return *this; - } -#endif -}; - -// axi_limit2_r - AXI limits for port 1 counter 2 -struct axi_limit2_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t max_beats : 2; // Burst split alignment - uint32_t reserved0 : 2; - uint32_t memtype : 4; // Memtype to be used to encode AxCACHE signals - uint32_t reserved1 : 8; - uint32_t - max_outstanding_read_m1 : 6; // Maximum number of outstanding AXI read transactions - 1 in range 0 to 63 - uint32_t reserved2 : 2; - uint32_t max_outstanding_write_m1 : 5; // Maximum number of outstanding AXI write transactions - 1 in range - // 0 to 31 - uint32_t reserved3 : 3; - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR axi_limit2_r() : word0(0) {} - CONSTEXPR axi_limit2_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - axi_limit2_r copy() volatile - { - return *this; - } - CONSTEXPR NPU_NAMESPACE::max_beats get_max_beats() const - { - NPU_NAMESPACE::max_beats value = static_cast(((1U << 2) - 1) & (word0 >> 0)); - return value; - } - NPU_NAMESPACE::max_beats get_max_beats() const volatile - { - NPU_NAMESPACE::max_beats value = static_cast(((1U << 2) - 1) & (word0 >> 0)); - return value; - } - CONSTEXPR axi_limit2_r &set_max_beats(NPU_NAMESPACE::max_beats value) - { - word0 = (((~((1U << 2) - 1)) << 0) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 0); - return *this; - } - volatile axi_limit2_r &set_max_beats(NPU_NAMESPACE::max_beats value) volatile - { - word0 = (((~((1U << 2) - 1)) << 0) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 0); - return *this; - } - CONSTEXPR NPU_NAMESPACE::axi_mem_encoding get_memtype() const - { - NPU_NAMESPACE::axi_mem_encoding value = - static_cast(((1U << 4) - 1) & (word0 >> 4)); - return value; - } - NPU_NAMESPACE::axi_mem_encoding get_memtype() const volatile - { - NPU_NAMESPACE::axi_mem_encoding value = - static_cast(((1U << 4) - 1) & (word0 >> 4)); - return value; - } - CONSTEXPR axi_limit2_r &set_memtype(NPU_NAMESPACE::axi_mem_encoding value) - { - word0 = (((~((1U << 4) - 1)) << 4) & word0) | ((((1U << 4) - 1) & static_cast(value)) << 4); - return *this; - } - volatile axi_limit2_r &set_memtype(NPU_NAMESPACE::axi_mem_encoding value) volatile - { - word0 = (((~((1U << 4) - 1)) << 4) & word0) | ((((1U << 4) - 1) & static_cast(value)) << 4); - return *this; - } - CONSTEXPR uint32_t get_max_outstanding_read_m1() const - { - uint32_t value = ((1U << 6) - 1) & (word0 >> 16); - return value; - } - uint32_t get_max_outstanding_read_m1() const volatile - { - uint32_t value = ((1U << 6) - 1) & (word0 >> 16); - return value; - } - CONSTEXPR axi_limit2_r &set_max_outstanding_read_m1(uint32_t value) - { - word0 = (((~((1U << 6) - 1)) << 16) & word0) | ((((1U << 6) - 1) & value) << 16); - return *this; - } - volatile axi_limit2_r &set_max_outstanding_read_m1(uint32_t value) volatile - { - word0 = (((~((1U << 6) - 1)) << 16) & word0) | ((((1U << 6) - 1) & value) << 16); - return *this; - } - CONSTEXPR uint32_t get_max_outstanding_write_m1() const - { - uint32_t value = ((1U << 5) - 1) & (word0 >> 24); - return value; - } - uint32_t get_max_outstanding_write_m1() const volatile - { - uint32_t value = ((1U << 5) - 1) & (word0 >> 24); - return value; - } - CONSTEXPR axi_limit2_r &set_max_outstanding_write_m1(uint32_t value) - { - word0 = (((~((1U << 5) - 1)) << 24) & word0) | ((((1U << 5) - 1) & value) << 24); - return *this; - } - volatile axi_limit2_r &set_max_outstanding_write_m1(uint32_t value) volatile - { - word0 = (((~((1U << 5) - 1)) << 24) & word0) | ((((1U << 5) - 1) & value) << 24); - return *this; - } -#endif -}; - -// axi_limit3_r - AXI limits for port 1 counter 3 -struct axi_limit3_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t max_beats : 2; // Burst split alignment - uint32_t reserved0 : 2; - uint32_t memtype : 4; // Memtype to be used to encode AxCACHE signals - uint32_t reserved1 : 8; - uint32_t - max_outstanding_read_m1 : 6; // Maximum number of outstanding AXI read transactions - 1 in range 0 to 63 - uint32_t reserved2 : 2; - uint32_t max_outstanding_write_m1 : 5; // Maximum number of outstanding AXI write transactions - 1 in range - // 0 to 31 - uint32_t reserved3 : 3; - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR axi_limit3_r() : word0(0) {} - CONSTEXPR axi_limit3_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - axi_limit3_r copy() volatile - { - return *this; - } - CONSTEXPR NPU_NAMESPACE::max_beats get_max_beats() const - { - NPU_NAMESPACE::max_beats value = static_cast(((1U << 2) - 1) & (word0 >> 0)); - return value; - } - NPU_NAMESPACE::max_beats get_max_beats() const volatile - { - NPU_NAMESPACE::max_beats value = static_cast(((1U << 2) - 1) & (word0 >> 0)); - return value; - } - CONSTEXPR axi_limit3_r &set_max_beats(NPU_NAMESPACE::max_beats value) - { - word0 = (((~((1U << 2) - 1)) << 0) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 0); - return *this; - } - volatile axi_limit3_r &set_max_beats(NPU_NAMESPACE::max_beats value) volatile - { - word0 = (((~((1U << 2) - 1)) << 0) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 0); - return *this; - } - CONSTEXPR NPU_NAMESPACE::axi_mem_encoding get_memtype() const - { - NPU_NAMESPACE::axi_mem_encoding value = - static_cast(((1U << 4) - 1) & (word0 >> 4)); - return value; - } - NPU_NAMESPACE::axi_mem_encoding get_memtype() const volatile - { - NPU_NAMESPACE::axi_mem_encoding value = - static_cast(((1U << 4) - 1) & (word0 >> 4)); - return value; - } - CONSTEXPR axi_limit3_r &set_memtype(NPU_NAMESPACE::axi_mem_encoding value) - { - word0 = (((~((1U << 4) - 1)) << 4) & word0) | ((((1U << 4) - 1) & static_cast(value)) << 4); - return *this; - } - volatile axi_limit3_r &set_memtype(NPU_NAMESPACE::axi_mem_encoding value) volatile - { - word0 = (((~((1U << 4) - 1)) << 4) & word0) | ((((1U << 4) - 1) & static_cast(value)) << 4); - return *this; - } - CONSTEXPR uint32_t get_max_outstanding_read_m1() const - { - uint32_t value = ((1U << 6) - 1) & (word0 >> 16); - return value; - } - uint32_t get_max_outstanding_read_m1() const volatile - { - uint32_t value = ((1U << 6) - 1) & (word0 >> 16); - return value; - } - CONSTEXPR axi_limit3_r &set_max_outstanding_read_m1(uint32_t value) - { - word0 = (((~((1U << 6) - 1)) << 16) & word0) | ((((1U << 6) - 1) & value) << 16); - return *this; - } - volatile axi_limit3_r &set_max_outstanding_read_m1(uint32_t value) volatile - { - word0 = (((~((1U << 6) - 1)) << 16) & word0) | ((((1U << 6) - 1) & value) << 16); - return *this; - } - CONSTEXPR uint32_t get_max_outstanding_write_m1() const - { - uint32_t value = ((1U << 5) - 1) & (word0 >> 24); - return value; - } - uint32_t get_max_outstanding_write_m1() const volatile - { - uint32_t value = ((1U << 5) - 1) & (word0 >> 24); - return value; - } - CONSTEXPR axi_limit3_r &set_max_outstanding_write_m1(uint32_t value) - { - word0 = (((~((1U << 5) - 1)) << 24) & word0) | ((((1U << 5) - 1) & value) << 24); - return *this; - } - volatile axi_limit3_r &set_max_outstanding_write_m1(uint32_t value) volatile - { - word0 = (((~((1U << 5) - 1)) << 24) & word0) | ((((1U << 5) - 1) & value) << 24); - return *this; - } -#endif -}; - -// basep_r - The driver can use this address to relocate the command stream on region 0. If the region contains data -// requiring A-byte alignment then the base must be a multiple of A -struct basep_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t offset_LO : 32; // Offset - LSB - uint32_t offset_HI : 8; // Offset - MSB - uint32_t reserved0 : 24; - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR basep_r() : word0(0), word1(0) {} - CONSTEXPR basep_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - basep_r copy() volatile - { - return *this; - } -#endif -}; - -// wd_status_r - WD_STATUS -struct wd_status_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t core_slice_state : 2; // WD core slice parser state - uint32_t core_idle : 1; // Core idle - uint32_t ctrl_state : 2; // WD control state - uint32_t ctrl_idle : 1; // All stripe jobs idle (all weights consumed) - uint32_t write_buf_index0 : 3; // current write index for next data from core - uint32_t write_buf_valid0 : 1; // write buf valid (full) - uint32_t write_buf_idle0 : 1; // write buf idle (empty) - uint32_t write_buf_index1 : 3; // current write index for next data from core - uint32_t write_buf_valid1 : 1; // write buf valid (full) - uint32_t write_buf_idle1 : 1; // write buf idle (empty) - uint32_t events : 12; // WD events mapped as appendix A - uint32_t reserved0 : 4; - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR wd_status_r() : word0(0) {} - CONSTEXPR wd_status_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - wd_status_r copy() volatile - { - return *this; - } - CONSTEXPR NPU_NAMESPACE::wd_core_slice_state get_core_slice_state() const - { - NPU_NAMESPACE::wd_core_slice_state value = - static_cast(((1U << 2) - 1) & (word0 >> 0)); - return value; - } - NPU_NAMESPACE::wd_core_slice_state get_core_slice_state() const volatile - { - NPU_NAMESPACE::wd_core_slice_state value = - static_cast(((1U << 2) - 1) & (word0 >> 0)); - return value; - } - CONSTEXPR wd_status_r &set_core_slice_state(NPU_NAMESPACE::wd_core_slice_state value) - { - word0 = (((~((1U << 2) - 1)) << 0) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 0); - return *this; - } - volatile wd_status_r &set_core_slice_state(NPU_NAMESPACE::wd_core_slice_state value) volatile - { - word0 = (((~((1U << 2) - 1)) << 0) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 0); - return *this; - } - CONSTEXPR uint32_t get_core_idle() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 2); - return value; - } - uint32_t get_core_idle() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 2); - return value; - } - CONSTEXPR wd_status_r &set_core_idle(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - volatile wd_status_r &set_core_idle(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - CONSTEXPR NPU_NAMESPACE::wd_ctrl_state get_ctrl_state() const - { - NPU_NAMESPACE::wd_ctrl_state value = static_cast(((1U << 2) - 1) & (word0 >> 3)); - return value; - } - NPU_NAMESPACE::wd_ctrl_state get_ctrl_state() const volatile - { - NPU_NAMESPACE::wd_ctrl_state value = static_cast(((1U << 2) - 1) & (word0 >> 3)); - return value; - } - CONSTEXPR wd_status_r &set_ctrl_state(NPU_NAMESPACE::wd_ctrl_state value) - { - word0 = (((~((1U << 2) - 1)) << 3) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 3); - return *this; - } - volatile wd_status_r &set_ctrl_state(NPU_NAMESPACE::wd_ctrl_state value) volatile - { - word0 = (((~((1U << 2) - 1)) << 3) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 3); - return *this; - } - CONSTEXPR uint32_t get_ctrl_idle() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 5); - return value; - } - uint32_t get_ctrl_idle() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 5); - return value; - } - CONSTEXPR wd_status_r &set_ctrl_idle(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 5) & word0) | ((((1U << 1) - 1) & value) << 5); - return *this; - } - volatile wd_status_r &set_ctrl_idle(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 5) & word0) | ((((1U << 1) - 1) & value) << 5); - return *this; - } - CONSTEXPR uint32_t get_write_buf_index0() const - { - uint32_t value = ((1U << 3) - 1) & (word0 >> 6); - return value; - } - uint32_t get_write_buf_index0() const volatile - { - uint32_t value = ((1U << 3) - 1) & (word0 >> 6); - return value; - } - CONSTEXPR wd_status_r &set_write_buf_index0(uint32_t value) - { - word0 = (((~((1U << 3) - 1)) << 6) & word0) | ((((1U << 3) - 1) & value) << 6); - return *this; - } - volatile wd_status_r &set_write_buf_index0(uint32_t value) volatile - { - word0 = (((~((1U << 3) - 1)) << 6) & word0) | ((((1U << 3) - 1) & value) << 6); - return *this; - } - CONSTEXPR uint32_t get_write_buf_valid0() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 9); - return value; - } - uint32_t get_write_buf_valid0() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 9); - return value; - } - CONSTEXPR wd_status_r &set_write_buf_valid0(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 9) & word0) | ((((1U << 1) - 1) & value) << 9); - return *this; - } - volatile wd_status_r &set_write_buf_valid0(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 9) & word0) | ((((1U << 1) - 1) & value) << 9); - return *this; - } - CONSTEXPR uint32_t get_write_buf_idle0() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 10); - return value; - } - uint32_t get_write_buf_idle0() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 10); - return value; - } - CONSTEXPR wd_status_r &set_write_buf_idle0(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 10) & word0) | ((((1U << 1) - 1) & value) << 10); - return *this; - } - volatile wd_status_r &set_write_buf_idle0(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 10) & word0) | ((((1U << 1) - 1) & value) << 10); - return *this; - } - CONSTEXPR uint32_t get_write_buf_index1() const - { - uint32_t value = ((1U << 3) - 1) & (word0 >> 11); - return value; - } - uint32_t get_write_buf_index1() const volatile - { - uint32_t value = ((1U << 3) - 1) & (word0 >> 11); - return value; - } - CONSTEXPR wd_status_r &set_write_buf_index1(uint32_t value) - { - word0 = (((~((1U << 3) - 1)) << 11) & word0) | ((((1U << 3) - 1) & value) << 11); - return *this; - } - volatile wd_status_r &set_write_buf_index1(uint32_t value) volatile - { - word0 = (((~((1U << 3) - 1)) << 11) & word0) | ((((1U << 3) - 1) & value) << 11); - return *this; - } - CONSTEXPR uint32_t get_write_buf_valid1() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 14); - return value; - } - uint32_t get_write_buf_valid1() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 14); - return value; - } - CONSTEXPR wd_status_r &set_write_buf_valid1(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 14) & word0) | ((((1U << 1) - 1) & value) << 14); - return *this; - } - volatile wd_status_r &set_write_buf_valid1(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 14) & word0) | ((((1U << 1) - 1) & value) << 14); - return *this; - } - CONSTEXPR uint32_t get_write_buf_idle1() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 15); - return value; - } - uint32_t get_write_buf_idle1() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 15); - return value; - } - CONSTEXPR wd_status_r &set_write_buf_idle1(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 15) & word0) | ((((1U << 1) - 1) & value) << 15); - return *this; - } - volatile wd_status_r &set_write_buf_idle1(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 15) & word0) | ((((1U << 1) - 1) & value) << 15); - return *this; - } - CONSTEXPR uint32_t get_events() const - { - uint32_t value = ((1U << 12) - 1) & (word0 >> 16); - return value; - } - uint32_t get_events() const volatile - { - uint32_t value = ((1U << 12) - 1) & (word0 >> 16); - return value; - } - CONSTEXPR wd_status_r &set_events(uint32_t value) - { - word0 = (((~((1U << 12) - 1)) << 16) & word0) | ((((1U << 12) - 1) & value) << 16); - return *this; - } - volatile wd_status_r &set_events(uint32_t value) volatile - { - word0 = (((~((1U << 12) - 1)) << 16) & word0) | ((((1U << 12) - 1) & value) << 16); - return *this; - } -#endif -}; - -// mac_status_r - MAC_STATUS -struct mac_status_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t block_cfg_valid : 1; // MAC has a valid block configuration - uint32_t trav_en : 1; // MAC is doing block traversal - uint32_t wait_for_ib : 1; // MAC is waiting for an Input Buffer to become available - uint32_t wait_for_acc_buf : 1; // MAC is waiting for an Accumulator Buffer to become available - uint32_t wait_for_weights : 1; // MAC is waiting for a Weight Block to become available - uint32_t stall_stripe : 1; // MAC is stalling between two stripes - uint32_t dw_sel : 1; // Currently used weight interface in MAC AI - uint32_t wait_for_dw0_ready : 1; // MAC AI is waiting for MAC DPU to send dw0_ready to WD - uint32_t wait_for_dw1_ready : 1; // MAC AI is waiting for MAC DPU to send dw1_ready to WD - uint32_t acc_buf_sel_ai : 1; // Currently used AccBuf interface in MAC AI - uint32_t wait_for_acc0_ready : 1; // MAC AI is waiting for acc0_ready from AO - uint32_t wait_for_acc1_ready : 1; // MAC AI is waiting for acc1_ready from AO - uint32_t acc_buf_sel_aa : 1; // Currently used AccBuf interface in MAC ADDER_ARRAY - uint32_t acc0_valid : 1; // MAC outgoing value of acc0_valid - uint32_t acc1_valid : 1; // MAC outgoing value of acc1_valid - uint32_t reserved0 : 1; - uint32_t events : 11; // Mapped to MAC events described in Appendix A - uint32_t reserved1 : 5; - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR mac_status_r() : word0(0) {} - CONSTEXPR mac_status_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - mac_status_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_block_cfg_valid() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 0); - return value; - } - uint32_t get_block_cfg_valid() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 0); - return value; - } - CONSTEXPR mac_status_r &set_block_cfg_valid(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - volatile mac_status_r &set_block_cfg_valid(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - CONSTEXPR uint32_t get_trav_en() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 1); - return value; - } - uint32_t get_trav_en() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 1); - return value; - } - CONSTEXPR mac_status_r &set_trav_en(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - volatile mac_status_r &set_trav_en(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - CONSTEXPR uint32_t get_wait_for_ib() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 2); - return value; - } - uint32_t get_wait_for_ib() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 2); - return value; - } - CONSTEXPR mac_status_r &set_wait_for_ib(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - volatile mac_status_r &set_wait_for_ib(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - CONSTEXPR uint32_t get_wait_for_acc_buf() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 3); - return value; - } - uint32_t get_wait_for_acc_buf() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 3); - return value; - } - CONSTEXPR mac_status_r &set_wait_for_acc_buf(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - volatile mac_status_r &set_wait_for_acc_buf(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - CONSTEXPR uint32_t get_wait_for_weights() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 4); - return value; - } - uint32_t get_wait_for_weights() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 4); - return value; - } - CONSTEXPR mac_status_r &set_wait_for_weights(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 4) & word0) | ((((1U << 1) - 1) & value) << 4); - return *this; - } - volatile mac_status_r &set_wait_for_weights(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 4) & word0) | ((((1U << 1) - 1) & value) << 4); - return *this; - } - CONSTEXPR uint32_t get_stall_stripe() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 5); - return value; - } - uint32_t get_stall_stripe() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 5); - return value; - } - CONSTEXPR mac_status_r &set_stall_stripe(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 5) & word0) | ((((1U << 1) - 1) & value) << 5); - return *this; - } - volatile mac_status_r &set_stall_stripe(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 5) & word0) | ((((1U << 1) - 1) & value) << 5); - return *this; - } - CONSTEXPR uint32_t get_dw_sel() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 6); - return value; - } - uint32_t get_dw_sel() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 6); - return value; - } - CONSTEXPR mac_status_r &set_dw_sel(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 6) & word0) | ((((1U << 1) - 1) & value) << 6); - return *this; - } - volatile mac_status_r &set_dw_sel(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 6) & word0) | ((((1U << 1) - 1) & value) << 6); - return *this; - } - CONSTEXPR uint32_t get_wait_for_dw0_ready() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 7); - return value; - } - uint32_t get_wait_for_dw0_ready() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 7); - return value; - } - CONSTEXPR mac_status_r &set_wait_for_dw0_ready(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 7) & word0) | ((((1U << 1) - 1) & value) << 7); - return *this; - } - volatile mac_status_r &set_wait_for_dw0_ready(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 7) & word0) | ((((1U << 1) - 1) & value) << 7); - return *this; - } - CONSTEXPR uint32_t get_wait_for_dw1_ready() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 8); - return value; - } - uint32_t get_wait_for_dw1_ready() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 8); - return value; - } - CONSTEXPR mac_status_r &set_wait_for_dw1_ready(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 8) & word0) | ((((1U << 1) - 1) & value) << 8); - return *this; - } - volatile mac_status_r &set_wait_for_dw1_ready(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 8) & word0) | ((((1U << 1) - 1) & value) << 8); - return *this; - } - CONSTEXPR uint32_t get_acc_buf_sel_ai() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 9); - return value; - } - uint32_t get_acc_buf_sel_ai() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 9); - return value; - } - CONSTEXPR mac_status_r &set_acc_buf_sel_ai(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 9) & word0) | ((((1U << 1) - 1) & value) << 9); - return *this; - } - volatile mac_status_r &set_acc_buf_sel_ai(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 9) & word0) | ((((1U << 1) - 1) & value) << 9); - return *this; - } - CONSTEXPR uint32_t get_wait_for_acc0_ready() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 10); - return value; - } - uint32_t get_wait_for_acc0_ready() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 10); - return value; - } - CONSTEXPR mac_status_r &set_wait_for_acc0_ready(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 10) & word0) | ((((1U << 1) - 1) & value) << 10); - return *this; - } - volatile mac_status_r &set_wait_for_acc0_ready(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 10) & word0) | ((((1U << 1) - 1) & value) << 10); - return *this; - } - CONSTEXPR uint32_t get_wait_for_acc1_ready() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 11); - return value; - } - uint32_t get_wait_for_acc1_ready() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 11); - return value; - } - CONSTEXPR mac_status_r &set_wait_for_acc1_ready(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 11) & word0) | ((((1U << 1) - 1) & value) << 11); - return *this; - } - volatile mac_status_r &set_wait_for_acc1_ready(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 11) & word0) | ((((1U << 1) - 1) & value) << 11); - return *this; - } - CONSTEXPR uint32_t get_acc_buf_sel_aa() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 12); - return value; - } - uint32_t get_acc_buf_sel_aa() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 12); - return value; - } - CONSTEXPR mac_status_r &set_acc_buf_sel_aa(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 12) & word0) | ((((1U << 1) - 1) & value) << 12); - return *this; - } - volatile mac_status_r &set_acc_buf_sel_aa(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 12) & word0) | ((((1U << 1) - 1) & value) << 12); - return *this; - } - CONSTEXPR uint32_t get_acc0_valid() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 13); - return value; - } - uint32_t get_acc0_valid() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 13); - return value; - } - CONSTEXPR mac_status_r &set_acc0_valid(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 13) & word0) | ((((1U << 1) - 1) & value) << 13); - return *this; - } - volatile mac_status_r &set_acc0_valid(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 13) & word0) | ((((1U << 1) - 1) & value) << 13); - return *this; - } - CONSTEXPR uint32_t get_acc1_valid() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 14); - return value; - } - uint32_t get_acc1_valid() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 14); - return value; - } - CONSTEXPR mac_status_r &set_acc1_valid(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 14) & word0) | ((((1U << 1) - 1) & value) << 14); - return *this; - } - volatile mac_status_r &set_acc1_valid(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 14) & word0) | ((((1U << 1) - 1) & value) << 14); - return *this; - } - CONSTEXPR uint32_t get_events() const - { - uint32_t value = ((1U << 11) - 1) & (word0 >> 16); - return value; - } - uint32_t get_events() const volatile - { - uint32_t value = ((1U << 11) - 1) & (word0 >> 16); - return value; - } - CONSTEXPR mac_status_r &set_events(uint32_t value) - { - word0 = (((~((1U << 11) - 1)) << 16) & word0) | ((((1U << 11) - 1) & value) << 16); - return *this; - } - volatile mac_status_r &set_events(uint32_t value) volatile - { - word0 = (((~((1U << 11) - 1)) << 16) & word0) | ((((1U << 11) - 1) & value) << 16); - return *this; - } -#endif -}; - -// ao_status_r - AO_STATUS -struct ao_status_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t cmd_sbw_valid : 1; // Block command to shared buffer write module is valid - uint32_t cmd_act_valid : 1; // Block command to activation function module is valid - uint32_t cmd_ctl_valid : 1; // Block command to control module is valid - uint32_t cmd_scl_valid : 1; // Block command to scale module is valid - uint32_t cmd_sbr_valid : 1; // Block command to shared buffer read module is valid - uint32_t cmd_ofm_valid : 1; // Block command to ofm parameter module is valid - uint32_t blk_cmd_ready : 1; // Ready to accept block command - uint32_t blk_cmd_valid : 1; // Block command from CC is valid - uint32_t reserved0 : 8; - uint32_t events : 8; // Mapped to AO events described in Appendix A - uint32_t reserved1 : 8; - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ao_status_r() : word0(0) {} - CONSTEXPR ao_status_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ao_status_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_cmd_sbw_valid() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 0); - return value; - } - uint32_t get_cmd_sbw_valid() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 0); - return value; - } - CONSTEXPR ao_status_r &set_cmd_sbw_valid(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - volatile ao_status_r &set_cmd_sbw_valid(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - CONSTEXPR uint32_t get_cmd_act_valid() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 1); - return value; - } - uint32_t get_cmd_act_valid() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 1); - return value; - } - CONSTEXPR ao_status_r &set_cmd_act_valid(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - volatile ao_status_r &set_cmd_act_valid(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - CONSTEXPR uint32_t get_cmd_ctl_valid() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 2); - return value; - } - uint32_t get_cmd_ctl_valid() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 2); - return value; - } - CONSTEXPR ao_status_r &set_cmd_ctl_valid(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - volatile ao_status_r &set_cmd_ctl_valid(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - CONSTEXPR uint32_t get_cmd_scl_valid() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 3); - return value; - } - uint32_t get_cmd_scl_valid() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 3); - return value; - } - CONSTEXPR ao_status_r &set_cmd_scl_valid(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - volatile ao_status_r &set_cmd_scl_valid(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - CONSTEXPR uint32_t get_cmd_sbr_valid() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 4); - return value; - } - uint32_t get_cmd_sbr_valid() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 4); - return value; - } - CONSTEXPR ao_status_r &set_cmd_sbr_valid(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 4) & word0) | ((((1U << 1) - 1) & value) << 4); - return *this; - } - volatile ao_status_r &set_cmd_sbr_valid(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 4) & word0) | ((((1U << 1) - 1) & value) << 4); - return *this; - } - CONSTEXPR uint32_t get_cmd_ofm_valid() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 5); - return value; - } - uint32_t get_cmd_ofm_valid() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 5); - return value; - } - CONSTEXPR ao_status_r &set_cmd_ofm_valid(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 5) & word0) | ((((1U << 1) - 1) & value) << 5); - return *this; - } - volatile ao_status_r &set_cmd_ofm_valid(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 5) & word0) | ((((1U << 1) - 1) & value) << 5); - return *this; - } - CONSTEXPR uint32_t get_blk_cmd_ready() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 6); - return value; - } - uint32_t get_blk_cmd_ready() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 6); - return value; - } - CONSTEXPR ao_status_r &set_blk_cmd_ready(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 6) & word0) | ((((1U << 1) - 1) & value) << 6); - return *this; - } - volatile ao_status_r &set_blk_cmd_ready(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 6) & word0) | ((((1U << 1) - 1) & value) << 6); - return *this; - } - CONSTEXPR uint32_t get_blk_cmd_valid() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 7); - return value; - } - uint32_t get_blk_cmd_valid() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 7); - return value; - } - CONSTEXPR ao_status_r &set_blk_cmd_valid(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 7) & word0) | ((((1U << 1) - 1) & value) << 7); - return *this; - } - volatile ao_status_r &set_blk_cmd_valid(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 7) & word0) | ((((1U << 1) - 1) & value) << 7); - return *this; - } - CONSTEXPR uint32_t get_events() const - { - uint32_t value = ((1U << 8) - 1) & (word0 >> 16); - return value; - } - uint32_t get_events() const volatile - { - uint32_t value = ((1U << 8) - 1) & (word0 >> 16); - return value; - } - CONSTEXPR ao_status_r &set_events(uint32_t value) - { - word0 = (((~((1U << 8) - 1)) << 16) & word0) | ((((1U << 8) - 1) & value) << 16); - return *this; - } - volatile ao_status_r &set_events(uint32_t value) volatile - { - word0 = (((~((1U << 8) - 1)) << 16) & word0) | ((((1U << 8) - 1) & value) << 16); - return *this; - } -#endif -}; - -// dma_status0_r - DMA_STATUS0 -struct dma_status0_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t cmd_idle : 1; // When this bit is high means that the CMD block is not busy in generating addresses - // for a CMD job - uint32_t ifm_idle : 1; // When this bit is high means that there are no ongoing IFM jobs - uint32_t wgt_idle_c0 : 1; // When this bit is high means that the WGT block is not busy in generating - // addresses for a WGT job - uint32_t bas_idle_c0 : 1; // When this bit is high means that the BAS block is not busy in generating - // addresses for a BAS job - uint32_t m2m_idle : 1; // When this bit is high means that there are no ongoing M2M jobs - uint32_t ofm_idle : 1; // When this bit is high means that there are no ongoing OFM jobs - uint32_t halt_req : 1; // CPM has requested to HALT AXI bus before soft reset - uint32_t halt_ack : 1; // DMA is in condition to halt the AXI bus since there are no pending transactions - uint32_t pause_req : 1; // CC has requested to pause the AXI - uint32_t pause_ack : 1; // DMA is in condition to pause the AXI bus since there are no pending transactions - uint32_t ib0_ai_valid_c0 : 1; // Data for AI to be read in IFM input buffer 0 - Core 0 - uint32_t ib0_ai_ready_c0 : 1; // Data consumed from AI in IFM input buffer 0 - Core 0 - uint32_t ib1_ai_valid_c0 : 1; // Data for AI to be read in IFM input buffer 1 - Core 0 - uint32_t ib1_ai_ready_c0 : 1; // Data consumed from AI in IFM input buffer 1 - Core 0 - uint32_t ib0_ao_valid_c0 : 1; // Data for AO to be read in IFM input buffer 0 - Core 0 - uint32_t ib0_ao_ready_c0 : 1; // Data consumed from AO in IFM input buffer 0 - Core 0 - uint32_t ib1_ao_valid_c0 : 1; // Data for AO to be read in IFM input buffer 0 - Core 0 - uint32_t ib1_ao_ready_c0 : 1; // Data consumed from AO in IFM input buffer 1 - Core 0 - uint32_t ob0_valid_c0 : 1; // Data for DMA ready to be consumed in OFM output buffer 0 - Core 0 - uint32_t ob0_ready_c0 : 1; // Data consumed from DMA in OFM output buffer 0 - Core 0 - uint32_t ob1_valid_c0 : 1; // Data for DMA ready to be consumed in OFM output buffer 1 - Core 0 - uint32_t ob1_ready_c0 : 1; // Data consumed from DMA in OFM output buffer 1 - Core 0 - uint32_t cmd_valid : 1; // New command word for CC to be consumed - uint32_t cmd_ready : 1; // command word consumed by CC - uint32_t wd_bitstream_valid_c0 : 1; // New weight word for WD to be consumed - Core 0 - uint32_t wd_bitstream_ready_c0 : 1; // Weight word consumed by WD - Core 0 - uint32_t bs_bitstream_valid_c0 : 1; // New BaS word for AO to be consumed - Core 0 - uint32_t bs_bitstream_ready_c0 : 1; // BaS word consumed by AO - Core 0 - uint32_t axi0_ar_stalled : 1; // Read transfer request stalled on arready low AXI0 (due to memory system) - uint32_t axi0_rd_limit_stall : 1; // Read stalled due to one AXI0 limit counter being reached - uint32_t axi0_aw_stalled : 1; // Write transfer request stalled on awready low AXI0 (due to memory system) - uint32_t axi0_w_stalled : 1; // Write transfer stalled on awready low AXI0 (due to memory system) - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR dma_status0_r() : word0(0) {} - CONSTEXPR dma_status0_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - dma_status0_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_cmd_idle() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 0); - return value; - } - uint32_t get_cmd_idle() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 0); - return value; - } - CONSTEXPR dma_status0_r &set_cmd_idle(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - volatile dma_status0_r &set_cmd_idle(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - CONSTEXPR uint32_t get_ifm_idle() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 1); - return value; - } - uint32_t get_ifm_idle() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 1); - return value; - } - CONSTEXPR dma_status0_r &set_ifm_idle(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - volatile dma_status0_r &set_ifm_idle(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - CONSTEXPR uint32_t get_wgt_idle_c0() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 2); - return value; - } - uint32_t get_wgt_idle_c0() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 2); - return value; - } - CONSTEXPR dma_status0_r &set_wgt_idle_c0(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - volatile dma_status0_r &set_wgt_idle_c0(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - CONSTEXPR uint32_t get_bas_idle_c0() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 3); - return value; - } - uint32_t get_bas_idle_c0() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 3); - return value; - } - CONSTEXPR dma_status0_r &set_bas_idle_c0(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - volatile dma_status0_r &set_bas_idle_c0(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - CONSTEXPR uint32_t get_m2m_idle() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 4); - return value; - } - uint32_t get_m2m_idle() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 4); - return value; - } - CONSTEXPR dma_status0_r &set_m2m_idle(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 4) & word0) | ((((1U << 1) - 1) & value) << 4); - return *this; - } - volatile dma_status0_r &set_m2m_idle(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 4) & word0) | ((((1U << 1) - 1) & value) << 4); - return *this; - } - CONSTEXPR uint32_t get_ofm_idle() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 5); - return value; - } - uint32_t get_ofm_idle() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 5); - return value; - } - CONSTEXPR dma_status0_r &set_ofm_idle(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 5) & word0) | ((((1U << 1) - 1) & value) << 5); - return *this; - } - volatile dma_status0_r &set_ofm_idle(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 5) & word0) | ((((1U << 1) - 1) & value) << 5); - return *this; - } - CONSTEXPR uint32_t get_halt_req() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 6); - return value; - } - uint32_t get_halt_req() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 6); - return value; - } - CONSTEXPR dma_status0_r &set_halt_req(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 6) & word0) | ((((1U << 1) - 1) & value) << 6); - return *this; - } - volatile dma_status0_r &set_halt_req(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 6) & word0) | ((((1U << 1) - 1) & value) << 6); - return *this; - } - CONSTEXPR uint32_t get_halt_ack() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 7); - return value; - } - uint32_t get_halt_ack() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 7); - return value; - } - CONSTEXPR dma_status0_r &set_halt_ack(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 7) & word0) | ((((1U << 1) - 1) & value) << 7); - return *this; - } - volatile dma_status0_r &set_halt_ack(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 7) & word0) | ((((1U << 1) - 1) & value) << 7); - return *this; - } - CONSTEXPR uint32_t get_pause_req() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 8); - return value; - } - uint32_t get_pause_req() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 8); - return value; - } - CONSTEXPR dma_status0_r &set_pause_req(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 8) & word0) | ((((1U << 1) - 1) & value) << 8); - return *this; - } - volatile dma_status0_r &set_pause_req(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 8) & word0) | ((((1U << 1) - 1) & value) << 8); - return *this; - } - CONSTEXPR uint32_t get_pause_ack() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 9); - return value; - } - uint32_t get_pause_ack() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 9); - return value; - } - CONSTEXPR dma_status0_r &set_pause_ack(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 9) & word0) | ((((1U << 1) - 1) & value) << 9); - return *this; - } - volatile dma_status0_r &set_pause_ack(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 9) & word0) | ((((1U << 1) - 1) & value) << 9); - return *this; - } - CONSTEXPR uint32_t get_ib0_ai_valid_c0() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 10); - return value; - } - uint32_t get_ib0_ai_valid_c0() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 10); - return value; - } - CONSTEXPR dma_status0_r &set_ib0_ai_valid_c0(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 10) & word0) | ((((1U << 1) - 1) & value) << 10); - return *this; - } - volatile dma_status0_r &set_ib0_ai_valid_c0(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 10) & word0) | ((((1U << 1) - 1) & value) << 10); - return *this; - } - CONSTEXPR uint32_t get_ib0_ai_ready_c0() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 11); - return value; - } - uint32_t get_ib0_ai_ready_c0() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 11); - return value; - } - CONSTEXPR dma_status0_r &set_ib0_ai_ready_c0(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 11) & word0) | ((((1U << 1) - 1) & value) << 11); - return *this; - } - volatile dma_status0_r &set_ib0_ai_ready_c0(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 11) & word0) | ((((1U << 1) - 1) & value) << 11); - return *this; - } - CONSTEXPR uint32_t get_ib1_ai_valid_c0() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 12); - return value; - } - uint32_t get_ib1_ai_valid_c0() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 12); - return value; - } - CONSTEXPR dma_status0_r &set_ib1_ai_valid_c0(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 12) & word0) | ((((1U << 1) - 1) & value) << 12); - return *this; - } - volatile dma_status0_r &set_ib1_ai_valid_c0(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 12) & word0) | ((((1U << 1) - 1) & value) << 12); - return *this; - } - CONSTEXPR uint32_t get_ib1_ai_ready_c0() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 13); - return value; - } - uint32_t get_ib1_ai_ready_c0() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 13); - return value; - } - CONSTEXPR dma_status0_r &set_ib1_ai_ready_c0(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 13) & word0) | ((((1U << 1) - 1) & value) << 13); - return *this; - } - volatile dma_status0_r &set_ib1_ai_ready_c0(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 13) & word0) | ((((1U << 1) - 1) & value) << 13); - return *this; - } - CONSTEXPR uint32_t get_ib0_ao_valid_c0() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 14); - return value; - } - uint32_t get_ib0_ao_valid_c0() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 14); - return value; - } - CONSTEXPR dma_status0_r &set_ib0_ao_valid_c0(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 14) & word0) | ((((1U << 1) - 1) & value) << 14); - return *this; - } - volatile dma_status0_r &set_ib0_ao_valid_c0(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 14) & word0) | ((((1U << 1) - 1) & value) << 14); - return *this; - } - CONSTEXPR uint32_t get_ib0_ao_ready_c0() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 15); - return value; - } - uint32_t get_ib0_ao_ready_c0() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 15); - return value; - } - CONSTEXPR dma_status0_r &set_ib0_ao_ready_c0(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 15) & word0) | ((((1U << 1) - 1) & value) << 15); - return *this; - } - volatile dma_status0_r &set_ib0_ao_ready_c0(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 15) & word0) | ((((1U << 1) - 1) & value) << 15); - return *this; - } - CONSTEXPR uint32_t get_ib1_ao_valid_c0() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 16); - return value; - } - uint32_t get_ib1_ao_valid_c0() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 16); - return value; - } - CONSTEXPR dma_status0_r &set_ib1_ao_valid_c0(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 16) & word0) | ((((1U << 1) - 1) & value) << 16); - return *this; - } - volatile dma_status0_r &set_ib1_ao_valid_c0(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 16) & word0) | ((((1U << 1) - 1) & value) << 16); - return *this; - } - CONSTEXPR uint32_t get_ib1_ao_ready_c0() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 17); - return value; - } - uint32_t get_ib1_ao_ready_c0() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 17); - return value; - } - CONSTEXPR dma_status0_r &set_ib1_ao_ready_c0(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 17) & word0) | ((((1U << 1) - 1) & value) << 17); - return *this; - } - volatile dma_status0_r &set_ib1_ao_ready_c0(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 17) & word0) | ((((1U << 1) - 1) & value) << 17); - return *this; - } - CONSTEXPR uint32_t get_ob0_valid_c0() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 18); - return value; - } - uint32_t get_ob0_valid_c0() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 18); - return value; - } - CONSTEXPR dma_status0_r &set_ob0_valid_c0(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 18) & word0) | ((((1U << 1) - 1) & value) << 18); - return *this; - } - volatile dma_status0_r &set_ob0_valid_c0(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 18) & word0) | ((((1U << 1) - 1) & value) << 18); - return *this; - } - CONSTEXPR uint32_t get_ob0_ready_c0() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 19); - return value; - } - uint32_t get_ob0_ready_c0() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 19); - return value; - } - CONSTEXPR dma_status0_r &set_ob0_ready_c0(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 19) & word0) | ((((1U << 1) - 1) & value) << 19); - return *this; - } - volatile dma_status0_r &set_ob0_ready_c0(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 19) & word0) | ((((1U << 1) - 1) & value) << 19); - return *this; - } - CONSTEXPR uint32_t get_ob1_valid_c0() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 20); - return value; - } - uint32_t get_ob1_valid_c0() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 20); - return value; - } - CONSTEXPR dma_status0_r &set_ob1_valid_c0(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 20) & word0) | ((((1U << 1) - 1) & value) << 20); - return *this; - } - volatile dma_status0_r &set_ob1_valid_c0(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 20) & word0) | ((((1U << 1) - 1) & value) << 20); - return *this; - } - CONSTEXPR uint32_t get_ob1_ready_c0() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 21); - return value; - } - uint32_t get_ob1_ready_c0() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 21); - return value; - } - CONSTEXPR dma_status0_r &set_ob1_ready_c0(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 21) & word0) | ((((1U << 1) - 1) & value) << 21); - return *this; - } - volatile dma_status0_r &set_ob1_ready_c0(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 21) & word0) | ((((1U << 1) - 1) & value) << 21); - return *this; - } - CONSTEXPR uint32_t get_cmd_valid() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 22); - return value; - } - uint32_t get_cmd_valid() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 22); - return value; - } - CONSTEXPR dma_status0_r &set_cmd_valid(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 22) & word0) | ((((1U << 1) - 1) & value) << 22); - return *this; - } - volatile dma_status0_r &set_cmd_valid(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 22) & word0) | ((((1U << 1) - 1) & value) << 22); - return *this; - } - CONSTEXPR uint32_t get_cmd_ready() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 23); - return value; - } - uint32_t get_cmd_ready() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 23); - return value; - } - CONSTEXPR dma_status0_r &set_cmd_ready(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 23) & word0) | ((((1U << 1) - 1) & value) << 23); - return *this; - } - volatile dma_status0_r &set_cmd_ready(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 23) & word0) | ((((1U << 1) - 1) & value) << 23); - return *this; - } - CONSTEXPR uint32_t get_wd_bitstream_valid_c0() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 24); - return value; - } - uint32_t get_wd_bitstream_valid_c0() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 24); - return value; - } - CONSTEXPR dma_status0_r &set_wd_bitstream_valid_c0(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 24) & word0) | ((((1U << 1) - 1) & value) << 24); - return *this; - } - volatile dma_status0_r &set_wd_bitstream_valid_c0(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 24) & word0) | ((((1U << 1) - 1) & value) << 24); - return *this; - } - CONSTEXPR uint32_t get_wd_bitstream_ready_c0() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 25); - return value; - } - uint32_t get_wd_bitstream_ready_c0() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 25); - return value; - } - CONSTEXPR dma_status0_r &set_wd_bitstream_ready_c0(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 25) & word0) | ((((1U << 1) - 1) & value) << 25); - return *this; - } - volatile dma_status0_r &set_wd_bitstream_ready_c0(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 25) & word0) | ((((1U << 1) - 1) & value) << 25); - return *this; - } - CONSTEXPR uint32_t get_bs_bitstream_valid_c0() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 26); - return value; - } - uint32_t get_bs_bitstream_valid_c0() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 26); - return value; - } - CONSTEXPR dma_status0_r &set_bs_bitstream_valid_c0(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 26) & word0) | ((((1U << 1) - 1) & value) << 26); - return *this; - } - volatile dma_status0_r &set_bs_bitstream_valid_c0(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 26) & word0) | ((((1U << 1) - 1) & value) << 26); - return *this; - } - CONSTEXPR uint32_t get_bs_bitstream_ready_c0() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 27); - return value; - } - uint32_t get_bs_bitstream_ready_c0() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 27); - return value; - } - CONSTEXPR dma_status0_r &set_bs_bitstream_ready_c0(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 27) & word0) | ((((1U << 1) - 1) & value) << 27); - return *this; - } - volatile dma_status0_r &set_bs_bitstream_ready_c0(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 27) & word0) | ((((1U << 1) - 1) & value) << 27); - return *this; - } - CONSTEXPR uint32_t get_axi0_ar_stalled() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 28); - return value; - } - uint32_t get_axi0_ar_stalled() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 28); - return value; - } - CONSTEXPR dma_status0_r &set_axi0_ar_stalled(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 28) & word0) | ((((1U << 1) - 1) & value) << 28); - return *this; - } - volatile dma_status0_r &set_axi0_ar_stalled(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 28) & word0) | ((((1U << 1) - 1) & value) << 28); - return *this; - } - CONSTEXPR uint32_t get_axi0_rd_limit_stall() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 29); - return value; - } - uint32_t get_axi0_rd_limit_stall() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 29); - return value; - } - CONSTEXPR dma_status0_r &set_axi0_rd_limit_stall(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 29) & word0) | ((((1U << 1) - 1) & value) << 29); - return *this; - } - volatile dma_status0_r &set_axi0_rd_limit_stall(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 29) & word0) | ((((1U << 1) - 1) & value) << 29); - return *this; - } - CONSTEXPR uint32_t get_axi0_aw_stalled() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 30); - return value; - } - uint32_t get_axi0_aw_stalled() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 30); - return value; - } - CONSTEXPR dma_status0_r &set_axi0_aw_stalled(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 30) & word0) | ((((1U << 1) - 1) & value) << 30); - return *this; - } - volatile dma_status0_r &set_axi0_aw_stalled(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 30) & word0) | ((((1U << 1) - 1) & value) << 30); - return *this; - } - CONSTEXPR uint32_t get_axi0_w_stalled() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 31); - return value; - } - uint32_t get_axi0_w_stalled() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 31); - return value; - } - CONSTEXPR dma_status0_r &set_axi0_w_stalled(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 31) & word0) | ((((1U << 1) - 1) & value) << 31); - return *this; - } - volatile dma_status0_r &set_axi0_w_stalled(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 31) & word0) | ((((1U << 1) - 1) & value) << 31); - return *this; - } -#endif -}; - -// dma_status1_r - DMA_STATUS1 -struct dma_status1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t axi0_wr_limit_stall : 1; // Write stalled due to one AXI0 limit counter being reached - uint32_t axi1_ar_stalled : 1; // Read transfer request stalled on arready low AXI1 (due to memory system) - uint32_t axi1_rd_limit_stall : 1; // Read stalled due to one AXI1 limit counter being reached - uint32_t axi1_wr_stalled : 1; // Write transfer request stalled on awready low AXI1 (due to memory system) - uint32_t axi1_w_stalled : 1; // Write transfer stalled on wready low AXI1 (due to memory system) - uint32_t axi1_wr_limit_stall : 1; // Write stalled due to one AXI1 limit counter being reached - uint32_t wgt_idle_c1 : 1; // When this bit is high means that the WGT block is not busy in generating - // addresses for a WGT job - uint32_t bas_idle_c1 : 1; // When this bit is high means that the BAS block is not busy in generating - // addresses for a BAS job - uint32_t ib0_ai_valid_c1 : 1; // Data for AI to be read in IFM input buffer 0 - Core 1 - uint32_t ib0_ai_ready_c1 : 1; // Data consumed from AI in IFM input buffer 0 - Core 1 - uint32_t ib1_ai_valid_c1 : 1; // Data for AI to be read in IFM input buffer 1 - Core 1 - uint32_t ib1_ai_ready_c1 : 1; // Data consumed from AI in IFM input buffer 1 - Core 1 - uint32_t ib0_ao_valid_c1 : 1; // Data for AO to be read in IFM input buffer 0 - Core 1 - uint32_t ib0_ao_ready_c1 : 1; // Data consumed from AO in IFM input buffer 0 - Core 1 - uint32_t ib1_ao_valid_c1 : 1; // Data for AO to be read in IFM input buffer 0 - Core 1 - uint32_t ib1_ao_ready_c1 : 1; // Data consumed from AO in IFM input buffer 1 - Core 1 - uint32_t ob0_valid_c1 : 1; // Data for DMA ready to be consumed in OFM output buffer 0 - Core 1 - uint32_t ob0_ready_c1 : 1; // Data consumed from DMA in OFM output buffer 0 - Core 1 - uint32_t ob1_valid_c1 : 1; // Data for DMA ready to be consumed in OFM output buffer 1 - Core 1 - uint32_t ob1_ready_c1 : 1; // Data consumed from DMA in OFM output buffer 1 - Core 1 - uint32_t wd_bitstream_valid_c1 : 1; // New weight word for WD to be consumed - Core 1 - uint32_t wd_bitstream_ready_c1 : 1; // Weight word consumed by WD - Core 1 - uint32_t bs_bitstream_valid_c1 : 1; // New BaS word for AO to be consumed - Core 1 - uint32_t bs_bitstream_ready_c1 : 1; // BaS word consumed by AO - Core 1 - uint32_t reserved0 : 8; - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR dma_status1_r() : word0(0) {} - CONSTEXPR dma_status1_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - dma_status1_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_axi0_wr_limit_stall() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 0); - return value; - } - uint32_t get_axi0_wr_limit_stall() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 0); - return value; - } - CONSTEXPR dma_status1_r &set_axi0_wr_limit_stall(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - volatile dma_status1_r &set_axi0_wr_limit_stall(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - CONSTEXPR uint32_t get_axi1_ar_stalled() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 1); - return value; - } - uint32_t get_axi1_ar_stalled() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 1); - return value; - } - CONSTEXPR dma_status1_r &set_axi1_ar_stalled(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - volatile dma_status1_r &set_axi1_ar_stalled(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - CONSTEXPR uint32_t get_axi1_rd_limit_stall() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 2); - return value; - } - uint32_t get_axi1_rd_limit_stall() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 2); - return value; - } - CONSTEXPR dma_status1_r &set_axi1_rd_limit_stall(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - volatile dma_status1_r &set_axi1_rd_limit_stall(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - CONSTEXPR uint32_t get_axi1_wr_stalled() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 3); - return value; - } - uint32_t get_axi1_wr_stalled() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 3); - return value; - } - CONSTEXPR dma_status1_r &set_axi1_wr_stalled(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - volatile dma_status1_r &set_axi1_wr_stalled(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - CONSTEXPR uint32_t get_axi1_w_stalled() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 4); - return value; - } - uint32_t get_axi1_w_stalled() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 4); - return value; - } - CONSTEXPR dma_status1_r &set_axi1_w_stalled(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 4) & word0) | ((((1U << 1) - 1) & value) << 4); - return *this; - } - volatile dma_status1_r &set_axi1_w_stalled(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 4) & word0) | ((((1U << 1) - 1) & value) << 4); - return *this; - } - CONSTEXPR uint32_t get_axi1_wr_limit_stall() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 5); - return value; - } - uint32_t get_axi1_wr_limit_stall() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 5); - return value; - } - CONSTEXPR dma_status1_r &set_axi1_wr_limit_stall(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 5) & word0) | ((((1U << 1) - 1) & value) << 5); - return *this; - } - volatile dma_status1_r &set_axi1_wr_limit_stall(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 5) & word0) | ((((1U << 1) - 1) & value) << 5); - return *this; - } - CONSTEXPR uint32_t get_wgt_idle_c1() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 6); - return value; - } - uint32_t get_wgt_idle_c1() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 6); - return value; - } - CONSTEXPR dma_status1_r &set_wgt_idle_c1(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 6) & word0) | ((((1U << 1) - 1) & value) << 6); - return *this; - } - volatile dma_status1_r &set_wgt_idle_c1(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 6) & word0) | ((((1U << 1) - 1) & value) << 6); - return *this; - } - CONSTEXPR uint32_t get_bas_idle_c1() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 7); - return value; - } - uint32_t get_bas_idle_c1() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 7); - return value; - } - CONSTEXPR dma_status1_r &set_bas_idle_c1(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 7) & word0) | ((((1U << 1) - 1) & value) << 7); - return *this; - } - volatile dma_status1_r &set_bas_idle_c1(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 7) & word0) | ((((1U << 1) - 1) & value) << 7); - return *this; - } - CONSTEXPR uint32_t get_ib0_ai_valid_c1() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 8); - return value; - } - uint32_t get_ib0_ai_valid_c1() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 8); - return value; - } - CONSTEXPR dma_status1_r &set_ib0_ai_valid_c1(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 8) & word0) | ((((1U << 1) - 1) & value) << 8); - return *this; - } - volatile dma_status1_r &set_ib0_ai_valid_c1(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 8) & word0) | ((((1U << 1) - 1) & value) << 8); - return *this; - } - CONSTEXPR uint32_t get_ib0_ai_ready_c1() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 9); - return value; - } - uint32_t get_ib0_ai_ready_c1() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 9); - return value; - } - CONSTEXPR dma_status1_r &set_ib0_ai_ready_c1(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 9) & word0) | ((((1U << 1) - 1) & value) << 9); - return *this; - } - volatile dma_status1_r &set_ib0_ai_ready_c1(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 9) & word0) | ((((1U << 1) - 1) & value) << 9); - return *this; - } - CONSTEXPR uint32_t get_ib1_ai_valid_c1() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 10); - return value; - } - uint32_t get_ib1_ai_valid_c1() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 10); - return value; - } - CONSTEXPR dma_status1_r &set_ib1_ai_valid_c1(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 10) & word0) | ((((1U << 1) - 1) & value) << 10); - return *this; - } - volatile dma_status1_r &set_ib1_ai_valid_c1(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 10) & word0) | ((((1U << 1) - 1) & value) << 10); - return *this; - } - CONSTEXPR uint32_t get_ib1_ai_ready_c1() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 11); - return value; - } - uint32_t get_ib1_ai_ready_c1() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 11); - return value; - } - CONSTEXPR dma_status1_r &set_ib1_ai_ready_c1(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 11) & word0) | ((((1U << 1) - 1) & value) << 11); - return *this; - } - volatile dma_status1_r &set_ib1_ai_ready_c1(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 11) & word0) | ((((1U << 1) - 1) & value) << 11); - return *this; - } - CONSTEXPR uint32_t get_ib0_ao_valid_c1() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 12); - return value; - } - uint32_t get_ib0_ao_valid_c1() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 12); - return value; - } - CONSTEXPR dma_status1_r &set_ib0_ao_valid_c1(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 12) & word0) | ((((1U << 1) - 1) & value) << 12); - return *this; - } - volatile dma_status1_r &set_ib0_ao_valid_c1(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 12) & word0) | ((((1U << 1) - 1) & value) << 12); - return *this; - } - CONSTEXPR uint32_t get_ib0_ao_ready_c1() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 13); - return value; - } - uint32_t get_ib0_ao_ready_c1() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 13); - return value; - } - CONSTEXPR dma_status1_r &set_ib0_ao_ready_c1(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 13) & word0) | ((((1U << 1) - 1) & value) << 13); - return *this; - } - volatile dma_status1_r &set_ib0_ao_ready_c1(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 13) & word0) | ((((1U << 1) - 1) & value) << 13); - return *this; - } - CONSTEXPR uint32_t get_ib1_ao_valid_c1() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 14); - return value; - } - uint32_t get_ib1_ao_valid_c1() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 14); - return value; - } - CONSTEXPR dma_status1_r &set_ib1_ao_valid_c1(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 14) & word0) | ((((1U << 1) - 1) & value) << 14); - return *this; - } - volatile dma_status1_r &set_ib1_ao_valid_c1(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 14) & word0) | ((((1U << 1) - 1) & value) << 14); - return *this; - } - CONSTEXPR uint32_t get_ib1_ao_ready_c1() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 15); - return value; - } - uint32_t get_ib1_ao_ready_c1() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 15); - return value; - } - CONSTEXPR dma_status1_r &set_ib1_ao_ready_c1(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 15) & word0) | ((((1U << 1) - 1) & value) << 15); - return *this; - } - volatile dma_status1_r &set_ib1_ao_ready_c1(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 15) & word0) | ((((1U << 1) - 1) & value) << 15); - return *this; - } - CONSTEXPR uint32_t get_ob0_valid_c1() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 16); - return value; - } - uint32_t get_ob0_valid_c1() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 16); - return value; - } - CONSTEXPR dma_status1_r &set_ob0_valid_c1(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 16) & word0) | ((((1U << 1) - 1) & value) << 16); - return *this; - } - volatile dma_status1_r &set_ob0_valid_c1(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 16) & word0) | ((((1U << 1) - 1) & value) << 16); - return *this; - } - CONSTEXPR uint32_t get_ob0_ready_c1() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 17); - return value; - } - uint32_t get_ob0_ready_c1() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 17); - return value; - } - CONSTEXPR dma_status1_r &set_ob0_ready_c1(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 17) & word0) | ((((1U << 1) - 1) & value) << 17); - return *this; - } - volatile dma_status1_r &set_ob0_ready_c1(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 17) & word0) | ((((1U << 1) - 1) & value) << 17); - return *this; - } - CONSTEXPR uint32_t get_ob1_valid_c1() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 18); - return value; - } - uint32_t get_ob1_valid_c1() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 18); - return value; - } - CONSTEXPR dma_status1_r &set_ob1_valid_c1(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 18) & word0) | ((((1U << 1) - 1) & value) << 18); - return *this; - } - volatile dma_status1_r &set_ob1_valid_c1(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 18) & word0) | ((((1U << 1) - 1) & value) << 18); - return *this; - } - CONSTEXPR uint32_t get_ob1_ready_c1() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 19); - return value; - } - uint32_t get_ob1_ready_c1() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 19); - return value; - } - CONSTEXPR dma_status1_r &set_ob1_ready_c1(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 19) & word0) | ((((1U << 1) - 1) & value) << 19); - return *this; - } - volatile dma_status1_r &set_ob1_ready_c1(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 19) & word0) | ((((1U << 1) - 1) & value) << 19); - return *this; - } - CONSTEXPR uint32_t get_wd_bitstream_valid_c1() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 20); - return value; - } - uint32_t get_wd_bitstream_valid_c1() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 20); - return value; - } - CONSTEXPR dma_status1_r &set_wd_bitstream_valid_c1(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 20) & word0) | ((((1U << 1) - 1) & value) << 20); - return *this; - } - volatile dma_status1_r &set_wd_bitstream_valid_c1(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 20) & word0) | ((((1U << 1) - 1) & value) << 20); - return *this; - } - CONSTEXPR uint32_t get_wd_bitstream_ready_c1() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 21); - return value; - } - uint32_t get_wd_bitstream_ready_c1() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 21); - return value; - } - CONSTEXPR dma_status1_r &set_wd_bitstream_ready_c1(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 21) & word0) | ((((1U << 1) - 1) & value) << 21); - return *this; - } - volatile dma_status1_r &set_wd_bitstream_ready_c1(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 21) & word0) | ((((1U << 1) - 1) & value) << 21); - return *this; - } - CONSTEXPR uint32_t get_bs_bitstream_valid_c1() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 22); - return value; - } - uint32_t get_bs_bitstream_valid_c1() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 22); - return value; - } - CONSTEXPR dma_status1_r &set_bs_bitstream_valid_c1(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 22) & word0) | ((((1U << 1) - 1) & value) << 22); - return *this; - } - volatile dma_status1_r &set_bs_bitstream_valid_c1(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 22) & word0) | ((((1U << 1) - 1) & value) << 22); - return *this; - } - CONSTEXPR uint32_t get_bs_bitstream_ready_c1() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 23); - return value; - } - uint32_t get_bs_bitstream_ready_c1() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 23); - return value; - } - CONSTEXPR dma_status1_r &set_bs_bitstream_ready_c1(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 23) & word0) | ((((1U << 1) - 1) & value) << 23); - return *this; - } - volatile dma_status1_r &set_bs_bitstream_ready_c1(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 23) & word0) | ((((1U << 1) - 1) & value) << 23); - return *this; - } -#endif -}; - -// clkforce_r - Force clocks on for clock gating -struct clkforce_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t top_level_clk : 1; // set to 1 to force on TOP level clock - uint32_t cc_clk : 1; // set to 1 to force on CC clock - uint32_t dma_clk : 1; // set to 1 to force on DMA clock - uint32_t mac_clk : 1; // set to 1 to force on MAC clock - uint32_t ao_clk : 1; // set to 1 to force on AO clock - uint32_t wd_clk : 1; // set to 1 to force on WD clock - uint32_t reserved0 : 26; - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR clkforce_r() : word0(0) {} - CONSTEXPR clkforce_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - clkforce_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_top_level_clk() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 0); - return value; - } - uint32_t get_top_level_clk() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 0); - return value; - } - CONSTEXPR clkforce_r &set_top_level_clk(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - volatile clkforce_r &set_top_level_clk(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - CONSTEXPR uint32_t get_cc_clk() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 1); - return value; - } - uint32_t get_cc_clk() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 1); - return value; - } - CONSTEXPR clkforce_r &set_cc_clk(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - volatile clkforce_r &set_cc_clk(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - CONSTEXPR uint32_t get_dma_clk() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 2); - return value; - } - uint32_t get_dma_clk() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 2); - return value; - } - CONSTEXPR clkforce_r &set_dma_clk(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - volatile clkforce_r &set_dma_clk(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - CONSTEXPR uint32_t get_mac_clk() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 3); - return value; - } - uint32_t get_mac_clk() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 3); - return value; - } - CONSTEXPR clkforce_r &set_mac_clk(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - volatile clkforce_r &set_mac_clk(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - CONSTEXPR uint32_t get_ao_clk() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 4); - return value; - } - uint32_t get_ao_clk() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 4); - return value; - } - CONSTEXPR clkforce_r &set_ao_clk(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 4) & word0) | ((((1U << 1) - 1) & value) << 4); - return *this; - } - volatile clkforce_r &set_ao_clk(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 4) & word0) | ((((1U << 1) - 1) & value) << 4); - return *this; - } - CONSTEXPR uint32_t get_wd_clk() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 5); - return value; - } - uint32_t get_wd_clk() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 5); - return value; - } - CONSTEXPR clkforce_r &set_wd_clk(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 5) & word0) | ((((1U << 1) - 1) & value) << 5); - return *this; - } - volatile clkforce_r &set_wd_clk(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 5) & word0) | ((((1U << 1) - 1) & value) << 5); - return *this; - } -#endif -}; - -// debug_address_r - Set debug address for register reads 0x400-0x7FF. The address must be 1KB aligned -struct debug_address_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t addr : 32; // Register address - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR debug_address_r() : word0(0) {} - CONSTEXPR debug_address_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - debug_address_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_addr() const - { - uint32_t value = word0; - return value; - } - uint32_t get_addr() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR debug_address_r &set_addr(uint32_t value) - { - word0 = value; - return *this; - } - volatile debug_address_r &set_addr(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// debug_misc_r - 32-bit read/write register for driver debug use. This does not affect NPU function -struct debug_misc_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t misc : 32; // Debug misc - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR debug_misc_r() : word0(0) {} - CONSTEXPR debug_misc_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - debug_misc_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_misc() const - { - uint32_t value = word0; - return value; - } - uint32_t get_misc() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR debug_misc_r &set_misc(uint32_t value) - { - word0 = value; - return *this; - } - volatile debug_misc_r &set_misc(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// debugcore_r - Select core number for debug registers (0x200-0x2FF) and RAM reads (0x400-0x7FF). Value is 0 or 1 -struct debugcore_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t core : 32; // Debug core - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR debugcore_r() : word0(0) {} - CONSTEXPR debugcore_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - debugcore_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_core() const - { - uint32_t value = word0; - return value; - } - uint32_t get_core() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR debugcore_r &set_core(uint32_t value) - { - word0 = value; - return *this; - } - volatile debugcore_r &set_core(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// debug_block_r - Set from which of four block banks the TSU registers are read. 0 = read from the current bank 256+n = -// force to read from bank n where n is in the range 0 to 3 -struct debug_block_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t block : 32; // Debug block - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR debug_block_r() : word0(0) {} - CONSTEXPR debug_block_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - debug_block_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_block() const - { - uint32_t value = word0; - return value; - } - uint32_t get_block() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR debug_block_r &set_block(uint32_t value) - { - word0 = value; - return *this; - } - volatile debug_block_r &set_block(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// pmcr_r - PMU Register control -struct pmcr_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t cnt_en : 1; // Enable counter - uint32_t event_cnt_rst : 1; // Reset event counter - uint32_t cycle_cnt_rst : 1; // Reset cycle counter - uint32_t mask_en : 1; // PMU can be enabled/disabled by command stream operation NPU_OP_PMU_MASK - uint32_t reserved0 : 7; - uint32_t num_event_cnt : 5; // Number of event counters - uint32_t reserved1 : 16; - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR pmcr_r() : word0(8192) {} - CONSTEXPR pmcr_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - pmcr_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_cnt_en() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 0); - return value; - } - uint32_t get_cnt_en() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 0); - return value; - } - CONSTEXPR pmcr_r &set_cnt_en(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - volatile pmcr_r &set_cnt_en(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - CONSTEXPR uint32_t get_event_cnt_rst() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 1); - return value; - } - uint32_t get_event_cnt_rst() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 1); - return value; - } - CONSTEXPR pmcr_r &set_event_cnt_rst(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - volatile pmcr_r &set_event_cnt_rst(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - CONSTEXPR uint32_t get_cycle_cnt_rst() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 2); - return value; - } - uint32_t get_cycle_cnt_rst() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 2); - return value; - } - CONSTEXPR pmcr_r &set_cycle_cnt_rst(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - volatile pmcr_r &set_cycle_cnt_rst(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - CONSTEXPR uint32_t get_mask_en() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 3); - return value; - } - uint32_t get_mask_en() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 3); - return value; - } - CONSTEXPR pmcr_r &set_mask_en(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - volatile pmcr_r &set_mask_en(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - CONSTEXPR uint32_t get_num_event_cnt() const - { - uint32_t value = ((1U << 5) - 1) & (word0 >> 11); - return value; - } - uint32_t get_num_event_cnt() const volatile - { - uint32_t value = ((1U << 5) - 1) & (word0 >> 11); - return value; - } - CONSTEXPR pmcr_r &set_num_event_cnt(uint32_t value) - { - word0 = (((~((1U << 5) - 1)) << 11) & word0) | ((((1U << 5) - 1) & value) << 11); - return *this; - } - volatile pmcr_r &set_num_event_cnt(uint32_t value) volatile - { - word0 = (((~((1U << 5) - 1)) << 11) & word0) | ((((1U << 5) - 1) & value) << 11); - return *this; - } -#endif -}; - -// pmcntenset_r - Count enable set register -struct pmcntenset_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t EVENT_CNT_0 : 1; // Event counter enable bit for PMEVCNTR0 - uint32_t EVENT_CNT_1 : 1; // Event counter enable bit for PMEVCNTR1 - uint32_t EVENT_CNT_2 : 1; // Event counter enable bit for PMEVCNTR2 - uint32_t EVENT_CNT_3 : 1; // Event counter enable bit for PMEVCNTR3 - uint32_t reserved0 : 27; - uint32_t CYCLE_CNT : 1; // PMCCNTR enable bit - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR pmcntenset_r() : word0(0) {} - CONSTEXPR pmcntenset_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - pmcntenset_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_0() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 0); - return value; - } - uint32_t get_EVENT_CNT_0() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 0); - return value; - } - CONSTEXPR pmcntenset_r &set_EVENT_CNT_0(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - volatile pmcntenset_r &set_EVENT_CNT_0(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_1() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 1); - return value; - } - uint32_t get_EVENT_CNT_1() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 1); - return value; - } - CONSTEXPR pmcntenset_r &set_EVENT_CNT_1(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - volatile pmcntenset_r &set_EVENT_CNT_1(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_2() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 2); - return value; - } - uint32_t get_EVENT_CNT_2() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 2); - return value; - } - CONSTEXPR pmcntenset_r &set_EVENT_CNT_2(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - volatile pmcntenset_r &set_EVENT_CNT_2(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_3() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 3); - return value; - } - uint32_t get_EVENT_CNT_3() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 3); - return value; - } - CONSTEXPR pmcntenset_r &set_EVENT_CNT_3(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - volatile pmcntenset_r &set_EVENT_CNT_3(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - CONSTEXPR uint32_t get_CYCLE_CNT() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 31); - return value; - } - uint32_t get_CYCLE_CNT() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 31); - return value; - } - CONSTEXPR pmcntenset_r &set_CYCLE_CNT(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 31) & word0) | ((((1U << 1) - 1) & value) << 31); - return *this; - } - volatile pmcntenset_r &set_CYCLE_CNT(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 31) & word0) | ((((1U << 1) - 1) & value) << 31); - return *this; - } -#endif -}; - -// pmcntenclr_r - Count enable clear register -struct pmcntenclr_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t EVENT_CNT_0 : 1; // Event counter disable bit for PMEVCNTR0 - uint32_t EVENT_CNT_1 : 1; // Event counter disable bit for PMEVCNTR1 - uint32_t EVENT_CNT_2 : 1; // Event counter disable bit for PMEVCNTR2 - uint32_t EVENT_CNT_3 : 1; // Event counter disable bit for PMEVCNTR3 - uint32_t reserved0 : 27; - uint32_t CYCLE_CNT : 1; // PMCCNTR disable bit - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR pmcntenclr_r() : word0(0) {} - CONSTEXPR pmcntenclr_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - pmcntenclr_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_0() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 0); - return value; - } - uint32_t get_EVENT_CNT_0() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 0); - return value; - } - CONSTEXPR pmcntenclr_r &set_EVENT_CNT_0(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - volatile pmcntenclr_r &set_EVENT_CNT_0(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_1() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 1); - return value; - } - uint32_t get_EVENT_CNT_1() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 1); - return value; - } - CONSTEXPR pmcntenclr_r &set_EVENT_CNT_1(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - volatile pmcntenclr_r &set_EVENT_CNT_1(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_2() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 2); - return value; - } - uint32_t get_EVENT_CNT_2() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 2); - return value; - } - CONSTEXPR pmcntenclr_r &set_EVENT_CNT_2(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - volatile pmcntenclr_r &set_EVENT_CNT_2(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_3() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 3); - return value; - } - uint32_t get_EVENT_CNT_3() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 3); - return value; - } - CONSTEXPR pmcntenclr_r &set_EVENT_CNT_3(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - volatile pmcntenclr_r &set_EVENT_CNT_3(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - CONSTEXPR uint32_t get_CYCLE_CNT() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 31); - return value; - } - uint32_t get_CYCLE_CNT() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 31); - return value; - } - CONSTEXPR pmcntenclr_r &set_CYCLE_CNT(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 31) & word0) | ((((1U << 1) - 1) & value) << 31); - return *this; - } - volatile pmcntenclr_r &set_CYCLE_CNT(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 31) & word0) | ((((1U << 1) - 1) & value) << 31); - return *this; - } -#endif -}; - -// pmovsset_r - Overflow flag status set register -struct pmovsset_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t EVENT_CNT_0_OVF : 1; // Event counter overflow set bit for PMEVCNTR0 - uint32_t EVENT_CNT_1_OVF : 1; // Event counter overflow set bit for PMEVCNTR1 - uint32_t EVENT_CNT_2_OVF : 1; // Event counter overflow set bit for PMEVCNTR2 - uint32_t EVENT_CNT_3_OVF : 1; // Event counter overflow set bit for PMEVCNTR3 - uint32_t reserved0 : 27; - uint32_t CYCLE_CNT_OVF : 1; // PMCCNTR overflow set bit - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR pmovsset_r() : word0(0) {} - CONSTEXPR pmovsset_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - pmovsset_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_0_OVF() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 0); - return value; - } - uint32_t get_EVENT_CNT_0_OVF() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 0); - return value; - } - CONSTEXPR pmovsset_r &set_EVENT_CNT_0_OVF(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - volatile pmovsset_r &set_EVENT_CNT_0_OVF(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_1_OVF() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 1); - return value; - } - uint32_t get_EVENT_CNT_1_OVF() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 1); - return value; - } - CONSTEXPR pmovsset_r &set_EVENT_CNT_1_OVF(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - volatile pmovsset_r &set_EVENT_CNT_1_OVF(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_2_OVF() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 2); - return value; - } - uint32_t get_EVENT_CNT_2_OVF() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 2); - return value; - } - CONSTEXPR pmovsset_r &set_EVENT_CNT_2_OVF(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - volatile pmovsset_r &set_EVENT_CNT_2_OVF(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_3_OVF() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 3); - return value; - } - uint32_t get_EVENT_CNT_3_OVF() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 3); - return value; - } - CONSTEXPR pmovsset_r &set_EVENT_CNT_3_OVF(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - volatile pmovsset_r &set_EVENT_CNT_3_OVF(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - CONSTEXPR uint32_t get_CYCLE_CNT_OVF() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 31); - return value; - } - uint32_t get_CYCLE_CNT_OVF() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 31); - return value; - } - CONSTEXPR pmovsset_r &set_CYCLE_CNT_OVF(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 31) & word0) | ((((1U << 1) - 1) & value) << 31); - return *this; - } - volatile pmovsset_r &set_CYCLE_CNT_OVF(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 31) & word0) | ((((1U << 1) - 1) & value) << 31); - return *this; - } -#endif -}; - -// pmovsclr_r - Overflow flag status clear register -struct pmovsclr_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t EVENT_CNT_0_OVF : 1; // Event counter overflow clear bit for PMEVCNTR0 - uint32_t EVENT_CNT_1_OVF : 1; // Event counter overflow clear bit for PMEVCNTR1 - uint32_t EVENT_CNT_2_OVF : 1; // Event counter overflow clear bit for PMEVCNTR2 - uint32_t EVENT_CNT_3_OVF : 1; // Event counter overflow clear bit for PMEVCNTR3 - uint32_t reserved0 : 27; - uint32_t CYCLE_CNT_OVF : 1; // PMCCNTR overflow clear bit - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR pmovsclr_r() : word0(0) {} - CONSTEXPR pmovsclr_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - pmovsclr_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_0_OVF() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 0); - return value; - } - uint32_t get_EVENT_CNT_0_OVF() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 0); - return value; - } - CONSTEXPR pmovsclr_r &set_EVENT_CNT_0_OVF(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - volatile pmovsclr_r &set_EVENT_CNT_0_OVF(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_1_OVF() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 1); - return value; - } - uint32_t get_EVENT_CNT_1_OVF() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 1); - return value; - } - CONSTEXPR pmovsclr_r &set_EVENT_CNT_1_OVF(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - volatile pmovsclr_r &set_EVENT_CNT_1_OVF(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_2_OVF() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 2); - return value; - } - uint32_t get_EVENT_CNT_2_OVF() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 2); - return value; - } - CONSTEXPR pmovsclr_r &set_EVENT_CNT_2_OVF(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - volatile pmovsclr_r &set_EVENT_CNT_2_OVF(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_3_OVF() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 3); - return value; - } - uint32_t get_EVENT_CNT_3_OVF() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 3); - return value; - } - CONSTEXPR pmovsclr_r &set_EVENT_CNT_3_OVF(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - volatile pmovsclr_r &set_EVENT_CNT_3_OVF(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - CONSTEXPR uint32_t get_CYCLE_CNT_OVF() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 31); - return value; - } - uint32_t get_CYCLE_CNT_OVF() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 31); - return value; - } - CONSTEXPR pmovsclr_r &set_CYCLE_CNT_OVF(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 31) & word0) | ((((1U << 1) - 1) & value) << 31); - return *this; - } - volatile pmovsclr_r &set_CYCLE_CNT_OVF(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 31) & word0) | ((((1U << 1) - 1) & value) << 31); - return *this; - } -#endif -}; - -// pmintset_r - Interrupt enable set register -struct pmintset_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t EVENT_CNT_0_INT : 1; // Event counter overflow interrupt request enable bit for PMEVCNTR0 - uint32_t EVENT_CNT_1_INT : 1; // Event counter overflow interrupt request enable bit for PMEVCNTR1 - uint32_t EVENT_CNT_2_INT : 1; // Event counter overflow interrupt request enable bit for PMEVCNTR2 - uint32_t EVENT_CNT_3_INT : 1; // Event counter overflow interrupt request enable bit for PMEVCNTR3 - uint32_t reserved0 : 27; - uint32_t CYCLE_CNT_INT : 1; // PMCCNTR overflow interrupt request enable bit - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR pmintset_r() : word0(0) {} - CONSTEXPR pmintset_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - pmintset_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_0_INT() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 0); - return value; - } - uint32_t get_EVENT_CNT_0_INT() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 0); - return value; - } - CONSTEXPR pmintset_r &set_EVENT_CNT_0_INT(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - volatile pmintset_r &set_EVENT_CNT_0_INT(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_1_INT() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 1); - return value; - } - uint32_t get_EVENT_CNT_1_INT() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 1); - return value; - } - CONSTEXPR pmintset_r &set_EVENT_CNT_1_INT(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - volatile pmintset_r &set_EVENT_CNT_1_INT(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_2_INT() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 2); - return value; - } - uint32_t get_EVENT_CNT_2_INT() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 2); - return value; - } - CONSTEXPR pmintset_r &set_EVENT_CNT_2_INT(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - volatile pmintset_r &set_EVENT_CNT_2_INT(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_3_INT() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 3); - return value; - } - uint32_t get_EVENT_CNT_3_INT() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 3); - return value; - } - CONSTEXPR pmintset_r &set_EVENT_CNT_3_INT(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - volatile pmintset_r &set_EVENT_CNT_3_INT(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - CONSTEXPR uint32_t get_CYCLE_CNT_INT() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 31); - return value; - } - uint32_t get_CYCLE_CNT_INT() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 31); - return value; - } - CONSTEXPR pmintset_r &set_CYCLE_CNT_INT(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 31) & word0) | ((((1U << 1) - 1) & value) << 31); - return *this; - } - volatile pmintset_r &set_CYCLE_CNT_INT(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 31) & word0) | ((((1U << 1) - 1) & value) << 31); - return *this; - } -#endif -}; - -// pmintclr_r - Interrupt enable clear register -struct pmintclr_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t EVENT_CNT_0_INT : 1; // Event counter overflow interrupt request disable bit for PMEVCNTR0 - uint32_t EVENT_CNT_1_INT : 1; // Event counter overflow interrupt request disable bit for PMEVCNTR1 - uint32_t EVENT_CNT_2_INT : 1; // Event counter overflow interrupt request disable bit for PMEVCNTR2 - uint32_t EVENT_CNT_3_INT : 1; // Event counter overflow interrupt request disable bit for PMEVCNTR3 - uint32_t reserved0 : 27; - uint32_t CYCLE_CNT_INT : 1; // PMCCNTR overflow interrupt request disable bit - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR pmintclr_r() : word0(0) {} - CONSTEXPR pmintclr_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - pmintclr_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_0_INT() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 0); - return value; - } - uint32_t get_EVENT_CNT_0_INT() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 0); - return value; - } - CONSTEXPR pmintclr_r &set_EVENT_CNT_0_INT(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - volatile pmintclr_r &set_EVENT_CNT_0_INT(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_1_INT() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 1); - return value; - } - uint32_t get_EVENT_CNT_1_INT() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 1); - return value; - } - CONSTEXPR pmintclr_r &set_EVENT_CNT_1_INT(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - volatile pmintclr_r &set_EVENT_CNT_1_INT(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_2_INT() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 2); - return value; - } - uint32_t get_EVENT_CNT_2_INT() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 2); - return value; - } - CONSTEXPR pmintclr_r &set_EVENT_CNT_2_INT(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - volatile pmintclr_r &set_EVENT_CNT_2_INT(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_3_INT() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 3); - return value; - } - uint32_t get_EVENT_CNT_3_INT() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 3); - return value; - } - CONSTEXPR pmintclr_r &set_EVENT_CNT_3_INT(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - volatile pmintclr_r &set_EVENT_CNT_3_INT(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - CONSTEXPR uint32_t get_CYCLE_CNT_INT() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 31); - return value; - } - uint32_t get_CYCLE_CNT_INT() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 31); - return value; - } - CONSTEXPR pmintclr_r &set_CYCLE_CNT_INT(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 31) & word0) | ((((1U << 1) - 1) & value) << 31); - return *this; - } - volatile pmintclr_r &set_CYCLE_CNT_INT(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 31) & word0) | ((((1U << 1) - 1) & value) << 31); - return *this; - } -#endif -}; - -// pmccntr_r - Performance monitor cycle count register -struct pmccntr_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t CYCLE_CNT_LO : 32; // Cycle count - LSB - uint32_t CYCLE_CNT_HI : 16; // Cycle count - MSB - uint32_t reserved0 : 16; - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR pmccntr_r() : word0(0), word1(0) {} - CONSTEXPR pmccntr_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - pmccntr_r copy() volatile - { - return *this; - } -#endif -}; - -// pmccntr_cfg_r - Set start/stop event on the cycle counter -struct pmccntr_cfg_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t CYCLE_CNT_CFG_START : 10; // Cycle counter start event - uint32_t reserved0 : 6; - uint32_t CYCLE_CNT_CFG_STOP : 10; // Cycle counter stop event - uint32_t reserved1 : 6; - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR pmccntr_cfg_r() : word0(0) {} - CONSTEXPR pmccntr_cfg_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - pmccntr_cfg_r copy() volatile - { - return *this; - } - CONSTEXPR NPU_NAMESPACE::pmu_event get_CYCLE_CNT_CFG_START() const - { - NPU_NAMESPACE::pmu_event value = static_cast(((1U << 10) - 1) & (word0 >> 0)); - return value; - } - NPU_NAMESPACE::pmu_event get_CYCLE_CNT_CFG_START() const volatile - { - NPU_NAMESPACE::pmu_event value = static_cast(((1U << 10) - 1) & (word0 >> 0)); - return value; - } - CONSTEXPR pmccntr_cfg_r &set_CYCLE_CNT_CFG_START(NPU_NAMESPACE::pmu_event value) - { - word0 = (((~((1U << 10) - 1)) << 0) & word0) | ((((1U << 10) - 1) & static_cast(value)) << 0); - return *this; - } - volatile pmccntr_cfg_r &set_CYCLE_CNT_CFG_START(NPU_NAMESPACE::pmu_event value) volatile - { - word0 = (((~((1U << 10) - 1)) << 0) & word0) | ((((1U << 10) - 1) & static_cast(value)) << 0); - return *this; - } - CONSTEXPR NPU_NAMESPACE::pmu_event get_CYCLE_CNT_CFG_STOP() const - { - NPU_NAMESPACE::pmu_event value = static_cast(((1U << 10) - 1) & (word0 >> 16)); - return value; - } - NPU_NAMESPACE::pmu_event get_CYCLE_CNT_CFG_STOP() const volatile - { - NPU_NAMESPACE::pmu_event value = static_cast(((1U << 10) - 1) & (word0 >> 16)); - return value; - } - CONSTEXPR pmccntr_cfg_r &set_CYCLE_CNT_CFG_STOP(NPU_NAMESPACE::pmu_event value) - { - word0 = (((~((1U << 10) - 1)) << 16) & word0) | ((((1U << 10) - 1) & static_cast(value)) << 16); - return *this; - } - volatile pmccntr_cfg_r &set_CYCLE_CNT_CFG_STOP(NPU_NAMESPACE::pmu_event value) volatile - { - word0 = (((~((1U << 10) - 1)) << 16) & word0) | ((((1U << 10) - 1) & static_cast(value)) << 16); - return *this; - } -#endif -}; - -// pmcaxi_chan_r - Set which AXI channel to monitor for latency measurements in PMU -struct pmcaxi_chan_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t CH_SEL : 4; // Channel select for latency measurements - uint32_t reserved0 : 4; - uint32_t AXI_CNT_SEL : 2; // AXI counter to monitor for latency measurements - uint32_t BW_CH_SEL_EN : 1; // Bandwidth channel selector - uint32_t reserved1 : 21; - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR pmcaxi_chan_r() : word0(0) {} - CONSTEXPR pmcaxi_chan_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - pmcaxi_chan_r copy() volatile - { - return *this; - } - CONSTEXPR NPU_NAMESPACE::pmu_axi_channel get_CH_SEL() const - { - NPU_NAMESPACE::pmu_axi_channel value = - static_cast(((1U << 4) - 1) & (word0 >> 0)); - return value; - } - NPU_NAMESPACE::pmu_axi_channel get_CH_SEL() const volatile - { - NPU_NAMESPACE::pmu_axi_channel value = - static_cast(((1U << 4) - 1) & (word0 >> 0)); - return value; - } - CONSTEXPR pmcaxi_chan_r &set_CH_SEL(NPU_NAMESPACE::pmu_axi_channel value) - { - word0 = (((~((1U << 4) - 1)) << 0) & word0) | ((((1U << 4) - 1) & static_cast(value)) << 0); - return *this; - } - volatile pmcaxi_chan_r &set_CH_SEL(NPU_NAMESPACE::pmu_axi_channel value) volatile - { - word0 = (((~((1U << 4) - 1)) << 0) & word0) | ((((1U << 4) - 1) & static_cast(value)) << 0); - return *this; - } - CONSTEXPR uint32_t get_AXI_CNT_SEL() const - { - uint32_t value = ((1U << 2) - 1) & (word0 >> 8); - return value; - } - uint32_t get_AXI_CNT_SEL() const volatile - { - uint32_t value = ((1U << 2) - 1) & (word0 >> 8); - return value; - } - CONSTEXPR pmcaxi_chan_r &set_AXI_CNT_SEL(uint32_t value) - { - word0 = (((~((1U << 2) - 1)) << 8) & word0) | ((((1U << 2) - 1) & value) << 8); - return *this; - } - volatile pmcaxi_chan_r &set_AXI_CNT_SEL(uint32_t value) volatile - { - word0 = (((~((1U << 2) - 1)) << 8) & word0) | ((((1U << 2) - 1) & value) << 8); - return *this; - } - CONSTEXPR uint32_t get_BW_CH_SEL_EN() const - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 10); - return value; - } - uint32_t get_BW_CH_SEL_EN() const volatile - { - uint32_t value = ((1U << 1) - 1) & (word0 >> 10); - return value; - } - CONSTEXPR pmcaxi_chan_r &set_BW_CH_SEL_EN(uint32_t value) - { - word0 = (((~((1U << 1) - 1)) << 10) & word0) | ((((1U << 1) - 1) & value) << 10); - return *this; - } - volatile pmcaxi_chan_r &set_BW_CH_SEL_EN(uint32_t value) volatile - { - word0 = (((~((1U << 1) - 1)) << 10) & word0) | ((((1U << 1) - 1) & value) << 10); - return *this; - } -#endif -}; - -// kernel_x_r - Kernel X offset of in kernel decomposition -struct kernel_x_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR kernel_x_r() : word0(0) {} - CONSTEXPR kernel_x_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - kernel_x_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR kernel_x_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile kernel_x_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// kernel_y_r - Kernel Y offset of in kernel decomposition -struct kernel_y_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR kernel_y_r() : word0(0) {} - CONSTEXPR kernel_y_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - kernel_y_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR kernel_y_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile kernel_y_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// kernel_w_m1_r - Kernel (width-1) of current block -struct kernel_w_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR kernel_w_m1_r() : word0(0) {} - CONSTEXPR kernel_w_m1_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - kernel_w_m1_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR kernel_w_m1_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile kernel_w_m1_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// kernel_h_m1_r - Kernel (height-1) of current block -struct kernel_h_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR kernel_h_m1_r() : word0(0) {} - CONSTEXPR kernel_h_m1_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - kernel_h_m1_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR kernel_h_m1_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile kernel_h_m1_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ofm_cblk_width_m1_r - OFM current block (width-1) -struct ofm_cblk_width_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ofm_cblk_width_m1_r() : word0(0) {} - CONSTEXPR ofm_cblk_width_m1_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ofm_cblk_width_m1_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ofm_cblk_width_m1_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ofm_cblk_width_m1_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ofm_cblk_height_m1_r - OFM current block (height-1) -struct ofm_cblk_height_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ofm_cblk_height_m1_r() : word0(0) {} - CONSTEXPR ofm_cblk_height_m1_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ofm_cblk_height_m1_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ofm_cblk_height_m1_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ofm_cblk_height_m1_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ofm_cblk_depth_m1_r - OFM current block (depth-1) -struct ofm_cblk_depth_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ofm_cblk_depth_m1_r() : word0(0) {} - CONSTEXPR ofm_cblk_depth_m1_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ofm_cblk_depth_m1_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ofm_cblk_depth_m1_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ofm_cblk_depth_m1_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ifm_cblk_depth_m1_r - IFM current block (depth-1) -struct ifm_cblk_depth_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ifm_cblk_depth_m1_r() : word0(0) {} - CONSTEXPR ifm_cblk_depth_m1_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ifm_cblk_depth_m1_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ifm_cblk_depth_m1_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ifm_cblk_depth_m1_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ofm_x_r - Block X coordinate in OFM -struct ofm_x_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ofm_x_r() : word0(0) {} - CONSTEXPR ofm_x_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ofm_x_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ofm_x_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ofm_x_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ofm_y_r - Block Y coordinate in OFM -struct ofm_y_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ofm_y_r() : word0(0) {} - CONSTEXPR ofm_y_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ofm_y_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ofm_y_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ofm_y_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ofm_z_r - Block Z (channel) coordinate in OFM -struct ofm_z_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ofm_z_r() : word0(0) {} - CONSTEXPR ofm_z_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ofm_z_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ofm_z_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ofm_z_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ifm_z_r - Block Z (channel) coordinate in IFM -struct ifm_z_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ifm_z_r() : word0(0) {} - CONSTEXPR ifm_z_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ifm_z_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ifm_z_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ifm_z_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// pad_top_r - Block top pad -struct pad_top_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR pad_top_r() : word0(0) {} - CONSTEXPR pad_top_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - pad_top_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR pad_top_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile pad_top_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// pad_left_r - Block left pad -struct pad_left_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR pad_left_r() : word0(0) {} - CONSTEXPR pad_left_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - pad_left_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR pad_left_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile pad_left_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ifm_cblk_width_r - IFM current block derived width -struct ifm_cblk_width_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ifm_cblk_width_r() : word0(0) {} - CONSTEXPR ifm_cblk_width_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ifm_cblk_width_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ifm_cblk_width_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ifm_cblk_width_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ifm_cblk_height_r - IFM current block derived height -struct ifm_cblk_height_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ifm_cblk_height_r() : word0(0) {} - CONSTEXPR ifm_cblk_height_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ifm_cblk_height_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ifm_cblk_height_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ifm_cblk_height_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// dma_ifm_src_r - DMA IFM channel source position on AXI -struct dma_ifm_src_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t offset_LO : 32; // Offset - LSB - uint32_t offset_HI : 8; // Offset - MSB - uint32_t reserved0 : 24; - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR dma_ifm_src_r() : word0(0), word1(0) {} - CONSTEXPR dma_ifm_src_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - dma_ifm_src_r copy() volatile - { - return *this; - } -#endif -}; - -// dma_ifm_dst_r - DMA IFM channel destination position in SHRAM -struct dma_ifm_dst_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR dma_ifm_dst_r() : word0(0) {} - CONSTEXPR dma_ifm_dst_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - dma_ifm_dst_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR dma_ifm_dst_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile dma_ifm_dst_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// dma_ofm_src_r - DMA OFM channel source position in SHRAM -struct dma_ofm_src_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR dma_ofm_src_r() : word0(0) {} - CONSTEXPR dma_ofm_src_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - dma_ofm_src_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR dma_ofm_src_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile dma_ofm_src_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// dma_ofm_dst_r - DMA OFM channel destination position on AXI -struct dma_ofm_dst_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t offset_LO : 32; // Offset - LSB - uint32_t offset_HI : 8; // Offset - MSB - uint32_t reserved0 : 24; - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR dma_ofm_dst_r() : word0(0), word1(0) {} - CONSTEXPR dma_ofm_dst_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - dma_ofm_dst_r copy() volatile - { - return *this; - } -#endif -}; - -// dma_weight_src_r - DMA weight channel source position on AXI -struct dma_weight_src_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t offset_LO : 32; // Offset - LSB - uint32_t offset_HI : 8; // Offset - MSB - uint32_t reserved0 : 24; - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR dma_weight_src_r() : word0(0), word1(0) {} - CONSTEXPR dma_weight_src_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - dma_weight_src_r copy() volatile - { - return *this; - } -#endif -}; - -// dma_cmd_src_r - DMA command channel source position on AXI -struct dma_cmd_src_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t offset_LO : 32; // Offset - LSB - uint32_t offset_HI : 8; // Offset - MSB - uint32_t reserved0 : 24; - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR dma_cmd_src_r() : word0(0), word1(0) {} - CONSTEXPR dma_cmd_src_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - dma_cmd_src_r copy() volatile - { - return *this; - } -#endif -}; - -// dma_cmd_size_r - DMA command channel number of bytes buffered -struct dma_cmd_size_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR dma_cmd_size_r() : word0(0) {} - CONSTEXPR dma_cmd_size_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - dma_cmd_size_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR dma_cmd_size_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile dma_cmd_size_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// dma_m2m_src_r - DMA memory to memory source position on AXI -struct dma_m2m_src_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t offset_LO : 32; // Offset - LSB - uint32_t offset_HI : 8; // Offset - MSB - uint32_t reserved0 : 24; - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR dma_m2m_src_r() : word0(0), word1(0) {} - CONSTEXPR dma_m2m_src_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - dma_m2m_src_r copy() volatile - { - return *this; - } -#endif -}; - -// dma_m2m_dst_r - DMA memory to memory destination position on AXI -struct dma_m2m_dst_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t offset_LO : 32; // Offset - LSB - uint32_t offset_HI : 8; // Offset - MSB - uint32_t reserved0 : 24; - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR dma_m2m_dst_r() : word0(0), word1(0) {} - CONSTEXPR dma_m2m_dst_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - dma_m2m_dst_r copy() volatile - { - return *this; - } -#endif -}; - -// current_qread_r - QREAD position being issued (rather than completed) -struct current_qread_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR current_qread_r() : word0(0) {} - CONSTEXPR current_qread_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - current_qread_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR current_qread_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile current_qread_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// dma_scale_src_r - DMA scale and bias channel source position on AXI -struct dma_scale_src_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t offset_LO : 32; // Offset - LSB - uint32_t offset_HI : 8; // Offset - MSB - uint32_t reserved0 : 24; - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR dma_scale_src_r() : word0(0), word1(0) {} - CONSTEXPR dma_scale_src_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - dma_scale_src_r copy() volatile - { - return *this; - } -#endif -}; - -// current_block_r - 0-3. Current block bank being executed by the TSU or last one executed if TSU is stopped -struct current_block_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR current_block_r() : word0(0) {} - CONSTEXPR current_block_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - current_block_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR current_block_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile current_block_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// current_op_r - Current NPU OP command being executed by the TSU -struct current_op_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR current_op_r() : word0(0) {} - CONSTEXPR current_op_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - current_op_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR current_op_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile current_op_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// current_cmd_r - Current 32-bit command being parsed by the command stream parser -struct current_cmd_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR current_cmd_r() : word0(0) {} - CONSTEXPR current_cmd_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - current_cmd_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR current_cmd_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile current_cmd_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// pmevcntr_r - Performance monitor event 0 count register -struct pmevcntr_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t count : 32; // Count word - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR pmevcntr_r() : word0(0) {} - CONSTEXPR pmevcntr_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - pmevcntr_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_count() const - { - uint32_t value = word0; - return value; - } - uint32_t get_count() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR pmevcntr_r &set_count(uint32_t value) - { - word0 = value; - return *this; - } - volatile pmevcntr_r &set_count(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// pmevtyper_r - Performance monitor event type register 0 -struct pmevtyper_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t EV_TYPE : 10; // Event Type - uint32_t reserved0 : 22; - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR pmevtyper_r() : word0(0) {} - CONSTEXPR pmevtyper_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - pmevtyper_r copy() volatile - { - return *this; - } - CONSTEXPR NPU_NAMESPACE::pmu_event get_EV_TYPE() const - { - NPU_NAMESPACE::pmu_event value = static_cast(((1U << 10) - 1) & (word0 >> 0)); - return value; - } - NPU_NAMESPACE::pmu_event get_EV_TYPE() const volatile - { - NPU_NAMESPACE::pmu_event value = static_cast(((1U << 10) - 1) & (word0 >> 0)); - return value; - } - CONSTEXPR pmevtyper_r &set_EV_TYPE(NPU_NAMESPACE::pmu_event value) - { - word0 = (((~((1U << 10) - 1)) << 0) & word0) | ((((1U << 10) - 1) & static_cast(value)) << 0); - return *this; - } - volatile pmevtyper_r &set_EV_TYPE(NPU_NAMESPACE::pmu_event value) volatile - { - word0 = (((~((1U << 10) - 1)) << 0) & word0) | ((((1U << 10) - 1) & static_cast(value)) << 0); - return *this; - } -#endif -}; - -// shared_buffer_r - Shared buffer debug access. Only valid in STOPPED state -struct shared_buffer_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t mem_word : 32; // Memory word - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR shared_buffer_r() : word0(0) {} - CONSTEXPR shared_buffer_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - shared_buffer_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_mem_word() const - { - uint32_t value = word0; - return value; - } - uint32_t get_mem_word() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR shared_buffer_r &set_mem_word(uint32_t value) - { - word0 = value; - return *this; - } - volatile shared_buffer_r &set_mem_word(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ifm_pad_top_r - None -struct ifm_pad_top_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ifm_pad_top_r() : word0(0) {} - CONSTEXPR ifm_pad_top_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ifm_pad_top_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ifm_pad_top_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ifm_pad_top_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ifm_pad_left_r - None -struct ifm_pad_left_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ifm_pad_left_r() : word0(0) {} - CONSTEXPR ifm_pad_left_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ifm_pad_left_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ifm_pad_left_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ifm_pad_left_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ifm_pad_right_r - None -struct ifm_pad_right_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ifm_pad_right_r() : word0(0) {} - CONSTEXPR ifm_pad_right_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ifm_pad_right_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ifm_pad_right_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ifm_pad_right_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ifm_pad_bottom_r - None -struct ifm_pad_bottom_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ifm_pad_bottom_r() : word0(0) {} - CONSTEXPR ifm_pad_bottom_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ifm_pad_bottom_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ifm_pad_bottom_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ifm_pad_bottom_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ifm_depth_m1_r - None -struct ifm_depth_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ifm_depth_m1_r() : word0(0) {} - CONSTEXPR ifm_depth_m1_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ifm_depth_m1_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ifm_depth_m1_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ifm_depth_m1_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ifm_precision_r - None -struct ifm_precision_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ifm_precision_r() : word0(0) {} - CONSTEXPR ifm_precision_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ifm_precision_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ifm_precision_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ifm_precision_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ifm_upscale_r - None -struct ifm_upscale_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ifm_upscale_r() : word0(0) {} - CONSTEXPR ifm_upscale_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ifm_upscale_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ifm_upscale_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ifm_upscale_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ifm_zero_point_r - None -struct ifm_zero_point_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ifm_zero_point_r() : word0(0) {} - CONSTEXPR ifm_zero_point_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ifm_zero_point_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ifm_zero_point_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ifm_zero_point_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ifm_width0_m1_r - None -struct ifm_width0_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ifm_width0_m1_r() : word0(0) {} - CONSTEXPR ifm_width0_m1_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ifm_width0_m1_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ifm_width0_m1_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ifm_width0_m1_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ifm_height0_m1_r - None -struct ifm_height0_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ifm_height0_m1_r() : word0(0) {} - CONSTEXPR ifm_height0_m1_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ifm_height0_m1_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ifm_height0_m1_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ifm_height0_m1_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ifm_height1_m1_r - None -struct ifm_height1_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ifm_height1_m1_r() : word0(0) {} - CONSTEXPR ifm_height1_m1_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ifm_height1_m1_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ifm_height1_m1_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ifm_height1_m1_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ifm_ib_end_r - None -struct ifm_ib_end_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ifm_ib_end_r() : word0(0) {} - CONSTEXPR ifm_ib_end_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ifm_ib_end_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ifm_ib_end_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ifm_ib_end_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ifm_region_r - None -struct ifm_region_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ifm_region_r() : word0(0) {} - CONSTEXPR ifm_region_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ifm_region_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ifm_region_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ifm_region_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ofm_width_m1_r - None -struct ofm_width_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ofm_width_m1_r() : word0(0) {} - CONSTEXPR ofm_width_m1_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ofm_width_m1_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ofm_width_m1_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ofm_width_m1_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ofm_height_m1_r - None -struct ofm_height_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ofm_height_m1_r() : word0(0) {} - CONSTEXPR ofm_height_m1_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ofm_height_m1_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ofm_height_m1_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ofm_height_m1_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ofm_depth_m1_r - None -struct ofm_depth_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ofm_depth_m1_r() : word0(0) {} - CONSTEXPR ofm_depth_m1_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ofm_depth_m1_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ofm_depth_m1_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ofm_depth_m1_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ofm_precision_r - None -struct ofm_precision_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ofm_precision_r() : word0(0) {} - CONSTEXPR ofm_precision_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ofm_precision_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ofm_precision_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ofm_precision_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ofm_blk_width_m1_r - None -struct ofm_blk_width_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ofm_blk_width_m1_r() : word0(0) {} - CONSTEXPR ofm_blk_width_m1_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ofm_blk_width_m1_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ofm_blk_width_m1_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ofm_blk_width_m1_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ofm_blk_height_m1_r - None -struct ofm_blk_height_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ofm_blk_height_m1_r() : word0(0) {} - CONSTEXPR ofm_blk_height_m1_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ofm_blk_height_m1_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ofm_blk_height_m1_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ofm_blk_height_m1_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ofm_blk_depth_m1_r - None -struct ofm_blk_depth_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ofm_blk_depth_m1_r() : word0(0) {} - CONSTEXPR ofm_blk_depth_m1_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ofm_blk_depth_m1_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ofm_blk_depth_m1_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ofm_blk_depth_m1_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ofm_zero_point_r - None -struct ofm_zero_point_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ofm_zero_point_r() : word0(0) {} - CONSTEXPR ofm_zero_point_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ofm_zero_point_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ofm_zero_point_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ofm_zero_point_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ofm_width0_m1_r - None -struct ofm_width0_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ofm_width0_m1_r() : word0(0) {} - CONSTEXPR ofm_width0_m1_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ofm_width0_m1_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ofm_width0_m1_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ofm_width0_m1_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ofm_height0_m1_r - None -struct ofm_height0_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ofm_height0_m1_r() : word0(0) {} - CONSTEXPR ofm_height0_m1_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ofm_height0_m1_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ofm_height0_m1_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ofm_height0_m1_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ofm_height1_m1_r - None -struct ofm_height1_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ofm_height1_m1_r() : word0(0) {} - CONSTEXPR ofm_height1_m1_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ofm_height1_m1_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ofm_height1_m1_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ofm_height1_m1_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ofm_region_r - None -struct ofm_region_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ofm_region_r() : word0(0) {} - CONSTEXPR ofm_region_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ofm_region_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ofm_region_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ofm_region_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// kernel_width_m1_r - None -struct kernel_width_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR kernel_width_m1_r() : word0(0) {} - CONSTEXPR kernel_width_m1_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - kernel_width_m1_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR kernel_width_m1_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile kernel_width_m1_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// kernel_height_m1_r - None -struct kernel_height_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR kernel_height_m1_r() : word0(0) {} - CONSTEXPR kernel_height_m1_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - kernel_height_m1_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR kernel_height_m1_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile kernel_height_m1_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// kernel_stride_r - None -struct kernel_stride_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR kernel_stride_r() : word0(0) {} - CONSTEXPR kernel_stride_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - kernel_stride_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR kernel_stride_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile kernel_stride_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// parallel_mode_r - None -struct parallel_mode_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR parallel_mode_r() : word0(0) {} - CONSTEXPR parallel_mode_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - parallel_mode_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR parallel_mode_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile parallel_mode_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// acc_format_r - None -struct acc_format_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR acc_format_r() : word0(0) {} - CONSTEXPR acc_format_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - acc_format_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR acc_format_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile acc_format_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// activation_r - None -struct activation_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR activation_r() : word0(0) {} - CONSTEXPR activation_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - activation_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR activation_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile activation_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// activation_min_r - None -struct activation_min_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR activation_min_r() : word0(0) {} - CONSTEXPR activation_min_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - activation_min_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR activation_min_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile activation_min_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// activation_max_r - None -struct activation_max_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR activation_max_r() : word0(0) {} - CONSTEXPR activation_max_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - activation_max_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR activation_max_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile activation_max_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// weight_region_r - None -struct weight_region_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR weight_region_r() : word0(0) {} - CONSTEXPR weight_region_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - weight_region_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR weight_region_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile weight_region_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// scale_region_r - None -struct scale_region_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR scale_region_r() : word0(0) {} - CONSTEXPR scale_region_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - scale_region_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR scale_region_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile scale_region_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ab_start_r - None -struct ab_start_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ab_start_r() : word0(0) {} - CONSTEXPR ab_start_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ab_start_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ab_start_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ab_start_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// blockdep_r - None -struct blockdep_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR blockdep_r() : word0(0) {} - CONSTEXPR blockdep_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - blockdep_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR blockdep_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile blockdep_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// dma0_src_region_r - None -struct dma0_src_region_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR dma0_src_region_r() : word0(0) {} - CONSTEXPR dma0_src_region_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - dma0_src_region_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR dma0_src_region_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile dma0_src_region_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// dma0_dst_region_r - None -struct dma0_dst_region_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR dma0_dst_region_r() : word0(0) {} - CONSTEXPR dma0_dst_region_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - dma0_dst_region_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR dma0_dst_region_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile dma0_dst_region_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// dma0_size0_r - None -struct dma0_size0_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR dma0_size0_r() : word0(0) {} - CONSTEXPR dma0_size0_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - dma0_size0_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR dma0_size0_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile dma0_size0_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// dma0_size1_r - None -struct dma0_size1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR dma0_size1_r() : word0(0) {} - CONSTEXPR dma0_size1_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - dma0_size1_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR dma0_size1_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile dma0_size1_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ifm2_broadcast_r - None -struct ifm2_broadcast_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ifm2_broadcast_r() : word0(0) {} - CONSTEXPR ifm2_broadcast_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ifm2_broadcast_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ifm2_broadcast_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ifm2_broadcast_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ifm2_scalar_r - None -struct ifm2_scalar_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ifm2_scalar_r() : word0(0) {} - CONSTEXPR ifm2_scalar_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ifm2_scalar_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ifm2_scalar_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ifm2_scalar_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ifm2_precision_r - None -struct ifm2_precision_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ifm2_precision_r() : word0(0) {} - CONSTEXPR ifm2_precision_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ifm2_precision_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ifm2_precision_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ifm2_precision_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ifm2_zero_point_r - None -struct ifm2_zero_point_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ifm2_zero_point_r() : word0(0) {} - CONSTEXPR ifm2_zero_point_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ifm2_zero_point_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ifm2_zero_point_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ifm2_zero_point_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ifm2_width0_m1_r - None -struct ifm2_width0_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ifm2_width0_m1_r() : word0(0) {} - CONSTEXPR ifm2_width0_m1_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ifm2_width0_m1_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ifm2_width0_m1_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ifm2_width0_m1_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ifm2_height0_m1_r - None -struct ifm2_height0_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ifm2_height0_m1_r() : word0(0) {} - CONSTEXPR ifm2_height0_m1_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ifm2_height0_m1_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ifm2_height0_m1_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ifm2_height0_m1_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ifm2_height1_m1_r - None -struct ifm2_height1_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ifm2_height1_m1_r() : word0(0) {} - CONSTEXPR ifm2_height1_m1_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ifm2_height1_m1_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ifm2_height1_m1_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ifm2_height1_m1_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ifm2_ib_start_r - None -struct ifm2_ib_start_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ifm2_ib_start_r() : word0(0) {} - CONSTEXPR ifm2_ib_start_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ifm2_ib_start_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ifm2_ib_start_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ifm2_ib_start_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ifm2_region_r - None -struct ifm2_region_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ifm2_region_r() : word0(0) {} - CONSTEXPR ifm2_region_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ifm2_region_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ifm2_region_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ifm2_region_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ifm_base0_r - None -struct ifm_base0_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR ifm_base0_r() : word0(0), word1(0) {} - CONSTEXPR ifm_base0_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - ifm_base0_r copy() volatile - { - return *this; - } -#endif -}; - -// ifm_base1_r - None -struct ifm_base1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR ifm_base1_r() : word0(0), word1(0) {} - CONSTEXPR ifm_base1_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - ifm_base1_r copy() volatile - { - return *this; - } -#endif -}; - -// ifm_base2_r - None -struct ifm_base2_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR ifm_base2_r() : word0(0), word1(0) {} - CONSTEXPR ifm_base2_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - ifm_base2_r copy() volatile - { - return *this; - } -#endif -}; - -// ifm_base3_r - None -struct ifm_base3_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR ifm_base3_r() : word0(0), word1(0) {} - CONSTEXPR ifm_base3_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - ifm_base3_r copy() volatile - { - return *this; - } -#endif -}; - -// ifm_stride_x_r - None -struct ifm_stride_x_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR ifm_stride_x_r() : word0(0), word1(0) {} - CONSTEXPR ifm_stride_x_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - ifm_stride_x_r copy() volatile - { - return *this; - } -#endif -}; - -// ifm_stride_y_r - None -struct ifm_stride_y_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR ifm_stride_y_r() : word0(0), word1(0) {} - CONSTEXPR ifm_stride_y_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - ifm_stride_y_r copy() volatile - { - return *this; - } -#endif -}; - -// ifm_stride_c_r - None -struct ifm_stride_c_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR ifm_stride_c_r() : word0(0), word1(0) {} - CONSTEXPR ifm_stride_c_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - ifm_stride_c_r copy() volatile - { - return *this; - } -#endif -}; - -// ofm_base0_r - None -struct ofm_base0_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR ofm_base0_r() : word0(0), word1(0) {} - CONSTEXPR ofm_base0_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - ofm_base0_r copy() volatile - { - return *this; - } -#endif -}; - -// ofm_base1_r - None -struct ofm_base1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR ofm_base1_r() : word0(0), word1(0) {} - CONSTEXPR ofm_base1_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - ofm_base1_r copy() volatile - { - return *this; - } -#endif -}; - -// ofm_base2_r - None -struct ofm_base2_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR ofm_base2_r() : word0(0), word1(0) {} - CONSTEXPR ofm_base2_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - ofm_base2_r copy() volatile - { - return *this; - } -#endif -}; - -// ofm_base3_r - None -struct ofm_base3_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR ofm_base3_r() : word0(0), word1(0) {} - CONSTEXPR ofm_base3_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - ofm_base3_r copy() volatile - { - return *this; - } -#endif -}; - -// ofm_stride_x_r - None -struct ofm_stride_x_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR ofm_stride_x_r() : word0(0), word1(0) {} - CONSTEXPR ofm_stride_x_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - ofm_stride_x_r copy() volatile - { - return *this; - } -#endif -}; - -// ofm_stride_y_r - None -struct ofm_stride_y_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR ofm_stride_y_r() : word0(0), word1(0) {} - CONSTEXPR ofm_stride_y_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - ofm_stride_y_r copy() volatile - { - return *this; - } -#endif -}; - -// ofm_stride_c_r - None -struct ofm_stride_c_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR ofm_stride_c_r() : word0(0), word1(0) {} - CONSTEXPR ofm_stride_c_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - ofm_stride_c_r copy() volatile - { - return *this; - } -#endif -}; - -// weight_base_r - None -struct weight_base_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR weight_base_r() : word0(0), word1(0) {} - CONSTEXPR weight_base_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - weight_base_r copy() volatile - { - return *this; - } -#endif -}; - -// weight_length_r - None -struct weight_length_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR weight_length_r() : word0(0), word1(0) {} - CONSTEXPR weight_length_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - weight_length_r copy() volatile - { - return *this; - } -#endif -}; - -// scale_base_r - None -struct scale_base_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR scale_base_r() : word0(0), word1(0) {} - CONSTEXPR scale_base_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - scale_base_r copy() volatile - { - return *this; - } -#endif -}; - -// scale_length_r - None -struct scale_length_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR scale_length_r() : word0(0), word1(0) {} - CONSTEXPR scale_length_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - scale_length_r copy() volatile - { - return *this; - } -#endif -}; - -// ofm_scale_r - None -struct ofm_scale_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ofm_scale_r() : word0(0) {} - CONSTEXPR ofm_scale_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ofm_scale_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ofm_scale_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ofm_scale_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// ofm_scale_shift_r - None -struct ofm_scale_shift_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR ofm_scale_shift_r() : word0(0) {} - CONSTEXPR ofm_scale_shift_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - ofm_scale_shift_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR ofm_scale_shift_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile ofm_scale_shift_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// opa_scale_r - None -struct opa_scale_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR opa_scale_r() : word0(0) {} - CONSTEXPR opa_scale_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - opa_scale_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR opa_scale_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile opa_scale_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// opa_scale_shift_r - None -struct opa_scale_shift_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR opa_scale_shift_r() : word0(0) {} - CONSTEXPR opa_scale_shift_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - opa_scale_shift_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR opa_scale_shift_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile opa_scale_shift_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// opb_scale_r - None -struct opb_scale_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR opb_scale_r() : word0(0) {} - CONSTEXPR opb_scale_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - opb_scale_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR opb_scale_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile opb_scale_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// dma0_src_r - None -struct dma0_src_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR dma0_src_r() : word0(0), word1(0) {} - CONSTEXPR dma0_src_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - dma0_src_r copy() volatile - { - return *this; - } -#endif -}; - -// dma0_dst_r - None -struct dma0_dst_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR dma0_dst_r() : word0(0), word1(0) {} - CONSTEXPR dma0_dst_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - dma0_dst_r copy() volatile - { - return *this; - } -#endif -}; - -// dma0_len_r - None -struct dma0_len_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR dma0_len_r() : word0(0), word1(0) {} - CONSTEXPR dma0_len_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - dma0_len_r copy() volatile - { - return *this; - } -#endif -}; - -// dma0_skip0_r - None -struct dma0_skip0_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR dma0_skip0_r() : word0(0), word1(0) {} - CONSTEXPR dma0_skip0_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - dma0_skip0_r copy() volatile - { - return *this; - } -#endif -}; - -// dma0_skip1_r - None -struct dma0_skip1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR dma0_skip1_r() : word0(0), word1(0) {} - CONSTEXPR dma0_skip1_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - dma0_skip1_r copy() volatile - { - return *this; - } -#endif -}; - -// ifm2_base0_r - None -struct ifm2_base0_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR ifm2_base0_r() : word0(0), word1(0) {} - CONSTEXPR ifm2_base0_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - ifm2_base0_r copy() volatile - { - return *this; - } -#endif -}; - -// ifm2_base1_r - None -struct ifm2_base1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR ifm2_base1_r() : word0(0), word1(0) {} - CONSTEXPR ifm2_base1_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - ifm2_base1_r copy() volatile - { - return *this; - } -#endif -}; - -// ifm2_base2_r - None -struct ifm2_base2_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR ifm2_base2_r() : word0(0), word1(0) {} - CONSTEXPR ifm2_base2_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - ifm2_base2_r copy() volatile - { - return *this; - } -#endif -}; - -// ifm2_base3_r - None -struct ifm2_base3_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR ifm2_base3_r() : word0(0), word1(0) {} - CONSTEXPR ifm2_base3_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - ifm2_base3_r copy() volatile - { - return *this; - } -#endif -}; - -// ifm2_stride_x_r - None -struct ifm2_stride_x_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR ifm2_stride_x_r() : word0(0), word1(0) {} - CONSTEXPR ifm2_stride_x_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - ifm2_stride_x_r copy() volatile - { - return *this; - } -#endif -}; - -// ifm2_stride_y_r - None -struct ifm2_stride_y_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR ifm2_stride_y_r() : word0(0), word1(0) {} - CONSTEXPR ifm2_stride_y_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - ifm2_stride_y_r copy() volatile - { - return *this; - } -#endif -}; - -// ifm2_stride_c_r - None -struct ifm2_stride_c_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR ifm2_stride_c_r() : word0(0), word1(0) {} - CONSTEXPR ifm2_stride_c_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - ifm2_stride_c_r copy() volatile - { - return *this; - } -#endif -}; - -// weight1_base_r - None -struct weight1_base_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR weight1_base_r() : word0(0), word1(0) {} - CONSTEXPR weight1_base_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - weight1_base_r copy() volatile - { - return *this; - } -#endif -}; - -// weight1_length_r - None -struct weight1_length_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR weight1_length_r() : word0(0), word1(0) {} - CONSTEXPR weight1_length_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - weight1_length_r copy() volatile - { - return *this; - } -#endif -}; - -// scale1_base_r - None -struct scale1_base_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR scale1_base_r() : word0(0), word1(0) {} - CONSTEXPR scale1_base_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - scale1_base_r copy() volatile - { - return *this; - } -#endif -}; - -// scale1_length_r - None -struct scale1_length_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else - private: - uint32_t word0; - uint32_t word1; - - public: - CONSTEXPR scale1_length_r() : word0(0), word1(0) {} - CONSTEXPR scale1_length_r(uint64_t init) : - word0(static_cast((init)&std::numeric_limits::max())), - word1(static_cast((init >> 32) & std::numeric_limits::max())) - { - } - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - void operator=(uint64_t value) volatile - { - word0 = static_cast((value)&std::numeric_limits::max()); - word1 = static_cast((value >> 32) & std::numeric_limits::max()); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - operator uint64_t() volatile - { - return (static_cast(word1) << 32) | word0; - } - scale1_length_r copy() volatile - { - return *this; - } -#endif -}; - -// revision_r - Internal FPGA build revision: first 32-bits of the Ultan Git hash used for the build -struct revision_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR revision_r() : word0(0) {} - CONSTEXPR revision_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - revision_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - uint32_t value = word0; - return value; - } - uint32_t get_value() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR revision_r &set_value(uint32_t value) - { - word0 = value; - return *this; - } - volatile revision_r &set_value(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// pid4_r - Peripheral ID byte 4 (Arm=code 4) -struct pid4_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t PID4 : 32; // Byte 4 of Peripheral ID (Lower 8 bits valid) - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR pid4_r() : word0(4) {} - CONSTEXPR pid4_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - pid4_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_PID4() const - { - uint32_t value = word0; - return value; - } - uint32_t get_PID4() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR pid4_r &set_PID4(uint32_t value) - { - word0 = value; - return *this; - } - volatile pid4_r &set_PID4(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// pid5_r - Peripheral ID byte 5 (reserved) -struct pid5_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t PID5 : 32; // Byte 5 of Peripheral ID (Lower 8 bits valid) - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR pid5_r() : word0(0) {} - CONSTEXPR pid5_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - pid5_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_PID5() const - { - uint32_t value = word0; - return value; - } - uint32_t get_PID5() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR pid5_r &set_PID5(uint32_t value) - { - word0 = value; - return *this; - } - volatile pid5_r &set_PID5(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// pid6_r - Peripheral ID byte 6 (reserved) -struct pid6_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t PID6 : 32; // Byte 6 of Peripheral ID (Lower 8 bits valid) - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR pid6_r() : word0(0) {} - CONSTEXPR pid6_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - pid6_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_PID6() const - { - uint32_t value = word0; - return value; - } - uint32_t get_PID6() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR pid6_r &set_PID6(uint32_t value) - { - word0 = value; - return *this; - } - volatile pid6_r &set_PID6(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// pid7_r - Peripheral ID byte 7 (reserved) -struct pid7_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t PID7 : 32; // Byte 7 of Peripheral ID (Lower 8 bits valid) - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR pid7_r() : word0(0) {} - CONSTEXPR pid7_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - pid7_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_PID7() const - { - uint32_t value = word0; - return value; - } - uint32_t get_PID7() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR pid7_r &set_PID7(uint32_t value) - { - word0 = value; - return *this; - } - volatile pid7_r &set_PID7(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// pid0_r - Peripheral ID byte 0. This is bits[7:0] of the part number -struct pid0_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t PID0 : 32; // Byte 0 of Peripheral ID (Lower 8 bits valid) - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR pid0_r() : word0(129) {} - CONSTEXPR pid0_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - pid0_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_PID0() const - { - uint32_t value = word0; - return value; - } - uint32_t get_PID0() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR pid0_r &set_PID0(uint32_t value) - { - word0 = value; - return *this; - } - volatile pid0_r &set_PID0(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// pid1_r - Peripheral ID byte 1. This is bits[11:8] of the part number in bits[3:0], and bits[3:0] of the Arm ID in -// bits[7:4] -struct pid1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t PID1 : 32; // Byte 1 of Peripheral ID (Lower 8 bits valid) - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR pid1_r() : word0(181) {} - CONSTEXPR pid1_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - pid1_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_PID1() const - { - uint32_t value = word0; - return value; - } - uint32_t get_PID1() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR pid1_r &set_PID1(uint32_t value) - { - word0 = value; - return *this; - } - volatile pid1_r &set_PID1(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// pid2_r - Peripheral ID byte 2. This is bits[6:4] of the Arm ID in bits[2:0], and bit 3 indicates format B -struct pid2_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t PID2 : 32; // Byte 2 of Peripheral ID (Lower 8 bits valid) - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR pid2_r() : word0(11) {} - CONSTEXPR pid2_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - pid2_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_PID2() const - { - uint32_t value = word0; - return value; - } - uint32_t get_PID2() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR pid2_r &set_PID2(uint32_t value) - { - word0 = value; - return *this; - } - volatile pid2_r &set_PID2(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// pid3_r - Peripheral ID byte 3 -struct pid3_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t PID3 : 32; // Byte 1 of Peripheral ID (Lower 8 bits valid) - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR pid3_r() : word0(0) {} - CONSTEXPR pid3_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - pid3_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_PID3() const - { - uint32_t value = word0; - return value; - } - uint32_t get_PID3() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR pid3_r &set_PID3(uint32_t value) - { - word0 = value; - return *this; - } - volatile pid3_r &set_PID3(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// cid0_r - Component ID byte 0 -struct cid0_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t CID0 : 32; // Byte 0 of Component ID (Lower 8 bits valid) - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR cid0_r() : word0(13) {} - CONSTEXPR cid0_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - cid0_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_CID0() const - { - uint32_t value = word0; - return value; - } - uint32_t get_CID0() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR cid0_r &set_CID0(uint32_t value) - { - word0 = value; - return *this; - } - volatile cid0_r &set_CID0(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// cid1_r - Component ID byte 1 -struct cid1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t CID1 : 32; // Byte 1 of Component ID (Lower 8 bits valid) - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR cid1_r() : word0(240) {} - CONSTEXPR cid1_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - cid1_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_CID1() const - { - uint32_t value = word0; - return value; - } - uint32_t get_CID1() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR cid1_r &set_CID1(uint32_t value) - { - word0 = value; - return *this; - } - volatile cid1_r &set_CID1(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// cid2_r - Component ID byte 2 -struct cid2_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t CID2 : 32; // Byte 2 of Component ID (Lower 8 bits valid) - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR cid2_r() : word0(5) {} - CONSTEXPR cid2_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - cid2_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_CID2() const - { - uint32_t value = word0; - return value; - } - uint32_t get_CID2() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR cid2_r &set_CID2(uint32_t value) - { - word0 = value; - return *this; - } - volatile cid2_r &set_CID2(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -// cid3_r - Component ID byte 3 -struct cid3_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t CID3 : 32; // Byte 3 of Component ID (Lower 8 bits valid) - }; - uint32_t word; - }; -#else - private: - uint32_t word0; - - public: - CONSTEXPR cid3_r() : word0(177) {} - CONSTEXPR cid3_r(uint32_t init) : word0(init) {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - void operator=(uint32_t value) volatile - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - operator uint32_t() volatile - { - return word0; - } - cid3_r copy() volatile - { - return *this; - } - CONSTEXPR uint32_t get_CID3() const - { - uint32_t value = word0; - return value; - } - uint32_t get_CID3() const volatile - { - uint32_t value = word0; - return value; - } - CONSTEXPR cid3_r &set_CID3(uint32_t value) - { - word0 = value; - return *this; - } - volatile cid3_r &set_CID3(uint32_t value) volatile - { - word0 = value; - return *this; - } -#endif -}; - -struct NPU_REG -{ - STRUCT id_r ID; // 0x0000 - STRUCT status_r STATUS; // 0x0004 - STRUCT cmd_r CMD; // 0x0008 - STRUCT reset_r RESET; // 0x000C - STRUCT qbase_r QBASE; // 0x0010 - STRUCT qread_r QREAD; // 0x0018 - STRUCT qconfig_r QCONFIG; // 0x001C - STRUCT qsize_r QSIZE; // 0x0020 - STRUCT prot_r PROT; // 0x0024 - STRUCT config_r CONFIG; // 0x0028 - STRUCT lock_r LOCK; // 0x002C - uint32_t unused0[3]; - STRUCT regioncfg_r REGIONCFG; // 0x003C - STRUCT axi_limit0_r AXI_LIMIT0; // 0x0040 - STRUCT axi_limit1_r AXI_LIMIT1; // 0x0044 - STRUCT axi_limit2_r AXI_LIMIT2; // 0x0048 - STRUCT axi_limit3_r AXI_LIMIT3; // 0x004C - uint32_t unused1[12]; - STRUCT basep_r BASEP[8]; // 0x0080 - uint32_t unused2[16]; - STRUCT wd_status_r WD_STATUS; // 0x0100 - STRUCT mac_status_r MAC_STATUS; // 0x0104 - STRUCT ao_status_r AO_STATUS; // 0x0108 - uint32_t unused3[1]; - STRUCT dma_status0_r DMA_STATUS0; // 0x0110 - STRUCT dma_status1_r DMA_STATUS1; // 0x0114 - uint32_t unused4[10]; - STRUCT clkforce_r CLKFORCE; // 0x0140 - STRUCT debug_address_r DEBUG_ADDRESS; // 0x0144 - STRUCT debug_misc_r DEBUG_MISC; // 0x0148 - STRUCT debugcore_r DEBUGCORE; // 0x014C - STRUCT debug_block_r DEBUG_BLOCK; // 0x0150 - uint32_t unused5[11]; - STRUCT pmcr_r PMCR; // 0x0180 - STRUCT pmcntenset_r PMCNTENSET; // 0x0184 - STRUCT pmcntenclr_r PMCNTENCLR; // 0x0188 - STRUCT pmovsset_r PMOVSSET; // 0x018C - STRUCT pmovsclr_r PMOVSCLR; // 0x0190 - STRUCT pmintset_r PMINTSET; // 0x0194 - STRUCT pmintclr_r PMINTCLR; // 0x0198 - uint32_t unused6[1]; - STRUCT pmccntr_r PMCCNTR; // 0x01A0 - STRUCT pmccntr_cfg_r PMCCNTR_CFG; // 0x01A8 - STRUCT pmcaxi_chan_r PMCAXI_CHAN; // 0x01AC - uint32_t unused7[20]; - STRUCT kernel_x_r KERNEL_X; // 0x0200 - STRUCT kernel_y_r KERNEL_Y; // 0x0204 - STRUCT kernel_w_m1_r KERNEL_W_M1; // 0x0208 - STRUCT kernel_h_m1_r KERNEL_H_M1; // 0x020C - STRUCT ofm_cblk_width_m1_r OFM_CBLK_WIDTH_M1; // 0x0210 - STRUCT ofm_cblk_height_m1_r OFM_CBLK_HEIGHT_M1; // 0x0214 - STRUCT ofm_cblk_depth_m1_r OFM_CBLK_DEPTH_M1; // 0x0218 - STRUCT ifm_cblk_depth_m1_r IFM_CBLK_DEPTH_M1; // 0x021C - STRUCT ofm_x_r OFM_X; // 0x0220 - STRUCT ofm_y_r OFM_Y; // 0x0224 - STRUCT ofm_z_r OFM_Z; // 0x0228 - STRUCT ifm_z_r IFM_Z; // 0x022C - STRUCT pad_top_r PAD_TOP; // 0x0230 - STRUCT pad_left_r PAD_LEFT; // 0x0234 - STRUCT ifm_cblk_width_r IFM_CBLK_WIDTH; // 0x0238 - STRUCT ifm_cblk_height_r IFM_CBLK_HEIGHT; // 0x023C - STRUCT dma_ifm_src_r DMA_IFM_SRC; // 0x0240 - STRUCT dma_ifm_dst_r DMA_IFM_DST; // 0x0248 - STRUCT dma_ofm_src_r DMA_OFM_SRC; // 0x024C - STRUCT dma_ofm_dst_r DMA_OFM_DST; // 0x0250 - STRUCT dma_weight_src_r DMA_WEIGHT_SRC; // 0x0258 - STRUCT dma_cmd_src_r DMA_CMD_SRC; // 0x0260 - STRUCT dma_cmd_size_r DMA_CMD_SIZE; // 0x0268 - STRUCT dma_m2m_src_r DMA_M2M_SRC; // 0x026C - STRUCT dma_m2m_dst_r DMA_M2M_DST; // 0x0274 - STRUCT current_qread_r CURRENT_QREAD; // 0x027C - STRUCT dma_scale_src_r DMA_SCALE_SRC; // 0x0280 - uint32_t unused8[11]; - STRUCT current_block_r CURRENT_BLOCK; // 0x02B4 - STRUCT current_op_r CURRENT_OP; // 0x02B8 - STRUCT current_cmd_r CURRENT_CMD; // 0x02BC - uint32_t unused9[16]; - STRUCT pmevcntr_r PMEVCNTR[4]; // 0x0300 - uint32_t unused10[28]; - STRUCT pmevtyper_r PMEVTYPER[4]; // 0x0380 - uint32_t unused11[28]; - STRUCT shared_buffer_r SHARED_BUFFER[256]; // 0x0400 - STRUCT ifm_pad_top_r IFM_PAD_TOP; // 0x0800 - STRUCT ifm_pad_left_r IFM_PAD_LEFT; // 0x0804 - STRUCT ifm_pad_right_r IFM_PAD_RIGHT; // 0x0808 - STRUCT ifm_pad_bottom_r IFM_PAD_BOTTOM; // 0x080C - STRUCT ifm_depth_m1_r IFM_DEPTH_M1; // 0x0810 - STRUCT ifm_precision_r IFM_PRECISION; // 0x0814 - uint32_t unused12[1]; - STRUCT ifm_upscale_r IFM_UPSCALE; // 0x081C - uint32_t unused13[1]; - STRUCT ifm_zero_point_r IFM_ZERO_POINT; // 0x0824 - STRUCT ifm_width0_m1_r IFM_WIDTH0_M1; // 0x0828 - STRUCT ifm_height0_m1_r IFM_HEIGHT0_M1; // 0x082C - STRUCT ifm_height1_m1_r IFM_HEIGHT1_M1; // 0x0830 - STRUCT ifm_ib_end_r IFM_IB_END; // 0x0834 - uint32_t unused14[1]; - STRUCT ifm_region_r IFM_REGION; // 0x083C - uint32_t unused15[1]; - STRUCT ofm_width_m1_r OFM_WIDTH_M1; // 0x0844 - STRUCT ofm_height_m1_r OFM_HEIGHT_M1; // 0x0848 - STRUCT ofm_depth_m1_r OFM_DEPTH_M1; // 0x084C - STRUCT ofm_precision_r OFM_PRECISION; // 0x0850 - STRUCT ofm_blk_width_m1_r OFM_BLK_WIDTH_M1; // 0x0854 - STRUCT ofm_blk_height_m1_r OFM_BLK_HEIGHT_M1; // 0x0858 - STRUCT ofm_blk_depth_m1_r OFM_BLK_DEPTH_M1; // 0x085C - STRUCT ofm_zero_point_r OFM_ZERO_POINT; // 0x0860 - uint32_t unused16[1]; - STRUCT ofm_width0_m1_r OFM_WIDTH0_M1; // 0x0868 - STRUCT ofm_height0_m1_r OFM_HEIGHT0_M1; // 0x086C - STRUCT ofm_height1_m1_r OFM_HEIGHT1_M1; // 0x0870 - uint32_t unused17[2]; - STRUCT ofm_region_r OFM_REGION; // 0x087C - STRUCT kernel_width_m1_r KERNEL_WIDTH_M1; // 0x0880 - STRUCT kernel_height_m1_r KERNEL_HEIGHT_M1; // 0x0884 - STRUCT kernel_stride_r KERNEL_STRIDE; // 0x0888 - STRUCT parallel_mode_r PARALLEL_MODE; // 0x088C - STRUCT acc_format_r ACC_FORMAT; // 0x0890 - STRUCT activation_r ACTIVATION; // 0x0894 - STRUCT activation_min_r ACTIVATION_MIN; // 0x0898 - STRUCT activation_max_r ACTIVATION_MAX; // 0x089C - STRUCT weight_region_r WEIGHT_REGION; // 0x08A0 - STRUCT scale_region_r SCALE_REGION; // 0x08A4 - uint32_t unused18[3]; - STRUCT ab_start_r AB_START; // 0x08B4 - uint32_t unused19[1]; - STRUCT blockdep_r BLOCKDEP; // 0x08BC - STRUCT dma0_src_region_r DMA0_SRC_REGION; // 0x08C0 - STRUCT dma0_dst_region_r DMA0_DST_REGION; // 0x08C4 - STRUCT dma0_size0_r DMA0_SIZE0; // 0x08C8 - STRUCT dma0_size1_r DMA0_SIZE1; // 0x08CC - uint32_t unused20[12]; - STRUCT ifm2_broadcast_r IFM2_BROADCAST; // 0x0900 - STRUCT ifm2_scalar_r IFM2_SCALAR; // 0x0904 - uint32_t unused21[3]; - STRUCT ifm2_precision_r IFM2_PRECISION; // 0x0914 - uint32_t unused22[3]; - STRUCT ifm2_zero_point_r IFM2_ZERO_POINT; // 0x0924 - STRUCT ifm2_width0_m1_r IFM2_WIDTH0_M1; // 0x0928 - STRUCT ifm2_height0_m1_r IFM2_HEIGHT0_M1; // 0x092C - STRUCT ifm2_height1_m1_r IFM2_HEIGHT1_M1; // 0x0930 - STRUCT ifm2_ib_start_r IFM2_IB_START; // 0x0934 - uint32_t unused23[1]; - STRUCT ifm2_region_r IFM2_REGION; // 0x093C - uint32_t unused24[48]; - STRUCT ifm_base0_r IFM_BASE0; // 0x0A00 - STRUCT ifm_base1_r IFM_BASE1; // 0x0A08 - STRUCT ifm_base2_r IFM_BASE2; // 0x0A10 - STRUCT ifm_base3_r IFM_BASE3; // 0x0A18 - STRUCT ifm_stride_x_r IFM_STRIDE_X; // 0x0A20 - STRUCT ifm_stride_y_r IFM_STRIDE_Y; // 0x0A28 - STRUCT ifm_stride_c_r IFM_STRIDE_C; // 0x0A30 - uint32_t unused25[2]; - STRUCT ofm_base0_r OFM_BASE0; // 0x0A40 - STRUCT ofm_base1_r OFM_BASE1; // 0x0A48 - STRUCT ofm_base2_r OFM_BASE2; // 0x0A50 - STRUCT ofm_base3_r OFM_BASE3; // 0x0A58 - STRUCT ofm_stride_x_r OFM_STRIDE_X; // 0x0A60 - STRUCT ofm_stride_y_r OFM_STRIDE_Y; // 0x0A68 - STRUCT ofm_stride_c_r OFM_STRIDE_C; // 0x0A70 - uint32_t unused26[2]; - STRUCT weight_base_r WEIGHT_BASE; // 0x0A80 - STRUCT weight_length_r WEIGHT_LENGTH; // 0x0A88 - STRUCT scale_base_r SCALE_BASE; // 0x0A90 - STRUCT scale_length_r SCALE_LENGTH; // 0x0A98 - STRUCT ofm_scale_r OFM_SCALE; // 0x0AA0 - STRUCT ofm_scale_shift_r OFM_SCALE_SHIFT; // 0x0AA4 - STRUCT opa_scale_r OPA_SCALE; // 0x0AA8 - STRUCT opa_scale_shift_r OPA_SCALE_SHIFT; // 0x0AAC - STRUCT opb_scale_r OPB_SCALE; // 0x0AB0 - uint32_t unused27[3]; - STRUCT dma0_src_r DMA0_SRC; // 0x0AC0 - STRUCT dma0_dst_r DMA0_DST; // 0x0AC8 - STRUCT dma0_len_r DMA0_LEN; // 0x0AD0 - STRUCT dma0_skip0_r DMA0_SKIP0; // 0x0AD8 - STRUCT dma0_skip1_r DMA0_SKIP1; // 0x0AE0 - uint32_t unused28[6]; - STRUCT ifm2_base0_r IFM2_BASE0; // 0x0B00 - STRUCT ifm2_base1_r IFM2_BASE1; // 0x0B08 - STRUCT ifm2_base2_r IFM2_BASE2; // 0x0B10 - STRUCT ifm2_base3_r IFM2_BASE3; // 0x0B18 - STRUCT ifm2_stride_x_r IFM2_STRIDE_X; // 0x0B20 - STRUCT ifm2_stride_y_r IFM2_STRIDE_Y; // 0x0B28 - STRUCT ifm2_stride_c_r IFM2_STRIDE_C; // 0x0B30 - uint32_t unused29[2]; - STRUCT weight1_base_r WEIGHT1_BASE; // 0x0B40 - STRUCT weight1_length_r WEIGHT1_LENGTH; // 0x0B48 - STRUCT scale1_base_r SCALE1_BASE; // 0x0B50 - STRUCT scale1_length_r SCALE1_LENGTH; // 0x0B58 - uint32_t unused30[280]; - STRUCT revision_r REVISION; // 0x0FC0 - uint32_t unused31[3]; - STRUCT pid4_r PID4; // 0x0FD0 - STRUCT pid5_r PID5; // 0x0FD4 - STRUCT pid6_r PID6; // 0x0FD8 - STRUCT pid7_r PID7; // 0x0FDC - STRUCT pid0_r PID0; // 0x0FE0 - STRUCT pid1_r PID1; // 0x0FE4 - STRUCT pid2_r PID2; // 0x0FE8 - STRUCT pid3_r PID3; // 0x0FEC - STRUCT cid0_r CID0; // 0x0FF0 - STRUCT cid1_r CID1; // 0x0FF4 - STRUCT cid2_r CID2; // 0x0FF8 - STRUCT cid3_r CID3; // 0x0FFC - -#ifdef __cplusplus - enum class access_type_t : uint8_t - { - RW, - RO, - WO - }; - NPU_REG() - { - reset(); - } - void reset() - { - ID = 268853249; - STATUS = 8; - CMD = 12; - RESET = 0; - QBASE = 0; - QREAD = 0; - QCONFIG = 0; - QSIZE = 0; - PROT = 0; - CONFIG = 268435456; - LOCK = 0; - REGIONCFG = 0; - AXI_LIMIT0 = 0; - AXI_LIMIT1 = 0; - AXI_LIMIT2 = 0; - AXI_LIMIT3 = 0; - for (size_t i = 0; i < (sizeof(BASEP) / sizeof(BASEP[0])); ++i) - BASEP[i] = 0; - WD_STATUS = 0; - MAC_STATUS = 0; - AO_STATUS = 0; - DMA_STATUS0 = 0; - DMA_STATUS1 = 0; - CLKFORCE = 0; - DEBUG_ADDRESS = 0; - DEBUG_MISC = 0; - DEBUGCORE = 0; - DEBUG_BLOCK = 0; - PMCR = 8192; - PMCNTENSET = 0; - PMCNTENCLR = 0; - PMOVSSET = 0; - PMOVSCLR = 0; - PMINTSET = 0; - PMINTCLR = 0; - PMCCNTR = 0; - PMCCNTR_CFG = 0; - PMCAXI_CHAN = 0; - KERNEL_X = 0; - KERNEL_Y = 0; - KERNEL_W_M1 = 0; - KERNEL_H_M1 = 0; - OFM_CBLK_WIDTH_M1 = 0; - OFM_CBLK_HEIGHT_M1 = 0; - OFM_CBLK_DEPTH_M1 = 0; - IFM_CBLK_DEPTH_M1 = 0; - OFM_X = 0; - OFM_Y = 0; - OFM_Z = 0; - IFM_Z = 0; - PAD_TOP = 0; - PAD_LEFT = 0; - IFM_CBLK_WIDTH = 0; - IFM_CBLK_HEIGHT = 0; - DMA_IFM_SRC = 0; - DMA_IFM_DST = 0; - DMA_OFM_SRC = 0; - DMA_OFM_DST = 0; - DMA_WEIGHT_SRC = 0; - DMA_CMD_SRC = 0; - DMA_CMD_SIZE = 0; - DMA_M2M_SRC = 0; - DMA_M2M_DST = 0; - CURRENT_QREAD = 0; - DMA_SCALE_SRC = 0; - CURRENT_BLOCK = 0; - CURRENT_OP = 0; - CURRENT_CMD = 0; - for (size_t i = 0; i < (sizeof(PMEVCNTR) / sizeof(PMEVCNTR[0])); ++i) - PMEVCNTR[i] = 0; - for (size_t i = 0; i < (sizeof(PMEVTYPER) / sizeof(PMEVTYPER[0])); ++i) - PMEVTYPER[i] = 0; - for (size_t i = 0; i < (sizeof(SHARED_BUFFER) / sizeof(SHARED_BUFFER[0])); ++i) - SHARED_BUFFER[i] = 0; - IFM_PAD_TOP = 0; - IFM_PAD_LEFT = 0; - IFM_PAD_RIGHT = 0; - IFM_PAD_BOTTOM = 0; - IFM_DEPTH_M1 = 0; - IFM_PRECISION = 0; - IFM_UPSCALE = 0; - IFM_ZERO_POINT = 0; - IFM_WIDTH0_M1 = 0; - IFM_HEIGHT0_M1 = 0; - IFM_HEIGHT1_M1 = 0; - IFM_IB_END = 0; - IFM_REGION = 0; - OFM_WIDTH_M1 = 0; - OFM_HEIGHT_M1 = 0; - OFM_DEPTH_M1 = 0; - OFM_PRECISION = 0; - OFM_BLK_WIDTH_M1 = 0; - OFM_BLK_HEIGHT_M1 = 0; - OFM_BLK_DEPTH_M1 = 0; - OFM_ZERO_POINT = 0; - OFM_WIDTH0_M1 = 0; - OFM_HEIGHT0_M1 = 0; - OFM_HEIGHT1_M1 = 0; - OFM_REGION = 0; - KERNEL_WIDTH_M1 = 0; - KERNEL_HEIGHT_M1 = 0; - KERNEL_STRIDE = 0; - PARALLEL_MODE = 0; - ACC_FORMAT = 0; - ACTIVATION = 0; - ACTIVATION_MIN = 0; - ACTIVATION_MAX = 0; - WEIGHT_REGION = 0; - SCALE_REGION = 0; - AB_START = 0; - BLOCKDEP = 0; - DMA0_SRC_REGION = 0; - DMA0_DST_REGION = 0; - DMA0_SIZE0 = 0; - DMA0_SIZE1 = 0; - IFM2_BROADCAST = 0; - IFM2_SCALAR = 0; - IFM2_PRECISION = 0; - IFM2_ZERO_POINT = 0; - IFM2_WIDTH0_M1 = 0; - IFM2_HEIGHT0_M1 = 0; - IFM2_HEIGHT1_M1 = 0; - IFM2_IB_START = 0; - IFM2_REGION = 0; - IFM_BASE0 = 0; - IFM_BASE1 = 0; - IFM_BASE2 = 0; - IFM_BASE3 = 0; - IFM_STRIDE_X = 0; - IFM_STRIDE_Y = 0; - IFM_STRIDE_C = 0; - OFM_BASE0 = 0; - OFM_BASE1 = 0; - OFM_BASE2 = 0; - OFM_BASE3 = 0; - OFM_STRIDE_X = 0; - OFM_STRIDE_Y = 0; - OFM_STRIDE_C = 0; - WEIGHT_BASE = 0; - WEIGHT_LENGTH = 0; - SCALE_BASE = 0; - SCALE_LENGTH = 0; - OFM_SCALE = 0; - OFM_SCALE_SHIFT = 0; - OPA_SCALE = 0; - OPA_SCALE_SHIFT = 0; - OPB_SCALE = 0; - DMA0_SRC = 0; - DMA0_DST = 0; - DMA0_LEN = 0; - DMA0_SKIP0 = 0; - DMA0_SKIP1 = 0; - IFM2_BASE0 = 0; - IFM2_BASE1 = 0; - IFM2_BASE2 = 0; - IFM2_BASE3 = 0; - IFM2_STRIDE_X = 0; - IFM2_STRIDE_Y = 0; - IFM2_STRIDE_C = 0; - WEIGHT1_BASE = 0; - WEIGHT1_LENGTH = 0; - SCALE1_BASE = 0; - SCALE1_LENGTH = 0; - REVISION = 0; - PID4 = 4; - PID5 = 0; - PID6 = 0; - PID7 = 0; - PID0 = 129; - PID1 = 181; - PID2 = 11; - PID3 = 0; - CID0 = 13; - CID1 = 240; - CID2 = 5; - CID3 = 177; - } - uint32_t &operator[](const int addr_offset) - { - return reinterpret_cast(this)[addr_offset / 4]; - } - access_type_t get_access_type(uint32_t offset) - { - switch (offset) - { - case 0: - return access_type_t::RO; - case 4: - return access_type_t::RO; - case 8: - return access_type_t::RW; - case 12: - return access_type_t::RW; - case 16: - return access_type_t::RW; - case 24: - return access_type_t::RO; - case 28: - return access_type_t::RW; - case 32: - return access_type_t::RW; - case 36: - return access_type_t::RO; - case 40: - return access_type_t::RO; - case 44: - return access_type_t::RW; - case 60: - return access_type_t::RW; - case 64: - return access_type_t::RW; - case 68: - return access_type_t::RW; - case 72: - return access_type_t::RW; - case 76: - return access_type_t::RW; - case 128: - return access_type_t::RW; - case 136: - return access_type_t::RW; - case 144: - return access_type_t::RW; - case 152: - return access_type_t::RW; - case 160: - return access_type_t::RW; - case 168: - return access_type_t::RW; - case 176: - return access_type_t::RW; - case 184: - return access_type_t::RW; - case 256: - return access_type_t::RO; - case 260: - return access_type_t::RO; - case 264: - return access_type_t::RO; - case 272: - return access_type_t::RO; - case 276: - return access_type_t::RO; - case 320: - return access_type_t::RW; - case 324: - return access_type_t::RW; - case 328: - return access_type_t::RW; - case 332: - return access_type_t::RW; - case 336: - return access_type_t::RW; - case 384: - return access_type_t::RW; - case 388: - return access_type_t::RW; - case 392: - return access_type_t::RW; - case 396: - return access_type_t::RW; - case 400: - return access_type_t::RW; - case 404: - return access_type_t::RW; - case 408: - return access_type_t::RW; - case 416: - return access_type_t::RW; - case 424: - return access_type_t::RW; - case 428: - return access_type_t::RW; - case 512: - return access_type_t::RO; - case 516: - return access_type_t::RO; - case 520: - return access_type_t::RO; - case 524: - return access_type_t::RO; - case 528: - return access_type_t::RO; - case 532: - return access_type_t::RO; - case 536: - return access_type_t::RO; - case 540: - return access_type_t::RO; - case 544: - return access_type_t::RO; - case 548: - return access_type_t::RO; - case 552: - return access_type_t::RO; - case 556: - return access_type_t::RO; - case 560: - return access_type_t::RO; - case 564: - return access_type_t::RO; - case 568: - return access_type_t::RO; - case 572: - return access_type_t::RO; - case 576: - return access_type_t::RO; - case 584: - return access_type_t::RO; - case 588: - return access_type_t::RO; - case 592: - return access_type_t::RO; - case 600: - return access_type_t::RO; - case 608: - return access_type_t::RO; - case 616: - return access_type_t::RO; - case 620: - return access_type_t::RO; - case 628: - return access_type_t::RO; - case 636: - return access_type_t::RO; - case 640: - return access_type_t::RO; - case 692: - return access_type_t::RO; - case 696: - return access_type_t::RO; - case 700: - return access_type_t::RO; - case 768: - return access_type_t::RW; - case 772: - return access_type_t::RW; - case 776: - return access_type_t::RW; - case 780: - return access_type_t::RW; - case 896: - return access_type_t::RW; - case 900: - return access_type_t::RW; - case 904: - return access_type_t::RW; - case 908: - return access_type_t::RW; - case 1024: - return access_type_t::RW; - case 1028: - return access_type_t::RW; - case 1032: - return access_type_t::RW; - case 1036: - return access_type_t::RW; - case 1040: - return access_type_t::RW; - case 1044: - return access_type_t::RW; - case 1048: - return access_type_t::RW; - case 1052: - return access_type_t::RW; - case 1056: - return access_type_t::RW; - case 1060: - return access_type_t::RW; - case 1064: - return access_type_t::RW; - case 1068: - return access_type_t::RW; - case 1072: - return access_type_t::RW; - case 1076: - return access_type_t::RW; - case 1080: - return access_type_t::RW; - case 1084: - return access_type_t::RW; - case 1088: - return access_type_t::RW; - case 1092: - return access_type_t::RW; - case 1096: - return access_type_t::RW; - case 1100: - return access_type_t::RW; - case 1104: - return access_type_t::RW; - case 1108: - return access_type_t::RW; - case 1112: - return access_type_t::RW; - case 1116: - return access_type_t::RW; - case 1120: - return access_type_t::RW; - case 1124: - return access_type_t::RW; - case 1128: - return access_type_t::RW; - case 1132: - return access_type_t::RW; - case 1136: - return access_type_t::RW; - case 1140: - return access_type_t::RW; - case 1144: - return access_type_t::RW; - case 1148: - return access_type_t::RW; - case 1152: - return access_type_t::RW; - case 1156: - return access_type_t::RW; - case 1160: - return access_type_t::RW; - case 1164: - return access_type_t::RW; - case 1168: - return access_type_t::RW; - case 1172: - return access_type_t::RW; - case 1176: - return access_type_t::RW; - case 1180: - return access_type_t::RW; - case 1184: - return access_type_t::RW; - case 1188: - return access_type_t::RW; - case 1192: - return access_type_t::RW; - case 1196: - return access_type_t::RW; - case 1200: - return access_type_t::RW; - case 1204: - return access_type_t::RW; - case 1208: - return access_type_t::RW; - case 1212: - return access_type_t::RW; - case 1216: - return access_type_t::RW; - case 1220: - return access_type_t::RW; - case 1224: - return access_type_t::RW; - case 1228: - return access_type_t::RW; - case 1232: - return access_type_t::RW; - case 1236: - return access_type_t::RW; - case 1240: - return access_type_t::RW; - case 1244: - return access_type_t::RW; - case 1248: - return access_type_t::RW; - case 1252: - return access_type_t::RW; - case 1256: - return access_type_t::RW; - case 1260: - return access_type_t::RW; - case 1264: - return access_type_t::RW; - case 1268: - return access_type_t::RW; - case 1272: - return access_type_t::RW; - case 1276: - return access_type_t::RW; - case 1280: - return access_type_t::RW; - case 1284: - return access_type_t::RW; - case 1288: - return access_type_t::RW; - case 1292: - return access_type_t::RW; - case 1296: - return access_type_t::RW; - case 1300: - return access_type_t::RW; - case 1304: - return access_type_t::RW; - case 1308: - return access_type_t::RW; - case 1312: - return access_type_t::RW; - case 1316: - return access_type_t::RW; - case 1320: - return access_type_t::RW; - case 1324: - return access_type_t::RW; - case 1328: - return access_type_t::RW; - case 1332: - return access_type_t::RW; - case 1336: - return access_type_t::RW; - case 1340: - return access_type_t::RW; - case 1344: - return access_type_t::RW; - case 1348: - return access_type_t::RW; - case 1352: - return access_type_t::RW; - case 1356: - return access_type_t::RW; - case 1360: - return access_type_t::RW; - case 1364: - return access_type_t::RW; - case 1368: - return access_type_t::RW; - case 1372: - return access_type_t::RW; - case 1376: - return access_type_t::RW; - case 1380: - return access_type_t::RW; - case 1384: - return access_type_t::RW; - case 1388: - return access_type_t::RW; - case 1392: - return access_type_t::RW; - case 1396: - return access_type_t::RW; - case 1400: - return access_type_t::RW; - case 1404: - return access_type_t::RW; - case 1408: - return access_type_t::RW; - case 1412: - return access_type_t::RW; - case 1416: - return access_type_t::RW; - case 1420: - return access_type_t::RW; - case 1424: - return access_type_t::RW; - case 1428: - return access_type_t::RW; - case 1432: - return access_type_t::RW; - case 1436: - return access_type_t::RW; - case 1440: - return access_type_t::RW; - case 1444: - return access_type_t::RW; - case 1448: - return access_type_t::RW; - case 1452: - return access_type_t::RW; - case 1456: - return access_type_t::RW; - case 1460: - return access_type_t::RW; - case 1464: - return access_type_t::RW; - case 1468: - return access_type_t::RW; - case 1472: - return access_type_t::RW; - case 1476: - return access_type_t::RW; - case 1480: - return access_type_t::RW; - case 1484: - return access_type_t::RW; - case 1488: - return access_type_t::RW; - case 1492: - return access_type_t::RW; - case 1496: - return access_type_t::RW; - case 1500: - return access_type_t::RW; - case 1504: - return access_type_t::RW; - case 1508: - return access_type_t::RW; - case 1512: - return access_type_t::RW; - case 1516: - return access_type_t::RW; - case 1520: - return access_type_t::RW; - case 1524: - return access_type_t::RW; - case 1528: - return access_type_t::RW; - case 1532: - return access_type_t::RW; - case 1536: - return access_type_t::RW; - case 1540: - return access_type_t::RW; - case 1544: - return access_type_t::RW; - case 1548: - return access_type_t::RW; - case 1552: - return access_type_t::RW; - case 1556: - return access_type_t::RW; - case 1560: - return access_type_t::RW; - case 1564: - return access_type_t::RW; - case 1568: - return access_type_t::RW; - case 1572: - return access_type_t::RW; - case 1576: - return access_type_t::RW; - case 1580: - return access_type_t::RW; - case 1584: - return access_type_t::RW; - case 1588: - return access_type_t::RW; - case 1592: - return access_type_t::RW; - case 1596: - return access_type_t::RW; - case 1600: - return access_type_t::RW; - case 1604: - return access_type_t::RW; - case 1608: - return access_type_t::RW; - case 1612: - return access_type_t::RW; - case 1616: - return access_type_t::RW; - case 1620: - return access_type_t::RW; - case 1624: - return access_type_t::RW; - case 1628: - return access_type_t::RW; - case 1632: - return access_type_t::RW; - case 1636: - return access_type_t::RW; - case 1640: - return access_type_t::RW; - case 1644: - return access_type_t::RW; - case 1648: - return access_type_t::RW; - case 1652: - return access_type_t::RW; - case 1656: - return access_type_t::RW; - case 1660: - return access_type_t::RW; - case 1664: - return access_type_t::RW; - case 1668: - return access_type_t::RW; - case 1672: - return access_type_t::RW; - case 1676: - return access_type_t::RW; - case 1680: - return access_type_t::RW; - case 1684: - return access_type_t::RW; - case 1688: - return access_type_t::RW; - case 1692: - return access_type_t::RW; - case 1696: - return access_type_t::RW; - case 1700: - return access_type_t::RW; - case 1704: - return access_type_t::RW; - case 1708: - return access_type_t::RW; - case 1712: - return access_type_t::RW; - case 1716: - return access_type_t::RW; - case 1720: - return access_type_t::RW; - case 1724: - return access_type_t::RW; - case 1728: - return access_type_t::RW; - case 1732: - return access_type_t::RW; - case 1736: - return access_type_t::RW; - case 1740: - return access_type_t::RW; - case 1744: - return access_type_t::RW; - case 1748: - return access_type_t::RW; - case 1752: - return access_type_t::RW; - case 1756: - return access_type_t::RW; - case 1760: - return access_type_t::RW; - case 1764: - return access_type_t::RW; - case 1768: - return access_type_t::RW; - case 1772: - return access_type_t::RW; - case 1776: - return access_type_t::RW; - case 1780: - return access_type_t::RW; - case 1784: - return access_type_t::RW; - case 1788: - return access_type_t::RW; - case 1792: - return access_type_t::RW; - case 1796: - return access_type_t::RW; - case 1800: - return access_type_t::RW; - case 1804: - return access_type_t::RW; - case 1808: - return access_type_t::RW; - case 1812: - return access_type_t::RW; - case 1816: - return access_type_t::RW; - case 1820: - return access_type_t::RW; - case 1824: - return access_type_t::RW; - case 1828: - return access_type_t::RW; - case 1832: - return access_type_t::RW; - case 1836: - return access_type_t::RW; - case 1840: - return access_type_t::RW; - case 1844: - return access_type_t::RW; - case 1848: - return access_type_t::RW; - case 1852: - return access_type_t::RW; - case 1856: - return access_type_t::RW; - case 1860: - return access_type_t::RW; - case 1864: - return access_type_t::RW; - case 1868: - return access_type_t::RW; - case 1872: - return access_type_t::RW; - case 1876: - return access_type_t::RW; - case 1880: - return access_type_t::RW; - case 1884: - return access_type_t::RW; - case 1888: - return access_type_t::RW; - case 1892: - return access_type_t::RW; - case 1896: - return access_type_t::RW; - case 1900: - return access_type_t::RW; - case 1904: - return access_type_t::RW; - case 1908: - return access_type_t::RW; - case 1912: - return access_type_t::RW; - case 1916: - return access_type_t::RW; - case 1920: - return access_type_t::RW; - case 1924: - return access_type_t::RW; - case 1928: - return access_type_t::RW; - case 1932: - return access_type_t::RW; - case 1936: - return access_type_t::RW; - case 1940: - return access_type_t::RW; - case 1944: - return access_type_t::RW; - case 1948: - return access_type_t::RW; - case 1952: - return access_type_t::RW; - case 1956: - return access_type_t::RW; - case 1960: - return access_type_t::RW; - case 1964: - return access_type_t::RW; - case 1968: - return access_type_t::RW; - case 1972: - return access_type_t::RW; - case 1976: - return access_type_t::RW; - case 1980: - return access_type_t::RW; - case 1984: - return access_type_t::RW; - case 1988: - return access_type_t::RW; - case 1992: - return access_type_t::RW; - case 1996: - return access_type_t::RW; - case 2000: - return access_type_t::RW; - case 2004: - return access_type_t::RW; - case 2008: - return access_type_t::RW; - case 2012: - return access_type_t::RW; - case 2016: - return access_type_t::RW; - case 2020: - return access_type_t::RW; - case 2024: - return access_type_t::RW; - case 2028: - return access_type_t::RW; - case 2032: - return access_type_t::RW; - case 2036: - return access_type_t::RW; - case 2040: - return access_type_t::RW; - case 2044: - return access_type_t::RW; - case 2048: - return access_type_t::RW; - case 2052: - return access_type_t::RW; - case 2056: - return access_type_t::RW; - case 2060: - return access_type_t::RW; - case 2064: - return access_type_t::RW; - case 2068: - return access_type_t::RW; - case 2076: - return access_type_t::RW; - case 2084: - return access_type_t::RW; - case 2088: - return access_type_t::RW; - case 2092: - return access_type_t::RW; - case 2096: - return access_type_t::RW; - case 2100: - return access_type_t::RW; - case 2108: - return access_type_t::RW; - case 2116: - return access_type_t::RW; - case 2120: - return access_type_t::RW; - case 2124: - return access_type_t::RW; - case 2128: - return access_type_t::RW; - case 2132: - return access_type_t::RW; - case 2136: - return access_type_t::RW; - case 2140: - return access_type_t::RW; - case 2144: - return access_type_t::RW; - case 2152: - return access_type_t::RW; - case 2156: - return access_type_t::RW; - case 2160: - return access_type_t::RW; - case 2172: - return access_type_t::RW; - case 2176: - return access_type_t::RW; - case 2180: - return access_type_t::RW; - case 2184: - return access_type_t::RW; - case 2188: - return access_type_t::RW; - case 2192: - return access_type_t::RW; - case 2196: - return access_type_t::RW; - case 2200: - return access_type_t::RW; - case 2204: - return access_type_t::RW; - case 2208: - return access_type_t::RW; - case 2212: - return access_type_t::RW; - case 2228: - return access_type_t::RW; - case 2236: - return access_type_t::RW; - case 2240: - return access_type_t::RW; - case 2244: - return access_type_t::RW; - case 2248: - return access_type_t::RW; - case 2252: - return access_type_t::RW; - case 2304: - return access_type_t::RW; - case 2308: - return access_type_t::RW; - case 2324: - return access_type_t::RW; - case 2340: - return access_type_t::RW; - case 2344: - return access_type_t::RW; - case 2348: - return access_type_t::RW; - case 2352: - return access_type_t::RW; - case 2356: - return access_type_t::RW; - case 2364: - return access_type_t::RW; - case 2560: - return access_type_t::RW; - case 2568: - return access_type_t::RW; - case 2576: - return access_type_t::RW; - case 2584: - return access_type_t::RW; - case 2592: - return access_type_t::RW; - case 2600: - return access_type_t::RW; - case 2608: - return access_type_t::RW; - case 2624: - return access_type_t::RW; - case 2632: - return access_type_t::RW; - case 2640: - return access_type_t::RW; - case 2648: - return access_type_t::RW; - case 2656: - return access_type_t::RW; - case 2664: - return access_type_t::RW; - case 2672: - return access_type_t::RW; - case 2688: - return access_type_t::RW; - case 2696: - return access_type_t::RW; - case 2704: - return access_type_t::RW; - case 2712: - return access_type_t::RW; - case 2720: - return access_type_t::RW; - case 2724: - return access_type_t::RW; - case 2728: - return access_type_t::RW; - case 2732: - return access_type_t::RW; - case 2736: - return access_type_t::RW; - case 2752: - return access_type_t::RW; - case 2760: - return access_type_t::RW; - case 2768: - return access_type_t::RW; - case 2776: - return access_type_t::RW; - case 2784: - return access_type_t::RW; - case 2816: - return access_type_t::RW; - case 2824: - return access_type_t::RW; - case 2832: - return access_type_t::RW; - case 2840: - return access_type_t::RW; - case 2848: - return access_type_t::RW; - case 2856: - return access_type_t::RW; - case 2864: - return access_type_t::RW; - case 2880: - return access_type_t::RW; - case 2888: - return access_type_t::RW; - case 2896: - return access_type_t::RW; - case 2904: - return access_type_t::RW; - case 4032: - return access_type_t::RO; - case 4048: - return access_type_t::RO; - case 4052: - return access_type_t::RO; - case 4056: - return access_type_t::RO; - case 4060: - return access_type_t::RO; - case 4064: - return access_type_t::RO; - case 4068: - return access_type_t::RO; - case 4072: - return access_type_t::RO; - case 4076: - return access_type_t::RO; - case 4080: - return access_type_t::RO; - case 4084: - return access_type_t::RO; - case 4088: - return access_type_t::RO; - case 4092: - return access_type_t::RO; - default: - return access_type_t::RO; - } - } -#endif -}; - -#ifdef __cplusplus -struct isa -{ -#ifdef NPU_DISASSEMBLE - static int disassemble(const uint32_t *in, - std::string &op, - std::vector> &fields) - { - switch (*in & 0xffff) - { - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_STOP): - { - const npu_op_stop_t &v = *reinterpret_cast(in); - op = "NPU_OP_STOP"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_IRQ): - { - const npu_op_irq_t &v = *reinterpret_cast(in); - op = "NPU_OP_IRQ"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_CONV): - { - const npu_op_conv_t &v = *reinterpret_cast(in); - op = "NPU_OP_CONV"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_DEPTHWISE): - { - const npu_op_depthwise_t &v = *reinterpret_cast(in); - op = "NPU_OP_DEPTHWISE"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_POOL): - { - const npu_op_pool_t &v = *reinterpret_cast(in); - op = "NPU_OP_POOL"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_ELEMENTWISE): - { - const npu_op_elementwise_t &v = *reinterpret_cast(in); - op = "NPU_OP_ELEMENTWISE"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_DMA_START): - { - const npu_op_dma_start_t &v = *reinterpret_cast(in); - op = "NPU_OP_DMA_START"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_DMA_WAIT): - { - const npu_op_dma_wait_t &v = *reinterpret_cast(in); - op = "NPU_OP_DMA_WAIT"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_KERNEL_WAIT): - { - const npu_op_kernel_wait_t &v = *reinterpret_cast(in); - op = "NPU_OP_KERNEL_WAIT"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_PMU_MASK): - { - const npu_op_pmu_mask_t &v = *reinterpret_cast(in); - op = "NPU_OP_PMU_MASK"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PAD_TOP): - { - const npu_set_ifm_pad_top_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM_PAD_TOP"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PAD_LEFT): - { - const npu_set_ifm_pad_left_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM_PAD_LEFT"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PAD_RIGHT): - { - const npu_set_ifm_pad_right_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM_PAD_RIGHT"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PAD_BOTTOM): - { - const npu_set_ifm_pad_bottom_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM_PAD_BOTTOM"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_DEPTH_M1): - { - const npu_set_ifm_depth_m1_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM_DEPTH_M1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PRECISION): - { - const npu_set_ifm_precision_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM_PRECISION"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_UPSCALE): - { - const npu_set_ifm_upscale_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM_UPSCALE"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_ZERO_POINT): - { - const npu_set_ifm_zero_point_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM_ZERO_POINT"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_WIDTH0_M1): - { - const npu_set_ifm_width0_m1_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM_WIDTH0_M1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_HEIGHT0_M1): - { - const npu_set_ifm_height0_m1_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM_HEIGHT0_M1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_HEIGHT1_M1): - { - const npu_set_ifm_height1_m1_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM_HEIGHT1_M1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_IB_END): - { - const npu_set_ifm_ib_end_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM_IB_END"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_REGION): - { - const npu_set_ifm_region_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM_REGION"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_WIDTH_M1): - { - const npu_set_ofm_width_m1_t &v = *reinterpret_cast(in); - op = "NPU_SET_OFM_WIDTH_M1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_HEIGHT_M1): - { - const npu_set_ofm_height_m1_t &v = *reinterpret_cast(in); - op = "NPU_SET_OFM_HEIGHT_M1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_DEPTH_M1): - { - const npu_set_ofm_depth_m1_t &v = *reinterpret_cast(in); - op = "NPU_SET_OFM_DEPTH_M1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_PRECISION): - { - const npu_set_ofm_precision_t &v = *reinterpret_cast(in); - op = "NPU_SET_OFM_PRECISION"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_BLK_WIDTH_M1): - { - const npu_set_ofm_blk_width_m1_t &v = *reinterpret_cast(in); - op = "NPU_SET_OFM_BLK_WIDTH_M1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_BLK_HEIGHT_M1): - { - const npu_set_ofm_blk_height_m1_t &v = *reinterpret_cast(in); - op = "NPU_SET_OFM_BLK_HEIGHT_M1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_BLK_DEPTH_M1): - { - const npu_set_ofm_blk_depth_m1_t &v = *reinterpret_cast(in); - op = "NPU_SET_OFM_BLK_DEPTH_M1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_ZERO_POINT): - { - const npu_set_ofm_zero_point_t &v = *reinterpret_cast(in); - op = "NPU_SET_OFM_ZERO_POINT"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_WIDTH0_M1): - { - const npu_set_ofm_width0_m1_t &v = *reinterpret_cast(in); - op = "NPU_SET_OFM_WIDTH0_M1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_HEIGHT0_M1): - { - const npu_set_ofm_height0_m1_t &v = *reinterpret_cast(in); - op = "NPU_SET_OFM_HEIGHT0_M1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_HEIGHT1_M1): - { - const npu_set_ofm_height1_m1_t &v = *reinterpret_cast(in); - op = "NPU_SET_OFM_HEIGHT1_M1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_REGION): - { - const npu_set_ofm_region_t &v = *reinterpret_cast(in); - op = "NPU_SET_OFM_REGION"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_KERNEL_WIDTH_M1): - { - const npu_set_kernel_width_m1_t &v = *reinterpret_cast(in); - op = "NPU_SET_KERNEL_WIDTH_M1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_KERNEL_HEIGHT_M1): - { - const npu_set_kernel_height_m1_t &v = *reinterpret_cast(in); - op = "NPU_SET_KERNEL_HEIGHT_M1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_KERNEL_STRIDE): - { - const npu_set_kernel_stride_t &v = *reinterpret_cast(in); - op = "NPU_SET_KERNEL_STRIDE"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_PARALLEL_MODE): - { - const npu_set_parallel_mode_t &v = *reinterpret_cast(in); - op = "NPU_SET_PARALLEL_MODE"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_ACC_FORMAT): - { - const npu_set_acc_format_t &v = *reinterpret_cast(in); - op = "NPU_SET_ACC_FORMAT"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_ACTIVATION): - { - const npu_set_activation_t &v = *reinterpret_cast(in); - op = "NPU_SET_ACTIVATION"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_ACTIVATION_MIN): - { - const npu_set_activation_min_t &v = *reinterpret_cast(in); - op = "NPU_SET_ACTIVATION_MIN"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_ACTIVATION_MAX): - { - const npu_set_activation_max_t &v = *reinterpret_cast(in); - op = "NPU_SET_ACTIVATION_MAX"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_WEIGHT_REGION): - { - const npu_set_weight_region_t &v = *reinterpret_cast(in); - op = "NPU_SET_WEIGHT_REGION"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_SCALE_REGION): - { - const npu_set_scale_region_t &v = *reinterpret_cast(in); - op = "NPU_SET_SCALE_REGION"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_AB_START): - { - const npu_set_ab_start_t &v = *reinterpret_cast(in); - op = "NPU_SET_AB_START"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_BLOCKDEP): - { - const npu_set_blockdep_t &v = *reinterpret_cast(in); - op = "NPU_SET_BLOCKDEP"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_SRC_REGION): - { - const npu_set_dma0_src_region_t &v = *reinterpret_cast(in); - op = "NPU_SET_DMA0_SRC_REGION"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_DST_REGION): - { - const npu_set_dma0_dst_region_t &v = *reinterpret_cast(in); - op = "NPU_SET_DMA0_DST_REGION"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_SIZE0): - { - const npu_set_dma0_size0_t &v = *reinterpret_cast(in); - op = "NPU_SET_DMA0_SIZE0"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_SIZE1): - { - const npu_set_dma0_size1_t &v = *reinterpret_cast(in); - op = "NPU_SET_DMA0_SIZE1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_BROADCAST): - { - const npu_set_ifm2_broadcast_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM2_BROADCAST"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_SCALAR): - { - const npu_set_ifm2_scalar_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM2_SCALAR"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_PRECISION): - { - const npu_set_ifm2_precision_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM2_PRECISION"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_ZERO_POINT): - { - const npu_set_ifm2_zero_point_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM2_ZERO_POINT"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_WIDTH0_M1): - { - const npu_set_ifm2_width0_m1_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM2_WIDTH0_M1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_HEIGHT0_M1): - { - const npu_set_ifm2_height0_m1_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM2_HEIGHT0_M1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_HEIGHT1_M1): - { - const npu_set_ifm2_height1_m1_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM2_HEIGHT1_M1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_IB_START): - { - const npu_set_ifm2_ib_start_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM2_IB_START"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_REGION): - { - const npu_set_ifm2_region_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM2_REGION"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_BASE0): - { - const npu_set_ifm_base0_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM_BASE0"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_BASE1): - { - const npu_set_ifm_base1_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM_BASE1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_BASE2): - { - const npu_set_ifm_base2_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM_BASE2"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_BASE3): - { - const npu_set_ifm_base3_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM_BASE3"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_STRIDE_X): - { - const npu_set_ifm_stride_x_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM_STRIDE_X"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_STRIDE_Y): - { - const npu_set_ifm_stride_y_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM_STRIDE_Y"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_STRIDE_C): - { - const npu_set_ifm_stride_c_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM_STRIDE_C"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_BASE0): - { - const npu_set_ofm_base0_t &v = *reinterpret_cast(in); - op = "NPU_SET_OFM_BASE0"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_BASE1): - { - const npu_set_ofm_base1_t &v = *reinterpret_cast(in); - op = "NPU_SET_OFM_BASE1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_BASE2): - { - const npu_set_ofm_base2_t &v = *reinterpret_cast(in); - op = "NPU_SET_OFM_BASE2"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_BASE3): - { - const npu_set_ofm_base3_t &v = *reinterpret_cast(in); - op = "NPU_SET_OFM_BASE3"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_STRIDE_X): - { - const npu_set_ofm_stride_x_t &v = *reinterpret_cast(in); - op = "NPU_SET_OFM_STRIDE_X"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_STRIDE_Y): - { - const npu_set_ofm_stride_y_t &v = *reinterpret_cast(in); - op = "NPU_SET_OFM_STRIDE_Y"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_STRIDE_C): - { - const npu_set_ofm_stride_c_t &v = *reinterpret_cast(in); - op = "NPU_SET_OFM_STRIDE_C"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT_BASE): - { - const npu_set_weight_base_t &v = *reinterpret_cast(in); - op = "NPU_SET_WEIGHT_BASE"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT_LENGTH): - { - const npu_set_weight_length_t &v = *reinterpret_cast(in); - op = "NPU_SET_WEIGHT_LENGTH"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_SCALE_BASE): - { - const npu_set_scale_base_t &v = *reinterpret_cast(in); - op = "NPU_SET_SCALE_BASE"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_SCALE_LENGTH): - { - const npu_set_scale_length_t &v = *reinterpret_cast(in); - op = "NPU_SET_SCALE_LENGTH"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_SCALE): - { - const npu_set_ofm_scale_t &v = *reinterpret_cast(in); - op = "NPU_SET_OFM_SCALE"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OPA_SCALE): - { - const npu_set_opa_scale_t &v = *reinterpret_cast(in); - op = "NPU_SET_OPA_SCALE"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OPB_SCALE): - { - const npu_set_opb_scale_t &v = *reinterpret_cast(in); - op = "NPU_SET_OPB_SCALE"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_SRC): - { - const npu_set_dma0_src_t &v = *reinterpret_cast(in); - op = "NPU_SET_DMA0_SRC"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_DST): - { - const npu_set_dma0_dst_t &v = *reinterpret_cast(in); - op = "NPU_SET_DMA0_DST"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_LEN): - { - const npu_set_dma0_len_t &v = *reinterpret_cast(in); - op = "NPU_SET_DMA0_LEN"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_SKIP0): - { - const npu_set_dma0_skip0_t &v = *reinterpret_cast(in); - op = "NPU_SET_DMA0_SKIP0"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_SKIP1): - { - const npu_set_dma0_skip1_t &v = *reinterpret_cast(in); - op = "NPU_SET_DMA0_SKIP1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_BASE0): - { - const npu_set_ifm2_base0_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM2_BASE0"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_BASE1): - { - const npu_set_ifm2_base1_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM2_BASE1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_BASE2): - { - const npu_set_ifm2_base2_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM2_BASE2"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_BASE3): - { - const npu_set_ifm2_base3_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM2_BASE3"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_STRIDE_X): - { - const npu_set_ifm2_stride_x_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM2_STRIDE_X"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_STRIDE_Y): - { - const npu_set_ifm2_stride_y_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM2_STRIDE_Y"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_STRIDE_C): - { - const npu_set_ifm2_stride_c_t &v = *reinterpret_cast(in); - op = "NPU_SET_IFM2_STRIDE_C"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT1_BASE): - { - const npu_set_weight1_base_t &v = *reinterpret_cast(in); - op = "NPU_SET_WEIGHT1_BASE"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT1_LENGTH): - { - const npu_set_weight1_length_t &v = *reinterpret_cast(in); - op = "NPU_SET_WEIGHT1_LENGTH"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_SCALE1_BASE): - { - const npu_set_scale1_base_t &v = *reinterpret_cast(in); - op = "NPU_SET_SCALE1_BASE"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | - static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_SCALE1_LENGTH): - { - const npu_set_scale1_length_t &v = *reinterpret_cast(in); - op = "NPU_SET_SCALE1_LENGTH"; - v.disassemble(fields); - break; - } - } - return (*in & (3 << 14)) != 0 ? 2 : 1; - } -#endif -#endif - // Signal the end of command stream - struct npu_op_stop_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t mask : 16; // Encoding for 16-bit mask value -#ifdef __cplusplus - public: - npu_op_stop_t(uint32_t _mask) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_STOP)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), mask(_mask & ((1U << 16) - 1)) - { - } - CONSTEXPR npu_op_stop_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_STOP)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), mask(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_STOP) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_STOP); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_op_stop_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_op_stop_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_mask() const - { - return static_cast(mask); - } - CONSTEXPR npu_op_stop_t &set_mask(uint32_t value) - { - mask = static_cast(value) & ((1U << 16) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("mask", std::to_string(mask))); - } -#endif -#endif - }; - // Raises an IRQ to the host - struct npu_op_irq_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t mask : 16; // Encoding for 16-bit mask value -#ifdef __cplusplus - public: - npu_op_irq_t(uint32_t _mask) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_IRQ)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), mask(_mask & ((1U << 16) - 1)) - { - } - CONSTEXPR npu_op_irq_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_IRQ)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), mask(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_IRQ) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_IRQ); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_op_irq_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_op_irq_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_mask() const - { - return static_cast(mask); - } - CONSTEXPR npu_op_irq_t &set_mask(uint32_t value) - { - mask = static_cast(value) & ((1U << 16) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("mask", std::to_string(mask))); - } -#endif -#endif - }; - // 2D convolution - struct npu_op_conv_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t reserved1 : 16; -#ifdef __cplusplus - public: - CONSTEXPR npu_op_conv_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_CONV)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), reserved1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_CONV) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_CONV); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_op_conv_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_op_conv_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const {} -#endif -#endif - }; - // Depth-wise 2D convolution - struct npu_op_depthwise_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t reserved1 : 16; -#ifdef __cplusplus - public: - CONSTEXPR npu_op_depthwise_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_DEPTHWISE)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), reserved1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_DEPTHWISE) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_DEPTHWISE); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_op_depthwise_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_op_depthwise_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const {} -#endif -#endif - }; - // Pooling - struct npu_op_pool_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t pooling_mode : 3; // Pooling mode - uint32_t reserved1 : 13; -#ifdef __cplusplus - public: - npu_op_pool_t(NPU_NAMESPACE::pooling_mode _pooling_mode) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_POOL)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - pooling_mode(static_cast(_pooling_mode) & ((1U << 3) - 1)), reserved1(0) - { - } - CONSTEXPR npu_op_pool_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_POOL)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), pooling_mode(0), reserved1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_POOL) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_POOL); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_op_pool_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_op_pool_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::pooling_mode get_pooling_mode() const - { - return static_cast(pooling_mode); - } - CONSTEXPR npu_op_pool_t &set_pooling_mode(NPU_NAMESPACE::pooling_mode value) - { - pooling_mode = static_cast(value) & ((1U << 3) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair( - "pooling_mode", - (pooling_mode < (sizeof(pooling_mode_str) / sizeof(pooling_mode_str[0])) ? - pooling_mode_str[pooling_mode] : - "****"))); - } -#endif -#endif - }; - // Elementwise operation - struct npu_op_elementwise_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t elementwise_mode : 6; // Elementwise mode - uint32_t reserved1 : 10; -#ifdef __cplusplus - public: - npu_op_elementwise_t(NPU_NAMESPACE::elementwise_mode _elementwise_mode) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_ELEMENTWISE)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - elementwise_mode(static_cast(_elementwise_mode) & ((1U << 6) - 1)), reserved1(0) - { - } - CONSTEXPR npu_op_elementwise_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_ELEMENTWISE)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), elementwise_mode(0), reserved1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_ELEMENTWISE) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_ELEMENTWISE); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_op_elementwise_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_op_elementwise_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::elementwise_mode get_elementwise_mode() const - { - return static_cast(elementwise_mode); - } - CONSTEXPR npu_op_elementwise_t &set_elementwise_mode(NPU_NAMESPACE::elementwise_mode value) - { - elementwise_mode = static_cast(value) & ((1U << 6) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair( - "elementwise_mode", - (elementwise_mode < (sizeof(elementwise_mode_str) / sizeof(elementwise_mode_str[0])) ? - elementwise_mode_str[elementwise_mode] : - "****"))); - } -#endif -#endif - }; - // Queue new DMA for the given channel - struct npu_op_dma_start_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t reserved1 : 16; -#ifdef __cplusplus - public: - CONSTEXPR npu_op_dma_start_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_DMA_START)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), reserved1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_DMA_START) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_DMA_START); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_op_dma_start_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_op_dma_start_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const {} -#endif -#endif - }; - // Wait for the DMA channel to have k or fewer active descriptors outstanding - struct npu_op_dma_wait_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t k : 4; // Number of outstanding descriptors - uint32_t reserved1 : 12; -#ifdef __cplusplus - public: - npu_op_dma_wait_t(uint32_t _k) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_DMA_WAIT)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), k(_k & ((1U << 4) - 1)), reserved1(0) - { - } - CONSTEXPR npu_op_dma_wait_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_DMA_WAIT)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), k(0), reserved1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_DMA_WAIT) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_DMA_WAIT); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_op_dma_wait_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_op_dma_wait_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_k() const - { - return static_cast(k); - } - CONSTEXPR npu_op_dma_wait_t &set_k(uint32_t value) - { - k = static_cast(value) & ((1U << 4) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("k", std::to_string(k))); - } -#endif -#endif - }; - // Wait for n or fewer kernel operations to be remaining - struct npu_op_kernel_wait_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t n : 2; // Number of kernel operations in range 0-3 - uint32_t reserved1 : 14; -#ifdef __cplusplus - public: - npu_op_kernel_wait_t(uint32_t _n) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_KERNEL_WAIT)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), n(_n & ((1U << 2) - 1)), reserved1(0) - { - } - CONSTEXPR npu_op_kernel_wait_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_KERNEL_WAIT)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), n(0), reserved1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_KERNEL_WAIT) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_KERNEL_WAIT); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_op_kernel_wait_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_op_kernel_wait_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_n() const - { - return static_cast(n); - } - CONSTEXPR npu_op_kernel_wait_t &set_n(uint32_t value) - { - n = static_cast(value) & ((1U << 2) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("n", std::to_string(n))); - } -#endif -#endif - }; - // Enable or disable PMU counting (debug feature only) - struct npu_op_pmu_mask_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t enable : 1; // Enable or disable PMU mask - uint32_t reserved1 : 15; -#ifdef __cplusplus - public: - npu_op_pmu_mask_t(uint32_t _enable) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_PMU_MASK)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), enable(_enable & ((1U << 1) - 1)), - reserved1(0) - { - } - CONSTEXPR npu_op_pmu_mask_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_PMU_MASK)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), enable(0), reserved1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_PMU_MASK) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_PMU_MASK); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_op_pmu_mask_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_op_pmu_mask_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_enable() const - { - return static_cast(enable); - } - CONSTEXPR npu_op_pmu_mask_t &set_enable(uint32_t value) - { - enable = static_cast(value) & ((1U << 1) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("enable", std::to_string(enable))); - } -#endif -#endif - }; - // IFM top pad - struct npu_set_ifm_pad_top_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t pad : 7; // IFM top pad - uint32_t reserved1 : 9; -#ifdef __cplusplus - public: - npu_set_ifm_pad_top_t(uint32_t _pad) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PAD_TOP)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), pad(_pad & ((1U << 7) - 1)), reserved1(0) - { - } - CONSTEXPR npu_set_ifm_pad_top_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PAD_TOP)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), pad(0), reserved1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PAD_TOP) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PAD_TOP); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm_pad_top_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm_pad_top_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_pad() const - { - return static_cast(pad); - } - CONSTEXPR npu_set_ifm_pad_top_t &set_pad(uint32_t value) - { - pad = static_cast(value) & ((1U << 7) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("pad", std::to_string(pad))); - } -#endif -#endif - }; - // IFM left pad - struct npu_set_ifm_pad_left_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t pad : 7; // IFM left pad - uint32_t reserved1 : 9; -#ifdef __cplusplus - public: - npu_set_ifm_pad_left_t(uint32_t _pad) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PAD_LEFT)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), pad(_pad & ((1U << 7) - 1)), reserved1(0) - { - } - CONSTEXPR npu_set_ifm_pad_left_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PAD_LEFT)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), pad(0), reserved1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PAD_LEFT) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PAD_LEFT); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm_pad_left_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm_pad_left_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_pad() const - { - return static_cast(pad); - } - CONSTEXPR npu_set_ifm_pad_left_t &set_pad(uint32_t value) - { - pad = static_cast(value) & ((1U << 7) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("pad", std::to_string(pad))); - } -#endif -#endif - }; - // IFM right pad - struct npu_set_ifm_pad_right_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t pad : 8; // IFM right pad. Max value is 128 - uint32_t reserved1 : 8; -#ifdef __cplusplus - public: - npu_set_ifm_pad_right_t(uint32_t _pad) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PAD_RIGHT)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), pad(_pad & ((1U << 8) - 1)), reserved1(0) - { - } - CONSTEXPR npu_set_ifm_pad_right_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PAD_RIGHT)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), pad(0), reserved1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PAD_RIGHT) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PAD_RIGHT); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm_pad_right_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm_pad_right_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_pad() const - { - return static_cast(pad); - } - CONSTEXPR npu_set_ifm_pad_right_t &set_pad(uint32_t value) - { - pad = static_cast(value) & ((1U << 8) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("pad", std::to_string(pad))); - } -#endif -#endif - }; - // IFM bottom pad - struct npu_set_ifm_pad_bottom_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t pad : 8; // IFM bottom pad. Max value is 128 - uint32_t reserved1 : 8; -#ifdef __cplusplus - public: - npu_set_ifm_pad_bottom_t(uint32_t _pad) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PAD_BOTTOM)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), pad(_pad & ((1U << 8) - 1)), reserved1(0) - { - } - CONSTEXPR npu_set_ifm_pad_bottom_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PAD_BOTTOM)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), pad(0), reserved1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PAD_BOTTOM) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PAD_BOTTOM); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm_pad_bottom_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm_pad_bottom_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_pad() const - { - return static_cast(pad); - } - CONSTEXPR npu_set_ifm_pad_bottom_t &set_pad(uint32_t value) - { - pad = static_cast(value) & ((1U << 8) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("pad", std::to_string(pad))); - } -#endif -#endif - }; - // Number of input channels for convolution - struct npu_set_ifm_depth_m1_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t depth_m1 : 16; // Number of input channels for convolution -#ifdef __cplusplus - public: - npu_set_ifm_depth_m1_t(uint32_t _depth_m1) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_DEPTH_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), depth_m1(_depth_m1 & ((1U << 16) - 1)) - { - } - CONSTEXPR npu_set_ifm_depth_m1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_DEPTH_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), depth_m1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_DEPTH_M1) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_DEPTH_M1); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm_depth_m1_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm_depth_m1_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_depth_m1() const - { - return static_cast(depth_m1); - } - CONSTEXPR npu_set_ifm_depth_m1_t &set_depth_m1(uint32_t value) - { - depth_m1 = static_cast(value) & ((1U << 16) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("depth_m1", std::to_string(depth_m1))); - } -#endif -#endif - }; - // IFM Precision - struct npu_set_ifm_precision_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t activation_type : 1; // IFM type - uint32_t reserved1 : 1; - uint32_t activation_precision : 2; // IFM precision - uint32_t reserved2 : 2; - uint32_t activation_format : 2; // IFM format - uint32_t scale_mode : 2; // IFM scale mode - uint32_t reserved3 : 4; - uint32_t round_mode : 2; // IFM round mode -#ifdef __cplusplus - public: - npu_set_ifm_precision_t(NPU_NAMESPACE::activation_type _activation_type, - NPU_NAMESPACE::activation_precision _activation_precision, - NPU_NAMESPACE::activation_format _activation_format, - NPU_NAMESPACE::ifm_scale_mode _scale_mode, - NPU_NAMESPACE::round_mode _round_mode) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PRECISION)), - reserved0(0), control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - activation_type(static_cast(_activation_type) & ((1U << 1) - 1)), reserved1(0), - activation_precision(static_cast(_activation_precision) & ((1U << 2) - 1)), reserved2(0), - activation_format(static_cast(_activation_format) & ((1U << 2) - 1)), - scale_mode(static_cast(_scale_mode) & ((1U << 2) - 1)), reserved3(0), - round_mode(static_cast(_round_mode) & ((1U << 2) - 1)) - { - } - CONSTEXPR npu_set_ifm_precision_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PRECISION)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), activation_type(0), reserved1(0), - activation_precision(0), reserved2(0), activation_format(0), scale_mode(0), reserved3(0), round_mode(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PRECISION) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PRECISION); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm_precision_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm_precision_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::activation_type get_activation_type() const - { - return static_cast(activation_type); - } - CONSTEXPR npu_set_ifm_precision_t &set_activation_type(NPU_NAMESPACE::activation_type value) - { - activation_type = static_cast(value) & ((1U << 1) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::activation_precision get_activation_precision() const - { - return static_cast(activation_precision); - } - CONSTEXPR npu_set_ifm_precision_t &set_activation_precision(NPU_NAMESPACE::activation_precision value) - { - activation_precision = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::activation_format get_activation_format() const - { - return static_cast(activation_format); - } - CONSTEXPR npu_set_ifm_precision_t &set_activation_format(NPU_NAMESPACE::activation_format value) - { - activation_format = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::ifm_scale_mode get_scale_mode() const - { - return static_cast(scale_mode); - } - CONSTEXPR npu_set_ifm_precision_t &set_scale_mode(NPU_NAMESPACE::ifm_scale_mode value) - { - scale_mode = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::round_mode get_round_mode() const - { - return static_cast(round_mode); - } - CONSTEXPR npu_set_ifm_precision_t &set_round_mode(NPU_NAMESPACE::round_mode value) - { - round_mode = static_cast(value) & ((1U << 2) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair( - "activation_type", - (activation_type < (sizeof(activation_type_str) / sizeof(activation_type_str[0])) ? - activation_type_str[activation_type] : - "****"))); - fields.push_back(std::make_pair( - "activation_precision", - (activation_precision < (sizeof(activation_precision_str) / sizeof(activation_precision_str[0])) ? - activation_precision_str[activation_precision] : - "****"))); - fields.push_back(std::make_pair( - "activation_format", - (activation_format < (sizeof(activation_format_str) / sizeof(activation_format_str[0])) ? - activation_format_str[activation_format] : - "****"))); - fields.push_back(std::make_pair( - "scale_mode", - (scale_mode < (sizeof(ifm_scale_mode_str) / sizeof(ifm_scale_mode_str[0])) ? - ifm_scale_mode_str[scale_mode] : - "****"))); - fields.push_back(std::make_pair( - "round_mode", - (round_mode < (sizeof(round_mode_str) / sizeof(round_mode_str[0])) ? round_mode_str[round_mode] : - "****"))); - } -#endif -#endif - }; - // IFM upscale mode - struct npu_set_ifm_upscale_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t mode : 2; // IFM upscale mode - uint32_t reserved1 : 14; -#ifdef __cplusplus - public: - npu_set_ifm_upscale_t(NPU_NAMESPACE::ifm_upscale_mode _mode) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_UPSCALE)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - mode(static_cast(_mode) & ((1U << 2) - 1)), reserved1(0) - { - } - CONSTEXPR npu_set_ifm_upscale_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_UPSCALE)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), mode(0), reserved1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_UPSCALE) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_UPSCALE); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm_upscale_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm_upscale_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::ifm_upscale_mode get_mode() const - { - return static_cast(mode); - } - CONSTEXPR npu_set_ifm_upscale_t &set_mode(NPU_NAMESPACE::ifm_upscale_mode value) - { - mode = static_cast(value) & ((1U << 2) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair( - "mode", - (mode < (sizeof(ifm_upscale_mode_str) / sizeof(ifm_upscale_mode_str[0])) ? ifm_upscale_mode_str[mode] : - "****"))); - } -#endif -#endif - }; - // IFM zero point - struct npu_set_ifm_zero_point_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t zero_point : 16; // Zero point offset -#ifdef __cplusplus - public: - npu_set_ifm_zero_point_t(uint32_t _zero_point) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_ZERO_POINT)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - zero_point(_zero_point & ((1U << 16) - 1)) - { - } - CONSTEXPR npu_set_ifm_zero_point_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_ZERO_POINT)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), zero_point(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_ZERO_POINT) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_ZERO_POINT); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm_zero_point_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm_zero_point_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_zero_point() const - { - return static_cast(zero_point); - } - CONSTEXPR npu_set_ifm_zero_point_t &set_zero_point(uint32_t value) - { - zero_point = static_cast(value) & ((1U << 16) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("zero_point", std::to_string(zero_point))); - } -#endif -#endif - }; - // IFM Tile 0 and tile 2 width - struct npu_set_ifm_width0_m1_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t width_m1 : 16; // IFM Tile 0 and tile 2 width -#ifdef __cplusplus - public: - npu_set_ifm_width0_m1_t(uint32_t _width_m1) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_WIDTH0_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), width_m1(_width_m1 & ((1U << 16) - 1)) - { - } - CONSTEXPR npu_set_ifm_width0_m1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_WIDTH0_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), width_m1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_WIDTH0_M1) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_WIDTH0_M1); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm_width0_m1_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm_width0_m1_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_width_m1() const - { - return static_cast(width_m1); - } - CONSTEXPR npu_set_ifm_width0_m1_t &set_width_m1(uint32_t value) - { - width_m1 = static_cast(value) & ((1U << 16) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("width_m1", std::to_string(width_m1))); - } -#endif -#endif - }; - // IFM Tile 0 height - struct npu_set_ifm_height0_m1_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t height_m1 : 16; // IFM Tile 0 height -#ifdef __cplusplus - public: - npu_set_ifm_height0_m1_t(uint32_t _height_m1) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_HEIGHT0_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), height_m1(_height_m1 & ((1U << 16) - 1)) - { - } - CONSTEXPR npu_set_ifm_height0_m1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_HEIGHT0_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), height_m1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_HEIGHT0_M1) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_HEIGHT0_M1); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm_height0_m1_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm_height0_m1_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_height_m1() const - { - return static_cast(height_m1); - } - CONSTEXPR npu_set_ifm_height0_m1_t &set_height_m1(uint32_t value) - { - height_m1 = static_cast(value) & ((1U << 16) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("height_m1", std::to_string(height_m1))); - } -#endif -#endif - }; - // IFM Tile 1 height - struct npu_set_ifm_height1_m1_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t height_m1 : 16; // IFM Tile 1 height -#ifdef __cplusplus - public: - npu_set_ifm_height1_m1_t(uint32_t _height_m1) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_HEIGHT1_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), height_m1(_height_m1 & ((1U << 16) - 1)) - { - } - CONSTEXPR npu_set_ifm_height1_m1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_HEIGHT1_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), height_m1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_HEIGHT1_M1) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_HEIGHT1_M1); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm_height1_m1_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm_height1_m1_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_height_m1() const - { - return static_cast(height_m1); - } - CONSTEXPR npu_set_ifm_height1_m1_t &set_height_m1(uint32_t value) - { - height_m1 = static_cast(value) & ((1U << 16) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("height_m1", std::to_string(height_m1))); - } -#endif -#endif - }; - // End of IB0,IB1 buffers - struct npu_set_ifm_ib_end_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t ib_end : 6; // End of IB0,IB1 buffers in the SHRAM in KB units. Multiple of 2 - uint32_t reserved1 : 10; -#ifdef __cplusplus - public: - npu_set_ifm_ib_end_t(uint32_t _ib_end) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_IB_END)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), ib_end(_ib_end & ((1U << 6) - 1)), - reserved1(0) - { - } - CONSTEXPR npu_set_ifm_ib_end_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_IB_END)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), ib_end(0), reserved1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_IB_END) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_IB_END); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm_ib_end_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm_ib_end_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_ib_end() const - { - return static_cast(ib_end); - } - CONSTEXPR npu_set_ifm_ib_end_t &set_ib_end(uint32_t value) - { - ib_end = static_cast(value) & ((1U << 6) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("ib_end", std::to_string(ib_end))); - } -#endif -#endif - }; - // Index n for IFM access - struct npu_set_ifm_region_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t region : 3; // Region number n - uint32_t reserved1 : 13; -#ifdef __cplusplus - public: - npu_set_ifm_region_t(uint32_t _region) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_REGION)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), region(_region & ((1U << 3) - 1)), - reserved1(0) - { - } - CONSTEXPR npu_set_ifm_region_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_REGION)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), region(0), reserved1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_REGION) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_REGION); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm_region_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm_region_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_region() const - { - return static_cast(region); - } - CONSTEXPR npu_set_ifm_region_t &set_region(uint32_t value) - { - region = static_cast(value) & ((1U << 3) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("region", std::to_string(region))); - } -#endif -#endif - }; - // Output feature map width - struct npu_set_ofm_width_m1_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t width_m1 : 16; // Output feature map width -#ifdef __cplusplus - public: - npu_set_ofm_width_m1_t(uint32_t _width_m1) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_WIDTH_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), width_m1(_width_m1 & ((1U << 16) - 1)) - { - } - CONSTEXPR npu_set_ofm_width_m1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_WIDTH_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), width_m1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_WIDTH_M1) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_WIDTH_M1); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ofm_width_m1_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ofm_width_m1_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_width_m1() const - { - return static_cast(width_m1); - } - CONSTEXPR npu_set_ofm_width_m1_t &set_width_m1(uint32_t value) - { - width_m1 = static_cast(value) & ((1U << 16) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("width_m1", std::to_string(width_m1))); - } -#endif -#endif - }; - // Output feature map height - struct npu_set_ofm_height_m1_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t height_m1 : 16; // Output feature map height -#ifdef __cplusplus - public: - npu_set_ofm_height_m1_t(uint32_t _height_m1) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_HEIGHT_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), height_m1(_height_m1 & ((1U << 16) - 1)) - { - } - CONSTEXPR npu_set_ofm_height_m1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_HEIGHT_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), height_m1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_HEIGHT_M1) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_HEIGHT_M1); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ofm_height_m1_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ofm_height_m1_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_height_m1() const - { - return static_cast(height_m1); - } - CONSTEXPR npu_set_ofm_height_m1_t &set_height_m1(uint32_t value) - { - height_m1 = static_cast(value) & ((1U << 16) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("height_m1", std::to_string(height_m1))); - } -#endif -#endif - }; - // Output feature map depth - struct npu_set_ofm_depth_m1_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t depth_m1 : 16; // Output feature map depth -#ifdef __cplusplus - public: - npu_set_ofm_depth_m1_t(uint32_t _depth_m1) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_DEPTH_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), depth_m1(_depth_m1 & ((1U << 16) - 1)) - { - } - CONSTEXPR npu_set_ofm_depth_m1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_DEPTH_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), depth_m1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_DEPTH_M1) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_DEPTH_M1); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ofm_depth_m1_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ofm_depth_m1_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_depth_m1() const - { - return static_cast(depth_m1); - } - CONSTEXPR npu_set_ofm_depth_m1_t &set_depth_m1(uint32_t value) - { - depth_m1 = static_cast(value) & ((1U << 16) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("depth_m1", std::to_string(depth_m1))); - } -#endif -#endif - }; - // OFM Precision - struct npu_set_ofm_precision_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t activation_type : 1; // OFM type - uint32_t activation_precision : 2; // OFM precision - uint32_t reserved1 : 3; - uint32_t activation_format : 2; // OFM format - uint32_t scale_mode : 1; // OFM scale mode - uint32_t reserved2 : 5; - uint32_t round_mode : 2; // OFM round mode -#ifdef __cplusplus - public: - npu_set_ofm_precision_t(NPU_NAMESPACE::activation_type _activation_type, - NPU_NAMESPACE::activation_precision _activation_precision, - NPU_NAMESPACE::activation_format _activation_format, - NPU_NAMESPACE::ofm_scale_mode _scale_mode, - NPU_NAMESPACE::round_mode _round_mode) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_PRECISION)), - reserved0(0), control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - activation_type(static_cast(_activation_type) & ((1U << 1) - 1)), - activation_precision(static_cast(_activation_precision) & ((1U << 2) - 1)), reserved1(0), - activation_format(static_cast(_activation_format) & ((1U << 2) - 1)), - scale_mode(static_cast(_scale_mode) & ((1U << 1) - 1)), reserved2(0), - round_mode(static_cast(_round_mode) & ((1U << 2) - 1)) - { - } - CONSTEXPR npu_set_ofm_precision_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_PRECISION)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), activation_type(0), - activation_precision(0), reserved1(0), activation_format(0), scale_mode(0), reserved2(0), round_mode(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_PRECISION) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_PRECISION); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ofm_precision_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ofm_precision_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::activation_type get_activation_type() const - { - return static_cast(activation_type); - } - CONSTEXPR npu_set_ofm_precision_t &set_activation_type(NPU_NAMESPACE::activation_type value) - { - activation_type = static_cast(value) & ((1U << 1) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::activation_precision get_activation_precision() const - { - return static_cast(activation_precision); - } - CONSTEXPR npu_set_ofm_precision_t &set_activation_precision(NPU_NAMESPACE::activation_precision value) - { - activation_precision = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::activation_format get_activation_format() const - { - return static_cast(activation_format); - } - CONSTEXPR npu_set_ofm_precision_t &set_activation_format(NPU_NAMESPACE::activation_format value) - { - activation_format = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::ofm_scale_mode get_scale_mode() const - { - return static_cast(scale_mode); - } - CONSTEXPR npu_set_ofm_precision_t &set_scale_mode(NPU_NAMESPACE::ofm_scale_mode value) - { - scale_mode = static_cast(value) & ((1U << 1) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::round_mode get_round_mode() const - { - return static_cast(round_mode); - } - CONSTEXPR npu_set_ofm_precision_t &set_round_mode(NPU_NAMESPACE::round_mode value) - { - round_mode = static_cast(value) & ((1U << 2) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair( - "activation_type", - (activation_type < (sizeof(activation_type_str) / sizeof(activation_type_str[0])) ? - activation_type_str[activation_type] : - "****"))); - fields.push_back(std::make_pair( - "activation_precision", - (activation_precision < (sizeof(activation_precision_str) / sizeof(activation_precision_str[0])) ? - activation_precision_str[activation_precision] : - "****"))); - fields.push_back(std::make_pair( - "activation_format", - (activation_format < (sizeof(activation_format_str) / sizeof(activation_format_str[0])) ? - activation_format_str[activation_format] : - "****"))); - fields.push_back(std::make_pair( - "scale_mode", - (scale_mode < (sizeof(ofm_scale_mode_str) / sizeof(ofm_scale_mode_str[0])) ? - ofm_scale_mode_str[scale_mode] : - "****"))); - fields.push_back(std::make_pair( - "round_mode", - (round_mode < (sizeof(round_mode_str) / sizeof(round_mode_str[0])) ? round_mode_str[round_mode] : - "****"))); - } -#endif -#endif - }; - // OFM block width - struct npu_set_ofm_blk_width_m1_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t width_m1 : 6; // OFM block width - uint32_t reserved1 : 10; -#ifdef __cplusplus - public: - npu_set_ofm_blk_width_m1_t(uint32_t _width_m1) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_BLK_WIDTH_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), width_m1(_width_m1 & ((1U << 6) - 1)), - reserved1(0) - { - } - CONSTEXPR npu_set_ofm_blk_width_m1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_BLK_WIDTH_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), width_m1(0), reserved1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_BLK_WIDTH_M1) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_BLK_WIDTH_M1); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ofm_blk_width_m1_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ofm_blk_width_m1_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_width_m1() const - { - return static_cast(width_m1); - } - CONSTEXPR npu_set_ofm_blk_width_m1_t &set_width_m1(uint32_t value) - { - width_m1 = static_cast(value) & ((1U << 6) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("width_m1", std::to_string(width_m1))); - } -#endif -#endif - }; - // OFM block height - struct npu_set_ofm_blk_height_m1_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t height_m1 : 5; // OFM block height - uint32_t reserved1 : 11; -#ifdef __cplusplus - public: - npu_set_ofm_blk_height_m1_t(uint32_t _height_m1) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_BLK_HEIGHT_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), height_m1(_height_m1 & ((1U << 5) - 1)), - reserved1(0) - { - } - CONSTEXPR npu_set_ofm_blk_height_m1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_BLK_HEIGHT_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), height_m1(0), reserved1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_BLK_HEIGHT_M1) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_BLK_HEIGHT_M1); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ofm_blk_height_m1_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ofm_blk_height_m1_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_height_m1() const - { - return static_cast(height_m1); - } - CONSTEXPR npu_set_ofm_blk_height_m1_t &set_height_m1(uint32_t value) - { - height_m1 = static_cast(value) & ((1U << 5) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("height_m1", std::to_string(height_m1))); - } -#endif -#endif - }; - // OFM block depth - struct npu_set_ofm_blk_depth_m1_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t depth_m1 : 7; // OFM block depth - uint32_t reserved1 : 9; -#ifdef __cplusplus - public: - npu_set_ofm_blk_depth_m1_t(uint32_t _depth_m1) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_BLK_DEPTH_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), depth_m1(_depth_m1 & ((1U << 7) - 1)), - reserved1(0) - { - } - CONSTEXPR npu_set_ofm_blk_depth_m1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_BLK_DEPTH_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), depth_m1(0), reserved1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_BLK_DEPTH_M1) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_BLK_DEPTH_M1); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ofm_blk_depth_m1_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ofm_blk_depth_m1_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_depth_m1() const - { - return static_cast(depth_m1); - } - CONSTEXPR npu_set_ofm_blk_depth_m1_t &set_depth_m1(uint32_t value) - { - depth_m1 = static_cast(value) & ((1U << 7) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("depth_m1", std::to_string(depth_m1))); - } -#endif -#endif - }; - // OFM zero point - struct npu_set_ofm_zero_point_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t zero_point : 16; // Zero point offset -#ifdef __cplusplus - public: - npu_set_ofm_zero_point_t(uint32_t _zero_point) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_ZERO_POINT)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - zero_point(_zero_point & ((1U << 16) - 1)) - { - } - CONSTEXPR npu_set_ofm_zero_point_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_ZERO_POINT)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), zero_point(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_ZERO_POINT) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_ZERO_POINT); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ofm_zero_point_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ofm_zero_point_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_zero_point() const - { - return static_cast(zero_point); - } - CONSTEXPR npu_set_ofm_zero_point_t &set_zero_point(uint32_t value) - { - zero_point = static_cast(value) & ((1U << 16) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("zero_point", std::to_string(zero_point))); - } -#endif -#endif - }; - // OFM Tile 0 and tile 2 width - struct npu_set_ofm_width0_m1_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t width_m1 : 16; // OFM Tile 0 and tile 2 width -#ifdef __cplusplus - public: - npu_set_ofm_width0_m1_t(uint32_t _width_m1) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_WIDTH0_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), width_m1(_width_m1 & ((1U << 16) - 1)) - { - } - CONSTEXPR npu_set_ofm_width0_m1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_WIDTH0_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), width_m1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_WIDTH0_M1) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_WIDTH0_M1); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ofm_width0_m1_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ofm_width0_m1_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_width_m1() const - { - return static_cast(width_m1); - } - CONSTEXPR npu_set_ofm_width0_m1_t &set_width_m1(uint32_t value) - { - width_m1 = static_cast(value) & ((1U << 16) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("width_m1", std::to_string(width_m1))); - } -#endif -#endif - }; - // OFM Tile 0 height - struct npu_set_ofm_height0_m1_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t height_m1 : 16; // OFM Tile 0 height -#ifdef __cplusplus - public: - npu_set_ofm_height0_m1_t(uint32_t _height_m1) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_HEIGHT0_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), height_m1(_height_m1 & ((1U << 16) - 1)) - { - } - CONSTEXPR npu_set_ofm_height0_m1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_HEIGHT0_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), height_m1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_HEIGHT0_M1) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_HEIGHT0_M1); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ofm_height0_m1_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ofm_height0_m1_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_height_m1() const - { - return static_cast(height_m1); - } - CONSTEXPR npu_set_ofm_height0_m1_t &set_height_m1(uint32_t value) - { - height_m1 = static_cast(value) & ((1U << 16) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("height_m1", std::to_string(height_m1))); - } -#endif -#endif - }; - // OFM Tile 1 height - struct npu_set_ofm_height1_m1_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t height_m1 : 16; // OFM Tile 1 height -#ifdef __cplusplus - public: - npu_set_ofm_height1_m1_t(uint32_t _height_m1) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_HEIGHT1_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), height_m1(_height_m1 & ((1U << 16) - 1)) - { - } - CONSTEXPR npu_set_ofm_height1_m1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_HEIGHT1_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), height_m1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_HEIGHT1_M1) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_HEIGHT1_M1); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ofm_height1_m1_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ofm_height1_m1_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_height_m1() const - { - return static_cast(height_m1); - } - CONSTEXPR npu_set_ofm_height1_m1_t &set_height_m1(uint32_t value) - { - height_m1 = static_cast(value) & ((1U << 16) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("height_m1", std::to_string(height_m1))); - } -#endif -#endif - }; - // Index n for OFM access - struct npu_set_ofm_region_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t region : 3; // Index n for OFM access - uint32_t reserved1 : 13; -#ifdef __cplusplus - public: - npu_set_ofm_region_t(uint32_t _region) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_REGION)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), region(_region & ((1U << 3) - 1)), - reserved1(0) - { - } - CONSTEXPR npu_set_ofm_region_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_REGION)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), region(0), reserved1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_REGION) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_REGION); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ofm_region_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ofm_region_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_region() const - { - return static_cast(region); - } - CONSTEXPR npu_set_ofm_region_t &set_region(uint32_t value) - { - region = static_cast(value) & ((1U << 3) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("region", std::to_string(region))); - } -#endif -#endif - }; - // Kernel width - struct npu_set_kernel_width_m1_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t width_m1 : 16; // Kernel width -#ifdef __cplusplus - public: - npu_set_kernel_width_m1_t(uint32_t _width_m1) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_KERNEL_WIDTH_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), width_m1(_width_m1 & ((1U << 16) - 1)) - { - } - CONSTEXPR npu_set_kernel_width_m1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_KERNEL_WIDTH_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), width_m1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_KERNEL_WIDTH_M1) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_KERNEL_WIDTH_M1); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_kernel_width_m1_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_kernel_width_m1_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_width_m1() const - { - return static_cast(width_m1); - } - CONSTEXPR npu_set_kernel_width_m1_t &set_width_m1(uint32_t value) - { - width_m1 = static_cast(value) & ((1U << 16) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("width_m1", std::to_string(width_m1))); - } -#endif -#endif - }; - // Kernel height - struct npu_set_kernel_height_m1_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t height_m1 : 16; // Kernel height -#ifdef __cplusplus - public: - npu_set_kernel_height_m1_t(uint32_t _height_m1) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_KERNEL_HEIGHT_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), height_m1(_height_m1 & ((1U << 16) - 1)) - { - } - CONSTEXPR npu_set_kernel_height_m1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_KERNEL_HEIGHT_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), height_m1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_KERNEL_HEIGHT_M1) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_KERNEL_HEIGHT_M1); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_kernel_height_m1_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_kernel_height_m1_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_height_m1() const - { - return static_cast(height_m1); - } - CONSTEXPR npu_set_kernel_height_m1_t &set_height_m1(uint32_t value) - { - height_m1 = static_cast(value) & ((1U << 16) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("height_m1", std::to_string(height_m1))); - } -#endif -#endif - }; - // Kernel stride - struct npu_set_kernel_stride_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t stride_x_lsb : 1; // Stride x LSB. (kernel_x_stride - 1)[0] - uint32_t stride_y_lsb : 1; // Stride y LSB. (kernel_y_stride - 1)[0] - uint32_t weight_order : 1; // Weight ordering mode - uint32_t dilation_x : 1; // Kernel x dilation - uint32_t dilation_y : 1; // Kernel y dilation - uint32_t decomposition : 1; // Kernel decomposition - uint32_t stride_x_msb : 1; // Stride x MSB. (kernel_x_stride - 1) >> 1 - uint32_t reserved1 : 2; - uint32_t stride_y_msb : 1; // Stride y MSB. (kernel_y_stride - 1) >> 1 - uint32_t reserved2 : 6; -#ifdef __cplusplus - public: - npu_set_kernel_stride_t(uint32_t _stride_x_lsb, - uint32_t _stride_y_lsb, - NPU_NAMESPACE::weight_order _weight_order, - NPU_NAMESPACE::kernel_dilation _dilation_x, - NPU_NAMESPACE::kernel_dilation _dilation_y, - NPU_NAMESPACE::kernel_decomposition _decomposition, - uint32_t _stride_x_msb, - uint32_t _stride_y_msb) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_KERNEL_STRIDE)), - reserved0(0), control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - stride_x_lsb(_stride_x_lsb & ((1U << 1) - 1)), stride_y_lsb(_stride_y_lsb & ((1U << 1) - 1)), - weight_order(static_cast(_weight_order) & ((1U << 1) - 1)), - dilation_x(static_cast(_dilation_x) & ((1U << 1) - 1)), - dilation_y(static_cast(_dilation_y) & ((1U << 1) - 1)), - decomposition(static_cast(_decomposition) & ((1U << 1) - 1)), - stride_x_msb(_stride_x_msb & ((1U << 1) - 1)), reserved1(0), stride_y_msb(_stride_y_msb & ((1U << 1) - 1)), - reserved2(0) - { - } - CONSTEXPR npu_set_kernel_stride_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_KERNEL_STRIDE)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), stride_x_lsb(0), stride_y_lsb(0), - weight_order(0), dilation_x(0), dilation_y(0), decomposition(0), stride_x_msb(0), reserved1(0), - stride_y_msb(0), reserved2(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_KERNEL_STRIDE) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_KERNEL_STRIDE); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_kernel_stride_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_kernel_stride_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_stride_x_lsb() const - { - return static_cast(stride_x_lsb); - } - CONSTEXPR npu_set_kernel_stride_t &set_stride_x_lsb(uint32_t value) - { - stride_x_lsb = static_cast(value) & ((1U << 1) - 1); - return *this; - } - CONSTEXPR uint32_t get_stride_y_lsb() const - { - return static_cast(stride_y_lsb); - } - CONSTEXPR npu_set_kernel_stride_t &set_stride_y_lsb(uint32_t value) - { - stride_y_lsb = static_cast(value) & ((1U << 1) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::weight_order get_weight_order() const - { - return static_cast(weight_order); - } - CONSTEXPR npu_set_kernel_stride_t &set_weight_order(NPU_NAMESPACE::weight_order value) - { - weight_order = static_cast(value) & ((1U << 1) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::kernel_dilation get_dilation_x() const - { - return static_cast(dilation_x); - } - CONSTEXPR npu_set_kernel_stride_t &set_dilation_x(NPU_NAMESPACE::kernel_dilation value) - { - dilation_x = static_cast(value) & ((1U << 1) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::kernel_dilation get_dilation_y() const - { - return static_cast(dilation_y); - } - CONSTEXPR npu_set_kernel_stride_t &set_dilation_y(NPU_NAMESPACE::kernel_dilation value) - { - dilation_y = static_cast(value) & ((1U << 1) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::kernel_decomposition get_decomposition() const - { - return static_cast(decomposition); - } - CONSTEXPR npu_set_kernel_stride_t &set_decomposition(NPU_NAMESPACE::kernel_decomposition value) - { - decomposition = static_cast(value) & ((1U << 1) - 1); - return *this; - } - CONSTEXPR uint32_t get_stride_x_msb() const - { - return static_cast(stride_x_msb); - } - CONSTEXPR npu_set_kernel_stride_t &set_stride_x_msb(uint32_t value) - { - stride_x_msb = static_cast(value) & ((1U << 1) - 1); - return *this; - } - CONSTEXPR uint32_t get_stride_y_msb() const - { - return static_cast(stride_y_msb); - } - CONSTEXPR npu_set_kernel_stride_t &set_stride_y_msb(uint32_t value) - { - stride_y_msb = static_cast(value) & ((1U << 1) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("stride_x_lsb", std::to_string(stride_x_lsb))); - fields.push_back(std::make_pair("stride_y_lsb", std::to_string(stride_y_lsb))); - fields.push_back(std::make_pair( - "weight_order", - (weight_order < (sizeof(weight_order_str) / sizeof(weight_order_str[0])) ? - weight_order_str[weight_order] : - "****"))); - fields.push_back(std::make_pair( - "dilation_x", - (dilation_x < (sizeof(kernel_dilation_str) / sizeof(kernel_dilation_str[0])) ? - kernel_dilation_str[dilation_x] : - "****"))); - fields.push_back(std::make_pair( - "dilation_y", - (dilation_y < (sizeof(kernel_dilation_str) / sizeof(kernel_dilation_str[0])) ? - kernel_dilation_str[dilation_y] : - "****"))); - fields.push_back(std::make_pair( - "decomposition", - (decomposition < (sizeof(kernel_decomposition_str) / sizeof(kernel_decomposition_str[0])) ? - kernel_decomposition_str[decomposition] : - "****"))); - fields.push_back(std::make_pair("stride_x_msb", std::to_string(stride_x_msb))); - fields.push_back(std::make_pair("stride_y_msb", std::to_string(stride_y_msb))); - } -#endif -#endif - }; - // Multi-core parallel mode - struct npu_set_parallel_mode_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t parallel_mode : 1; // Multi-core parallel mode - uint32_t reserved1 : 15; -#ifdef __cplusplus - public: - npu_set_parallel_mode_t(NPU_NAMESPACE::parallel_mode _parallel_mode) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_PARALLEL_MODE)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - parallel_mode(static_cast(_parallel_mode) & ((1U << 1) - 1)), reserved1(0) - { - } - CONSTEXPR npu_set_parallel_mode_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_PARALLEL_MODE)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), parallel_mode(0), reserved1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_PARALLEL_MODE) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_PARALLEL_MODE); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_parallel_mode_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_parallel_mode_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::parallel_mode get_parallel_mode() const - { - return static_cast(parallel_mode); - } - CONSTEXPR npu_set_parallel_mode_t &set_parallel_mode(NPU_NAMESPACE::parallel_mode value) - { - parallel_mode = static_cast(value) & ((1U << 1) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair( - "parallel_mode", - (parallel_mode < (sizeof(parallel_mode_str) / sizeof(parallel_mode_str[0])) ? - parallel_mode_str[parallel_mode] : - "****"))); - } -#endif -#endif - }; - // Accumulator format - struct npu_set_acc_format_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t acc_format : 2; // Accumulator format - uint32_t reserved1 : 14; -#ifdef __cplusplus - public: - npu_set_acc_format_t(NPU_NAMESPACE::acc_format _acc_format) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_ACC_FORMAT)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - acc_format(static_cast(_acc_format) & ((1U << 2) - 1)), reserved1(0) - { - } - CONSTEXPR npu_set_acc_format_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_ACC_FORMAT)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), acc_format(0), reserved1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_ACC_FORMAT) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_ACC_FORMAT); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_acc_format_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_acc_format_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::acc_format get_acc_format() const - { - return static_cast(acc_format); - } - CONSTEXPR npu_set_acc_format_t &set_acc_format(NPU_NAMESPACE::acc_format value) - { - acc_format = static_cast(value) & ((1U << 2) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair( - "acc_format", - (acc_format < (sizeof(acc_format_str) / sizeof(acc_format_str[0])) ? acc_format_str[acc_format] : - "****"))); - } -#endif -#endif - }; - // Activation function and clip range - struct npu_set_activation_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t activation_function : 5; // Activation function (before table lookup) - uint32_t reserved1 : 7; - uint32_t activation_clip_range : 3; // Activation clip range. This must be set to 0 if table lookup is not used - uint32_t reserved2 : 1; -#ifdef __cplusplus - public: - npu_set_activation_t(NPU_NAMESPACE::activation_function _activation_function, - NPU_NAMESPACE::activation_clip_range _activation_clip_range) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_ACTIVATION)), - reserved0(0), control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - activation_function(static_cast(_activation_function) & ((1U << 5) - 1)), reserved1(0), - activation_clip_range(static_cast(_activation_clip_range) & ((1U << 3) - 1)), reserved2(0) - { - } - CONSTEXPR npu_set_activation_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_ACTIVATION)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), activation_function(0), reserved1(0), - activation_clip_range(0), reserved2(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_ACTIVATION) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_ACTIVATION); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_activation_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_activation_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::activation_function get_activation_function() const - { - return static_cast(activation_function); - } - CONSTEXPR npu_set_activation_t &set_activation_function(NPU_NAMESPACE::activation_function value) - { - activation_function = static_cast(value) & ((1U << 5) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::activation_clip_range get_activation_clip_range() const - { - return static_cast(activation_clip_range); - } - CONSTEXPR npu_set_activation_t &set_activation_clip_range(NPU_NAMESPACE::activation_clip_range value) - { - activation_clip_range = static_cast(value) & ((1U << 3) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair( - "activation_function", - (activation_function < (sizeof(activation_function_str) / sizeof(activation_function_str[0])) ? - activation_function_str[activation_function] : - "****"))); - fields.push_back(std::make_pair( - "activation_clip_range", - (activation_clip_range < (sizeof(activation_clip_range_str) / sizeof(activation_clip_range_str[0])) ? - activation_clip_range_str[activation_clip_range] : - "****"))); - } -#endif -#endif - }; - // Lower bound clip - struct npu_set_activation_min_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t clip_boundary : 16; // Clip boundary for OFM activations -#ifdef __cplusplus - public: - npu_set_activation_min_t(uint32_t _clip_boundary) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_ACTIVATION_MIN)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - clip_boundary(_clip_boundary & ((1U << 16) - 1)) - { - } - CONSTEXPR npu_set_activation_min_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_ACTIVATION_MIN)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), clip_boundary(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_ACTIVATION_MIN) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_ACTIVATION_MIN); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_activation_min_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_activation_min_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_clip_boundary() const - { - return static_cast(clip_boundary); - } - CONSTEXPR npu_set_activation_min_t &set_clip_boundary(uint32_t value) - { - clip_boundary = static_cast(value) & ((1U << 16) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("clip_boundary", std::to_string(clip_boundary))); - } -#endif -#endif - }; - // Upper bound clip - struct npu_set_activation_max_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t clip_boundary : 16; // Clip boundary for OFM activations -#ifdef __cplusplus - public: - npu_set_activation_max_t(uint32_t _clip_boundary) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_ACTIVATION_MAX)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - clip_boundary(_clip_boundary & ((1U << 16) - 1)) - { - } - CONSTEXPR npu_set_activation_max_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_ACTIVATION_MAX)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), clip_boundary(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_ACTIVATION_MAX) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_ACTIVATION_MAX); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_activation_max_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_activation_max_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_clip_boundary() const - { - return static_cast(clip_boundary); - } - CONSTEXPR npu_set_activation_max_t &set_clip_boundary(uint32_t value) - { - clip_boundary = static_cast(value) & ((1U << 16) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("clip_boundary", std::to_string(clip_boundary))); - } -#endif -#endif - }; - // Index n for weight stream access - struct npu_set_weight_region_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t region : 3; // Index n for weight stream access - uint32_t reserved1 : 13; -#ifdef __cplusplus - public: - npu_set_weight_region_t(uint32_t _region) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_WEIGHT_REGION)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), region(_region & ((1U << 3) - 1)), - reserved1(0) - { - } - CONSTEXPR npu_set_weight_region_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_WEIGHT_REGION)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), region(0), reserved1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_WEIGHT_REGION) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_WEIGHT_REGION); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_weight_region_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_weight_region_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_region() const - { - return static_cast(region); - } - CONSTEXPR npu_set_weight_region_t &set_region(uint32_t value) - { - region = static_cast(value) & ((1U << 3) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("region", std::to_string(region))); - } -#endif -#endif - }; - // Index n for scale stream access - struct npu_set_scale_region_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t region : 3; // Index n for scale stream access - uint32_t reserved1 : 13; -#ifdef __cplusplus - public: - npu_set_scale_region_t(uint32_t _region) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_SCALE_REGION)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), region(_region & ((1U << 3) - 1)), - reserved1(0) - { - } - CONSTEXPR npu_set_scale_region_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_SCALE_REGION)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), region(0), reserved1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_SCALE_REGION) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_SCALE_REGION); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_scale_region_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_scale_region_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_region() const - { - return static_cast(region); - } - CONSTEXPR npu_set_scale_region_t &set_region(uint32_t value) - { - region = static_cast(value) & ((1U << 3) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("region", std::to_string(region))); - } -#endif -#endif - }; - // Start of ACC0,ACC1 buffers - struct npu_set_ab_start_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t ab_start : 6; // Start of ACC0,ACC1 buffers in the SHRAM in KB units. Multiple of 2 - uint32_t reserved1 : 10; -#ifdef __cplusplus - public: - npu_set_ab_start_t(uint32_t _ab_start) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_AB_START)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), ab_start(_ab_start & ((1U << 6) - 1)), - reserved1(0) - { - } - CONSTEXPR npu_set_ab_start_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_AB_START)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), ab_start(0), reserved1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_AB_START) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_AB_START); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ab_start_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ab_start_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_ab_start() const - { - return static_cast(ab_start); - } - CONSTEXPR npu_set_ab_start_t &set_ab_start(uint32_t value) - { - ab_start = static_cast(value) & ((1U << 6) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("ab_start", std::to_string(ab_start))); - } -#endif -#endif - }; - // Block number of blocks dependency - struct npu_set_blockdep_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t blockdep : 2; // Block number of blocks dependency between kernel operations - uint32_t reserved1 : 14; -#ifdef __cplusplus - public: - npu_set_blockdep_t(uint32_t _blockdep) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_BLOCKDEP)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), blockdep(_blockdep & ((1U << 2) - 1)), - reserved1(0) - { - } - CONSTEXPR npu_set_blockdep_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_BLOCKDEP)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), blockdep(0), reserved1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_BLOCKDEP) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_BLOCKDEP); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_blockdep_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_blockdep_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_blockdep() const - { - return static_cast(blockdep); - } - CONSTEXPR npu_set_blockdep_t &set_blockdep(uint32_t value) - { - blockdep = static_cast(value) & ((1U << 2) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("blockdep", std::to_string(blockdep))); - } -#endif -#endif - }; - // DMA0 source region - struct npu_set_dma0_src_region_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t region : 3; // Region number - uint32_t reserved1 : 5; - uint32_t region_mode : 1; // Region mode - uint32_t stride_mode : 2; // Stride mode - uint32_t reserved2 : 5; -#ifdef __cplusplus - public: - npu_set_dma0_src_region_t(uint32_t _region, - NPU_NAMESPACE::dma_region_mode _region_mode, - NPU_NAMESPACE::dma_stride_mode _stride_mode) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_SRC_REGION)), - reserved0(0), control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - region(_region & ((1U << 3) - 1)), reserved1(0), - region_mode(static_cast(_region_mode) & ((1U << 1) - 1)), - stride_mode(static_cast(_stride_mode) & ((1U << 2) - 1)), reserved2(0) - { - } - CONSTEXPR npu_set_dma0_src_region_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_SRC_REGION)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), region(0), reserved1(0), region_mode(0), - stride_mode(0), reserved2(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_SRC_REGION) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_SRC_REGION); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_dma0_src_region_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_dma0_src_region_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_region() const - { - return static_cast(region); - } - CONSTEXPR npu_set_dma0_src_region_t &set_region(uint32_t value) - { - region = static_cast(value) & ((1U << 3) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::dma_region_mode get_region_mode() const - { - return static_cast(region_mode); - } - CONSTEXPR npu_set_dma0_src_region_t &set_region_mode(NPU_NAMESPACE::dma_region_mode value) - { - region_mode = static_cast(value) & ((1U << 1) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::dma_stride_mode get_stride_mode() const - { - return static_cast(stride_mode); - } - CONSTEXPR npu_set_dma0_src_region_t &set_stride_mode(NPU_NAMESPACE::dma_stride_mode value) - { - stride_mode = static_cast(value) & ((1U << 2) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("region", std::to_string(region))); - fields.push_back(std::make_pair( - "region_mode", - (region_mode < (sizeof(dma_region_mode_str) / sizeof(dma_region_mode_str[0])) ? - dma_region_mode_str[region_mode] : - "****"))); - fields.push_back(std::make_pair( - "stride_mode", - (stride_mode < (sizeof(dma_stride_mode_str) / sizeof(dma_stride_mode_str[0])) ? - dma_stride_mode_str[stride_mode] : - "****"))); - } -#endif -#endif - }; - // DMA0 destination region - struct npu_set_dma0_dst_region_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t region : 3; // Region number if region_mode is region_mode_external. Else core mask to write to (bit k - // set for core k=0,1) - uint32_t reserved1 : 5; - uint32_t region_mode : 1; // Region mode - uint32_t stride_mode : 2; // Stride mode - uint32_t reserved2 : 5; -#ifdef __cplusplus - public: - npu_set_dma0_dst_region_t(uint32_t _region, - NPU_NAMESPACE::dma_region_mode _region_mode, - NPU_NAMESPACE::dma_stride_mode _stride_mode) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_DST_REGION)), - reserved0(0), control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - region(_region & ((1U << 3) - 1)), reserved1(0), - region_mode(static_cast(_region_mode) & ((1U << 1) - 1)), - stride_mode(static_cast(_stride_mode) & ((1U << 2) - 1)), reserved2(0) - { - } - CONSTEXPR npu_set_dma0_dst_region_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_DST_REGION)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), region(0), reserved1(0), region_mode(0), - stride_mode(0), reserved2(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_DST_REGION) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_DST_REGION); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_dma0_dst_region_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_dma0_dst_region_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_region() const - { - return static_cast(region); - } - CONSTEXPR npu_set_dma0_dst_region_t &set_region(uint32_t value) - { - region = static_cast(value) & ((1U << 3) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::dma_region_mode get_region_mode() const - { - return static_cast(region_mode); - } - CONSTEXPR npu_set_dma0_dst_region_t &set_region_mode(NPU_NAMESPACE::dma_region_mode value) - { - region_mode = static_cast(value) & ((1U << 1) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::dma_stride_mode get_stride_mode() const - { - return static_cast(stride_mode); - } - CONSTEXPR npu_set_dma0_dst_region_t &set_stride_mode(NPU_NAMESPACE::dma_stride_mode value) - { - stride_mode = static_cast(value) & ((1U << 2) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("region", std::to_string(region))); - fields.push_back(std::make_pair( - "region_mode", - (region_mode < (sizeof(dma_region_mode_str) / sizeof(dma_region_mode_str[0])) ? - dma_region_mode_str[region_mode] : - "****"))); - fields.push_back(std::make_pair( - "stride_mode", - (stride_mode < (sizeof(dma_stride_mode_str) / sizeof(dma_stride_mode_str[0])) ? - dma_stride_mode_str[stride_mode] : - "****"))); - } -#endif -#endif - }; - // Size of second dimension for 2D/3D transfers - struct npu_set_dma0_size0_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t size : 16; // Size of second dimension for 2D/3D transfers -#ifdef __cplusplus - public: - npu_set_dma0_size0_t(uint32_t _size) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_SIZE0)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), size(_size & ((1U << 16) - 1)) - { - } - CONSTEXPR npu_set_dma0_size0_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_SIZE0)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), size(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_SIZE0) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_SIZE0); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_dma0_size0_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_dma0_size0_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_size() const - { - return static_cast(size); - } - CONSTEXPR npu_set_dma0_size0_t &set_size(uint32_t value) - { - size = static_cast(value) & ((1U << 16) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("size", std::to_string(size))); - } -#endif -#endif - }; - // Size of third dimension for 3D transfers - struct npu_set_dma0_size1_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t size : 16; // Size of third dimension for 3D transfers -#ifdef __cplusplus - public: - npu_set_dma0_size1_t(uint32_t _size) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_SIZE1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), size(_size & ((1U << 16) - 1)) - { - } - CONSTEXPR npu_set_dma0_size1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_SIZE1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), size(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_SIZE1) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_SIZE1); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_dma0_size1_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_dma0_size1_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_size() const - { - return static_cast(size); - } - CONSTEXPR npu_set_dma0_size1_t &set_size(uint32_t value) - { - size = static_cast(value) & ((1U << 16) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("size", std::to_string(size))); - } -#endif -#endif - }; - // IFM2 broadcast configuration - struct npu_set_ifm2_broadcast_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t - broadcast_h : 1; // Broadcast H dimension (if set then any accesses to IFM2 sets y=0 and IFM2 height=1) - uint32_t broadcast_w : 1; // Broadcast W dimension (if set then any accesses to IFM2 sets x=0 and IFM2 width=1) - uint32_t broadcast_c : 1; // Broadcast C dimension (if set then any accesses to IFM2 sets c=0 and IFM2 depth=1) - uint32_t reserved1 : 3; - uint32_t operand_order : 1; // Operand order - uint32_t broadcast_constant : 1; // Broadcast constant given by NPU_SET_IFM2_SCALAR and so ignore BH, BW and BC - uint32_t reserved2 : 8; -#ifdef __cplusplus - public: - npu_set_ifm2_broadcast_t(NPU_NAMESPACE::broadcast_mode _broadcast_h, - NPU_NAMESPACE::broadcast_mode _broadcast_w, - NPU_NAMESPACE::broadcast_mode _broadcast_c, - NPU_NAMESPACE::ifm2_operand_order _operand_order, - NPU_NAMESPACE::broadcast_mode _broadcast_constant) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_BROADCAST)), - reserved0(0), control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - broadcast_h(static_cast(_broadcast_h) & ((1U << 1) - 1)), - broadcast_w(static_cast(_broadcast_w) & ((1U << 1) - 1)), - broadcast_c(static_cast(_broadcast_c) & ((1U << 1) - 1)), reserved1(0), - operand_order(static_cast(_operand_order) & ((1U << 1) - 1)), - broadcast_constant(static_cast(_broadcast_constant) & ((1U << 1) - 1)), reserved2(0) - { - } - CONSTEXPR npu_set_ifm2_broadcast_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_BROADCAST)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), broadcast_h(0), broadcast_w(0), - broadcast_c(0), reserved1(0), operand_order(0), broadcast_constant(0), reserved2(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_BROADCAST) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_BROADCAST); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm2_broadcast_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm2_broadcast_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::broadcast_mode get_broadcast_h() const - { - return static_cast(broadcast_h); - } - CONSTEXPR npu_set_ifm2_broadcast_t &set_broadcast_h(NPU_NAMESPACE::broadcast_mode value) - { - broadcast_h = static_cast(value) & ((1U << 1) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::broadcast_mode get_broadcast_w() const - { - return static_cast(broadcast_w); - } - CONSTEXPR npu_set_ifm2_broadcast_t &set_broadcast_w(NPU_NAMESPACE::broadcast_mode value) - { - broadcast_w = static_cast(value) & ((1U << 1) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::broadcast_mode get_broadcast_c() const - { - return static_cast(broadcast_c); - } - CONSTEXPR npu_set_ifm2_broadcast_t &set_broadcast_c(NPU_NAMESPACE::broadcast_mode value) - { - broadcast_c = static_cast(value) & ((1U << 1) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::ifm2_operand_order get_operand_order() const - { - return static_cast(operand_order); - } - CONSTEXPR npu_set_ifm2_broadcast_t &set_operand_order(NPU_NAMESPACE::ifm2_operand_order value) - { - operand_order = static_cast(value) & ((1U << 1) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::broadcast_mode get_broadcast_constant() const - { - return static_cast(broadcast_constant); - } - CONSTEXPR npu_set_ifm2_broadcast_t &set_broadcast_constant(NPU_NAMESPACE::broadcast_mode value) - { - broadcast_constant = static_cast(value) & ((1U << 1) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair( - "broadcast_h", - (broadcast_h < (sizeof(broadcast_mode_str) / sizeof(broadcast_mode_str[0])) ? - broadcast_mode_str[broadcast_h] : - "****"))); - fields.push_back(std::make_pair( - "broadcast_w", - (broadcast_w < (sizeof(broadcast_mode_str) / sizeof(broadcast_mode_str[0])) ? - broadcast_mode_str[broadcast_w] : - "****"))); - fields.push_back(std::make_pair( - "broadcast_c", - (broadcast_c < (sizeof(broadcast_mode_str) / sizeof(broadcast_mode_str[0])) ? - broadcast_mode_str[broadcast_c] : - "****"))); - fields.push_back(std::make_pair( - "operand_order", - (operand_order < (sizeof(ifm2_operand_order_str) / sizeof(ifm2_operand_order_str[0])) ? - ifm2_operand_order_str[operand_order] : - "****"))); - fields.push_back(std::make_pair( - "broadcast_constant", - (broadcast_constant < (sizeof(broadcast_mode_str) / sizeof(broadcast_mode_str[0])) ? - broadcast_mode_str[broadcast_constant] : - "****"))); - } -#endif -#endif - }; - // IFM2 scalar value - struct npu_set_ifm2_scalar_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t scalar : 16; // int16 or uint16 depending on ifm2_precision.type -#ifdef __cplusplus - public: - npu_set_ifm2_scalar_t(uint32_t _scalar) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_SCALAR)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), scalar(_scalar & ((1U << 16) - 1)) - { - } - CONSTEXPR npu_set_ifm2_scalar_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_SCALAR)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), scalar(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_SCALAR) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_SCALAR); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm2_scalar_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm2_scalar_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_scalar() const - { - return static_cast(scalar); - } - CONSTEXPR npu_set_ifm2_scalar_t &set_scalar(uint32_t value) - { - scalar = static_cast(value) & ((1U << 16) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("scalar", std::to_string(scalar))); - } -#endif -#endif - }; - // IFM2 Precision - struct npu_set_ifm2_precision_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t activation_type : 1; // IFM type - MUST MATCH IFM - uint32_t reserved1 : 1; - uint32_t activation_precision : 2; // IFM precision - MUST MATCH IFM - uint32_t reserved2 : 2; - uint32_t activation_format : 2; // IFM format - uint32_t reserved3 : 8; -#ifdef __cplusplus - public: - npu_set_ifm2_precision_t(NPU_NAMESPACE::activation_type _activation_type, - NPU_NAMESPACE::activation_precision _activation_precision, - NPU_NAMESPACE::activation_format _activation_format) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_PRECISION)), - reserved0(0), control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - activation_type(static_cast(_activation_type) & ((1U << 1) - 1)), reserved1(0), - activation_precision(static_cast(_activation_precision) & ((1U << 2) - 1)), reserved2(0), - activation_format(static_cast(_activation_format) & ((1U << 2) - 1)), reserved3(0) - { - } - CONSTEXPR npu_set_ifm2_precision_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_PRECISION)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), activation_type(0), reserved1(0), - activation_precision(0), reserved2(0), activation_format(0), reserved3(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_PRECISION) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_PRECISION); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm2_precision_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm2_precision_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::activation_type get_activation_type() const - { - return static_cast(activation_type); - } - CONSTEXPR npu_set_ifm2_precision_t &set_activation_type(NPU_NAMESPACE::activation_type value) - { - activation_type = static_cast(value) & ((1U << 1) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::activation_precision get_activation_precision() const - { - return static_cast(activation_precision); - } - CONSTEXPR npu_set_ifm2_precision_t &set_activation_precision(NPU_NAMESPACE::activation_precision value) - { - activation_precision = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::activation_format get_activation_format() const - { - return static_cast(activation_format); - } - CONSTEXPR npu_set_ifm2_precision_t &set_activation_format(NPU_NAMESPACE::activation_format value) - { - activation_format = static_cast(value) & ((1U << 2) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair( - "activation_type", - (activation_type < (sizeof(activation_type_str) / sizeof(activation_type_str[0])) ? - activation_type_str[activation_type] : - "****"))); - fields.push_back(std::make_pair( - "activation_precision", - (activation_precision < (sizeof(activation_precision_str) / sizeof(activation_precision_str[0])) ? - activation_precision_str[activation_precision] : - "****"))); - fields.push_back(std::make_pair( - "activation_format", - (activation_format < (sizeof(activation_format_str) / sizeof(activation_format_str[0])) ? - activation_format_str[activation_format] : - "****"))); - } -#endif -#endif - }; - // IFM2 zero point - struct npu_set_ifm2_zero_point_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t zero_point : 16; // Zero point offset -#ifdef __cplusplus - public: - npu_set_ifm2_zero_point_t(uint32_t _zero_point) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_ZERO_POINT)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - zero_point(_zero_point & ((1U << 16) - 1)) - { - } - CONSTEXPR npu_set_ifm2_zero_point_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_ZERO_POINT)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), zero_point(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_ZERO_POINT) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_ZERO_POINT); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm2_zero_point_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm2_zero_point_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_zero_point() const - { - return static_cast(zero_point); - } - CONSTEXPR npu_set_ifm2_zero_point_t &set_zero_point(uint32_t value) - { - zero_point = static_cast(value) & ((1U << 16) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("zero_point", std::to_string(zero_point))); - } -#endif -#endif - }; - // IFM2 Tile 0 and tile 2 width - struct npu_set_ifm2_width0_m1_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t width_m1 : 16; // IFM2 Tile 0 and tile 2 width -#ifdef __cplusplus - public: - npu_set_ifm2_width0_m1_t(uint32_t _width_m1) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_WIDTH0_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), width_m1(_width_m1 & ((1U << 16) - 1)) - { - } - CONSTEXPR npu_set_ifm2_width0_m1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_WIDTH0_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), width_m1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_WIDTH0_M1) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_WIDTH0_M1); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm2_width0_m1_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm2_width0_m1_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_width_m1() const - { - return static_cast(width_m1); - } - CONSTEXPR npu_set_ifm2_width0_m1_t &set_width_m1(uint32_t value) - { - width_m1 = static_cast(value) & ((1U << 16) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("width_m1", std::to_string(width_m1))); - } -#endif -#endif - }; - // IFM2 Tile 0 height - struct npu_set_ifm2_height0_m1_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t height_m1 : 16; // IFM2 Tile 0 height -#ifdef __cplusplus - public: - npu_set_ifm2_height0_m1_t(uint32_t _height_m1) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_HEIGHT0_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), height_m1(_height_m1 & ((1U << 16) - 1)) - { - } - CONSTEXPR npu_set_ifm2_height0_m1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_HEIGHT0_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), height_m1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_HEIGHT0_M1) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_HEIGHT0_M1); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm2_height0_m1_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm2_height0_m1_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_height_m1() const - { - return static_cast(height_m1); - } - CONSTEXPR npu_set_ifm2_height0_m1_t &set_height_m1(uint32_t value) - { - height_m1 = static_cast(value) & ((1U << 16) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("height_m1", std::to_string(height_m1))); - } -#endif -#endif - }; - // IFM2 Tile 1 height - struct npu_set_ifm2_height1_m1_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t height_m1 : 16; // IFM2 Tile 1 height -#ifdef __cplusplus - public: - npu_set_ifm2_height1_m1_t(uint32_t _height_m1) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_HEIGHT1_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), height_m1(_height_m1 & ((1U << 16) - 1)) - { - } - CONSTEXPR npu_set_ifm2_height1_m1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_HEIGHT1_M1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), height_m1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_HEIGHT1_M1) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_HEIGHT1_M1); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm2_height1_m1_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm2_height1_m1_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_height_m1() const - { - return static_cast(height_m1); - } - CONSTEXPR npu_set_ifm2_height1_m1_t &set_height_m1(uint32_t value) - { - height_m1 = static_cast(value) & ((1U << 16) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("height_m1", std::to_string(height_m1))); - } -#endif -#endif - }; - // Start of IB0,IB1 buffers for IFM2 - struct npu_set_ifm2_ib_start_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t ib_start : 6; // Start of IB0,IB1 buffers for IFM2 in the SHRAM in KB units. Multiple of 2 - uint32_t reserved1 : 10; -#ifdef __cplusplus - public: - npu_set_ifm2_ib_start_t(uint32_t _ib_start) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_IB_START)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), ib_start(_ib_start & ((1U << 6) - 1)), - reserved1(0) - { - } - CONSTEXPR npu_set_ifm2_ib_start_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_IB_START)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), ib_start(0), reserved1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_IB_START) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_IB_START); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm2_ib_start_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm2_ib_start_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_ib_start() const - { - return static_cast(ib_start); - } - CONSTEXPR npu_set_ifm2_ib_start_t &set_ib_start(uint32_t value) - { - ib_start = static_cast(value) & ((1U << 6) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("ib_start", std::to_string(ib_start))); - } -#endif -#endif - }; - // Index n for IFM2 access - struct npu_set_ifm2_region_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t region : 3; // Index n for IFM2 access - uint32_t reserved1 : 13; -#ifdef __cplusplus - public: - npu_set_ifm2_region_t(uint32_t _region) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_REGION)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), region(_region & ((1U << 3) - 1)), - reserved1(0) - { - } - CONSTEXPR npu_set_ifm2_region_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_REGION)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), region(0), reserved1(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_REGION) && - control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_REGION); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm2_region_t &set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm2_region_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_region() const - { - return static_cast(region); - } - CONSTEXPR npu_set_ifm2_region_t &set_region(uint32_t value) - { - region = static_cast(value) & ((1U << 3) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("region", std::to_string(region))); - } -#endif -#endif - }; - // IFM Tile 0 address - struct npu_set_ifm_base0_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t addr_hi : 8; // address extension - uint32_t reserved1 : 8; - uint32_t addr_lo : 32; // address offset -#ifdef __cplusplus - public: - npu_set_ifm_base0_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_BASE0)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & std::numeric_limits::max())), reserved1(0), - addr_lo(static_cast((_addr)&std::numeric_limits::max())) - { - } - CONSTEXPR npu_set_ifm_base0_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_BASE0)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), addr_hi(0), reserved1(0), addr_lo(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_BASE0) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_BASE0); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_ifm_base0_t &set_addr(uint64_t value) - { - addr_lo = static_cast((value)&std::numeric_limits::max()); - addr_hi = static_cast((value >> 32) & std::numeric_limits::max()); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - std::stringstream saddr; - saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif - }; - // IFM Tile 1 address - struct npu_set_ifm_base1_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t addr_hi : 8; // address extension - uint32_t reserved1 : 8; - uint32_t addr_lo : 32; // address offset -#ifdef __cplusplus - public: - npu_set_ifm_base1_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_BASE1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & std::numeric_limits::max())), reserved1(0), - addr_lo(static_cast((_addr)&std::numeric_limits::max())) - { - } - CONSTEXPR npu_set_ifm_base1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_BASE1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), addr_hi(0), reserved1(0), addr_lo(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_BASE1) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_BASE1); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_ifm_base1_t &set_addr(uint64_t value) - { - addr_lo = static_cast((value)&std::numeric_limits::max()); - addr_hi = static_cast((value >> 32) & std::numeric_limits::max()); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - std::stringstream saddr; - saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif - }; - // IFM Tile 2 address - struct npu_set_ifm_base2_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t addr_hi : 8; // address extension - uint32_t reserved1 : 8; - uint32_t addr_lo : 32; // address offset -#ifdef __cplusplus - public: - npu_set_ifm_base2_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_BASE2)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & std::numeric_limits::max())), reserved1(0), - addr_lo(static_cast((_addr)&std::numeric_limits::max())) - { - } - CONSTEXPR npu_set_ifm_base2_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_BASE2)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), addr_hi(0), reserved1(0), addr_lo(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_BASE2) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_BASE2); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_ifm_base2_t &set_addr(uint64_t value) - { - addr_lo = static_cast((value)&std::numeric_limits::max()); - addr_hi = static_cast((value >> 32) & std::numeric_limits::max()); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - std::stringstream saddr; - saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif - }; - // IFM Tile 3 address - struct npu_set_ifm_base3_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t addr_hi : 8; // address extension - uint32_t reserved1 : 8; - uint32_t addr_lo : 32; // address offset -#ifdef __cplusplus - public: - npu_set_ifm_base3_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_BASE3)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & std::numeric_limits::max())), reserved1(0), - addr_lo(static_cast((_addr)&std::numeric_limits::max())) - { - } - CONSTEXPR npu_set_ifm_base3_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_BASE3)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), addr_hi(0), reserved1(0), addr_lo(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_BASE3) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_BASE3); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_ifm_base3_t &set_addr(uint64_t value) - { - addr_lo = static_cast((value)&std::numeric_limits::max()); - addr_hi = static_cast((value >> 32) & std::numeric_limits::max()); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - std::stringstream saddr; - saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif - }; - // IFM byte stride between horizontal values - struct npu_set_ifm_stride_x_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t addr_hi : 8; // address extension - uint32_t reserved1 : 8; - uint32_t addr_lo : 32; // address offset -#ifdef __cplusplus - public: - npu_set_ifm_stride_x_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_STRIDE_X)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & std::numeric_limits::max())), reserved1(0), - addr_lo(static_cast((_addr)&std::numeric_limits::max())) - { - } - CONSTEXPR npu_set_ifm_stride_x_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_STRIDE_X)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), addr_hi(0), reserved1(0), addr_lo(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_STRIDE_X) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_STRIDE_X); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_ifm_stride_x_t &set_addr(uint64_t value) - { - addr_lo = static_cast((value)&std::numeric_limits::max()); - addr_hi = static_cast((value >> 32) & std::numeric_limits::max()); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - std::stringstream saddr; - saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif - }; - // IFM byte stride between vertical values - struct npu_set_ifm_stride_y_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t addr_hi : 8; // address extension - uint32_t reserved1 : 8; - uint32_t addr_lo : 32; // address offset -#ifdef __cplusplus - public: - npu_set_ifm_stride_y_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_STRIDE_Y)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & std::numeric_limits::max())), reserved1(0), - addr_lo(static_cast((_addr)&std::numeric_limits::max())) - { - } - CONSTEXPR npu_set_ifm_stride_y_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_STRIDE_Y)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), addr_hi(0), reserved1(0), addr_lo(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_STRIDE_Y) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_STRIDE_Y); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_ifm_stride_y_t &set_addr(uint64_t value) - { - addr_lo = static_cast((value)&std::numeric_limits::max()); - addr_hi = static_cast((value >> 32) & std::numeric_limits::max()); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - std::stringstream saddr; - saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif - }; - // IFM byte stride between channel blocks (of 16 bytes each block) - struct npu_set_ifm_stride_c_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t addr_hi : 8; // address extension - uint32_t reserved1 : 8; - uint32_t addr_lo : 32; // address offset -#ifdef __cplusplus - public: - npu_set_ifm_stride_c_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_STRIDE_C)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & std::numeric_limits::max())), reserved1(0), - addr_lo(static_cast((_addr)&std::numeric_limits::max())) - { - } - CONSTEXPR npu_set_ifm_stride_c_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_STRIDE_C)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), addr_hi(0), reserved1(0), addr_lo(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_STRIDE_C) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_STRIDE_C); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_ifm_stride_c_t &set_addr(uint64_t value) - { - addr_lo = static_cast((value)&std::numeric_limits::max()); - addr_hi = static_cast((value >> 32) & std::numeric_limits::max()); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - std::stringstream saddr; - saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif - }; - // OFM Tile 0 address - struct npu_set_ofm_base0_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t addr_hi : 8; // address extension - uint32_t reserved1 : 8; - uint32_t addr_lo : 32; // address offset -#ifdef __cplusplus - public: - npu_set_ofm_base0_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_BASE0)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & std::numeric_limits::max())), reserved1(0), - addr_lo(static_cast((_addr)&std::numeric_limits::max())) - { - } - CONSTEXPR npu_set_ofm_base0_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_BASE0)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), addr_hi(0), reserved1(0), addr_lo(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_BASE0) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_BASE0); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_ofm_base0_t &set_addr(uint64_t value) - { - addr_lo = static_cast((value)&std::numeric_limits::max()); - addr_hi = static_cast((value >> 32) & std::numeric_limits::max()); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - std::stringstream saddr; - saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif - }; - // OFM Tile 1 address - struct npu_set_ofm_base1_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t addr_hi : 8; // address extension - uint32_t reserved1 : 8; - uint32_t addr_lo : 32; // address offset -#ifdef __cplusplus - public: - npu_set_ofm_base1_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_BASE1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & std::numeric_limits::max())), reserved1(0), - addr_lo(static_cast((_addr)&std::numeric_limits::max())) - { - } - CONSTEXPR npu_set_ofm_base1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_BASE1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), addr_hi(0), reserved1(0), addr_lo(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_BASE1) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_BASE1); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_ofm_base1_t &set_addr(uint64_t value) - { - addr_lo = static_cast((value)&std::numeric_limits::max()); - addr_hi = static_cast((value >> 32) & std::numeric_limits::max()); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - std::stringstream saddr; - saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif - }; - // OFM Tile 2 address - struct npu_set_ofm_base2_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t addr_hi : 8; // address extension - uint32_t reserved1 : 8; - uint32_t addr_lo : 32; // address offset -#ifdef __cplusplus - public: - npu_set_ofm_base2_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_BASE2)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & std::numeric_limits::max())), reserved1(0), - addr_lo(static_cast((_addr)&std::numeric_limits::max())) - { - } - CONSTEXPR npu_set_ofm_base2_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_BASE2)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), addr_hi(0), reserved1(0), addr_lo(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_BASE2) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_BASE2); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_ofm_base2_t &set_addr(uint64_t value) - { - addr_lo = static_cast((value)&std::numeric_limits::max()); - addr_hi = static_cast((value >> 32) & std::numeric_limits::max()); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - std::stringstream saddr; - saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif - }; - // OFM Tile 3 address - struct npu_set_ofm_base3_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t addr_hi : 8; // address extension - uint32_t reserved1 : 8; - uint32_t addr_lo : 32; // address offset -#ifdef __cplusplus - public: - npu_set_ofm_base3_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_BASE3)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & std::numeric_limits::max())), reserved1(0), - addr_lo(static_cast((_addr)&std::numeric_limits::max())) - { - } - CONSTEXPR npu_set_ofm_base3_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_BASE3)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), addr_hi(0), reserved1(0), addr_lo(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_BASE3) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_BASE3); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_ofm_base3_t &set_addr(uint64_t value) - { - addr_lo = static_cast((value)&std::numeric_limits::max()); - addr_hi = static_cast((value >> 32) & std::numeric_limits::max()); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - std::stringstream saddr; - saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif - }; - // OFM byte stride between horizontal values - struct npu_set_ofm_stride_x_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t addr_hi : 8; // address extension - uint32_t reserved1 : 8; - uint32_t addr_lo : 32; // address offset -#ifdef __cplusplus - public: - npu_set_ofm_stride_x_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_STRIDE_X)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & std::numeric_limits::max())), reserved1(0), - addr_lo(static_cast((_addr)&std::numeric_limits::max())) - { - } - CONSTEXPR npu_set_ofm_stride_x_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_STRIDE_X)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), addr_hi(0), reserved1(0), addr_lo(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_STRIDE_X) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_STRIDE_X); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_ofm_stride_x_t &set_addr(uint64_t value) - { - addr_lo = static_cast((value)&std::numeric_limits::max()); - addr_hi = static_cast((value >> 32) & std::numeric_limits::max()); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - std::stringstream saddr; - saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif - }; - // OFM byte stride between vertical values - struct npu_set_ofm_stride_y_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t addr_hi : 8; // address extension - uint32_t reserved1 : 8; - uint32_t addr_lo : 32; // address offset -#ifdef __cplusplus - public: - npu_set_ofm_stride_y_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_STRIDE_Y)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & std::numeric_limits::max())), reserved1(0), - addr_lo(static_cast((_addr)&std::numeric_limits::max())) - { - } - CONSTEXPR npu_set_ofm_stride_y_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_STRIDE_Y)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), addr_hi(0), reserved1(0), addr_lo(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_STRIDE_Y) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_STRIDE_Y); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_ofm_stride_y_t &set_addr(uint64_t value) - { - addr_lo = static_cast((value)&std::numeric_limits::max()); - addr_hi = static_cast((value >> 32) & std::numeric_limits::max()); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - std::stringstream saddr; - saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif - }; - // OFM byte stride between channel blocks (of 16 bytes each block) - struct npu_set_ofm_stride_c_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t addr_hi : 8; // address extension - uint32_t reserved1 : 8; - uint32_t addr_lo : 32; // address offset -#ifdef __cplusplus - public: - npu_set_ofm_stride_c_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_STRIDE_C)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & std::numeric_limits::max())), reserved1(0), - addr_lo(static_cast((_addr)&std::numeric_limits::max())) - { - } - CONSTEXPR npu_set_ofm_stride_c_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_STRIDE_C)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), addr_hi(0), reserved1(0), addr_lo(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_STRIDE_C) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_STRIDE_C); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_ofm_stride_c_t &set_addr(uint64_t value) - { - addr_lo = static_cast((value)&std::numeric_limits::max()); - addr_hi = static_cast((value >> 32) & std::numeric_limits::max()); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - std::stringstream saddr; - saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif - }; - // Weight stream byte offset in WEIGHT_REGION - struct npu_set_weight_base_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t addr_hi : 8; // address extension - uint32_t reserved1 : 8; - uint32_t addr_lo : 32; // address offset -#ifdef __cplusplus - public: - npu_set_weight_base_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT_BASE)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & std::numeric_limits::max())), reserved1(0), - addr_lo(static_cast((_addr)&std::numeric_limits::max())) - { - } - CONSTEXPR npu_set_weight_base_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT_BASE)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), addr_hi(0), reserved1(0), addr_lo(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT_BASE) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT_BASE); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_weight_base_t &set_addr(uint64_t value) - { - addr_lo = static_cast((value)&std::numeric_limits::max()); - addr_hi = static_cast((value >> 32) & std::numeric_limits::max()); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - std::stringstream saddr; - saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif - }; - // Weight stream byte length - struct npu_set_weight_length_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t reserved1 : 16; - uint32_t length : 32; // Weight stream byte length -#ifdef __cplusplus - public: - npu_set_weight_length_t(uint32_t _length) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT_LENGTH)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), length(_length) - { - } - CONSTEXPR npu_set_weight_length_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT_LENGTH)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), length(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT_LENGTH) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT_LENGTH); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd1_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_weight_length_t &set_opcode(NPU_NAMESPACE::cmd1_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_weight_length_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_length() const - { - return static_cast(length); - } - CONSTEXPR npu_set_weight_length_t &set_length(uint32_t value) - { - length = value; - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("length", std::to_string(length))); - } -#endif -#endif - }; - // Scale and bias stream input byte offset from SCALE_REGION - struct npu_set_scale_base_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t addr_hi : 8; // address extension - uint32_t reserved1 : 8; - uint32_t addr_lo : 32; // address offset -#ifdef __cplusplus - public: - npu_set_scale_base_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_SCALE_BASE)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & std::numeric_limits::max())), reserved1(0), - addr_lo(static_cast((_addr)&std::numeric_limits::max())) - { - } - CONSTEXPR npu_set_scale_base_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_SCALE_BASE)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), addr_hi(0), reserved1(0), addr_lo(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_SCALE_BASE) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_SCALE_BASE); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_scale_base_t &set_addr(uint64_t value) - { - addr_lo = static_cast((value)&std::numeric_limits::max()); - addr_hi = static_cast((value >> 32) & std::numeric_limits::max()); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - std::stringstream saddr; - saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif - }; - // Scale and bias stream input byte length - struct npu_set_scale_length_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t reserved1 : 16; - uint32_t length : 20; // Scale and bias stream byte length - uint32_t reserved2 : 12; -#ifdef __cplusplus - public: - npu_set_scale_length_t(uint32_t _length) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_SCALE_LENGTH)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), - length(_length & ((1U << 20) - 1)), reserved2(0) - { - } - CONSTEXPR npu_set_scale_length_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_SCALE_LENGTH)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), length(0), reserved2(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_SCALE_LENGTH) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_SCALE_LENGTH); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd1_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_scale_length_t &set_opcode(NPU_NAMESPACE::cmd1_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_scale_length_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_length() const - { - return static_cast(length); - } - CONSTEXPR npu_set_scale_length_t &set_length(uint32_t value) - { - length = value & ((1U << 20) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("length", std::to_string(length))); - } -#endif -#endif - }; - // OFM scale - struct npu_set_ofm_scale_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t shift : 6; // Shift - uint32_t reserved1 : 10; - uint32_t scale : 32; // Scale. Not applied for 32-bit operations -#ifdef __cplusplus - public: - npu_set_ofm_scale_t(uint32_t _shift, uint32_t _scale) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_SCALE)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), shift(_shift & ((1U << 6) - 1)), - reserved1(0), scale(_scale) - { - } - CONSTEXPR npu_set_ofm_scale_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_SCALE)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), shift(0), reserved1(0), scale(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_SCALE) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_SCALE); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd1_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ofm_scale_t &set_opcode(NPU_NAMESPACE::cmd1_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ofm_scale_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_shift() const - { - return static_cast(shift); - } - CONSTEXPR npu_set_ofm_scale_t &set_shift(uint32_t value) - { - shift = static_cast(value) & ((1U << 6) - 1); - return *this; - } - CONSTEXPR uint32_t get_scale() const - { - return static_cast(scale); - } - CONSTEXPR npu_set_ofm_scale_t &set_scale(uint32_t value) - { - scale = value; - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("shift", std::to_string(shift))); - fields.push_back(std::make_pair("scale", std::to_string(scale))); - } -#endif -#endif - }; - // Input operand A scale - struct npu_set_opa_scale_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t shift : 6; // Shift. Ignored if IFM scale mode is 0 - uint32_t reserved1 : 10; - uint32_t scale : 32; // Scale. 16-bit if IFM scale mode is 0 -#ifdef __cplusplus - public: - npu_set_opa_scale_t(uint32_t _shift, uint32_t _scale) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OPA_SCALE)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), shift(_shift & ((1U << 6) - 1)), - reserved1(0), scale(_scale) - { - } - CONSTEXPR npu_set_opa_scale_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OPA_SCALE)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), shift(0), reserved1(0), scale(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OPA_SCALE) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OPA_SCALE); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd1_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_opa_scale_t &set_opcode(NPU_NAMESPACE::cmd1_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_opa_scale_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_shift() const - { - return static_cast(shift); - } - CONSTEXPR npu_set_opa_scale_t &set_shift(uint32_t value) - { - shift = static_cast(value) & ((1U << 6) - 1); - return *this; - } - CONSTEXPR uint32_t get_scale() const - { - return static_cast(scale); - } - CONSTEXPR npu_set_opa_scale_t &set_scale(uint32_t value) - { - scale = value; - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("shift", std::to_string(shift))); - fields.push_back(std::make_pair("scale", std::to_string(scale))); - } -#endif -#endif - }; - // Input operand B scale - struct npu_set_opb_scale_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t reserved1 : 16; - uint32_t scale : 16; // Scale. Not used if IFM scale mode is 1 or 2 - uint32_t reserved2 : 16; -#ifdef __cplusplus - public: - npu_set_opb_scale_t(uint32_t _scale) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OPB_SCALE)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), - scale(_scale & ((1U << 16) - 1)), reserved2(0) - { - } - CONSTEXPR npu_set_opb_scale_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OPB_SCALE)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), scale(0), reserved2(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OPB_SCALE) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OPB_SCALE); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd1_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_opb_scale_t &set_opcode(NPU_NAMESPACE::cmd1_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_opb_scale_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_scale() const - { - return static_cast(scale); - } - CONSTEXPR npu_set_opb_scale_t &set_scale(uint32_t value) - { - scale = static_cast(value) & ((1U << 16) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("scale", std::to_string(scale))); - } -#endif -#endif - }; - // DMA user channel 0 source byte offset from DMA0_SRC_REGION - struct npu_set_dma0_src_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t addr_hi : 8; // address extension - uint32_t reserved1 : 8; - uint32_t addr_lo : 32; // address offset -#ifdef __cplusplus - public: - npu_set_dma0_src_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_SRC)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & std::numeric_limits::max())), reserved1(0), - addr_lo(static_cast((_addr)&std::numeric_limits::max())) - { - } - CONSTEXPR npu_set_dma0_src_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_SRC)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), addr_hi(0), reserved1(0), addr_lo(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_SRC) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_SRC); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_dma0_src_t &set_addr(uint64_t value) - { - addr_lo = static_cast((value)&std::numeric_limits::max()); - addr_hi = static_cast((value >> 32) & std::numeric_limits::max()); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - std::stringstream saddr; - saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif - }; - // DMA user channel 0 destination byte offset from DMA0_DST_REGION - struct npu_set_dma0_dst_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t addr_hi : 8; // address extension - uint32_t reserved1 : 8; - uint32_t addr_lo : 32; // address offset -#ifdef __cplusplus - public: - npu_set_dma0_dst_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_DST)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & std::numeric_limits::max())), reserved1(0), - addr_lo(static_cast((_addr)&std::numeric_limits::max())) - { - } - CONSTEXPR npu_set_dma0_dst_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_DST)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), addr_hi(0), reserved1(0), addr_lo(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_DST) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_DST); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_dma0_dst_t &set_addr(uint64_t value) - { - addr_lo = static_cast((value)&std::numeric_limits::max()); - addr_hi = static_cast((value >> 32) & std::numeric_limits::max()); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - std::stringstream saddr; - saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif - }; - // DMA user channel 0 transfer length in bytes for each 1D transfer - struct npu_set_dma0_len_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t addr_hi : 8; // address extension - uint32_t reserved1 : 8; - uint32_t addr_lo : 32; // address offset -#ifdef __cplusplus - public: - npu_set_dma0_len_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_LEN)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & std::numeric_limits::max())), reserved1(0), - addr_lo(static_cast((_addr)&std::numeric_limits::max())) - { - } - CONSTEXPR npu_set_dma0_len_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_LEN)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), addr_hi(0), reserved1(0), addr_lo(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_LEN) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_LEN); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_dma0_len_t &set_addr(uint64_t value) - { - addr_lo = static_cast((value)&std::numeric_limits::max()); - addr_hi = static_cast((value >> 32) & std::numeric_limits::max()); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - std::stringstream saddr; - saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif - }; - // byte distance to skip after each inner (1D) transfer (2D/3D mode) (any alignment) - struct npu_set_dma0_skip0_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t addr_hi : 8; // address extension - uint32_t reserved1 : 8; - uint32_t addr_lo : 32; // address offset -#ifdef __cplusplus - public: - npu_set_dma0_skip0_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_SKIP0)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & std::numeric_limits::max())), reserved1(0), - addr_lo(static_cast((_addr)&std::numeric_limits::max())) - { - } - CONSTEXPR npu_set_dma0_skip0_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_SKIP0)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), addr_hi(0), reserved1(0), addr_lo(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_SKIP0) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_SKIP0); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_dma0_skip0_t &set_addr(uint64_t value) - { - addr_lo = static_cast((value)&std::numeric_limits::max()); - addr_hi = static_cast((value >> 32) & std::numeric_limits::max()); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - std::stringstream saddr; - saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif - }; - // byte distance to skip after each 2D transfer (3D mode) (any alignment) - struct npu_set_dma0_skip1_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t addr_hi : 8; // address extension - uint32_t reserved1 : 8; - uint32_t addr_lo : 32; // address offset -#ifdef __cplusplus - public: - npu_set_dma0_skip1_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_SKIP1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & std::numeric_limits::max())), reserved1(0), - addr_lo(static_cast((_addr)&std::numeric_limits::max())) - { - } - CONSTEXPR npu_set_dma0_skip1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_SKIP1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), addr_hi(0), reserved1(0), addr_lo(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_SKIP1) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_SKIP1); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_dma0_skip1_t &set_addr(uint64_t value) - { - addr_lo = static_cast((value)&std::numeric_limits::max()); - addr_hi = static_cast((value >> 32) & std::numeric_limits::max()); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - std::stringstream saddr; - saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif - }; - // IFM2 Tile 0 address - struct npu_set_ifm2_base0_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t addr_hi : 8; // address extension - uint32_t reserved1 : 8; - uint32_t addr_lo : 32; // address offset -#ifdef __cplusplus - public: - npu_set_ifm2_base0_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_BASE0)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & std::numeric_limits::max())), reserved1(0), - addr_lo(static_cast((_addr)&std::numeric_limits::max())) - { - } - CONSTEXPR npu_set_ifm2_base0_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_BASE0)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), addr_hi(0), reserved1(0), addr_lo(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_BASE0) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_BASE0); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_ifm2_base0_t &set_addr(uint64_t value) - { - addr_lo = static_cast((value)&std::numeric_limits::max()); - addr_hi = static_cast((value >> 32) & std::numeric_limits::max()); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - std::stringstream saddr; - saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif - }; - // IFM2 Tile 1 address - struct npu_set_ifm2_base1_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t addr_hi : 8; // address extension - uint32_t reserved1 : 8; - uint32_t addr_lo : 32; // address offset -#ifdef __cplusplus - public: - npu_set_ifm2_base1_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_BASE1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & std::numeric_limits::max())), reserved1(0), - addr_lo(static_cast((_addr)&std::numeric_limits::max())) - { - } - CONSTEXPR npu_set_ifm2_base1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_BASE1)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), addr_hi(0), reserved1(0), addr_lo(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_BASE1) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_BASE1); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_ifm2_base1_t &set_addr(uint64_t value) - { - addr_lo = static_cast((value)&std::numeric_limits::max()); - addr_hi = static_cast((value >> 32) & std::numeric_limits::max()); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - std::stringstream saddr; - saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif - }; - // IFM2 Tile 2 address - struct npu_set_ifm2_base2_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t addr_hi : 8; // address extension - uint32_t reserved1 : 8; - uint32_t addr_lo : 32; // address offset -#ifdef __cplusplus - public: - npu_set_ifm2_base2_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_BASE2)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & std::numeric_limits::max())), reserved1(0), - addr_lo(static_cast((_addr)&std::numeric_limits::max())) - { - } - CONSTEXPR npu_set_ifm2_base2_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_BASE2)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), addr_hi(0), reserved1(0), addr_lo(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_BASE2) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_BASE2); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_ifm2_base2_t &set_addr(uint64_t value) - { - addr_lo = static_cast((value)&std::numeric_limits::max()); - addr_hi = static_cast((value >> 32) & std::numeric_limits::max()); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - std::stringstream saddr; - saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif - }; - // IFM2 Tile 3 address - struct npu_set_ifm2_base3_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t addr_hi : 8; // address extension - uint32_t reserved1 : 8; - uint32_t addr_lo : 32; // address offset -#ifdef __cplusplus - public: - npu_set_ifm2_base3_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_BASE3)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & std::numeric_limits::max())), reserved1(0), - addr_lo(static_cast((_addr)&std::numeric_limits::max())) - { - } - CONSTEXPR npu_set_ifm2_base3_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_BASE3)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), addr_hi(0), reserved1(0), addr_lo(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_BASE3) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_BASE3); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_ifm2_base3_t &set_addr(uint64_t value) - { - addr_lo = static_cast((value)&std::numeric_limits::max()); - addr_hi = static_cast((value >> 32) & std::numeric_limits::max()); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - std::stringstream saddr; - saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif - }; - // IFM2 byte stride between horizontal values - struct npu_set_ifm2_stride_x_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t addr_hi : 8; // address extension - uint32_t reserved1 : 8; - uint32_t addr_lo : 32; // address offset -#ifdef __cplusplus - public: - npu_set_ifm2_stride_x_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_STRIDE_X)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & std::numeric_limits::max())), reserved1(0), - addr_lo(static_cast((_addr)&std::numeric_limits::max())) - { - } - CONSTEXPR npu_set_ifm2_stride_x_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_STRIDE_X)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), addr_hi(0), reserved1(0), addr_lo(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_STRIDE_X) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_STRIDE_X); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_ifm2_stride_x_t &set_addr(uint64_t value) - { - addr_lo = static_cast((value)&std::numeric_limits::max()); - addr_hi = static_cast((value >> 32) & std::numeric_limits::max()); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - std::stringstream saddr; - saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif - }; - // IFM2 byte stride between vertical values - struct npu_set_ifm2_stride_y_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t addr_hi : 8; // address extension - uint32_t reserved1 : 8; - uint32_t addr_lo : 32; // address offset -#ifdef __cplusplus - public: - npu_set_ifm2_stride_y_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_STRIDE_Y)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & std::numeric_limits::max())), reserved1(0), - addr_lo(static_cast((_addr)&std::numeric_limits::max())) - { - } - CONSTEXPR npu_set_ifm2_stride_y_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_STRIDE_Y)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), addr_hi(0), reserved1(0), addr_lo(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_STRIDE_Y) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_STRIDE_Y); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_ifm2_stride_y_t &set_addr(uint64_t value) - { - addr_lo = static_cast((value)&std::numeric_limits::max()); - addr_hi = static_cast((value >> 32) & std::numeric_limits::max()); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - std::stringstream saddr; - saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif - }; - // IFM2 byte stride between channel blocks (of 16 bytes each block) - struct npu_set_ifm2_stride_c_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t addr_hi : 8; // address extension - uint32_t reserved1 : 8; - uint32_t addr_lo : 32; // address offset -#ifdef __cplusplus - public: - npu_set_ifm2_stride_c_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_STRIDE_C)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & std::numeric_limits::max())), reserved1(0), - addr_lo(static_cast((_addr)&std::numeric_limits::max())) - { - } - CONSTEXPR npu_set_ifm2_stride_c_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_STRIDE_C)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), addr_hi(0), reserved1(0), addr_lo(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_STRIDE_C) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_STRIDE_C); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_ifm2_stride_c_t &set_addr(uint64_t value) - { - addr_lo = static_cast((value)&std::numeric_limits::max()); - addr_hi = static_cast((value >> 32) & std::numeric_limits::max()); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - std::stringstream saddr; - saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif - }; - // Weight stream byte offset in WEIGHT_REGION for core 1 - struct npu_set_weight1_base_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t addr_hi : 8; // address extension - uint32_t reserved1 : 8; - uint32_t addr_lo : 32; // address offset -#ifdef __cplusplus - public: - npu_set_weight1_base_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT1_BASE)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & std::numeric_limits::max())), reserved1(0), - addr_lo(static_cast((_addr)&std::numeric_limits::max())) - { - } - CONSTEXPR npu_set_weight1_base_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT1_BASE)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), addr_hi(0), reserved1(0), addr_lo(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT1_BASE) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT1_BASE); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_weight1_base_t &set_addr(uint64_t value) - { - addr_lo = static_cast((value)&std::numeric_limits::max()); - addr_hi = static_cast((value >> 32) & std::numeric_limits::max()); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - std::stringstream saddr; - saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif - }; - // Weight stream byte length for core 1 - struct npu_set_weight1_length_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t reserved1 : 16; - uint32_t length : 32; // Weight stream byte length -#ifdef __cplusplus - public: - npu_set_weight1_length_t(uint32_t _length) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT1_LENGTH)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), length(_length) - { - } - CONSTEXPR npu_set_weight1_length_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT1_LENGTH)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), length(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT1_LENGTH) && - control >= 1 && control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT1_LENGTH); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd1_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_weight1_length_t &set_opcode(NPU_NAMESPACE::cmd1_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_weight1_length_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_length() const - { - return static_cast(length); - } - CONSTEXPR npu_set_weight1_length_t &set_length(uint32_t value) - { - length = value; - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("length", std::to_string(length))); - } -#endif -#endif - }; - // Scale and bias stream input byte offset from SCALE_REGION for core 1 - struct npu_set_scale1_base_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t addr_hi : 8; // address extension - uint32_t reserved1 : 8; - uint32_t addr_lo : 32; // address offset -#ifdef __cplusplus - public: - npu_set_scale1_base_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_SCALE1_BASE)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & std::numeric_limits::max())), reserved1(0), - addr_lo(static_cast((_addr)&std::numeric_limits::max())) - { - } - CONSTEXPR npu_set_scale1_base_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_SCALE1_BASE)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), addr_hi(0), reserved1(0), addr_lo(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_SCALE1_BASE) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_SCALE1_BASE); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_scale1_base_t &set_addr(uint64_t value) - { - addr_lo = static_cast((value)&std::numeric_limits::max()); - addr_hi = static_cast((value >> 32) & std::numeric_limits::max()); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - std::stringstream saddr; - saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif - }; - // Scale and bias stream input byte length for core 1 - struct npu_set_scale1_length_t - { -#ifdef __cplusplus - private: -#endif - uint32_t opcode : 10; // opcode - uint32_t reserved0 : 4; - uint32_t control : 2; // control - uint32_t reserved1 : 16; - uint32_t length : 20; // Scale and bias stream byte length - uint32_t reserved2 : 12; -#ifdef __cplusplus - public: - npu_set_scale1_length_t(uint32_t _length) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_SCALE1_LENGTH)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), - length(_length & ((1U << 20) - 1)), reserved2(0) - { - } - CONSTEXPR npu_set_scale1_length_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_SCALE1_LENGTH)), reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), reserved1(0), length(0), reserved2(0) - { - } - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_SCALE1_LENGTH) && control >= 1 && - control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_SCALE1_LENGTH); - control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word; - std::memcpy(&word, this, sizeof(word)); - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd1_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_scale1_length_t &set_opcode(NPU_NAMESPACE::cmd1_opcode value) - { - opcode = static_cast(value) & ((1U << 10) - 1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_scale1_length_t &set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2) - 1); - return *this; - } - CONSTEXPR uint32_t get_length() const - { - return static_cast(length); - } - CONSTEXPR npu_set_scale1_length_t &set_length(uint32_t value) - { - length = value & ((1U << 20) - 1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector> &fields) const - { - fields.push_back(std::make_pair("length", std::to_string(length))); - } -#endif -#endif - }; -#ifdef __cplusplus -}; -#endif -#define NPU_OP_STRUCTS \ - NPU_OP_(stop) \ - NPU_OP_(irq) \ - NPU_OP_(conv) \ - NPU_OP_(depthwise) \ - NPU_OP_(pool) \ - NPU_OP_(elementwise) \ - NPU_OP_(dma_start) \ - NPU_OP_(dma_wait) \ - NPU_OP_(kernel_wait) \ - NPU_OP_(pmu_mask) - -#define NPU_SET_STRUCTS \ - NPU_SET_(ifm_pad_top) \ - NPU_SET_(ifm_pad_left) \ - NPU_SET_(ifm_pad_right) \ - NPU_SET_(ifm_pad_bottom) \ - NPU_SET_(ifm_depth_m1) \ - NPU_SET_(ifm_precision) \ - NPU_SET_(ifm_upscale) \ - NPU_SET_(ifm_zero_point) \ - NPU_SET_(ifm_width0_m1) \ - NPU_SET_(ifm_height0_m1) \ - NPU_SET_(ifm_height1_m1) \ - NPU_SET_(ifm_ib_end) \ - NPU_SET_(ifm_region) \ - NPU_SET_(ofm_width_m1) \ - NPU_SET_(ofm_height_m1) \ - NPU_SET_(ofm_depth_m1) \ - NPU_SET_(ofm_precision) \ - NPU_SET_(ofm_blk_width_m1) \ - NPU_SET_(ofm_blk_height_m1) \ - NPU_SET_(ofm_blk_depth_m1) \ - NPU_SET_(ofm_zero_point) \ - NPU_SET_(ofm_width0_m1) \ - NPU_SET_(ofm_height0_m1) \ - NPU_SET_(ofm_height1_m1) \ - NPU_SET_(ofm_region) \ - NPU_SET_(kernel_width_m1) \ - NPU_SET_(kernel_height_m1) \ - NPU_SET_(kernel_stride) \ - NPU_SET_(parallel_mode) \ - NPU_SET_(acc_format) \ - NPU_SET_(activation) \ - NPU_SET_(activation_min) \ - NPU_SET_(activation_max) \ - NPU_SET_(weight_region) \ - NPU_SET_(scale_region) \ - NPU_SET_(ab_start) \ - NPU_SET_(blockdep) \ - NPU_SET_(dma0_src_region) \ - NPU_SET_(dma0_dst_region) \ - NPU_SET_(dma0_size0) \ - NPU_SET_(dma0_size1) \ - NPU_SET_(ifm2_broadcast) \ - NPU_SET_(ifm2_scalar) \ - NPU_SET_(ifm2_precision) \ - NPU_SET_(ifm2_zero_point) \ - NPU_SET_(ifm2_width0_m1) \ - NPU_SET_(ifm2_height0_m1) \ - NPU_SET_(ifm2_height1_m1) \ - NPU_SET_(ifm2_ib_start) \ - NPU_SET_(ifm2_region) \ - NPU_SET_(ifm_base0) \ - NPU_SET_(ifm_base1) \ - NPU_SET_(ifm_base2) \ - NPU_SET_(ifm_base3) \ - NPU_SET_(ifm_stride_x) \ - NPU_SET_(ifm_stride_y) \ - NPU_SET_(ifm_stride_c) \ - NPU_SET_(ofm_base0) \ - NPU_SET_(ofm_base1) \ - NPU_SET_(ofm_base2) \ - NPU_SET_(ofm_base3) \ - NPU_SET_(ofm_stride_x) \ - NPU_SET_(ofm_stride_y) \ - NPU_SET_(ofm_stride_c) \ - NPU_SET_(weight_base) \ - NPU_SET_(weight_length) \ - NPU_SET_(scale_base) \ - NPU_SET_(scale_length) \ - NPU_SET_(ofm_scale) \ - NPU_SET_(opa_scale) \ - NPU_SET_(opb_scale) \ - NPU_SET_(dma0_src) \ - NPU_SET_(dma0_dst) \ - NPU_SET_(dma0_len) \ - NPU_SET_(dma0_skip0) \ - NPU_SET_(dma0_skip1) \ - NPU_SET_(ifm2_base0) \ - NPU_SET_(ifm2_base1) \ - NPU_SET_(ifm2_base2) \ - NPU_SET_(ifm2_base3) \ - NPU_SET_(ifm2_stride_x) \ - NPU_SET_(ifm2_stride_y) \ - NPU_SET_(ifm2_stride_c) \ - NPU_SET_(weight1_base) \ - NPU_SET_(weight1_length) \ - NPU_SET_(scale1_base) \ - NPU_SET_(scale1_length) - -#define EXPAND_ACC_FORMAT(FUNC, SEP) FUNC(acc_format, I32) SEP FUNC(acc_format, I40) SEP FUNC(acc_format, F16) - -#define EXPAND_ACTIVATION_CLIP_RANGE(FUNC, SEP) \ - FUNC(activation_clip_range, OFM_PRECISION) \ - SEP FUNC(activation_clip_range, FORCE_UINT8) SEP FUNC(activation_clip_range, FORCE_INT8) \ - SEP FUNC(activation_clip_range, FORCE_INT16) - -#define EXPAND_ACTIVATION_FORMAT(FUNC, SEP) FUNC(activation_format, NHWC) SEP FUNC(activation_format, NHCWB16) - -#define EXPAND_ACTIVATION_FUNCTION(FUNC, SEP) \ - FUNC(activation_function, RELU) \ - SEP FUNC(activation_function, TANH) SEP FUNC(activation_function, SIGMOID) SEP FUNC(activation_function, TABLE_0) \ - SEP FUNC(activation_function, TABLE_1) SEP FUNC(activation_function, TABLE_2) \ - SEP FUNC(activation_function, TABLE_3) SEP FUNC(activation_function, TABLE_4) \ - SEP FUNC(activation_function, TABLE_5) SEP FUNC(activation_function, TABLE_6) \ - SEP FUNC(activation_function, TABLE_7) - -#define EXPAND_ACTIVATION_PRECISION(FUNC, SEP) \ - FUNC(activation_precision, B8) \ - SEP FUNC(activation_precision, B16) SEP FUNC(activation_precision, B32) SEP FUNC(activation_precision, B64) - -#define EXPAND_ACTIVATION_TYPE(FUNC, SEP) FUNC(activation_type, UNSIGNED) SEP FUNC(activation_type, SIGNED) - -#define EXPAND_AXI_MEM_ENCODING(FUNC, SEP) \ - FUNC(axi_mem_encoding, DEVICE_NON_BUFFERABLE) \ - SEP FUNC(axi_mem_encoding, DEVICE_BUFFERABLE) SEP FUNC(axi_mem_encoding, NORMAL_NON_CACHEABLE_NON_BUFFERABLE) \ - SEP FUNC(axi_mem_encoding, NORMAL_NON_CACHEABLE_BUFFERABLE) \ - SEP FUNC(axi_mem_encoding, WRITE_THROUGH_NO_ALLOCATE) \ - SEP FUNC(axi_mem_encoding, WRITE_THROUGH_READ_ALLOCATE) \ - SEP FUNC(axi_mem_encoding, WRITE_THROUGH_WRITE_ALLOCATE) \ - SEP FUNC(axi_mem_encoding, WRITE_THROUGH_READ_AND_WRITE_ALLOCATE) \ - SEP FUNC(axi_mem_encoding, WRITE_BACK_NO_ALLOCATE) \ - SEP FUNC(axi_mem_encoding, WRITE_BACK_READ_ALLOCATE) \ - SEP FUNC(axi_mem_encoding, WRITE_BACK_WRITE_ALLOCATE) \ - SEP FUNC(axi_mem_encoding, WRITE_BACK_READ_AND_WRITE_ALLOCATE) - -#define EXPAND_BROADCAST_MODE(FUNC, SEP) FUNC(broadcast_mode, DISABLE) SEP FUNC(broadcast_mode, ENABLE) - -#define EXPAND_CMD0_OPCODE(FUNC, SEP) \ - FUNC(cmd0_opcode, NPU_OP_STOP) \ - SEP FUNC(cmd0_opcode, NPU_OP_IRQ) SEP FUNC(cmd0_opcode, NPU_OP_CONV) SEP FUNC( \ - cmd0_opcode, NPU_OP_DEPTHWISE) SEP FUNC(cmd0_opcode, NPU_OP_POOL) SEP FUNC(cmd0_opcode, NPU_OP_ELEMENTWISE) \ - SEP FUNC(cmd0_opcode, NPU_OP_DMA_START) SEP FUNC(cmd0_opcode, NPU_OP_DMA_WAIT) SEP FUNC( \ - cmd0_opcode, NPU_OP_KERNEL_WAIT) SEP FUNC(cmd0_opcode, NPU_OP_PMU_MASK) SEP FUNC(cmd0_opcode, \ - NPU_SET_IFM_PAD_TOP) \ - SEP FUNC(cmd0_opcode, NPU_SET_IFM_PAD_LEFT) SEP FUNC(cmd0_opcode, NPU_SET_IFM_PAD_RIGHT) SEP FUNC( \ - cmd0_opcode, NPU_SET_IFM_PAD_BOTTOM) SEP FUNC(cmd0_opcode, \ - NPU_SET_IFM_DEPTH_M1) SEP FUNC(cmd0_opcode, \ - NPU_SET_IFM_PRECISION) \ - SEP FUNC(cmd0_opcode, NPU_SET_IFM_UPSCALE) SEP FUNC(cmd0_opcode, NPU_SET_IFM_ZERO_POINT) SEP FUNC( \ - cmd0_opcode, NPU_SET_IFM_WIDTH0_M1) SEP FUNC(cmd0_opcode, NPU_SET_IFM_HEIGHT0_M1) \ - SEP FUNC(cmd0_opcode, NPU_SET_IFM_HEIGHT1_M1) SEP FUNC(cmd0_opcode, NPU_SET_IFM_IB_END) SEP FUNC( \ - cmd0_opcode, NPU_SET_IFM_REGION) SEP FUNC(cmd0_opcode, NPU_SET_OFM_WIDTH_M1) \ - SEP FUNC(cmd0_opcode, NPU_SET_OFM_HEIGHT_M1) SEP FUNC(cmd0_opcode, NPU_SET_OFM_DEPTH_M1) \ - SEP FUNC(cmd0_opcode, NPU_SET_OFM_PRECISION) SEP FUNC( \ - cmd0_opcode, NPU_SET_OFM_BLK_WIDTH_M1) SEP FUNC(cmd0_opcode, \ - NPU_SET_OFM_BLK_HEIGHT_M1) \ - SEP FUNC(cmd0_opcode, NPU_SET_OFM_BLK_DEPTH_M1) SEP FUNC( \ - cmd0_opcode, NPU_SET_OFM_ZERO_POINT) SEP FUNC(cmd0_opcode, NPU_SET_OFM_WIDTH0_M1) \ - SEP FUNC(cmd0_opcode, NPU_SET_OFM_HEIGHT0_M1) SEP FUNC( \ - cmd0_opcode, \ - NPU_SET_OFM_HEIGHT1_M1) SEP FUNC(cmd0_opcode, NPU_SET_OFM_REGION) \ - SEP FUNC(cmd0_opcode, NPU_SET_KERNEL_WIDTH_M1) SEP FUNC( \ - cmd0_opcode, \ - NPU_SET_KERNEL_HEIGHT_M1) SEP FUNC(cmd0_opcode, NPU_SET_KERNEL_STRIDE) \ - SEP FUNC(cmd0_opcode, NPU_SET_PARALLEL_MODE) SEP FUNC( \ - cmd0_opcode, \ - NPU_SET_ACC_FORMAT) SEP FUNC(cmd0_opcode, NPU_SET_ACTIVATION) \ - SEP FUNC(cmd0_opcode, \ - NPU_SET_ACTIVATION_MIN) SEP FUNC(cmd0_opcode, \ - NPU_SET_ACTIVATION_MAX) \ - SEP FUNC(cmd0_opcode, NPU_SET_WEIGHT_REGION) SEP FUNC( \ - cmd0_opcode, \ - NPU_SET_SCALE_REGION) SEP FUNC(cmd0_opcode, NPU_SET_AB_START) \ - SEP FUNC(cmd0_opcode, NPU_SET_BLOCKDEP) \ - SEP FUNC(cmd0_opcode, NPU_SET_DMA0_SRC_REGION) SEP FUNC( \ - cmd0_opcode, \ - NPU_SET_DMA0_DST_REGION) SEP FUNC(cmd0_opcode, \ - NPU_SET_DMA0_SIZE0) \ - SEP FUNC(cmd0_opcode, NPU_SET_DMA0_SIZE1) SEP FUNC( \ - cmd0_opcode, \ - NPU_SET_IFM2_BROADCAST) SEP \ - FUNC(cmd0_opcode, NPU_SET_IFM2_SCALAR) SEP FUNC( \ - cmd0_opcode, \ - NPU_SET_IFM2_PRECISION) SEP \ - FUNC(cmd0_opcode, NPU_SET_IFM2_ZERO_POINT) SEP \ - FUNC(cmd0_opcode, \ - NPU_SET_IFM2_WIDTH0_M1) SEP \ - FUNC(cmd0_opcode, \ - NPU_SET_IFM2_HEIGHT0_M1) SEP \ - FUNC(cmd0_opcode, \ - NPU_SET_IFM2_HEIGHT1_M1) \ - SEP FUNC( \ - cmd0_opcode, \ - NPU_SET_IFM2_IB_START) \ - SEP FUNC( \ - cmd0_opcode, \ - NPU_SET_IFM2_REGION) - -#define EXPAND_CMD1_OPCODE(FUNC, SEP) \ - FUNC(cmd1_opcode, NPU_SET_IFM_BASE0) \ - SEP FUNC(cmd1_opcode, NPU_SET_IFM_BASE1) SEP FUNC(cmd1_opcode, NPU_SET_IFM_BASE2) \ - SEP FUNC(cmd1_opcode, NPU_SET_IFM_BASE3) SEP FUNC(cmd1_opcode, NPU_SET_IFM_STRIDE_X) \ - SEP FUNC(cmd1_opcode, NPU_SET_IFM_STRIDE_Y) SEP FUNC(cmd1_opcode, NPU_SET_IFM_STRIDE_C) SEP FUNC( \ - cmd1_opcode, NPU_SET_OFM_BASE0) SEP FUNC(cmd1_opcode, NPU_SET_OFM_BASE1) \ - SEP FUNC(cmd1_opcode, NPU_SET_OFM_BASE2) SEP FUNC(cmd1_opcode, NPU_SET_OFM_BASE3) SEP FUNC( \ - cmd1_opcode, NPU_SET_OFM_STRIDE_X) SEP FUNC(cmd1_opcode, NPU_SET_OFM_STRIDE_Y) \ - SEP FUNC(cmd1_opcode, NPU_SET_OFM_STRIDE_C) SEP FUNC(cmd1_opcode, NPU_SET_WEIGHT_BASE) SEP FUNC( \ - cmd1_opcode, NPU_SET_WEIGHT_LENGTH) SEP FUNC(cmd1_opcode, NPU_SET_SCALE_BASE) \ - SEP FUNC(cmd1_opcode, NPU_SET_SCALE_LENGTH) SEP FUNC(cmd1_opcode, NPU_SET_OFM_SCALE) \ - SEP FUNC(cmd1_opcode, NPU_SET_OPA_SCALE) SEP FUNC(cmd1_opcode, NPU_SET_OPB_SCALE) \ - SEP FUNC(cmd1_opcode, NPU_SET_DMA0_SRC) SEP FUNC(cmd1_opcode, NPU_SET_DMA0_DST) \ - SEP FUNC(cmd1_opcode, NPU_SET_DMA0_LEN) SEP FUNC(cmd1_opcode, NPU_SET_DMA0_SKIP0) \ - SEP FUNC(cmd1_opcode, NPU_SET_DMA0_SKIP1) SEP FUNC( \ - cmd1_opcode, NPU_SET_IFM2_BASE0) SEP FUNC(cmd1_opcode, NPU_SET_IFM2_BASE1) \ - SEP FUNC(cmd1_opcode, NPU_SET_IFM2_BASE2) SEP FUNC(cmd1_opcode, \ - NPU_SET_IFM2_BASE3) \ - SEP FUNC(cmd1_opcode, NPU_SET_IFM2_STRIDE_X) \ - SEP FUNC(cmd1_opcode, NPU_SET_IFM2_STRIDE_Y) \ - SEP FUNC(cmd1_opcode, NPU_SET_IFM2_STRIDE_C) \ - SEP FUNC(cmd1_opcode, NPU_SET_WEIGHT1_BASE) \ - SEP FUNC(cmd1_opcode, NPU_SET_WEIGHT1_LENGTH) \ - SEP FUNC(cmd1_opcode, NPU_SET_SCALE1_BASE) \ - SEP FUNC(cmd1_opcode, NPU_SET_SCALE1_LENGTH) - -#define EXPAND_CMD_CTRL(FUNC, SEP) FUNC(cmd_ctrl, CMD0_CTRL) SEP FUNC(cmd_ctrl, CMD1_CTRL) - -#define EXPAND_CUSTOM_DMA(FUNC, SEP) FUNC(custom_dma, NOT_IMPLEMENTED) SEP FUNC(custom_dma, IMPLEMENTED) - -#define EXPAND_DMA_FAULT_SRC(FUNC, SEP) FUNC(dma_fault_src, AXI_M0) SEP FUNC(dma_fault_src, AXI_M1) - -#define EXPAND_DMA_REGION_MODE(FUNC, SEP) FUNC(dma_region_mode, EXTERNAL) SEP FUNC(dma_region_mode, INTERNAL) - -#define EXPAND_DMA_STRIDE_MODE(FUNC, SEP) \ - FUNC(dma_stride_mode, D1) SEP FUNC(dma_stride_mode, D2) SEP FUNC(dma_stride_mode, D3) - -#define EXPAND_ELEMENTWISE_MODE(FUNC, SEP) \ - FUNC(elementwise_mode, MUL) \ - SEP FUNC(elementwise_mode, ADD) SEP FUNC(elementwise_mode, SUB) SEP FUNC(elementwise_mode, MIN) \ - SEP FUNC(elementwise_mode, MAX) SEP FUNC(elementwise_mode, LRELU) SEP FUNC(elementwise_mode, ABS) \ - SEP FUNC(elementwise_mode, CLZ) SEP FUNC(elementwise_mode, SHR) SEP FUNC(elementwise_mode, SHL) - -#define EXPAND_FUNCTIONAL_SAFETY(FUNC, SEP) \ - FUNC(functional_safety, NOT_IMPLEMENTED) SEP FUNC(functional_safety, IMPLEMENTED) - -#define EXPAND_IFM2_OPERAND_ORDER(FUNC, SEP) FUNC(ifm2_operand_order, ORDER_B) SEP FUNC(ifm2_operand_order, ORDER_A) - -#define EXPAND_IFM_SCALE_MODE(FUNC, SEP) \ - FUNC(ifm_scale_mode, OPA_OPB_16) SEP FUNC(ifm_scale_mode, OPA_32) SEP FUNC(ifm_scale_mode, OPB_32) - -#define EXPAND_IFM_UPSCALE_MODE(FUNC, SEP) \ - FUNC(ifm_upscale_mode, NONE) SEP FUNC(ifm_upscale_mode, NEAREST) SEP FUNC(ifm_upscale_mode, ZEROS) - -#define EXPAND_KERNEL_DECOMPOSITION(FUNC, SEP) FUNC(kernel_decomposition, D8X8) SEP FUNC(kernel_decomposition, D4X4) - -#define EXPAND_KERNEL_DILATION(FUNC, SEP) FUNC(kernel_dilation, NONE) SEP FUNC(kernel_dilation, X2) - -#define EXPAND_MAX_BEATS(FUNC, SEP) FUNC(max_beats, B64) SEP FUNC(max_beats, B128) SEP FUNC(max_beats, B256) - -#define EXPAND_MEM_ATTR(FUNC, SEP) \ - FUNC(mem_attr, AXI0_OUTSTANDING_COUNTER0) \ - SEP FUNC(mem_attr, AXI0_OUTSTANDING_COUNTER1) SEP FUNC(mem_attr, AXI1_OUTSTANDING_COUNTER2) \ - SEP FUNC(mem_attr, AXI1_OUTSTANDING_COUNTER3) - -#define EXPAND_OFM_SCALE_MODE(FUNC, SEP) FUNC(ofm_scale_mode, PER_CHANNEL) SEP FUNC(ofm_scale_mode, GLOBAL) - -#define EXPAND_PARALLEL_MODE(FUNC, SEP) FUNC(parallel_mode, SINGLE_CORE) SEP FUNC(parallel_mode, DUAL_CORE_DEPTH) - -#define EXPAND_PMU_AXI_CHANNEL(FUNC, SEP) \ - FUNC(pmu_axi_channel, RD_CMD) \ - SEP FUNC(pmu_axi_channel, RD_IFM) SEP FUNC(pmu_axi_channel, RD_WEIGHTS) SEP FUNC(pmu_axi_channel, RD_SCALE_BIAS) \ - SEP FUNC(pmu_axi_channel, RD_MEM2MEM) SEP FUNC(pmu_axi_channel, WR_OFM) SEP FUNC(pmu_axi_channel, WR_MEM2MEM) - -#define EXPAND_PMU_EVENT(FUNC, SEP) \ - FUNC(pmu_event, NO_EVENT) \ - SEP FUNC(pmu_event, CYCLE) SEP FUNC(pmu_event, NPU_IDLE) SEP FUNC(pmu_event, CC_STALLED_ON_BLOCKDEP) SEP FUNC( \ - pmu_event, CC_STALLED_ON_SHRAM_RECONFIG) SEP FUNC(pmu_event, NPU_ACTIVE) SEP FUNC(pmu_event, MAC_ACTIVE) \ - SEP FUNC(pmu_event, MAC_ACTIVE_8BIT) SEP FUNC(pmu_event, MAC_ACTIVE_16BIT) SEP FUNC( \ - pmu_event, MAC_DPU_ACTIVE) SEP FUNC(pmu_event, MAC_STALLED_BY_WD_ACC) SEP FUNC(pmu_event, \ - MAC_STALLED_BY_WD) \ - SEP FUNC(pmu_event, MAC_STALLED_BY_ACC) SEP FUNC(pmu_event, MAC_STALLED_BY_IB) SEP FUNC( \ - pmu_event, \ - MAC_ACTIVE_32BIT) SEP FUNC(pmu_event, \ - MAC_STALLED_BY_INT_W) SEP FUNC(pmu_event, \ - MAC_STALLED_BY_INT_ACC) SEP FUNC(pmu_event, \ - AO_ACTIVE) \ - SEP FUNC(pmu_event, AO_ACTIVE_8BIT) SEP FUNC(pmu_event, AO_ACTIVE_16BIT) SEP FUNC( \ - pmu_event, AO_STALLED_BY_OFMP_OB) SEP FUNC(pmu_event, AO_STALLED_BY_OFMP) SEP \ - FUNC(pmu_event, AO_STALLED_BY_OB) SEP FUNC(pmu_event, AO_STALLED_BY_ACC_IB) SEP FUNC( \ - pmu_event, AO_STALLED_BY_ACC) SEP FUNC(pmu_event, AO_STALLED_BY_IB) SEP \ - FUNC(pmu_event, WD_ACTIVE) SEP FUNC(pmu_event, WD_STALLED) SEP FUNC(pmu_event, WD_STALLED_BY_WS) SEP FUNC( \ - pmu_event, WD_STALLED_BY_WD_BUF) SEP FUNC(pmu_event, \ - WD_PARSE_ACTIVE) SEP \ - FUNC(pmu_event, WD_PARSE_STALLED) SEP FUNC(pmu_event, WD_PARSE_STALLED_IN) SEP FUNC( \ - pmu_event, WD_PARSE_STALLED_OUT) SEP FUNC(pmu_event, \ - WD_TRANS_WS) SEP \ - FUNC(pmu_event, WD_TRANS_WB) SEP FUNC(pmu_event, WD_TRANS_DW0) SEP FUNC( \ - pmu_event, WD_TRANS_DW1) SEP FUNC(pmu_event, \ - AXI0_RD_TRANS_ACCEPTED) SEP \ - FUNC(pmu_event, AXI0_RD_TRANS_COMPLETED) SEP FUNC(pmu_event, AXI0_RD_DATA_BEAT_RECEIVED) SEP FUNC( \ - pmu_event, AXI0_RD_TRAN_REQ_STALLED) SEP FUNC(pmu_event, \ - AXI0_WR_TRANS_ACCEPTED) SEP \ - FUNC(pmu_event, AXI0_WR_TRANS_COMPLETED_M) SEP FUNC( \ - pmu_event, AXI0_WR_TRANS_COMPLETED_S) SEP \ - FUNC(pmu_event, AXI0_WR_DATA_BEAT_WRITTEN) SEP FUNC( \ - pmu_event, AXI0_WR_TRAN_REQ_STALLED) SEP \ - FUNC(pmu_event, AXI0_WR_DATA_BEAT_STALLED) SEP FUNC( \ - pmu_event, \ - AXI0_ENABLED_CYCLES) SEP FUNC(pmu_event, \ - AXI0_RD_STALL_LIMIT) SEP \ - FUNC(pmu_event, AXI0_WR_STALL_LIMIT) SEP FUNC( \ - pmu_event, \ - AXI_LATENCY_ANY) SEP FUNC(pmu_event, \ - AXI_LATENCY_32) SEP \ - FUNC(pmu_event, \ - AXI_LATENCY_64) SEP FUNC(pmu_event, \ - AXI_LATENCY_128) SEP \ - FUNC(pmu_event, AXI_LATENCY_256) SEP FUNC( \ - pmu_event, \ - AXI_LATENCY_512) SEP FUNC(pmu_event, \ - AXI_LATENCY_1024) SEP \ - FUNC(pmu_event, ECC_DMA) SEP FUNC( \ - pmu_event, \ - ECC_SB0) SEP FUNC(pmu_event, \ - AXI1_RD_TRANS_ACCEPTED) SEP \ - FUNC(pmu_event, AXI1_RD_TRANS_COMPLETED) SEP FUNC( \ - pmu_event, AXI1_RD_DATA_BEAT_RECEIVED) SEP \ - FUNC(pmu_event, AXI1_RD_TRAN_REQ_STALLED) SEP FUNC( \ - pmu_event, AXI1_WR_TRANS_ACCEPTED) SEP \ - FUNC(pmu_event, AXI1_WR_TRANS_COMPLETED_M) SEP FUNC( \ - pmu_event, \ - AXI1_WR_TRANS_COMPLETED_S) SEP \ - FUNC(pmu_event, \ - AXI1_WR_DATA_BEAT_WRITTEN) SEP \ - FUNC(pmu_event, \ - AXI1_WR_TRAN_REQ_STALLED) SEP \ - FUNC( \ - pmu_event, \ - AXI1_WR_DATA_BEAT_STALLED) SEP \ - FUNC( \ - pmu_event, \ - AXI1_ENABLED_CYCLES) SEP \ - FUNC( \ - pmu_event, \ - AXI1_RD_STALL_LIMIT) SEP \ - FUNC( \ - pmu_event, \ - AXI1_WR_STALL_LIMIT) \ - SEP FUNC( \ - pmu_event, \ - ECC_SB1) - -#define EXPAND_POOLING_MODE(FUNC, SEP) \ - FUNC(pooling_mode, MAX) SEP FUNC(pooling_mode, AVERAGE) SEP FUNC(pooling_mode, REDUCE_SUM) - -#define EXPAND_PRIVILEGE_LEVEL(FUNC, SEP) FUNC(privilege_level, USER) SEP FUNC(privilege_level, PRIVILEGED) - -#define EXPAND_ROUND_MODE(FUNC, SEP) FUNC(round_mode, DBL) SEP FUNC(round_mode, TRUNCATE) SEP FUNC(round_mode, NATURAL) - -#define EXPAND_SECURITY_LEVEL(FUNC, SEP) FUNC(security_level, SECURE) SEP FUNC(security_level, NON_SECURE) - -#define EXPAND_STATE(FUNC, SEP) FUNC(state, STOPPED) SEP FUNC(state, RUNNING) - -#define EXPAND_WD_CORE_SLICE_STATE(FUNC, SEP) \ - FUNC(wd_core_slice_state, HEADER) SEP FUNC(wd_core_slice_state, PALETTE) SEP FUNC(wd_core_slice_state, WEIGHTS) - -#define EXPAND_WD_CTRL_STATE(FUNC, SEP) \ - FUNC(wd_ctrl_state, IDLE) \ - SEP FUNC(wd_ctrl_state, DRAIN) SEP FUNC(wd_ctrl_state, OFD_INIT) SEP FUNC(wd_ctrl_state, OFD_RUN) - -#define EXPAND_WEIGHT_ORDER(FUNC, SEP) FUNC(weight_order, DEPTH_FIRST) SEP FUNC(weight_order, PART_KERNEL_FIRST) - -#ifdef __cplusplus -} -#endif -#endif diff --git a/ai_layer/engine/include/executorch/backends/arm/third-party/ethos-u-core-driver/src/ethosu85_interface.h b/ai_layer/engine/include/executorch/backends/arm/third-party/ethos-u-core-driver/src/ethosu85_interface.h deleted file mode 100644 index 18c9d6cb..00000000 --- a/ai_layer/engine/include/executorch/backends/arm/third-party/ethos-u-core-driver/src/ethosu85_interface.h +++ /dev/null @@ -1,24620 +0,0 @@ -/* - * SPDX-FileCopyrightText: Copyright 2020-2024 Arm Limited and/or its affiliates - * SPDX-License-Identifier: Apache-2.0 - * - * Licensed under the Apache License, Version 2.0 (the License); you may - * not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an AS IS BASIS, WITHOUT - * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -// clang-format off - -#ifndef ETHOSU85_INTERFACE_H -#define ETHOSU85_INTERFACE_H - -#ifdef __KERNEL__ -#include -#else -#include -#endif - -#if !defined(__cplusplus) || __cplusplus < 201402L -#define CONSTEXPR -#else -#define CONSTEXPR constexpr -#endif - -#ifndef __cplusplus -#define STRUCT struct -#else -#define STRUCT -#endif - -#if defined(__cplusplus) && defined(NPU_DISASSEMBLE) -#include -#include -#include -#endif - -#if defined(__cplusplus) && !defined(NPU_NAMESPACE) -#define NPU_NAMESPACE npu -#endif - -#ifdef __cplusplus -#include -#include -#include -#endif - -#ifdef __cplusplus -namespace NPU_NAMESPACE -{ -#endif -#define NNX_ARCH_VERSION_MAJOR 2 -#define NNX_ARCH_VERSION_MINOR 0 -#define NNX_ARCH_VERSION_PATCH 0 - -// Register offsets -// -// Register subpage BASE -// -#define NPU_REG_ID 0x0000 -#define NPU_REG_STATUS 0x0004 -#define NPU_REG_CMD 0x0008 -#define NPU_REG_RESET 0x000C -#define NPU_REG_QBASE 0x0010 -#define NPU_REG_QBASE_HI 0x0014 -#define NPU_REG_QREAD 0x0018 -#define NPU_REG_QCONFIG 0x001C -#define NPU_REG_QSIZE 0x0020 -#define NPU_REG_PROT 0x0024 -#define NPU_REG_CONFIG 0x0028 -#define NPU_REG_COND_STATUS 0x0030 -#define NPU_REG_POWER_CTRL 0x0038 -#define NPU_REG_REGIONCFG 0x003C -#define NPU_REG_MEM_ATTR_BASE 0x0040 -#define NPU_REG_MEM_ATTR_ARRLEN 0x0004 -#define NPU_REG_AXI_SRAM 0x0050 -#define NPU_REG_AXI_EXT 0x0054 -#define NPU_REG_CFG_SRAM_CAP 0x0060 -#define NPU_REG_CFG_EXT_CAP 0x0064 -#define NPU_REG_CFG_SRAM_HASH0 0x0068 -#define NPU_REG_CFG_SRAM_HASH0_HI 0x006C -#define NPU_REG_CFG_SRAM_HASH1 0x0070 -#define NPU_REG_CFG_SRAM_HASH1_HI 0x0074 -#define NPU_REG_CFG_EXT_HASH0 0x0078 -#define NPU_REG_CFG_EXT_HASH0_HI 0x007C -#define BASE_REGISTERS_SIZE 0x0080 - -// -// Register subpage BASE_POINTERS -// -#define NPU_REG_BASEP_BASE 0x0080 -#define NPU_REG_BASEP_ARRLEN 0x0008 -#define BASE_POINTERS_REGISTERS_SIZE 0x0100 - -// -// Register subpage DEBUG -// -#define NPU_REG_CLKFORCE 0x0140 -#define NPU_REG_DEBUG_ADDRESS 0x0144 -#define NPU_REG_DEBUG_MISC 0x0148 -#define NPU_REG_FEATURE_DISABLE 0x0154 -#define DEBUG_REGISTERS_SIZE 0x0180 - -// -// Register subpage TSU_DEBUG -// -#define NPU_REG_DMA_IFM_SRC 0x0240 -#define NPU_REG_DMA_IFM_SRC_HI 0x0244 -#define NPU_REG_DMA_OFM_DST 0x0250 -#define NPU_REG_DMA_OFM_DST_HI 0x0254 -#define NPU_REG_DMA_WEIGHT_SRC 0x0258 -#define NPU_REG_DMA_WEIGHT_SRC_HI 0x025C -#define NPU_REG_DMA_CMD_SRC 0x0260 -#define NPU_REG_DMA_CMD_SRC_HI 0x0264 -#define NPU_REG_DMA_CMD_SIZE 0x0268 -#define NPU_REG_DMA_M2M_SRC 0x026C -#define NPU_REG_DMA_M2M_SRC_HI 0x0270 -#define NPU_REG_DMA_M2M_DST 0x0274 -#define NPU_REG_DMA_M2M_DST_HI 0x0278 -#define NPU_REG_CURRENT_QREAD 0x027C -#define NPU_REG_DMA_SCALE_SRC 0x0280 -#define NPU_REG_DMA_SCALE_SRC_HI 0x0284 -#define NPU_REG_DMA_WEIGHT1_SRC 0x0288 -#define NPU_REG_DMA_WEIGHT1_SRC_HI 0x028C -#define NPU_REG_DMA_WEIGHT2_SRC 0x0290 -#define NPU_REG_DMA_WEIGHT2_SRC_HI 0x0294 -#define NPU_REG_DMA_WEIGHT3_SRC 0x0298 -#define NPU_REG_DMA_WEIGHT3_SRC_HI 0x029C -#define NPU_REG_CURRENT_OP 0x02B8 -#define NPU_REG_CURRENT_CMD 0x02BC -#define TSU_DEBUG_REGISTERS_SIZE 0x0300 - -// -// Register subpage INTERNAL_MEMORY -// -#define NPU_REG_INTERNAL_MEMORY_BASE 0x0400 -#define NPU_REG_INTERNAL_MEMORY_ARRLEN 0x0100 -#define INTERNAL_MEMORY_REGISTERS_SIZE 0x0800 - -// -// Register subpage TSU_IFM -// -#define NPU_REG_IFM_PAD_TOP 0x0800 -#define NPU_REG_IFM_PAD_LEFT 0x0804 -#define NPU_REG_IFM_PAD_RIGHT 0x0808 -#define NPU_REG_IFM_PAD_BOTTOM 0x080C -#define NPU_REG_IFM_DEPTH_M1 0x0810 -#define NPU_REG_IFM_PRECISION 0x0814 -#define NPU_REG_IFM_UPSCALE 0x081C -#define NPU_REG_IFM_BROADCAST 0x0820 -#define NPU_REG_IFM_ZERO_POINT 0x0824 -#define NPU_REG_IFM_WIDTH0_M1 0x0828 -#define NPU_REG_IFM_HEIGHT0_M1 0x082C -#define NPU_REG_IFM_HEIGHT1_M1 0x0830 -#define NPU_REG_IFM_REGION 0x083C -#define TSU_IFM_REGISTERS_SIZE 0x0840 - -// -// Register subpage TSU_OFM -// -#define NPU_REG_OFM_WIDTH_M1 0x0844 -#define NPU_REG_OFM_HEIGHT_M1 0x0848 -#define NPU_REG_OFM_DEPTH_M1 0x084C -#define NPU_REG_OFM_PRECISION 0x0850 -#define NPU_REG_OFM_BLK_WIDTH_M1 0x0854 -#define NPU_REG_OFM_BLK_HEIGHT_M1 0x0858 -#define NPU_REG_OFM_BLK_DEPTH_M1 0x085C -#define NPU_REG_OFM_ZERO_POINT 0x0860 -#define NPU_REG_OFM_WIDTH0_M1 0x0868 -#define NPU_REG_OFM_HEIGHT0_M1 0x086C -#define NPU_REG_OFM_HEIGHT1_M1 0x0870 -#define NPU_REG_OFM_REGION 0x087C -#define TSU_OFM_REGISTERS_SIZE 0x0880 - -// -// Register subpage TSU_KERNEL -// -#define NPU_REG_KERNEL_WIDTH_M1 0x0880 -#define NPU_REG_KERNEL_HEIGHT_M1 0x0884 -#define NPU_REG_KERNEL_STRIDE 0x0888 -#define NPU_REG_ACC_FORMAT 0x0890 -#define NPU_REG_ACTIVATION 0x0894 -#define NPU_REG_ACTIVATION_MIN 0x0898 -#define NPU_REG_ACTIVATION_MAX 0x089C -#define NPU_REG_WEIGHT_REGION 0x08A0 -#define NPU_REG_SCALE_REGION 0x08A4 -#define NPU_REG_RESIZE_X_SCALE_N_M1 0x08A8 -#define NPU_REG_RESIZE_Y_SCALE_N_M1 0x08AC -#define NPU_REG_RESIZE_X_OFFSET 0x08B0 -#define NPU_REG_RESIZE_Y_OFFSET 0x08B4 -#define NPU_REG_WEIGHT_FORMAT 0x08B8 -#define NPU_REG_BLOCKDEP 0x08BC -#define TSU_KERNEL_REGISTERS_SIZE 0x08C0 - -// -// Register subpage TSU_DMA -// -#define NPU_REG_DMA0_SRC_REGION 0x08C0 -#define NPU_REG_DMA0_DST_REGION 0x08C4 -#define NPU_REG_DMA0_SIZE0 0x08C8 -#define NPU_REG_DMA0_SIZE1 0x08CC -#define NPU_REG_DMA0_IDX_REGION 0x08D0 -#define TSU_DMA_REGISTERS_SIZE 0x0900 - -// -// Register subpage TSU_IFM2 -// -#define NPU_REG_IFM2_BROADCAST 0x0900 -#define NPU_REG_IFM2_PRECISION 0x0914 -#define NPU_REG_IFM2_ZERO_POINT 0x0924 -#define NPU_REG_IFM2_WIDTH0_M1 0x0928 -#define NPU_REG_IFM2_HEIGHT0_M1 0x092C -#define NPU_REG_IFM2_HEIGHT1_M1 0x0930 -#define NPU_REG_IFM2_REGION 0x093C -#define TSU_IFM2_REGISTERS_SIZE 0x0940 - -// -// Register subpage TSU_IFM_BASE -// -#define NPU_REG_IFM_BASE0 0x0A00 -#define NPU_REG_IFM_BASE0_HI 0x0A04 -#define NPU_REG_IFM_BASE1 0x0A08 -#define NPU_REG_IFM_BASE1_HI 0x0A0C -#define NPU_REG_IFM_BASE2 0x0A10 -#define NPU_REG_IFM_BASE2_HI 0x0A14 -#define NPU_REG_IFM_BASE3 0x0A18 -#define NPU_REG_IFM_BASE3_HI 0x0A1C -#define NPU_REG_IFM_STRIDE_X 0x0A20 -#define NPU_REG_IFM_STRIDE_X_HI 0x0A24 -#define NPU_REG_IFM_STRIDE_Y 0x0A28 -#define NPU_REG_IFM_STRIDE_Y_HI 0x0A2C -#define NPU_REG_IFM_STRIDE_C 0x0A30 -#define NPU_REG_IFM_STRIDE_C_HI 0x0A34 -#define TSU_IFM_BASE_REGISTERS_SIZE 0x0A40 - -// -// Register subpage TSU_OFM_BASE -// -#define NPU_REG_OFM_BASE0 0x0A40 -#define NPU_REG_OFM_BASE0_HI 0x0A44 -#define NPU_REG_OFM_BASE1 0x0A48 -#define NPU_REG_OFM_BASE1_HI 0x0A4C -#define NPU_REG_OFM_BASE2 0x0A50 -#define NPU_REG_OFM_BASE2_HI 0x0A54 -#define NPU_REG_OFM_BASE3 0x0A58 -#define NPU_REG_OFM_BASE3_HI 0x0A5C -#define NPU_REG_OFM_STRIDE_X 0x0A60 -#define NPU_REG_OFM_STRIDE_X_HI 0x0A64 -#define NPU_REG_OFM_STRIDE_Y 0x0A68 -#define NPU_REG_OFM_STRIDE_Y_HI 0x0A6C -#define NPU_REG_OFM_STRIDE_C 0x0A70 -#define NPU_REG_OFM_STRIDE_C_HI 0x0A74 -#define TSU_OFM_BASE_REGISTERS_SIZE 0x0A80 - -// -// Register subpage TSU_WS_BASE -// -#define NPU_REG_WEIGHT_BASE 0x0A80 -#define NPU_REG_WEIGHT_BASE_HI 0x0A84 -#define NPU_REG_WEIGHT_LENGTH 0x0A88 -#define NPU_REG_WEIGHT_LENGTH_HI 0x0A8C -#define NPU_REG_SCALE_BASE 0x0A90 -#define NPU_REG_SCALE_BASE_HI 0x0A94 -#define NPU_REG_SCALE_LENGTH 0x0A98 -#define NPU_REG_SCALE_LENGTH_HI 0x0A9C -#define NPU_REG_OFM_SCALE 0x0AA0 -#define NPU_REG_OFM_SCALE_HI 0x0AA4 -#define NPU_REG_IFM_SCALE 0x0AA8 -#define NPU_REG_IFM_SCALE_HI 0x0AAC -#define NPU_REG_IFM2_SCALE 0x0AB0 -#define NPU_REG_IFM2_SCALE_HI 0x0AB4 -#define NPU_REG_OP_SCALAR 0x0AB8 -#define NPU_REG_OP_SCALAR_HI 0x0ABC -#define TSU_WS_BASE_REGISTERS_SIZE 0x0AC0 - -// -// Register subpage TSU_DMA_BASE -// -#define NPU_REG_DMA0_SRC 0x0AC0 -#define NPU_REG_DMA0_SRC_HI 0x0AC4 -#define NPU_REG_DMA0_DST 0x0AC8 -#define NPU_REG_DMA0_DST_HI 0x0ACC -#define NPU_REG_DMA0_LEN 0x0AD0 -#define NPU_REG_DMA0_LEN_HI 0x0AD4 -#define NPU_REG_DMA0_SRC_STRIDE0 0x0AD8 -#define NPU_REG_DMA0_SRC_STRIDE0_HI 0x0ADC -#define NPU_REG_DMA0_SRC_STRIDE1 0x0AE0 -#define NPU_REG_DMA0_SRC_STRIDE1_HI 0x0AE4 -#define NPU_REG_DMA0_DST_STRIDE0 0x0AE8 -#define NPU_REG_DMA0_DST_STRIDE0_HI 0x0AEC -#define NPU_REG_DMA0_DST_STRIDE1 0x0AF0 -#define NPU_REG_DMA0_DST_STRIDE1_HI 0x0AF4 -#define NPU_REG_DMA0_IDX 0x0AF8 -#define NPU_REG_DMA0_IDX_HI 0x0AFC -#define TSU_DMA_BASE_REGISTERS_SIZE 0x0B00 - -// -// Register subpage TSU_IFM2_BASE -// -#define NPU_REG_IFM2_BASE0 0x0B00 -#define NPU_REG_IFM2_BASE0_HI 0x0B04 -#define NPU_REG_IFM2_BASE1 0x0B08 -#define NPU_REG_IFM2_BASE1_HI 0x0B0C -#define NPU_REG_IFM2_BASE2 0x0B10 -#define NPU_REG_IFM2_BASE2_HI 0x0B14 -#define NPU_REG_IFM2_BASE3 0x0B18 -#define NPU_REG_IFM2_BASE3_HI 0x0B1C -#define NPU_REG_IFM2_STRIDE_X 0x0B20 -#define NPU_REG_IFM2_STRIDE_X_HI 0x0B24 -#define NPU_REG_IFM2_STRIDE_Y 0x0B28 -#define NPU_REG_IFM2_STRIDE_Y_HI 0x0B2C -#define NPU_REG_IFM2_STRIDE_C 0x0B30 -#define NPU_REG_IFM2_STRIDE_C_HI 0x0B34 -#define TSU_IFM2_BASE_REGISTERS_SIZE 0x0B40 - -// -// Register subpage TSU_WS1_BASE -// -#define NPU_REG_WEIGHT1_BASE 0x0B40 -#define NPU_REG_WEIGHT1_BASE_HI 0x0B44 -#define NPU_REG_WEIGHT1_LENGTH 0x0B48 -#define NPU_REG_WEIGHT1_LENGTH_HI 0x0B4C -#define NPU_REG_WEIGHT2_BASE 0x0B50 -#define NPU_REG_WEIGHT2_BASE_HI 0x0B54 -#define NPU_REG_WEIGHT2_LENGTH 0x0B58 -#define NPU_REG_WEIGHT2_LENGTH_HI 0x0B5C -#define NPU_REG_WEIGHT3_BASE 0x0B60 -#define NPU_REG_WEIGHT3_BASE_HI 0x0B64 -#define NPU_REG_WEIGHT3_LENGTH 0x0B68 -#define NPU_REG_WEIGHT3_LENGTH_HI 0x0B6C -#define NPU_REG_RESIZE_X_STEP 0x0B70 -#define NPU_REG_RESIZE_X_STEP_HI 0x0B74 -#define NPU_REG_RESIZE_Y_STEP 0x0B78 -#define NPU_REG_RESIZE_Y_STEP_HI 0x0B7C -#define TSU_WS1_BASE_REGISTERS_SIZE 0x0B80 - -// -// Register subpage TSU_USER_BASE -// -#define TSU_USER_BASE_REGISTERS_SIZE 0x0BC0 - -// -// Register subpage TSU_DMA_EBASE -// -#define NPU_REG_DMA0_IDX_MAX 0x0BC0 -#define NPU_REG_DMA0_IDX_MAX_HI 0x0BC4 -#define NPU_REG_DMA0_IDX_SKIP1 0x0BC8 -#define NPU_REG_DMA0_IDX_SKIP1_HI 0x0BCC -#define TSU_DMA_EBASE_REGISTERS_SIZE 0x0C00 - -// -// Register subpage ID -// -#define NPU_REG_REVISION 0x0FC0 -#define NPU_REG_PID4 0x0FD0 -#define NPU_REG_PID5 0x0FD4 -#define NPU_REG_PID6 0x0FD8 -#define NPU_REG_PID7 0x0FDC -#define NPU_REG_PID0 0x0FE0 -#define NPU_REG_PID1 0x0FE4 -#define NPU_REG_PID2 0x0FE8 -#define NPU_REG_PID3 0x0FEC -#define NPU_REG_CID0 0x0FF0 -#define NPU_REG_CID1 0x0FF4 -#define NPU_REG_CID2 0x0FF8 -#define NPU_REG_CID3 0x0FFC -#define ID_REGISTERS_SIZE 0x1000 - -// -// Register subpage DEBUG_STATUS -// -#define NPU_REG_WD_STATUS 0x1100 -#define NPU_REG_MAC_STATUS 0x1104 -#define NPU_REG_AO_STATUS 0x1108 -#define NPU_REG_DMA_STATUS0 0x1110 -#define NPU_REG_DMA_STATUS1 0x1114 -#define DEBUG_STATUS_REGISTERS_SIZE 0x1180 - -// -// Register subpage PMU -// -#define NPU_REG_PMCR 0x1180 -#define NPU_REG_PMCNTENSET 0x1184 -#define NPU_REG_PMCNTENCLR 0x1188 -#define NPU_REG_PMOVSSET 0x118C -#define NPU_REG_PMOVSCLR 0x1190 -#define NPU_REG_PMINTSET 0x1194 -#define NPU_REG_PMINTCLR 0x1198 -#define NPU_REG_PMCCNTR 0x11A0 -#define NPU_REG_PMCCNTR_HI 0x11A4 -#define NPU_REG_PMCCNTR_CFG 0x11A8 -#define NPU_REG_PMCAXI_CHAN 0x11AC -#define NPU_REG_PMCLUT 0x11B0 -#define PMU_REGISTERS_SIZE 0x1200 - -// -// Register subpage PMU_COUNTERS -// -#define NPU_REG_PMEVCNTR_BASE 0x1300 -#define NPU_REG_PMEVCNTR_ARRLEN 0x0008 -#define NPU_REG_PMEVTYPER_BASE 0x1380 -#define NPU_REG_PMEVTYPER_ARRLEN 0x0008 -#define PMU_COUNTERS_REGISTERS_SIZE 0x1400 - -#ifdef __cplusplus -// Enum types -enum class acc_format : uint8_t -{ - I32 = 0, - I48 = 1, -}; - -enum class acc_input : uint8_t -{ - RESET = 0, - KEEP = 1, - IFM2 = 2, -}; - -enum class acc_output : uint8_t -{ - ENABLE = 0, - DISABLE = 1, -}; - -enum class activation_clip_range : uint8_t -{ - B16 = 0, - NONE = 1, -}; - -enum class activation_format : uint8_t -{ - NHWC = 0, - NHCWB16 = 1, -}; - -enum class activation_function : uint8_t -{ - LUT_NONE = 0, - LUT_U8_U8 = 1, - LUT_S8_S8 = 4, - LUT_S8_S16 = 5, - LUT_S8_S32 = 7, - LUT_S16_S16 = 8, - LUT_S16_S32 = 9, - LUT_TANH = 10, - LUT_SIGMOID = 11, -}; - -enum class activation_precision : uint8_t -{ - B8 = 0, - B16 = 1, - B32 = 2, - B64 = 3, -}; - -enum class activation_reverse : uint8_t -{ - NONE = 0, - H = 1, - W = 2, - C = 3, -}; - -enum class activation_storage : uint8_t -{ - TILE2X2 = 0, - TILE3X1 = 1, - CHAINED = 2, - NONE = 3, -}; - -enum class activation_transpose : uint8_t -{ - HWC = 0, - WHC = 1, - HCW = 2, - WCH = 3, - CHW = 6, - CWH = 7, -}; - -enum class activation_type : uint8_t -{ - UNSIGNED = 0, - SIGNED = 1, -}; - -enum class axi_mem_domain : uint8_t -{ - NON_SHARABLE = 0, - INNER_SHARABLE = 1, - OUTER_SHARABLE = 2, - SYSTEM = 3, -}; - -enum class axi_mem_encoding : uint8_t -{ - DEVICE_NON_BUFFERABLE = 0, - DEVICE_BUFFERABLE = 1, - NORMAL_NON_CACHEABLE_NON_BUFFERABLE = 2, - NORMAL_NON_CACHEABLE_BUFFERABLE = 3, - WRITE_THROUGH_NO_ALLOCATE = 4, - WRITE_THROUGH_READ_ALLOCATE = 5, - WRITE_THROUGH_WRITE_ALLOCATE = 6, - WRITE_THROUGH_READ_AND_WRITE_ALLOCATE = 7, - WRITE_BACK_NO_ALLOCATE = 8, - WRITE_BACK_READ_ALLOCATE = 9, - WRITE_BACK_WRITE_ALLOCATE = 10, - WRITE_BACK_READ_AND_WRITE_ALLOCATE = 11, -}; - -enum class axi_port : uint8_t -{ - SRAM = 0, - EXT = 1, -}; - -enum class branch_cond : uint8_t -{ - ALWAYS = 0, - RF_TRUE = 1, -}; - -enum class broadcast_mode : uint8_t -{ - NONE = 0, - H = 1, - W = 2, - HW = 3, - C = 4, - CH = 5, - CW = 6, - CWH = 7, - SCALAR = 8, -}; - -enum class cmd0_opcode : uint16_t -{ - NPU_OP_STOP = 0, - NPU_OP_IRQ = 1, - NPU_OP_CONV = 2, - NPU_OP_DEPTHWISE = 3, - NPU_OP_POOL = 5, - NPU_OP_ELEMENTWISE = 6, - NPU_OP_RESIZE = 7, - NPU_OP_DMA_START = 16, - NPU_OP_DMA_WAIT = 17, - NPU_OP_KERNEL_WAIT = 18, - NPU_OP_PMU_MASK = 19, - NPU_SET_IFM_PAD_TOP = 256, - NPU_SET_IFM_PAD_LEFT = 257, - NPU_SET_IFM_PAD_RIGHT = 258, - NPU_SET_IFM_PAD_BOTTOM = 259, - NPU_SET_IFM_DEPTH_M1 = 260, - NPU_SET_IFM_PRECISION = 261, - NPU_SET_IFM_UPSCALE = 263, - NPU_SET_IFM_BROADCAST = 264, - NPU_SET_IFM_ZERO_POINT = 265, - NPU_SET_IFM_WIDTH0_M1 = 266, - NPU_SET_IFM_HEIGHT0_M1 = 267, - NPU_SET_IFM_HEIGHT1_M1 = 268, - NPU_SET_IFM_REGION = 271, - NPU_SET_OFM_WIDTH_M1 = 273, - NPU_SET_OFM_HEIGHT_M1 = 274, - NPU_SET_OFM_DEPTH_M1 = 275, - NPU_SET_OFM_PRECISION = 276, - NPU_SET_OFM_BLK_WIDTH_M1 = 277, - NPU_SET_OFM_BLK_HEIGHT_M1 = 278, - NPU_SET_OFM_BLK_DEPTH_M1 = 279, - NPU_SET_OFM_ZERO_POINT = 280, - NPU_SET_OFM_WIDTH0_M1 = 282, - NPU_SET_OFM_HEIGHT0_M1 = 283, - NPU_SET_OFM_HEIGHT1_M1 = 284, - NPU_SET_OFM_REGION = 287, - NPU_SET_KERNEL_WIDTH_M1 = 288, - NPU_SET_KERNEL_HEIGHT_M1 = 289, - NPU_SET_KERNEL_STRIDE = 290, - NPU_SET_ACC_FORMAT = 292, - NPU_SET_ACTIVATION = 293, - NPU_SET_ACTIVATION_MIN = 294, - NPU_SET_ACTIVATION_MAX = 295, - NPU_SET_WEIGHT_REGION = 296, - NPU_SET_SCALE_REGION = 297, - NPU_SET_RESIZE_X_SCALE_N_M1 = 298, - NPU_SET_RESIZE_Y_SCALE_N_M1 = 299, - NPU_SET_RESIZE_X_OFFSET = 300, - NPU_SET_RESIZE_Y_OFFSET = 301, - NPU_SET_WEIGHT_FORMAT = 302, - NPU_SET_BLOCKDEP = 303, - NPU_SET_DMA0_SRC_REGION = 304, - NPU_SET_DMA0_DST_REGION = 305, - NPU_SET_DMA0_SIZE0 = 306, - NPU_SET_DMA0_SIZE1 = 307, - NPU_SET_DMA0_IDX_REGION = 308, - NPU_SET_IFM2_BROADCAST = 384, - NPU_SET_IFM2_PRECISION = 389, - NPU_SET_IFM2_ZERO_POINT = 393, - NPU_SET_IFM2_WIDTH0_M1 = 394, - NPU_SET_IFM2_HEIGHT0_M1 = 395, - NPU_SET_IFM2_HEIGHT1_M1 = 396, - NPU_SET_IFM2_REGION = 399, -}; - -enum class cmd1_opcode : uint16_t -{ - NPU_SET_IFM_BASE0 = 0, - NPU_SET_IFM_BASE1 = 1, - NPU_SET_IFM_BASE2 = 2, - NPU_SET_IFM_BASE3 = 3, - NPU_SET_IFM_STRIDE_X = 4, - NPU_SET_IFM_STRIDE_Y = 5, - NPU_SET_IFM_STRIDE_C = 6, - NPU_SET_OFM_BASE0 = 16, - NPU_SET_OFM_BASE1 = 17, - NPU_SET_OFM_BASE2 = 18, - NPU_SET_OFM_BASE3 = 19, - NPU_SET_OFM_STRIDE_X = 20, - NPU_SET_OFM_STRIDE_Y = 21, - NPU_SET_OFM_STRIDE_C = 22, - NPU_SET_WEIGHT_BASE = 32, - NPU_SET_WEIGHT_LENGTH = 33, - NPU_SET_SCALE_BASE = 34, - NPU_SET_SCALE_LENGTH = 35, - NPU_SET_OFM_SCALE = 36, - NPU_SET_IFM_SCALE = 37, - NPU_SET_IFM2_SCALE = 38, - NPU_SET_OP_SCALAR = 39, - NPU_SET_DMA0_SRC = 48, - NPU_SET_DMA0_DST = 49, - NPU_SET_DMA0_LEN = 50, - NPU_SET_DMA0_SRC_STRIDE0 = 51, - NPU_SET_DMA0_SRC_STRIDE1 = 52, - NPU_SET_DMA0_DST_STRIDE0 = 53, - NPU_SET_DMA0_DST_STRIDE1 = 54, - NPU_SET_DMA0_IDX = 55, - NPU_SET_DMA0_IDX_MAX = 56, - NPU_SET_DMA0_IDX_SKIP1 = 57, - NPU_SET_IFM2_BASE0 = 128, - NPU_SET_IFM2_BASE1 = 129, - NPU_SET_IFM2_BASE2 = 130, - NPU_SET_IFM2_BASE3 = 131, - NPU_SET_IFM2_STRIDE_X = 132, - NPU_SET_IFM2_STRIDE_Y = 133, - NPU_SET_IFM2_STRIDE_C = 134, - NPU_SET_WEIGHT1_BASE = 144, - NPU_SET_WEIGHT1_LENGTH = 145, - NPU_SET_WEIGHT2_BASE = 146, - NPU_SET_WEIGHT2_LENGTH = 147, - NPU_SET_WEIGHT3_BASE = 148, - NPU_SET_WEIGHT3_LENGTH = 149, - NPU_SET_RESIZE_X = 150, - NPU_SET_RESIZE_Y = 151, - NPU_OP_BRANCH = 256, -}; - -enum class cmd_ctrl : uint8_t -{ - CMD0_CTRL = 0, - CMD1_CTRL = 1, -}; - -enum class custom_dma : uint8_t -{ - NOT_IMPLEMENTED = 0, - IMPLEMENTED = 1, -}; - -enum class dma_fault_src : uint8_t -{ - SRAM = 0, - EXT = 1, -}; - -enum class dma_idx_mode : uint8_t -{ - DISABLED = 0, - ENABLED = 1, -}; - -enum class dma_region_mode : uint8_t -{ - EXTERNAL = 0, - INTERNAL = 1, -}; - -enum class dma_stride_mode : uint8_t -{ - D1 = 0, - D2 = 1, - D3 = 2, -}; - -enum class elementwise_mode : uint8_t -{ - MUL = 0, - ADD = 1, - SUB = 2, - MIN = 3, - MAX = 4, - LRELU = 5, - ABS = 6, - CLZ = 7, - SHR = 8, - SHL = 9, - LSR = 10, - DIV = 11, - CMP_EQ = 16, - CMP_NE = 17, - CMP_GE = 18, - CMP_GT = 19, - AND = 33, - OR = 34, - XOR = 35, - NOT = 36, - AND_NOT = 42, -}; - -enum class ifm_upscale_mode : uint8_t -{ - NONE = 0, - NEAREST = 1, - ZEROS = 2, -}; - -enum class kernel_decomposition : uint8_t -{ - D8X8 = 0, - D4X4 = 1, -}; - -enum class kernel_dilation : uint8_t -{ - NONE = 0, - X2 = 1, -}; - -enum class max_beats : uint8_t -{ - B64 = 0, - B128 = 1, - B256 = 2, -}; - -enum class microblock : uint8_t -{ - U1X1 = 0, - U1X2 = 1, - U1X4 = 2, - U2X2 = 3, - U2X4 = 4, - U4X4 = 5, -}; - -enum class ofm_scale_mode : uint8_t -{ - PER_CHANNEL = 0, - GLOBAL = 1, -}; - -enum class pmu_axi_channel : uint8_t -{ - RD_CMD = 0, - RD_IFM = 1, - RD_WEIGHTS = 2, - RD_SCALE_BIAS = 3, - RD_MEM2MEM = 4, - RD_IFM_STREAM = 5, - RD_MEM2MEM_IDX = 6, - WR_OFM = 8, - WR_MEM2MEM = 9, -}; - -enum class pmu_event : uint16_t -{ - NO_EVENT = 0, - CYCLE = 17, - NPU_IDLE = 32, - CC_STALLED_ON_BLOCKDEP = 33, - NPU_ACTIVE = 35, - MAC_ACTIVE = 48, - MAC_DPU_ACTIVE = 51, - MAC_STALLED_BY_W_OR_ACC = 52, - MAC_STALLED_BY_W = 53, - MAC_STALLED_BY_ACC = 54, - MAC_STALLED_BY_IB = 55, - AO_ACTIVE = 64, - AO_STALLED_BY_BS_OR_OB = 67, - AO_STALLED_BY_BS = 68, - AO_STALLED_BY_OB = 69, - AO_STALLED_BY_AB_OR_CB = 70, - AO_STALLED_BY_AB = 71, - AO_STALLED_BY_CB = 72, - WD_ACTIVE = 80, - WD_STALLED = 81, - WD_STALLED_BY_WD_BUF = 83, - WD_STALLED_BY_WS_FC = 84, - WD_STALLED_BY_WS_TC = 85, - WD_TRANS_WBLK = 89, - WD_TRANS_WS_FC = 90, - WD_TRANS_WS_TC = 91, - WD_STALLED_BY_WS_SC0 = 96, - WD_STALLED_BY_WS_SC1 = 97, - WD_STALLED_BY_WS_SC2 = 98, - WD_STALLED_BY_WS_SC3 = 99, - WD_PARSE_ACTIVE_SC0 = 100, - WD_PARSE_ACTIVE_SC1 = 101, - WD_PARSE_ACTIVE_SC2 = 102, - WD_PARSE_ACTIVE_SC3 = 103, - WD_PARSE_STALL_SC0 = 104, - WD_PARSE_STALL_SC1 = 105, - WD_PARSE_STALL_SC2 = 106, - WD_PARSE_STALL_SC3 = 107, - WD_PARSE_STALL_IN_SC0 = 108, - WD_PARSE_STALL_IN_SC1 = 109, - WD_PARSE_STALL_IN_SC2 = 110, - WD_PARSE_STALL_IN_SC3 = 111, - WD_PARSE_STALL_OUT_SC0 = 112, - WD_PARSE_STALL_OUT_SC1 = 113, - WD_PARSE_STALL_OUT_SC2 = 114, - WD_PARSE_STALL_OUT_SC3 = 115, - WD_TRANS_WS_SC0 = 116, - WD_TRANS_WS_SC1 = 117, - WD_TRANS_WS_SC2 = 118, - WD_TRANS_WS_SC3 = 119, - WD_TRANS_WB0 = 120, - WD_TRANS_WB1 = 121, - WD_TRANS_WB2 = 122, - WD_TRANS_WB3 = 123, - SRAM_RD_TRANS_ACCEPTED = 128, - SRAM_RD_TRANS_COMPLETED = 129, - SRAM_RD_DATA_BEAT_RECEIVED = 130, - SRAM_RD_TRAN_REQ_STALLED = 131, - SRAM_WR_TRANS_ACCEPTED = 132, - SRAM_WR_TRANS_COMPLETED_M = 133, - SRAM_WR_TRANS_COMPLETED_S = 134, - SRAM_WR_DATA_BEAT_WRITTEN = 135, - SRAM_WR_TRAN_REQ_STALLED = 136, - SRAM_WR_DATA_BEAT_STALLED = 137, - SRAM_ENABLED_CYCLES = 140, - SRAM_RD_STALL_LIMIT = 142, - SRAM_WR_STALL_LIMIT = 143, - AXI_LATENCY_ANY = 160, - AXI_LATENCY_32 = 161, - AXI_LATENCY_64 = 162, - AXI_LATENCY_128 = 163, - AXI_LATENCY_256 = 164, - AXI_LATENCY_512 = 165, - AXI_LATENCY_1024 = 166, - ECC_DMA = 176, - ECC_MAC_IB = 177, - ECC_MAC_AB = 178, - ECC_AO_CB = 179, - ECC_AO_OB = 180, - ECC_AO_LUT = 181, - EXT_RD_TRANS_ACCEPTED = 384, - EXT_RD_TRANS_COMPLETED = 385, - EXT_RD_DATA_BEAT_RECEIVED = 386, - EXT_RD_TRAN_REQ_STALLED = 387, - EXT_WR_TRANS_ACCEPTED = 388, - EXT_WR_TRANS_COMPLETED_M = 389, - EXT_WR_TRANS_COMPLETED_S = 390, - EXT_WR_DATA_BEAT_WRITTEN = 391, - EXT_WR_TRAN_REQ_STALLED = 392, - EXT_WR_DATA_BEAT_STALLED = 393, - EXT_ENABLED_CYCLES = 396, - EXT_RD_STALL_LIMIT = 398, - EXT_WR_STALL_LIMIT = 399, - SRAM0_RD_TRANS_ACCEPTED = 512, - SRAM0_RD_TRANS_COMPLETED = 513, - SRAM0_RD_DATA_BEAT_RECEIVED = 514, - SRAM0_RD_TRAN_REQ_STALLED = 515, - SRAM0_WR_TRANS_ACCEPTED = 516, - SRAM0_WR_TRANS_COMPLETED_M = 517, - SRAM0_WR_TRANS_COMPLETED_S = 518, - SRAM0_WR_DATA_BEAT_WRITTEN = 519, - SRAM0_WR_TRAN_REQ_STALLED = 520, - SRAM0_WR_DATA_BEAT_STALLED = 521, - SRAM0_ENABLED_CYCLES = 524, - SRAM0_RD_STALL_LIMIT = 526, - SRAM0_WR_STALL_LIMIT = 527, - SRAM1_RD_TRANS_ACCEPTED = 528, - SRAM1_RD_TRANS_COMPLETED = 529, - SRAM1_RD_DATA_BEAT_RECEIVED = 530, - SRAM1_RD_TRAN_REQ_STALLED = 531, - SRAM1_WR_TRANS_ACCEPTED = 532, - SRAM1_WR_TRANS_COMPLETED_M = 533, - SRAM1_WR_TRANS_COMPLETED_S = 534, - SRAM1_WR_DATA_BEAT_WRITTEN = 535, - SRAM1_WR_TRAN_REQ_STALLED = 536, - SRAM1_WR_DATA_BEAT_STALLED = 537, - SRAM1_ENABLED_CYCLES = 540, - SRAM1_RD_STALL_LIMIT = 542, - SRAM1_WR_STALL_LIMIT = 543, - SRAM2_RD_TRANS_ACCEPTED = 544, - SRAM2_RD_TRANS_COMPLETED = 545, - SRAM2_RD_DATA_BEAT_RECEIVED = 546, - SRAM2_RD_TRAN_REQ_STALLED = 547, - SRAM2_WR_TRANS_ACCEPTED = 548, - SRAM2_WR_TRANS_COMPLETED_M = 549, - SRAM2_WR_TRANS_COMPLETED_S = 550, - SRAM2_WR_DATA_BEAT_WRITTEN = 551, - SRAM2_WR_TRAN_REQ_STALLED = 552, - SRAM2_WR_DATA_BEAT_STALLED = 553, - SRAM2_ENABLED_CYCLES = 556, - SRAM2_RD_STALL_LIMIT = 558, - SRAM2_WR_STALL_LIMIT = 559, - SRAM3_RD_TRANS_ACCEPTED = 560, - SRAM3_RD_TRANS_COMPLETED = 561, - SRAM3_RD_DATA_BEAT_RECEIVED = 562, - SRAM3_RD_TRAN_REQ_STALLED = 563, - SRAM3_WR_TRANS_ACCEPTED = 564, - SRAM3_WR_TRANS_COMPLETED_M = 565, - SRAM3_WR_TRANS_COMPLETED_S = 566, - SRAM3_WR_DATA_BEAT_WRITTEN = 567, - SRAM3_WR_TRAN_REQ_STALLED = 568, - SRAM3_WR_DATA_BEAT_STALLED = 569, - SRAM3_ENABLED_CYCLES = 572, - SRAM3_RD_STALL_LIMIT = 574, - SRAM3_WR_STALL_LIMIT = 575, - EXT0_RD_TRANS_ACCEPTED = 640, - EXT0_RD_TRANS_COMPLETED = 641, - EXT0_RD_DATA_BEAT_RECEIVED = 642, - EXT0_RD_TRAN_REQ_STALLED = 643, - EXT0_WR_TRANS_ACCEPTED = 644, - EXT0_WR_TRANS_COMPLETED_M = 645, - EXT0_WR_TRANS_COMPLETED_S = 646, - EXT0_WR_DATA_BEAT_WRITTEN = 647, - EXT0_WR_TRAN_REQ_STALLED = 648, - EXT0_WR_DATA_BEAT_STALLED = 649, - EXT0_ENABLED_CYCLES = 652, - EXT0_RD_STALL_LIMIT = 654, - EXT0_WR_STALL_LIMIT = 655, - EXT1_RD_TRANS_ACCEPTED = 656, - EXT1_RD_TRANS_COMPLETED = 657, - EXT1_RD_DATA_BEAT_RECEIVED = 658, - EXT1_RD_TRAN_REQ_STALLED = 659, - EXT1_WR_TRANS_ACCEPTED = 660, - EXT1_WR_TRANS_COMPLETED_M = 661, - EXT1_WR_TRANS_COMPLETED_S = 662, - EXT1_WR_DATA_BEAT_WRITTEN = 663, - EXT1_WR_TRAN_REQ_STALLED = 664, - EXT1_WR_DATA_BEAT_STALLED = 665, - EXT1_ENABLED_CYCLES = 668, - EXT1_RD_STALL_LIMIT = 670, - EXT1_WR_STALL_LIMIT = 671, -}; - -enum class pmu_port_disable : uint8_t -{ - ENABLE = 0, - DISABLE = 1, -}; - -enum class pooling_mode : uint8_t -{ - MAX = 0, - AVERAGE = 1, - REDUCE_SUM = 2, - SUM = 3, - NONE = 4, - MIN = 5, - ARGMAX_X = 6, - ARGMAX_Y = 7, -}; - -enum class privilege_level : uint8_t -{ - USER = 0, - PRIVILEGED = 1, -}; - -enum class ram_id : uint8_t -{ - LUT = 0, - IB = 1, - AB = 2, - CB = 3, - OB = 4, -}; - -enum class resize_mode : uint8_t -{ - BILINEAR = 0, - REPLICATE = 1, - NEAREST = 2, -}; - -enum class round_mode_ifm : uint8_t -{ - DOUBLE_SYMMETRIC = 0, - NATURAL = 1, -}; - -enum class round_mode_ofm : uint8_t -{ - DOUBLE_SYMMETRIC = 0, - NATURAL = 1, - DOUBLE_ASYMMETRIC = 2, - SYMMETRIC = 3, - TRUNCATE_TO_ZERO = 4, - TRUNCATE_TO_LOWER = 5, -}; - -enum class security_level : uint8_t -{ - SECURE = 0, - NON_SECURE = 1, -}; - -enum class state : uint8_t -{ - STOPPED = 0, - RUNNING = 1, -}; - -enum class wd_active_core : uint8_t -{ - NONE = 0, - STANDARD = 1, - FAST = 2, - TENSOR = 3, -}; - -enum class weight_format : uint8_t -{ - SWD = 0, - FWD = 1, -}; - -enum class weight_order : uint8_t -{ - DEPTH_FIRST = 0, - PART_KERNEL_FIRST = 1, -}; - -enum class weight_sparsity : uint8_t -{ - NONE = 0, - SPARSE_2_4 = 1, -}; - -#else - -enum acc_format -{ - ACC_FORMAT_I32 = 0, - ACC_FORMAT_I48 = 1, -}; - -enum acc_input -{ - ACC_INPUT_RESET = 0, - ACC_INPUT_KEEP = 1, - ACC_INPUT_IFM2 = 2, -}; - -enum acc_output -{ - ACC_OUTPUT_ENABLE = 0, - ACC_OUTPUT_DISABLE = 1, -}; - -enum activation_clip_range -{ - ACTIVATION_CLIP_RANGE_B16 = 0, - ACTIVATION_CLIP_RANGE_NONE = 1, -}; - -enum activation_format -{ - ACTIVATION_FORMAT_NHWC = 0, - ACTIVATION_FORMAT_NHCWB16 = 1, -}; - -enum activation_function -{ - ACTIVATION_FUNCTION_LUT_NONE = 0, - ACTIVATION_FUNCTION_LUT_U8_U8 = 1, - ACTIVATION_FUNCTION_LUT_S8_S8 = 4, - ACTIVATION_FUNCTION_LUT_S8_S16 = 5, - ACTIVATION_FUNCTION_LUT_S8_S32 = 7, - ACTIVATION_FUNCTION_LUT_S16_S16 = 8, - ACTIVATION_FUNCTION_LUT_S16_S32 = 9, - ACTIVATION_FUNCTION_LUT_TANH = 10, - ACTIVATION_FUNCTION_LUT_SIGMOID = 11, -}; - -enum activation_precision -{ - ACTIVATION_PRECISION_B8 = 0, - ACTIVATION_PRECISION_B16 = 1, - ACTIVATION_PRECISION_B32 = 2, - ACTIVATION_PRECISION_B64 = 3, -}; - -enum activation_reverse -{ - ACTIVATION_REVERSE_NONE = 0, - ACTIVATION_REVERSE_H = 1, - ACTIVATION_REVERSE_W = 2, - ACTIVATION_REVERSE_C = 3, -}; - -enum activation_storage -{ - ACTIVATION_STORAGE_TILE2X2 = 0, - ACTIVATION_STORAGE_TILE3X1 = 1, - ACTIVATION_STORAGE_CHAINED = 2, - ACTIVATION_STORAGE_NONE = 3, -}; - -enum activation_transpose -{ - ACTIVATION_TRANSPOSE_HWC = 0, - ACTIVATION_TRANSPOSE_WHC = 1, - ACTIVATION_TRANSPOSE_HCW = 2, - ACTIVATION_TRANSPOSE_WCH = 3, - ACTIVATION_TRANSPOSE_CHW = 6, - ACTIVATION_TRANSPOSE_CWH = 7, -}; - -enum activation_type -{ - ACTIVATION_TYPE_UNSIGNED = 0, - ACTIVATION_TYPE_SIGNED = 1, -}; - -enum axi_mem_domain -{ - AXI_MEM_DOMAIN_NON_SHARABLE = 0, - AXI_MEM_DOMAIN_INNER_SHARABLE = 1, - AXI_MEM_DOMAIN_OUTER_SHARABLE = 2, - AXI_MEM_DOMAIN_SYSTEM = 3, -}; - -enum axi_mem_encoding -{ - AXI_MEM_ENCODING_DEVICE_NON_BUFFERABLE = 0, - AXI_MEM_ENCODING_DEVICE_BUFFERABLE = 1, - AXI_MEM_ENCODING_NORMAL_NON_CACHEABLE_NON_BUFFERABLE = 2, - AXI_MEM_ENCODING_NORMAL_NON_CACHEABLE_BUFFERABLE = 3, - AXI_MEM_ENCODING_WRITE_THROUGH_NO_ALLOCATE = 4, - AXI_MEM_ENCODING_WRITE_THROUGH_READ_ALLOCATE = 5, - AXI_MEM_ENCODING_WRITE_THROUGH_WRITE_ALLOCATE = 6, - AXI_MEM_ENCODING_WRITE_THROUGH_READ_AND_WRITE_ALLOCATE = 7, - AXI_MEM_ENCODING_WRITE_BACK_NO_ALLOCATE = 8, - AXI_MEM_ENCODING_WRITE_BACK_READ_ALLOCATE = 9, - AXI_MEM_ENCODING_WRITE_BACK_WRITE_ALLOCATE = 10, - AXI_MEM_ENCODING_WRITE_BACK_READ_AND_WRITE_ALLOCATE = 11, -}; - -enum axi_port -{ - AXI_PORT_SRAM = 0, - AXI_PORT_EXT = 1, -}; - -enum branch_cond -{ - BRANCH_COND_ALWAYS = 0, - BRANCH_COND_RF_TRUE = 1, -}; - -enum broadcast_mode -{ - BROADCAST_MODE_NONE = 0, - BROADCAST_MODE_H = 1, - BROADCAST_MODE_W = 2, - BROADCAST_MODE_HW = 3, - BROADCAST_MODE_C = 4, - BROADCAST_MODE_CH = 5, - BROADCAST_MODE_CW = 6, - BROADCAST_MODE_CWH = 7, - BROADCAST_MODE_SCALAR = 8, -}; - -enum cmd0_opcode -{ - CMD0_OPCODE_NPU_OP_STOP = 0, - CMD0_OPCODE_NPU_OP_IRQ = 1, - CMD0_OPCODE_NPU_OP_CONV = 2, - CMD0_OPCODE_NPU_OP_DEPTHWISE = 3, - CMD0_OPCODE_NPU_OP_POOL = 5, - CMD0_OPCODE_NPU_OP_ELEMENTWISE = 6, - CMD0_OPCODE_NPU_OP_RESIZE = 7, - CMD0_OPCODE_NPU_OP_DMA_START = 16, - CMD0_OPCODE_NPU_OP_DMA_WAIT = 17, - CMD0_OPCODE_NPU_OP_KERNEL_WAIT = 18, - CMD0_OPCODE_NPU_OP_PMU_MASK = 19, - CMD0_OPCODE_NPU_SET_IFM_PAD_TOP = 256, - CMD0_OPCODE_NPU_SET_IFM_PAD_LEFT = 257, - CMD0_OPCODE_NPU_SET_IFM_PAD_RIGHT = 258, - CMD0_OPCODE_NPU_SET_IFM_PAD_BOTTOM = 259, - CMD0_OPCODE_NPU_SET_IFM_DEPTH_M1 = 260, - CMD0_OPCODE_NPU_SET_IFM_PRECISION = 261, - CMD0_OPCODE_NPU_SET_IFM_UPSCALE = 263, - CMD0_OPCODE_NPU_SET_IFM_BROADCAST = 264, - CMD0_OPCODE_NPU_SET_IFM_ZERO_POINT = 265, - CMD0_OPCODE_NPU_SET_IFM_WIDTH0_M1 = 266, - CMD0_OPCODE_NPU_SET_IFM_HEIGHT0_M1 = 267, - CMD0_OPCODE_NPU_SET_IFM_HEIGHT1_M1 = 268, - CMD0_OPCODE_NPU_SET_IFM_REGION = 271, - CMD0_OPCODE_NPU_SET_OFM_WIDTH_M1 = 273, - CMD0_OPCODE_NPU_SET_OFM_HEIGHT_M1 = 274, - CMD0_OPCODE_NPU_SET_OFM_DEPTH_M1 = 275, - CMD0_OPCODE_NPU_SET_OFM_PRECISION = 276, - CMD0_OPCODE_NPU_SET_OFM_BLK_WIDTH_M1 = 277, - CMD0_OPCODE_NPU_SET_OFM_BLK_HEIGHT_M1 = 278, - CMD0_OPCODE_NPU_SET_OFM_BLK_DEPTH_M1 = 279, - CMD0_OPCODE_NPU_SET_OFM_ZERO_POINT = 280, - CMD0_OPCODE_NPU_SET_OFM_WIDTH0_M1 = 282, - CMD0_OPCODE_NPU_SET_OFM_HEIGHT0_M1 = 283, - CMD0_OPCODE_NPU_SET_OFM_HEIGHT1_M1 = 284, - CMD0_OPCODE_NPU_SET_OFM_REGION = 287, - CMD0_OPCODE_NPU_SET_KERNEL_WIDTH_M1 = 288, - CMD0_OPCODE_NPU_SET_KERNEL_HEIGHT_M1 = 289, - CMD0_OPCODE_NPU_SET_KERNEL_STRIDE = 290, - CMD0_OPCODE_NPU_SET_ACC_FORMAT = 292, - CMD0_OPCODE_NPU_SET_ACTIVATION = 293, - CMD0_OPCODE_NPU_SET_ACTIVATION_MIN = 294, - CMD0_OPCODE_NPU_SET_ACTIVATION_MAX = 295, - CMD0_OPCODE_NPU_SET_WEIGHT_REGION = 296, - CMD0_OPCODE_NPU_SET_SCALE_REGION = 297, - CMD0_OPCODE_NPU_SET_RESIZE_X_SCALE_N_M1 = 298, - CMD0_OPCODE_NPU_SET_RESIZE_Y_SCALE_N_M1 = 299, - CMD0_OPCODE_NPU_SET_RESIZE_X_OFFSET = 300, - CMD0_OPCODE_NPU_SET_RESIZE_Y_OFFSET = 301, - CMD0_OPCODE_NPU_SET_WEIGHT_FORMAT = 302, - CMD0_OPCODE_NPU_SET_BLOCKDEP = 303, - CMD0_OPCODE_NPU_SET_DMA0_SRC_REGION = 304, - CMD0_OPCODE_NPU_SET_DMA0_DST_REGION = 305, - CMD0_OPCODE_NPU_SET_DMA0_SIZE0 = 306, - CMD0_OPCODE_NPU_SET_DMA0_SIZE1 = 307, - CMD0_OPCODE_NPU_SET_DMA0_IDX_REGION = 308, - CMD0_OPCODE_NPU_SET_IFM2_BROADCAST = 384, - CMD0_OPCODE_NPU_SET_IFM2_PRECISION = 389, - CMD0_OPCODE_NPU_SET_IFM2_ZERO_POINT = 393, - CMD0_OPCODE_NPU_SET_IFM2_WIDTH0_M1 = 394, - CMD0_OPCODE_NPU_SET_IFM2_HEIGHT0_M1 = 395, - CMD0_OPCODE_NPU_SET_IFM2_HEIGHT1_M1 = 396, - CMD0_OPCODE_NPU_SET_IFM2_REGION = 399, -}; - -enum cmd1_opcode -{ - CMD1_OPCODE_NPU_SET_IFM_BASE0 = 0, - CMD1_OPCODE_NPU_SET_IFM_BASE1 = 1, - CMD1_OPCODE_NPU_SET_IFM_BASE2 = 2, - CMD1_OPCODE_NPU_SET_IFM_BASE3 = 3, - CMD1_OPCODE_NPU_SET_IFM_STRIDE_X = 4, - CMD1_OPCODE_NPU_SET_IFM_STRIDE_Y = 5, - CMD1_OPCODE_NPU_SET_IFM_STRIDE_C = 6, - CMD1_OPCODE_NPU_SET_OFM_BASE0 = 16, - CMD1_OPCODE_NPU_SET_OFM_BASE1 = 17, - CMD1_OPCODE_NPU_SET_OFM_BASE2 = 18, - CMD1_OPCODE_NPU_SET_OFM_BASE3 = 19, - CMD1_OPCODE_NPU_SET_OFM_STRIDE_X = 20, - CMD1_OPCODE_NPU_SET_OFM_STRIDE_Y = 21, - CMD1_OPCODE_NPU_SET_OFM_STRIDE_C = 22, - CMD1_OPCODE_NPU_SET_WEIGHT_BASE = 32, - CMD1_OPCODE_NPU_SET_WEIGHT_LENGTH = 33, - CMD1_OPCODE_NPU_SET_SCALE_BASE = 34, - CMD1_OPCODE_NPU_SET_SCALE_LENGTH = 35, - CMD1_OPCODE_NPU_SET_OFM_SCALE = 36, - CMD1_OPCODE_NPU_SET_IFM_SCALE = 37, - CMD1_OPCODE_NPU_SET_IFM2_SCALE = 38, - CMD1_OPCODE_NPU_SET_OP_SCALAR = 39, - CMD1_OPCODE_NPU_SET_DMA0_SRC = 48, - CMD1_OPCODE_NPU_SET_DMA0_DST = 49, - CMD1_OPCODE_NPU_SET_DMA0_LEN = 50, - CMD1_OPCODE_NPU_SET_DMA0_SRC_STRIDE0 = 51, - CMD1_OPCODE_NPU_SET_DMA0_SRC_STRIDE1 = 52, - CMD1_OPCODE_NPU_SET_DMA0_DST_STRIDE0 = 53, - CMD1_OPCODE_NPU_SET_DMA0_DST_STRIDE1 = 54, - CMD1_OPCODE_NPU_SET_DMA0_IDX = 55, - CMD1_OPCODE_NPU_SET_DMA0_IDX_MAX = 56, - CMD1_OPCODE_NPU_SET_DMA0_IDX_SKIP1 = 57, - CMD1_OPCODE_NPU_SET_IFM2_BASE0 = 128, - CMD1_OPCODE_NPU_SET_IFM2_BASE1 = 129, - CMD1_OPCODE_NPU_SET_IFM2_BASE2 = 130, - CMD1_OPCODE_NPU_SET_IFM2_BASE3 = 131, - CMD1_OPCODE_NPU_SET_IFM2_STRIDE_X = 132, - CMD1_OPCODE_NPU_SET_IFM2_STRIDE_Y = 133, - CMD1_OPCODE_NPU_SET_IFM2_STRIDE_C = 134, - CMD1_OPCODE_NPU_SET_WEIGHT1_BASE = 144, - CMD1_OPCODE_NPU_SET_WEIGHT1_LENGTH = 145, - CMD1_OPCODE_NPU_SET_WEIGHT2_BASE = 146, - CMD1_OPCODE_NPU_SET_WEIGHT2_LENGTH = 147, - CMD1_OPCODE_NPU_SET_WEIGHT3_BASE = 148, - CMD1_OPCODE_NPU_SET_WEIGHT3_LENGTH = 149, - CMD1_OPCODE_NPU_SET_RESIZE_X = 150, - CMD1_OPCODE_NPU_SET_RESIZE_Y = 151, - CMD1_OPCODE_NPU_OP_BRANCH = 256, -}; - -enum cmd_ctrl -{ - CMD_CTRL_CMD0_CTRL = 0, - CMD_CTRL_CMD1_CTRL = 1, -}; - -enum custom_dma -{ - CUSTOM_DMA_NOT_IMPLEMENTED = 0, - CUSTOM_DMA_IMPLEMENTED = 1, -}; - -enum dma_fault_src -{ - DMA_FAULT_SRC_SRAM = 0, - DMA_FAULT_SRC_EXT = 1, -}; - -enum dma_idx_mode -{ - DMA_IDX_MODE_DISABLED = 0, - DMA_IDX_MODE_ENABLED = 1, -}; - -enum dma_region_mode -{ - DMA_REGION_MODE_EXTERNAL = 0, - DMA_REGION_MODE_INTERNAL = 1, -}; - -enum dma_stride_mode -{ - DMA_STRIDE_MODE_D1 = 0, - DMA_STRIDE_MODE_D2 = 1, - DMA_STRIDE_MODE_D3 = 2, -}; - -enum elementwise_mode -{ - ELEMENTWISE_MODE_MUL = 0, - ELEMENTWISE_MODE_ADD = 1, - ELEMENTWISE_MODE_SUB = 2, - ELEMENTWISE_MODE_MIN = 3, - ELEMENTWISE_MODE_MAX = 4, - ELEMENTWISE_MODE_LRELU = 5, - ELEMENTWISE_MODE_ABS = 6, - ELEMENTWISE_MODE_CLZ = 7, - ELEMENTWISE_MODE_SHR = 8, - ELEMENTWISE_MODE_SHL = 9, - ELEMENTWISE_MODE_LSR = 10, - ELEMENTWISE_MODE_DIV = 11, - ELEMENTWISE_MODE_CMP_EQ = 16, - ELEMENTWISE_MODE_CMP_NE = 17, - ELEMENTWISE_MODE_CMP_GE = 18, - ELEMENTWISE_MODE_CMP_GT = 19, - ELEMENTWISE_MODE_AND = 33, - ELEMENTWISE_MODE_OR = 34, - ELEMENTWISE_MODE_XOR = 35, - ELEMENTWISE_MODE_NOT = 36, - ELEMENTWISE_MODE_AND_NOT = 42, -}; - -enum ifm_upscale_mode -{ - IFM_UPSCALE_MODE_NONE = 0, - IFM_UPSCALE_MODE_NEAREST = 1, - IFM_UPSCALE_MODE_ZEROS = 2, -}; - -enum kernel_decomposition -{ - KERNEL_DECOMPOSITION_D8X8 = 0, - KERNEL_DECOMPOSITION_D4X4 = 1, -}; - -enum kernel_dilation -{ - KERNEL_DILATION_NONE = 0, - KERNEL_DILATION_X2 = 1, -}; - -enum max_beats -{ - MAX_BEATS_B64 = 0, - MAX_BEATS_B128 = 1, - MAX_BEATS_B256 = 2, -}; - -enum microblock -{ - MICROBLOCK_U1X1 = 0, - MICROBLOCK_U1X2 = 1, - MICROBLOCK_U1X4 = 2, - MICROBLOCK_U2X2 = 3, - MICROBLOCK_U2X4 = 4, - MICROBLOCK_U4X4 = 5, -}; - -enum ofm_scale_mode -{ - OFM_SCALE_MODE_PER_CHANNEL = 0, - OFM_SCALE_MODE_GLOBAL = 1, -}; - -enum pmu_axi_channel -{ - PMU_AXI_CHANNEL_RD_CMD = 0, - PMU_AXI_CHANNEL_RD_IFM = 1, - PMU_AXI_CHANNEL_RD_WEIGHTS = 2, - PMU_AXI_CHANNEL_RD_SCALE_BIAS = 3, - PMU_AXI_CHANNEL_RD_MEM2MEM = 4, - PMU_AXI_CHANNEL_RD_IFM_STREAM = 5, - PMU_AXI_CHANNEL_RD_MEM2MEM_IDX = 6, - PMU_AXI_CHANNEL_WR_OFM = 8, - PMU_AXI_CHANNEL_WR_MEM2MEM = 9, -}; - -enum pmu_event -{ - PMU_EVENT_NO_EVENT = 0, - PMU_EVENT_CYCLE = 17, - PMU_EVENT_NPU_IDLE = 32, - PMU_EVENT_CC_STALLED_ON_BLOCKDEP = 33, - PMU_EVENT_NPU_ACTIVE = 35, - PMU_EVENT_MAC_ACTIVE = 48, - PMU_EVENT_MAC_DPU_ACTIVE = 51, - PMU_EVENT_MAC_STALLED_BY_W_OR_ACC = 52, - PMU_EVENT_MAC_STALLED_BY_W = 53, - PMU_EVENT_MAC_STALLED_BY_ACC = 54, - PMU_EVENT_MAC_STALLED_BY_IB = 55, - PMU_EVENT_AO_ACTIVE = 64, - PMU_EVENT_AO_STALLED_BY_BS_OR_OB = 67, - PMU_EVENT_AO_STALLED_BY_BS = 68, - PMU_EVENT_AO_STALLED_BY_OB = 69, - PMU_EVENT_AO_STALLED_BY_AB_OR_CB = 70, - PMU_EVENT_AO_STALLED_BY_AB = 71, - PMU_EVENT_AO_STALLED_BY_CB = 72, - PMU_EVENT_WD_ACTIVE = 80, - PMU_EVENT_WD_STALLED = 81, - PMU_EVENT_WD_STALLED_BY_WD_BUF = 83, - PMU_EVENT_WD_STALLED_BY_WS_FC = 84, - PMU_EVENT_WD_STALLED_BY_WS_TC = 85, - PMU_EVENT_WD_TRANS_WBLK = 89, - PMU_EVENT_WD_TRANS_WS_FC = 90, - PMU_EVENT_WD_TRANS_WS_TC = 91, - PMU_EVENT_WD_STALLED_BY_WS_SC0 = 96, - PMU_EVENT_WD_STALLED_BY_WS_SC1 = 97, - PMU_EVENT_WD_STALLED_BY_WS_SC2 = 98, - PMU_EVENT_WD_STALLED_BY_WS_SC3 = 99, - PMU_EVENT_WD_PARSE_ACTIVE_SC0 = 100, - PMU_EVENT_WD_PARSE_ACTIVE_SC1 = 101, - PMU_EVENT_WD_PARSE_ACTIVE_SC2 = 102, - PMU_EVENT_WD_PARSE_ACTIVE_SC3 = 103, - PMU_EVENT_WD_PARSE_STALL_SC0 = 104, - PMU_EVENT_WD_PARSE_STALL_SC1 = 105, - PMU_EVENT_WD_PARSE_STALL_SC2 = 106, - PMU_EVENT_WD_PARSE_STALL_SC3 = 107, - PMU_EVENT_WD_PARSE_STALL_IN_SC0 = 108, - PMU_EVENT_WD_PARSE_STALL_IN_SC1 = 109, - PMU_EVENT_WD_PARSE_STALL_IN_SC2 = 110, - PMU_EVENT_WD_PARSE_STALL_IN_SC3 = 111, - PMU_EVENT_WD_PARSE_STALL_OUT_SC0 = 112, - PMU_EVENT_WD_PARSE_STALL_OUT_SC1 = 113, - PMU_EVENT_WD_PARSE_STALL_OUT_SC2 = 114, - PMU_EVENT_WD_PARSE_STALL_OUT_SC3 = 115, - PMU_EVENT_WD_TRANS_WS_SC0 = 116, - PMU_EVENT_WD_TRANS_WS_SC1 = 117, - PMU_EVENT_WD_TRANS_WS_SC2 = 118, - PMU_EVENT_WD_TRANS_WS_SC3 = 119, - PMU_EVENT_WD_TRANS_WB0 = 120, - PMU_EVENT_WD_TRANS_WB1 = 121, - PMU_EVENT_WD_TRANS_WB2 = 122, - PMU_EVENT_WD_TRANS_WB3 = 123, - PMU_EVENT_SRAM_RD_TRANS_ACCEPTED = 128, - PMU_EVENT_SRAM_RD_TRANS_COMPLETED = 129, - PMU_EVENT_SRAM_RD_DATA_BEAT_RECEIVED = 130, - PMU_EVENT_SRAM_RD_TRAN_REQ_STALLED = 131, - PMU_EVENT_SRAM_WR_TRANS_ACCEPTED = 132, - PMU_EVENT_SRAM_WR_TRANS_COMPLETED_M = 133, - PMU_EVENT_SRAM_WR_TRANS_COMPLETED_S = 134, - PMU_EVENT_SRAM_WR_DATA_BEAT_WRITTEN = 135, - PMU_EVENT_SRAM_WR_TRAN_REQ_STALLED = 136, - PMU_EVENT_SRAM_WR_DATA_BEAT_STALLED = 137, - PMU_EVENT_SRAM_ENABLED_CYCLES = 140, - PMU_EVENT_SRAM_RD_STALL_LIMIT = 142, - PMU_EVENT_SRAM_WR_STALL_LIMIT = 143, - PMU_EVENT_AXI_LATENCY_ANY = 160, - PMU_EVENT_AXI_LATENCY_32 = 161, - PMU_EVENT_AXI_LATENCY_64 = 162, - PMU_EVENT_AXI_LATENCY_128 = 163, - PMU_EVENT_AXI_LATENCY_256 = 164, - PMU_EVENT_AXI_LATENCY_512 = 165, - PMU_EVENT_AXI_LATENCY_1024 = 166, - PMU_EVENT_ECC_DMA = 176, - PMU_EVENT_ECC_MAC_IB = 177, - PMU_EVENT_ECC_MAC_AB = 178, - PMU_EVENT_ECC_AO_CB = 179, - PMU_EVENT_ECC_AO_OB = 180, - PMU_EVENT_ECC_AO_LUT = 181, - PMU_EVENT_EXT_RD_TRANS_ACCEPTED = 384, - PMU_EVENT_EXT_RD_TRANS_COMPLETED = 385, - PMU_EVENT_EXT_RD_DATA_BEAT_RECEIVED = 386, - PMU_EVENT_EXT_RD_TRAN_REQ_STALLED = 387, - PMU_EVENT_EXT_WR_TRANS_ACCEPTED = 388, - PMU_EVENT_EXT_WR_TRANS_COMPLETED_M = 389, - PMU_EVENT_EXT_WR_TRANS_COMPLETED_S = 390, - PMU_EVENT_EXT_WR_DATA_BEAT_WRITTEN = 391, - PMU_EVENT_EXT_WR_TRAN_REQ_STALLED = 392, - PMU_EVENT_EXT_WR_DATA_BEAT_STALLED = 393, - PMU_EVENT_EXT_ENABLED_CYCLES = 396, - PMU_EVENT_EXT_RD_STALL_LIMIT = 398, - PMU_EVENT_EXT_WR_STALL_LIMIT = 399, - PMU_EVENT_SRAM0_RD_TRANS_ACCEPTED = 512, - PMU_EVENT_SRAM0_RD_TRANS_COMPLETED = 513, - PMU_EVENT_SRAM0_RD_DATA_BEAT_RECEIVED = 514, - PMU_EVENT_SRAM0_RD_TRAN_REQ_STALLED = 515, - PMU_EVENT_SRAM0_WR_TRANS_ACCEPTED = 516, - PMU_EVENT_SRAM0_WR_TRANS_COMPLETED_M = 517, - PMU_EVENT_SRAM0_WR_TRANS_COMPLETED_S = 518, - PMU_EVENT_SRAM0_WR_DATA_BEAT_WRITTEN = 519, - PMU_EVENT_SRAM0_WR_TRAN_REQ_STALLED = 520, - PMU_EVENT_SRAM0_WR_DATA_BEAT_STALLED = 521, - PMU_EVENT_SRAM0_ENABLED_CYCLES = 524, - PMU_EVENT_SRAM0_RD_STALL_LIMIT = 526, - PMU_EVENT_SRAM0_WR_STALL_LIMIT = 527, - PMU_EVENT_SRAM1_RD_TRANS_ACCEPTED = 528, - PMU_EVENT_SRAM1_RD_TRANS_COMPLETED = 529, - PMU_EVENT_SRAM1_RD_DATA_BEAT_RECEIVED = 530, - PMU_EVENT_SRAM1_RD_TRAN_REQ_STALLED = 531, - PMU_EVENT_SRAM1_WR_TRANS_ACCEPTED = 532, - PMU_EVENT_SRAM1_WR_TRANS_COMPLETED_M = 533, - PMU_EVENT_SRAM1_WR_TRANS_COMPLETED_S = 534, - PMU_EVENT_SRAM1_WR_DATA_BEAT_WRITTEN = 535, - PMU_EVENT_SRAM1_WR_TRAN_REQ_STALLED = 536, - PMU_EVENT_SRAM1_WR_DATA_BEAT_STALLED = 537, - PMU_EVENT_SRAM1_ENABLED_CYCLES = 540, - PMU_EVENT_SRAM1_RD_STALL_LIMIT = 542, - PMU_EVENT_SRAM1_WR_STALL_LIMIT = 543, - PMU_EVENT_SRAM2_RD_TRANS_ACCEPTED = 544, - PMU_EVENT_SRAM2_RD_TRANS_COMPLETED = 545, - PMU_EVENT_SRAM2_RD_DATA_BEAT_RECEIVED = 546, - PMU_EVENT_SRAM2_RD_TRAN_REQ_STALLED = 547, - PMU_EVENT_SRAM2_WR_TRANS_ACCEPTED = 548, - PMU_EVENT_SRAM2_WR_TRANS_COMPLETED_M = 549, - PMU_EVENT_SRAM2_WR_TRANS_COMPLETED_S = 550, - PMU_EVENT_SRAM2_WR_DATA_BEAT_WRITTEN = 551, - PMU_EVENT_SRAM2_WR_TRAN_REQ_STALLED = 552, - PMU_EVENT_SRAM2_WR_DATA_BEAT_STALLED = 553, - PMU_EVENT_SRAM2_ENABLED_CYCLES = 556, - PMU_EVENT_SRAM2_RD_STALL_LIMIT = 558, - PMU_EVENT_SRAM2_WR_STALL_LIMIT = 559, - PMU_EVENT_SRAM3_RD_TRANS_ACCEPTED = 560, - PMU_EVENT_SRAM3_RD_TRANS_COMPLETED = 561, - PMU_EVENT_SRAM3_RD_DATA_BEAT_RECEIVED = 562, - PMU_EVENT_SRAM3_RD_TRAN_REQ_STALLED = 563, - PMU_EVENT_SRAM3_WR_TRANS_ACCEPTED = 564, - PMU_EVENT_SRAM3_WR_TRANS_COMPLETED_M = 565, - PMU_EVENT_SRAM3_WR_TRANS_COMPLETED_S = 566, - PMU_EVENT_SRAM3_WR_DATA_BEAT_WRITTEN = 567, - PMU_EVENT_SRAM3_WR_TRAN_REQ_STALLED = 568, - PMU_EVENT_SRAM3_WR_DATA_BEAT_STALLED = 569, - PMU_EVENT_SRAM3_ENABLED_CYCLES = 572, - PMU_EVENT_SRAM3_RD_STALL_LIMIT = 574, - PMU_EVENT_SRAM3_WR_STALL_LIMIT = 575, - PMU_EVENT_EXT0_RD_TRANS_ACCEPTED = 640, - PMU_EVENT_EXT0_RD_TRANS_COMPLETED = 641, - PMU_EVENT_EXT0_RD_DATA_BEAT_RECEIVED = 642, - PMU_EVENT_EXT0_RD_TRAN_REQ_STALLED = 643, - PMU_EVENT_EXT0_WR_TRANS_ACCEPTED = 644, - PMU_EVENT_EXT0_WR_TRANS_COMPLETED_M = 645, - PMU_EVENT_EXT0_WR_TRANS_COMPLETED_S = 646, - PMU_EVENT_EXT0_WR_DATA_BEAT_WRITTEN = 647, - PMU_EVENT_EXT0_WR_TRAN_REQ_STALLED = 648, - PMU_EVENT_EXT0_WR_DATA_BEAT_STALLED = 649, - PMU_EVENT_EXT0_ENABLED_CYCLES = 652, - PMU_EVENT_EXT0_RD_STALL_LIMIT = 654, - PMU_EVENT_EXT0_WR_STALL_LIMIT = 655, - PMU_EVENT_EXT1_RD_TRANS_ACCEPTED = 656, - PMU_EVENT_EXT1_RD_TRANS_COMPLETED = 657, - PMU_EVENT_EXT1_RD_DATA_BEAT_RECEIVED = 658, - PMU_EVENT_EXT1_RD_TRAN_REQ_STALLED = 659, - PMU_EVENT_EXT1_WR_TRANS_ACCEPTED = 660, - PMU_EVENT_EXT1_WR_TRANS_COMPLETED_M = 661, - PMU_EVENT_EXT1_WR_TRANS_COMPLETED_S = 662, - PMU_EVENT_EXT1_WR_DATA_BEAT_WRITTEN = 663, - PMU_EVENT_EXT1_WR_TRAN_REQ_STALLED = 664, - PMU_EVENT_EXT1_WR_DATA_BEAT_STALLED = 665, - PMU_EVENT_EXT1_ENABLED_CYCLES = 668, - PMU_EVENT_EXT1_RD_STALL_LIMIT = 670, - PMU_EVENT_EXT1_WR_STALL_LIMIT = 671, -}; - -enum pmu_port_disable -{ - PMU_PORT_DISABLE_ENABLE = 0, - PMU_PORT_DISABLE_DISABLE = 1, -}; - -enum pooling_mode -{ - POOLING_MODE_MAX = 0, - POOLING_MODE_AVERAGE = 1, - POOLING_MODE_REDUCE_SUM = 2, - POOLING_MODE_SUM = 3, - POOLING_MODE_NONE = 4, - POOLING_MODE_MIN = 5, - POOLING_MODE_ARGMAX_X = 6, - POOLING_MODE_ARGMAX_Y = 7, -}; - -enum privilege_level -{ - PRIVILEGE_LEVEL_USER = 0, - PRIVILEGE_LEVEL_PRIVILEGED = 1, -}; - -enum ram_id -{ - RAM_ID_LUT = 0, - RAM_ID_IB = 1, - RAM_ID_AB = 2, - RAM_ID_CB = 3, - RAM_ID_OB = 4, -}; - -enum resize_mode -{ - RESIZE_MODE_BILINEAR = 0, - RESIZE_MODE_REPLICATE = 1, - RESIZE_MODE_NEAREST = 2, -}; - -enum round_mode_ifm -{ - ROUND_MODE_IFM_DOUBLE_SYMMETRIC = 0, - ROUND_MODE_IFM_NATURAL = 1, -}; - -enum round_mode_ofm -{ - ROUND_MODE_OFM_DOUBLE_SYMMETRIC = 0, - ROUND_MODE_OFM_NATURAL = 1, - ROUND_MODE_OFM_DOUBLE_ASYMMETRIC = 2, - ROUND_MODE_OFM_SYMMETRIC = 3, - ROUND_MODE_OFM_TRUNCATE_TO_ZERO = 4, - ROUND_MODE_OFM_TRUNCATE_TO_LOWER = 5, -}; - -enum security_level -{ - SECURITY_LEVEL_SECURE = 0, - SECURITY_LEVEL_NON_SECURE = 1, -}; - -enum state -{ - STATE_STOPPED = 0, - STATE_RUNNING = 1, -}; - -enum wd_active_core -{ - WD_ACTIVE_CORE_NONE = 0, - WD_ACTIVE_CORE_STANDARD = 1, - WD_ACTIVE_CORE_FAST = 2, - WD_ACTIVE_CORE_TENSOR = 3, -}; - -enum weight_format -{ - WEIGHT_FORMAT_SWD = 0, - WEIGHT_FORMAT_FWD = 1, -}; - -enum weight_order -{ - WEIGHT_ORDER_DEPTH_FIRST = 0, - WEIGHT_ORDER_PART_KERNEL_FIRST = 1, -}; - -enum weight_sparsity -{ - WEIGHT_SPARSITY_NONE = 0, - WEIGHT_SPARSITY_SPARSE_2_4 = 1, -}; - -#endif - -#ifdef NPU_DISASSEMBLE - -static const char* acc_format_str[] = -{ - "ACC_FORMAT_I32", - "ACC_FORMAT_I48", -}; - -static const char* acc_input_str[] = -{ - "ACC_INPUT_RESET", - "ACC_INPUT_KEEP", - "ACC_INPUT_IFM2", -}; - -static const char* acc_output_str[] = -{ - "ACC_OUTPUT_ENABLE", - "ACC_OUTPUT_DISABLE", -}; - -static const char* activation_clip_range_str[] = -{ - "ACTIVATION_CLIP_RANGE_B16", - "ACTIVATION_CLIP_RANGE_NONE", -}; - -static const char* activation_format_str[] = -{ - "ACTIVATION_FORMAT_NHWC", - "ACTIVATION_FORMAT_NHCWB16", -}; - -static const char* activation_function_str[] = -{ - "ACTIVATION_FUNCTION_LUT_NONE", - "ACTIVATION_FUNCTION_LUT_U8_U8", - "****", - "****", - "ACTIVATION_FUNCTION_LUT_S8_S8", - "ACTIVATION_FUNCTION_LUT_S8_S16", - "****", - "ACTIVATION_FUNCTION_LUT_S8_S32", - "ACTIVATION_FUNCTION_LUT_S16_S16", - "ACTIVATION_FUNCTION_LUT_S16_S32", - "ACTIVATION_FUNCTION_LUT_TANH", - "ACTIVATION_FUNCTION_LUT_SIGMOID", -}; - -static const char* activation_precision_str[] = -{ - "ACTIVATION_PRECISION_B8", - "ACTIVATION_PRECISION_B16", - "ACTIVATION_PRECISION_B32", - "ACTIVATION_PRECISION_B64", -}; - -static const char* activation_reverse_str[] = -{ - "ACTIVATION_REVERSE_NONE", - "ACTIVATION_REVERSE_H", - "ACTIVATION_REVERSE_W", - "ACTIVATION_REVERSE_C", -}; - -static const char* activation_storage_str[] = -{ - "ACTIVATION_STORAGE_TILE2X2", - "ACTIVATION_STORAGE_TILE3X1", - "ACTIVATION_STORAGE_CHAINED", - "ACTIVATION_STORAGE_NONE", -}; - -static const char* activation_transpose_str[] = -{ - "ACTIVATION_TRANSPOSE_HWC", - "ACTIVATION_TRANSPOSE_WHC", - "ACTIVATION_TRANSPOSE_HCW", - "ACTIVATION_TRANSPOSE_WCH", - "****", - "****", - "ACTIVATION_TRANSPOSE_CHW", - "ACTIVATION_TRANSPOSE_CWH", -}; - -static const char* activation_type_str[] = -{ - "ACTIVATION_TYPE_UNSIGNED", - "ACTIVATION_TYPE_SIGNED", -}; - -static const char* axi_mem_domain_str[] = -{ - "AXI_MEM_DOMAIN_NON_SHARABLE", - "AXI_MEM_DOMAIN_INNER_SHARABLE", - "AXI_MEM_DOMAIN_OUTER_SHARABLE", - "AXI_MEM_DOMAIN_SYSTEM", -}; - -static const char* axi_mem_encoding_str[] = -{ - "AXI_MEM_ENCODING_DEVICE_NON_BUFFERABLE", - "AXI_MEM_ENCODING_DEVICE_BUFFERABLE", - "AXI_MEM_ENCODING_NORMAL_NON_CACHEABLE_NON_BUFFERABLE", - "AXI_MEM_ENCODING_NORMAL_NON_CACHEABLE_BUFFERABLE", - "AXI_MEM_ENCODING_WRITE_THROUGH_NO_ALLOCATE", - "AXI_MEM_ENCODING_WRITE_THROUGH_READ_ALLOCATE", - "AXI_MEM_ENCODING_WRITE_THROUGH_WRITE_ALLOCATE", - "AXI_MEM_ENCODING_WRITE_THROUGH_READ_AND_WRITE_ALLOCATE", - "AXI_MEM_ENCODING_WRITE_BACK_NO_ALLOCATE", - "AXI_MEM_ENCODING_WRITE_BACK_READ_ALLOCATE", - "AXI_MEM_ENCODING_WRITE_BACK_WRITE_ALLOCATE", - "AXI_MEM_ENCODING_WRITE_BACK_READ_AND_WRITE_ALLOCATE", -}; - -static const char* axi_port_str[] = -{ - "AXI_PORT_SRAM", - "AXI_PORT_EXT", -}; - -static const char* branch_cond_str[] = -{ - "BRANCH_COND_ALWAYS", - "BRANCH_COND_RF_TRUE", -}; - -static const char* broadcast_mode_str[] = -{ - "BROADCAST_MODE_NONE", - "BROADCAST_MODE_H", - "BROADCAST_MODE_W", - "BROADCAST_MODE_HW", - "BROADCAST_MODE_C", - "BROADCAST_MODE_CH", - "BROADCAST_MODE_CW", - "BROADCAST_MODE_CWH", - "BROADCAST_MODE_SCALAR", -}; - -static const char* cmd0_opcode_str[] = -{ - "CMD0_OPCODE_NPU_OP_STOP", - "CMD0_OPCODE_NPU_OP_IRQ", - "CMD0_OPCODE_NPU_OP_CONV", - "CMD0_OPCODE_NPU_OP_DEPTHWISE", - "****", - "CMD0_OPCODE_NPU_OP_POOL", - "CMD0_OPCODE_NPU_OP_ELEMENTWISE", - "CMD0_OPCODE_NPU_OP_RESIZE", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "CMD0_OPCODE_NPU_OP_DMA_START", - "CMD0_OPCODE_NPU_OP_DMA_WAIT", - "CMD0_OPCODE_NPU_OP_KERNEL_WAIT", - "CMD0_OPCODE_NPU_OP_PMU_MASK", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "CMD0_OPCODE_NPU_SET_IFM_PAD_TOP", - "CMD0_OPCODE_NPU_SET_IFM_PAD_LEFT", - "CMD0_OPCODE_NPU_SET_IFM_PAD_RIGHT", - "CMD0_OPCODE_NPU_SET_IFM_PAD_BOTTOM", - "CMD0_OPCODE_NPU_SET_IFM_DEPTH_M1", - "CMD0_OPCODE_NPU_SET_IFM_PRECISION", - "****", - "CMD0_OPCODE_NPU_SET_IFM_UPSCALE", - "CMD0_OPCODE_NPU_SET_IFM_BROADCAST", - "CMD0_OPCODE_NPU_SET_IFM_ZERO_POINT", - "CMD0_OPCODE_NPU_SET_IFM_WIDTH0_M1", - "CMD0_OPCODE_NPU_SET_IFM_HEIGHT0_M1", - "CMD0_OPCODE_NPU_SET_IFM_HEIGHT1_M1", - "****", - "****", - "CMD0_OPCODE_NPU_SET_IFM_REGION", - "****", - "CMD0_OPCODE_NPU_SET_OFM_WIDTH_M1", - "CMD0_OPCODE_NPU_SET_OFM_HEIGHT_M1", - "CMD0_OPCODE_NPU_SET_OFM_DEPTH_M1", - "CMD0_OPCODE_NPU_SET_OFM_PRECISION", - "CMD0_OPCODE_NPU_SET_OFM_BLK_WIDTH_M1", - "CMD0_OPCODE_NPU_SET_OFM_BLK_HEIGHT_M1", - "CMD0_OPCODE_NPU_SET_OFM_BLK_DEPTH_M1", - "CMD0_OPCODE_NPU_SET_OFM_ZERO_POINT", - "****", - "CMD0_OPCODE_NPU_SET_OFM_WIDTH0_M1", - "CMD0_OPCODE_NPU_SET_OFM_HEIGHT0_M1", - "CMD0_OPCODE_NPU_SET_OFM_HEIGHT1_M1", - "****", - "****", - "CMD0_OPCODE_NPU_SET_OFM_REGION", - "CMD0_OPCODE_NPU_SET_KERNEL_WIDTH_M1", - "CMD0_OPCODE_NPU_SET_KERNEL_HEIGHT_M1", - "CMD0_OPCODE_NPU_SET_KERNEL_STRIDE", - "****", - "CMD0_OPCODE_NPU_SET_ACC_FORMAT", - "CMD0_OPCODE_NPU_SET_ACTIVATION", - "CMD0_OPCODE_NPU_SET_ACTIVATION_MIN", - "CMD0_OPCODE_NPU_SET_ACTIVATION_MAX", - "CMD0_OPCODE_NPU_SET_WEIGHT_REGION", - "CMD0_OPCODE_NPU_SET_SCALE_REGION", - "CMD0_OPCODE_NPU_SET_RESIZE_X_SCALE_N_M1", - "CMD0_OPCODE_NPU_SET_RESIZE_Y_SCALE_N_M1", - "CMD0_OPCODE_NPU_SET_RESIZE_X_OFFSET", - "CMD0_OPCODE_NPU_SET_RESIZE_Y_OFFSET", - "CMD0_OPCODE_NPU_SET_WEIGHT_FORMAT", - "CMD0_OPCODE_NPU_SET_BLOCKDEP", - "CMD0_OPCODE_NPU_SET_DMA0_SRC_REGION", - "CMD0_OPCODE_NPU_SET_DMA0_DST_REGION", - "CMD0_OPCODE_NPU_SET_DMA0_SIZE0", - "CMD0_OPCODE_NPU_SET_DMA0_SIZE1", - "CMD0_OPCODE_NPU_SET_DMA0_IDX_REGION", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "CMD0_OPCODE_NPU_SET_IFM2_BROADCAST", - "****", - "****", - "****", - "****", - "CMD0_OPCODE_NPU_SET_IFM2_PRECISION", - "****", - "****", - "****", - "CMD0_OPCODE_NPU_SET_IFM2_ZERO_POINT", - "CMD0_OPCODE_NPU_SET_IFM2_WIDTH0_M1", - "CMD0_OPCODE_NPU_SET_IFM2_HEIGHT0_M1", - "CMD0_OPCODE_NPU_SET_IFM2_HEIGHT1_M1", - "****", - "****", - "CMD0_OPCODE_NPU_SET_IFM2_REGION", -}; - -static const char* cmd1_opcode_str[] = -{ - "CMD1_OPCODE_NPU_SET_IFM_BASE0", - "CMD1_OPCODE_NPU_SET_IFM_BASE1", - "CMD1_OPCODE_NPU_SET_IFM_BASE2", - "CMD1_OPCODE_NPU_SET_IFM_BASE3", - "CMD1_OPCODE_NPU_SET_IFM_STRIDE_X", - "CMD1_OPCODE_NPU_SET_IFM_STRIDE_Y", - "CMD1_OPCODE_NPU_SET_IFM_STRIDE_C", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "CMD1_OPCODE_NPU_SET_OFM_BASE0", - "CMD1_OPCODE_NPU_SET_OFM_BASE1", - "CMD1_OPCODE_NPU_SET_OFM_BASE2", - "CMD1_OPCODE_NPU_SET_OFM_BASE3", - "CMD1_OPCODE_NPU_SET_OFM_STRIDE_X", - "CMD1_OPCODE_NPU_SET_OFM_STRIDE_Y", - "CMD1_OPCODE_NPU_SET_OFM_STRIDE_C", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "CMD1_OPCODE_NPU_SET_WEIGHT_BASE", - "CMD1_OPCODE_NPU_SET_WEIGHT_LENGTH", - "CMD1_OPCODE_NPU_SET_SCALE_BASE", - "CMD1_OPCODE_NPU_SET_SCALE_LENGTH", - "CMD1_OPCODE_NPU_SET_OFM_SCALE", - "CMD1_OPCODE_NPU_SET_IFM_SCALE", - "CMD1_OPCODE_NPU_SET_IFM2_SCALE", - "CMD1_OPCODE_NPU_SET_OP_SCALAR", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "CMD1_OPCODE_NPU_SET_DMA0_SRC", - "CMD1_OPCODE_NPU_SET_DMA0_DST", - "CMD1_OPCODE_NPU_SET_DMA0_LEN", - "CMD1_OPCODE_NPU_SET_DMA0_SRC_STRIDE0", - "CMD1_OPCODE_NPU_SET_DMA0_SRC_STRIDE1", - "CMD1_OPCODE_NPU_SET_DMA0_DST_STRIDE0", - "CMD1_OPCODE_NPU_SET_DMA0_DST_STRIDE1", - "CMD1_OPCODE_NPU_SET_DMA0_IDX", - "CMD1_OPCODE_NPU_SET_DMA0_IDX_MAX", - "CMD1_OPCODE_NPU_SET_DMA0_IDX_SKIP1", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "CMD1_OPCODE_NPU_SET_IFM2_BASE0", - "CMD1_OPCODE_NPU_SET_IFM2_BASE1", - "CMD1_OPCODE_NPU_SET_IFM2_BASE2", - "CMD1_OPCODE_NPU_SET_IFM2_BASE3", - "CMD1_OPCODE_NPU_SET_IFM2_STRIDE_X", - "CMD1_OPCODE_NPU_SET_IFM2_STRIDE_Y", - "CMD1_OPCODE_NPU_SET_IFM2_STRIDE_C", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "CMD1_OPCODE_NPU_SET_WEIGHT1_BASE", - "CMD1_OPCODE_NPU_SET_WEIGHT1_LENGTH", - "CMD1_OPCODE_NPU_SET_WEIGHT2_BASE", - "CMD1_OPCODE_NPU_SET_WEIGHT2_LENGTH", - "CMD1_OPCODE_NPU_SET_WEIGHT3_BASE", - "CMD1_OPCODE_NPU_SET_WEIGHT3_LENGTH", - "CMD1_OPCODE_NPU_SET_RESIZE_X", - "CMD1_OPCODE_NPU_SET_RESIZE_Y", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "CMD1_OPCODE_NPU_OP_BRANCH", -}; - -static const char* cmd_ctrl_str[] = -{ - "CMD_CTRL_CMD0_CTRL", - "CMD_CTRL_CMD1_CTRL", -}; - -static const char* custom_dma_str[] = -{ - "CUSTOM_DMA_NOT_IMPLEMENTED", - "CUSTOM_DMA_IMPLEMENTED", -}; - -static const char* dma_fault_src_str[] = -{ - "DMA_FAULT_SRC_SRAM", - "DMA_FAULT_SRC_EXT", -}; - -static const char* dma_idx_mode_str[] = -{ - "DMA_IDX_MODE_DISABLED", - "DMA_IDX_MODE_ENABLED", -}; - -static const char* dma_region_mode_str[] = -{ - "DMA_REGION_MODE_EXTERNAL", - "DMA_REGION_MODE_INTERNAL", -}; - -static const char* dma_stride_mode_str[] = -{ - "DMA_STRIDE_MODE_D1", - "DMA_STRIDE_MODE_D2", - "DMA_STRIDE_MODE_D3", -}; - -static const char* elementwise_mode_str[] = -{ - "ELEMENTWISE_MODE_MUL", - "ELEMENTWISE_MODE_ADD", - "ELEMENTWISE_MODE_SUB", - "ELEMENTWISE_MODE_MIN", - "ELEMENTWISE_MODE_MAX", - "ELEMENTWISE_MODE_LRELU", - "ELEMENTWISE_MODE_ABS", - "ELEMENTWISE_MODE_CLZ", - "ELEMENTWISE_MODE_SHR", - "ELEMENTWISE_MODE_SHL", - "ELEMENTWISE_MODE_LSR", - "ELEMENTWISE_MODE_DIV", - "****", - "****", - "****", - "****", - "ELEMENTWISE_MODE_CMP_EQ", - "ELEMENTWISE_MODE_CMP_NE", - "ELEMENTWISE_MODE_CMP_GE", - "ELEMENTWISE_MODE_CMP_GT", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "ELEMENTWISE_MODE_AND", - "ELEMENTWISE_MODE_OR", - "ELEMENTWISE_MODE_XOR", - "ELEMENTWISE_MODE_NOT", - "****", - "****", - "****", - "****", - "****", - "ELEMENTWISE_MODE_AND_NOT", -}; - -static const char* ifm_upscale_mode_str[] = -{ - "IFM_UPSCALE_MODE_NONE", - "IFM_UPSCALE_MODE_NEAREST", - "IFM_UPSCALE_MODE_ZEROS", -}; - -static const char* kernel_decomposition_str[] = -{ - "KERNEL_DECOMPOSITION_D8X8", - "KERNEL_DECOMPOSITION_D4X4", -}; - -static const char* kernel_dilation_str[] = -{ - "KERNEL_DILATION_NONE", - "KERNEL_DILATION_X2", -}; - -static const char* max_beats_str[] = -{ - "MAX_BEATS_B64", - "MAX_BEATS_B128", - "MAX_BEATS_B256", -}; - -static const char* microblock_str[] = -{ - "MICROBLOCK_U1X1", - "MICROBLOCK_U1X2", - "MICROBLOCK_U1X4", - "MICROBLOCK_U2X2", - "MICROBLOCK_U2X4", - "MICROBLOCK_U4X4", -}; - -static const char* ofm_scale_mode_str[] = -{ - "OFM_SCALE_MODE_PER_CHANNEL", - "OFM_SCALE_MODE_GLOBAL", -}; - -static const char* pmu_axi_channel_str[] = -{ - "PMU_AXI_CHANNEL_RD_CMD", - "PMU_AXI_CHANNEL_RD_IFM", - "PMU_AXI_CHANNEL_RD_WEIGHTS", - "PMU_AXI_CHANNEL_RD_SCALE_BIAS", - "PMU_AXI_CHANNEL_RD_MEM2MEM", - "PMU_AXI_CHANNEL_RD_IFM_STREAM", - "PMU_AXI_CHANNEL_RD_MEM2MEM_IDX", - "****", - "PMU_AXI_CHANNEL_WR_OFM", - "PMU_AXI_CHANNEL_WR_MEM2MEM", -}; - -static const char* pmu_event_str[] = -{ - "PMU_EVENT_NO_EVENT", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "PMU_EVENT_CYCLE", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "PMU_EVENT_NPU_IDLE", - "PMU_EVENT_CC_STALLED_ON_BLOCKDEP", - "****", - "PMU_EVENT_NPU_ACTIVE", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "PMU_EVENT_MAC_ACTIVE", - "****", - "****", - "PMU_EVENT_MAC_DPU_ACTIVE", - "PMU_EVENT_MAC_STALLED_BY_W_OR_ACC", - "PMU_EVENT_MAC_STALLED_BY_W", - "PMU_EVENT_MAC_STALLED_BY_ACC", - "PMU_EVENT_MAC_STALLED_BY_IB", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "PMU_EVENT_AO_ACTIVE", - "****", - "****", - "PMU_EVENT_AO_STALLED_BY_BS_OR_OB", - "PMU_EVENT_AO_STALLED_BY_BS", - "PMU_EVENT_AO_STALLED_BY_OB", - "PMU_EVENT_AO_STALLED_BY_AB_OR_CB", - "PMU_EVENT_AO_STALLED_BY_AB", - "PMU_EVENT_AO_STALLED_BY_CB", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "PMU_EVENT_WD_ACTIVE", - "PMU_EVENT_WD_STALLED", - "****", - "PMU_EVENT_WD_STALLED_BY_WD_BUF", - "PMU_EVENT_WD_STALLED_BY_WS_FC", - "PMU_EVENT_WD_STALLED_BY_WS_TC", - "****", - "****", - "****", - "PMU_EVENT_WD_TRANS_WBLK", - "PMU_EVENT_WD_TRANS_WS_FC", - "PMU_EVENT_WD_TRANS_WS_TC", - "****", - "****", - "****", - "****", - "PMU_EVENT_WD_STALLED_BY_WS_SC0", - "PMU_EVENT_WD_STALLED_BY_WS_SC1", - "PMU_EVENT_WD_STALLED_BY_WS_SC2", - "PMU_EVENT_WD_STALLED_BY_WS_SC3", - "PMU_EVENT_WD_PARSE_ACTIVE_SC0", - "PMU_EVENT_WD_PARSE_ACTIVE_SC1", - "PMU_EVENT_WD_PARSE_ACTIVE_SC2", - "PMU_EVENT_WD_PARSE_ACTIVE_SC3", - "PMU_EVENT_WD_PARSE_STALL_SC0", - "PMU_EVENT_WD_PARSE_STALL_SC1", - "PMU_EVENT_WD_PARSE_STALL_SC2", - "PMU_EVENT_WD_PARSE_STALL_SC3", - "PMU_EVENT_WD_PARSE_STALL_IN_SC0", - "PMU_EVENT_WD_PARSE_STALL_IN_SC1", - "PMU_EVENT_WD_PARSE_STALL_IN_SC2", - "PMU_EVENT_WD_PARSE_STALL_IN_SC3", - "PMU_EVENT_WD_PARSE_STALL_OUT_SC0", - "PMU_EVENT_WD_PARSE_STALL_OUT_SC1", - "PMU_EVENT_WD_PARSE_STALL_OUT_SC2", - "PMU_EVENT_WD_PARSE_STALL_OUT_SC3", - "PMU_EVENT_WD_TRANS_WS_SC0", - "PMU_EVENT_WD_TRANS_WS_SC1", - "PMU_EVENT_WD_TRANS_WS_SC2", - "PMU_EVENT_WD_TRANS_WS_SC3", - "PMU_EVENT_WD_TRANS_WB0", - "PMU_EVENT_WD_TRANS_WB1", - "PMU_EVENT_WD_TRANS_WB2", - "PMU_EVENT_WD_TRANS_WB3", - "****", - "****", - "****", - "****", - "PMU_EVENT_SRAM_RD_TRANS_ACCEPTED", - "PMU_EVENT_SRAM_RD_TRANS_COMPLETED", - "PMU_EVENT_SRAM_RD_DATA_BEAT_RECEIVED", - "PMU_EVENT_SRAM_RD_TRAN_REQ_STALLED", - "PMU_EVENT_SRAM_WR_TRANS_ACCEPTED", - "PMU_EVENT_SRAM_WR_TRANS_COMPLETED_M", - "PMU_EVENT_SRAM_WR_TRANS_COMPLETED_S", - "PMU_EVENT_SRAM_WR_DATA_BEAT_WRITTEN", - "PMU_EVENT_SRAM_WR_TRAN_REQ_STALLED", - "PMU_EVENT_SRAM_WR_DATA_BEAT_STALLED", - "****", - "****", - "PMU_EVENT_SRAM_ENABLED_CYCLES", - "****", - "PMU_EVENT_SRAM_RD_STALL_LIMIT", - "PMU_EVENT_SRAM_WR_STALL_LIMIT", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "PMU_EVENT_AXI_LATENCY_ANY", - "PMU_EVENT_AXI_LATENCY_32", - "PMU_EVENT_AXI_LATENCY_64", - "PMU_EVENT_AXI_LATENCY_128", - "PMU_EVENT_AXI_LATENCY_256", - "PMU_EVENT_AXI_LATENCY_512", - "PMU_EVENT_AXI_LATENCY_1024", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "PMU_EVENT_ECC_DMA", - "PMU_EVENT_ECC_MAC_IB", - "PMU_EVENT_ECC_MAC_AB", - "PMU_EVENT_ECC_AO_CB", - "PMU_EVENT_ECC_AO_OB", - "PMU_EVENT_ECC_AO_LUT", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "PMU_EVENT_EXT_RD_TRANS_ACCEPTED", - "PMU_EVENT_EXT_RD_TRANS_COMPLETED", - "PMU_EVENT_EXT_RD_DATA_BEAT_RECEIVED", - "PMU_EVENT_EXT_RD_TRAN_REQ_STALLED", - "PMU_EVENT_EXT_WR_TRANS_ACCEPTED", - "PMU_EVENT_EXT_WR_TRANS_COMPLETED_M", - "PMU_EVENT_EXT_WR_TRANS_COMPLETED_S", - "PMU_EVENT_EXT_WR_DATA_BEAT_WRITTEN", - "PMU_EVENT_EXT_WR_TRAN_REQ_STALLED", - "PMU_EVENT_EXT_WR_DATA_BEAT_STALLED", - "****", - "****", - "PMU_EVENT_EXT_ENABLED_CYCLES", - "****", - "PMU_EVENT_EXT_RD_STALL_LIMIT", - "PMU_EVENT_EXT_WR_STALL_LIMIT", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "PMU_EVENT_SRAM0_RD_TRANS_ACCEPTED", - "PMU_EVENT_SRAM0_RD_TRANS_COMPLETED", - "PMU_EVENT_SRAM0_RD_DATA_BEAT_RECEIVED", - "PMU_EVENT_SRAM0_RD_TRAN_REQ_STALLED", - "PMU_EVENT_SRAM0_WR_TRANS_ACCEPTED", - "PMU_EVENT_SRAM0_WR_TRANS_COMPLETED_M", - "PMU_EVENT_SRAM0_WR_TRANS_COMPLETED_S", - "PMU_EVENT_SRAM0_WR_DATA_BEAT_WRITTEN", - "PMU_EVENT_SRAM0_WR_TRAN_REQ_STALLED", - "PMU_EVENT_SRAM0_WR_DATA_BEAT_STALLED", - "****", - "****", - "PMU_EVENT_SRAM0_ENABLED_CYCLES", - "****", - "PMU_EVENT_SRAM0_RD_STALL_LIMIT", - "PMU_EVENT_SRAM0_WR_STALL_LIMIT", - "PMU_EVENT_SRAM1_RD_TRANS_ACCEPTED", - "PMU_EVENT_SRAM1_RD_TRANS_COMPLETED", - "PMU_EVENT_SRAM1_RD_DATA_BEAT_RECEIVED", - "PMU_EVENT_SRAM1_RD_TRAN_REQ_STALLED", - "PMU_EVENT_SRAM1_WR_TRANS_ACCEPTED", - "PMU_EVENT_SRAM1_WR_TRANS_COMPLETED_M", - "PMU_EVENT_SRAM1_WR_TRANS_COMPLETED_S", - "PMU_EVENT_SRAM1_WR_DATA_BEAT_WRITTEN", - "PMU_EVENT_SRAM1_WR_TRAN_REQ_STALLED", - "PMU_EVENT_SRAM1_WR_DATA_BEAT_STALLED", - "****", - "****", - "PMU_EVENT_SRAM1_ENABLED_CYCLES", - "****", - "PMU_EVENT_SRAM1_RD_STALL_LIMIT", - "PMU_EVENT_SRAM1_WR_STALL_LIMIT", - "PMU_EVENT_SRAM2_RD_TRANS_ACCEPTED", - "PMU_EVENT_SRAM2_RD_TRANS_COMPLETED", - "PMU_EVENT_SRAM2_RD_DATA_BEAT_RECEIVED", - "PMU_EVENT_SRAM2_RD_TRAN_REQ_STALLED", - "PMU_EVENT_SRAM2_WR_TRANS_ACCEPTED", - "PMU_EVENT_SRAM2_WR_TRANS_COMPLETED_M", - "PMU_EVENT_SRAM2_WR_TRANS_COMPLETED_S", - "PMU_EVENT_SRAM2_WR_DATA_BEAT_WRITTEN", - "PMU_EVENT_SRAM2_WR_TRAN_REQ_STALLED", - "PMU_EVENT_SRAM2_WR_DATA_BEAT_STALLED", - "****", - "****", - "PMU_EVENT_SRAM2_ENABLED_CYCLES", - "****", - "PMU_EVENT_SRAM2_RD_STALL_LIMIT", - "PMU_EVENT_SRAM2_WR_STALL_LIMIT", - "PMU_EVENT_SRAM3_RD_TRANS_ACCEPTED", - "PMU_EVENT_SRAM3_RD_TRANS_COMPLETED", - "PMU_EVENT_SRAM3_RD_DATA_BEAT_RECEIVED", - "PMU_EVENT_SRAM3_RD_TRAN_REQ_STALLED", - "PMU_EVENT_SRAM3_WR_TRANS_ACCEPTED", - "PMU_EVENT_SRAM3_WR_TRANS_COMPLETED_M", - "PMU_EVENT_SRAM3_WR_TRANS_COMPLETED_S", - "PMU_EVENT_SRAM3_WR_DATA_BEAT_WRITTEN", - "PMU_EVENT_SRAM3_WR_TRAN_REQ_STALLED", - "PMU_EVENT_SRAM3_WR_DATA_BEAT_STALLED", - "****", - "****", - "PMU_EVENT_SRAM3_ENABLED_CYCLES", - "****", - "PMU_EVENT_SRAM3_RD_STALL_LIMIT", - "PMU_EVENT_SRAM3_WR_STALL_LIMIT", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "****", - "PMU_EVENT_EXT0_RD_TRANS_ACCEPTED", - "PMU_EVENT_EXT0_RD_TRANS_COMPLETED", - "PMU_EVENT_EXT0_RD_DATA_BEAT_RECEIVED", - "PMU_EVENT_EXT0_RD_TRAN_REQ_STALLED", - "PMU_EVENT_EXT0_WR_TRANS_ACCEPTED", - "PMU_EVENT_EXT0_WR_TRANS_COMPLETED_M", - "PMU_EVENT_EXT0_WR_TRANS_COMPLETED_S", - "PMU_EVENT_EXT0_WR_DATA_BEAT_WRITTEN", - "PMU_EVENT_EXT0_WR_TRAN_REQ_STALLED", - "PMU_EVENT_EXT0_WR_DATA_BEAT_STALLED", - "****", - "****", - "PMU_EVENT_EXT0_ENABLED_CYCLES", - "****", - "PMU_EVENT_EXT0_RD_STALL_LIMIT", - "PMU_EVENT_EXT0_WR_STALL_LIMIT", - "PMU_EVENT_EXT1_RD_TRANS_ACCEPTED", - "PMU_EVENT_EXT1_RD_TRANS_COMPLETED", - "PMU_EVENT_EXT1_RD_DATA_BEAT_RECEIVED", - "PMU_EVENT_EXT1_RD_TRAN_REQ_STALLED", - "PMU_EVENT_EXT1_WR_TRANS_ACCEPTED", - "PMU_EVENT_EXT1_WR_TRANS_COMPLETED_M", - "PMU_EVENT_EXT1_WR_TRANS_COMPLETED_S", - "PMU_EVENT_EXT1_WR_DATA_BEAT_WRITTEN", - "PMU_EVENT_EXT1_WR_TRAN_REQ_STALLED", - "PMU_EVENT_EXT1_WR_DATA_BEAT_STALLED", - "****", - "****", - "PMU_EVENT_EXT1_ENABLED_CYCLES", - "****", - "PMU_EVENT_EXT1_RD_STALL_LIMIT", - "PMU_EVENT_EXT1_WR_STALL_LIMIT", -}; - -static const char* pmu_port_disable_str[] = -{ - "PMU_PORT_DISABLE_ENABLE", - "PMU_PORT_DISABLE_DISABLE", -}; - -static const char* pooling_mode_str[] = -{ - "POOLING_MODE_MAX", - "POOLING_MODE_AVERAGE", - "POOLING_MODE_REDUCE_SUM", - "POOLING_MODE_SUM", - "POOLING_MODE_NONE", - "POOLING_MODE_MIN", - "POOLING_MODE_ARGMAX_X", - "POOLING_MODE_ARGMAX_Y", -}; - -static const char* privilege_level_str[] = -{ - "PRIVILEGE_LEVEL_USER", - "PRIVILEGE_LEVEL_PRIVILEGED", -}; - -static const char* ram_id_str[] = -{ - "RAM_ID_LUT", - "RAM_ID_IB", - "RAM_ID_AB", - "RAM_ID_CB", - "RAM_ID_OB", -}; - -static const char* resize_mode_str[] = -{ - "RESIZE_MODE_BILINEAR", - "RESIZE_MODE_REPLICATE", - "RESIZE_MODE_NEAREST", -}; - -static const char* round_mode_ifm_str[] = -{ - "ROUND_MODE_IFM_DOUBLE_SYMMETRIC", - "ROUND_MODE_IFM_NATURAL", -}; - -static const char* round_mode_ofm_str[] = -{ - "ROUND_MODE_OFM_DOUBLE_SYMMETRIC", - "ROUND_MODE_OFM_NATURAL", - "ROUND_MODE_OFM_DOUBLE_ASYMMETRIC", - "ROUND_MODE_OFM_SYMMETRIC", - "ROUND_MODE_OFM_TRUNCATE_TO_ZERO", - "ROUND_MODE_OFM_TRUNCATE_TO_LOWER", -}; - -static const char* security_level_str[] = -{ - "SECURITY_LEVEL_SECURE", - "SECURITY_LEVEL_NON_SECURE", -}; - -static const char* state_str[] = -{ - "STATE_STOPPED", - "STATE_RUNNING", -}; - -static const char* wd_active_core_str[] = -{ - "WD_ACTIVE_CORE_NONE", - "WD_ACTIVE_CORE_STANDARD", - "WD_ACTIVE_CORE_FAST", - "WD_ACTIVE_CORE_TENSOR", -}; - -static const char* weight_format_str[] = -{ - "WEIGHT_FORMAT_SWD", - "WEIGHT_FORMAT_FWD", -}; - -static const char* weight_order_str[] = -{ - "WEIGHT_ORDER_DEPTH_FIRST", - "WEIGHT_ORDER_PART_KERNEL_FIRST", -}; - -static const char* weight_sparsity_str[] = -{ - "WEIGHT_SPARSITY_NONE", - "WEIGHT_SPARSITY_SPARSE_2_4", -}; - -#endif - -// Register type structs -// id_r - ID register -struct id_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t version_status : 4; // This value is the version of the product - uint32_t version_minor : 4; // This value is the n for the P part of an RnPn release number - uint32_t version_major : 4; // This value is the n for the R part of an RnPn release number - uint32_t product_major : 4; // Product major ID number (unique per base product) - uint32_t arch_patch_rev : 4; // This value is the patch number of the architecture version a.b - uint32_t arch_minor_rev : 8; // This value is the minor architecture version number, b in the architecture version a.b - uint32_t arch_major_rev : 4; // This value is the major architecture version number, a in the architecture version a.b - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR id_r() : - word0(536899585) - {} - CONSTEXPR id_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - id_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_version_status() const - { - auto v = ((1U << 4) - 1) & (word0 >> 0); - return v; - } - CONSTEXPR id_r& set_version_status(uint32_t value) - { - word0 = (~(((1U << 4) - 1)<<0) & word0) | ((((1U << 4) - 1) & value) << 0); - return *this; - } - CONSTEXPR uint32_t get_version_minor() const - { - auto v = ((1U << 4) - 1) & (word0 >> 4); - return v; - } - CONSTEXPR id_r& set_version_minor(uint32_t value) - { - word0 = (~(((1U << 4) - 1)<<4) & word0) | ((((1U << 4) - 1) & value) << 4); - return *this; - } - CONSTEXPR uint32_t get_version_major() const - { - auto v = ((1U << 4) - 1) & (word0 >> 8); - return v; - } - CONSTEXPR id_r& set_version_major(uint32_t value) - { - word0 = (~(((1U << 4) - 1)<<8) & word0) | ((((1U << 4) - 1) & value) << 8); - return *this; - } - CONSTEXPR uint32_t get_product_major() const - { - auto v = ((1U << 4) - 1) & (word0 >> 12); - return v; - } - CONSTEXPR id_r& set_product_major(uint32_t value) - { - word0 = (~(((1U << 4) - 1)<<12) & word0) | ((((1U << 4) - 1) & value) << 12); - return *this; - } - CONSTEXPR uint32_t get_arch_patch_rev() const - { - auto v = ((1U << 4) - 1) & (word0 >> 16); - return v; - } - CONSTEXPR id_r& set_arch_patch_rev(uint32_t value) - { - word0 = (~(((1U << 4) - 1)<<16) & word0) | ((((1U << 4) - 1) & value) << 16); - return *this; - } - CONSTEXPR uint32_t get_arch_minor_rev() const - { - auto v = ((1U << 8) - 1) & (word0 >> 20); - return v; - } - CONSTEXPR id_r& set_arch_minor_rev(uint32_t value) - { - word0 = (~(((1U << 8) - 1)<<20) & word0) | ((((1U << 8) - 1) & value) << 20); - return *this; - } - CONSTEXPR uint32_t get_arch_major_rev() const - { - auto v = ((1U << 4) - 1) & (word0 >> 28); - return v; - } - CONSTEXPR id_r& set_arch_major_rev(uint32_t value) - { - word0 = (~(((1U << 4) - 1)<<28) & word0) | ((((1U << 4) - 1) & value) << 28); - return *this; - } -#endif -}; - -// status_r - Register describes the current operating status of the NPU -struct status_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t state : 1; // 0 = NPU is in stopped state. 1 = NPU is in running state - uint32_t irq_raised : 1; // 0 = IRQ not raised. 1 = IRQ raised - uint32_t bus_status : 1; // 0 = No bus fault. 1 = Bus abort detected and processing halted - uint32_t reset_status : 1; // 0 = No reset in progress. 1 = Reset in progress - uint32_t cmd_parse_error : 1; // 0 = No parsing error. 1 = Command stream parsing error detected - uint32_t cmd_end_reached : 1; // 0 = Command stream end is not reached. 1 = Command stream end is reached - uint32_t pmu_irq_raised : 1; // 0 = No PMU IRQ raised. 1 = PMU IRQ raised - uint32_t reserved0 : 1; - uint32_t ecc_fault : 1; // 0 = No ECC fault detected. 1 = ECC fault detected - uint32_t branch_fault : 1; // 0 = No branch fault. 1 = Branch fault detected - uint32_t reserved1 : 1; - uint32_t faulting_interface : 1; // The faulting interface on bus abort - uint32_t faulting_channel : 4; // The faulting channel on a bus abort - uint32_t irq_history_mask : 16; // The IRQ History mask - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR status_r() : - word0(8) - {} - CONSTEXPR status_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - status_r copy() - { - return *this; - } - CONSTEXPR NPU_NAMESPACE::state get_state() const - { - auto v = ((1U << 1) - 1) & (word0 >> 0); - assert(v <= 1); - return static_cast(v); - } - CONSTEXPR status_r& set_state(NPU_NAMESPACE::state value) - { - word0 = (~(((1U << 1) - 1)<<0) & word0) | ((((1U << 1) - 1) & static_cast(value)) << 0); - return *this; - } - CONSTEXPR uint32_t get_irq_raised() const - { - auto v = ((1U << 1) - 1) & (word0 >> 1); - return v; - } - CONSTEXPR status_r& set_irq_raised(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - CONSTEXPR uint32_t get_bus_status() const - { - auto v = ((1U << 1) - 1) & (word0 >> 2); - return v; - } - CONSTEXPR status_r& set_bus_status(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - CONSTEXPR uint32_t get_reset_status() const - { - auto v = ((1U << 1) - 1) & (word0 >> 3); - return v; - } - CONSTEXPR status_r& set_reset_status(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - CONSTEXPR uint32_t get_cmd_parse_error() const - { - auto v = ((1U << 1) - 1) & (word0 >> 4); - return v; - } - CONSTEXPR status_r& set_cmd_parse_error(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<4) & word0) | ((((1U << 1) - 1) & value) << 4); - return *this; - } - CONSTEXPR uint32_t get_cmd_end_reached() const - { - auto v = ((1U << 1) - 1) & (word0 >> 5); - return v; - } - CONSTEXPR status_r& set_cmd_end_reached(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<5) & word0) | ((((1U << 1) - 1) & value) << 5); - return *this; - } - CONSTEXPR uint32_t get_pmu_irq_raised() const - { - auto v = ((1U << 1) - 1) & (word0 >> 6); - return v; - } - CONSTEXPR status_r& set_pmu_irq_raised(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<6) & word0) | ((((1U << 1) - 1) & value) << 6); - return *this; - } - CONSTEXPR uint32_t get_ecc_fault() const - { - auto v = ((1U << 1) - 1) & (word0 >> 8); - return v; - } - CONSTEXPR status_r& set_ecc_fault(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<8) & word0) | ((((1U << 1) - 1) & value) << 8); - return *this; - } - CONSTEXPR uint32_t get_branch_fault() const - { - auto v = ((1U << 1) - 1) & (word0 >> 9); - return v; - } - CONSTEXPR status_r& set_branch_fault(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<9) & word0) | ((((1U << 1) - 1) & value) << 9); - return *this; - } - CONSTEXPR NPU_NAMESPACE::dma_fault_src get_faulting_interface() const - { - auto v = ((1U << 1) - 1) & (word0 >> 11); - assert(v <= 1); - return static_cast(v); - } - CONSTEXPR status_r& set_faulting_interface(NPU_NAMESPACE::dma_fault_src value) - { - word0 = (~(((1U << 1) - 1)<<11) & word0) | ((((1U << 1) - 1) & static_cast(value)) << 11); - return *this; - } - CONSTEXPR NPU_NAMESPACE::pmu_axi_channel get_faulting_channel() const - { - auto v = ((1U << 4) - 1) & (word0 >> 12); - assert(v <= 9); - return static_cast(v); - } - CONSTEXPR status_r& set_faulting_channel(NPU_NAMESPACE::pmu_axi_channel value) - { - word0 = (~(((1U << 4) - 1)<<12) & word0) | ((((1U << 4) - 1) & static_cast(value)) << 12); - return *this; - } - CONSTEXPR uint32_t get_irq_history_mask() const - { - auto v = ((1U << 16) - 1) & (word0 >> 16); - return v; - } - CONSTEXPR status_r& set_irq_history_mask(uint32_t value) - { - word0 = (~(((1U << 16) - 1)<<16) & word0) | ((((1U << 16) - 1) & value) << 16); - return *this; - } -#endif -}; - -// cmd_r - The command register. This register reads as last written command -struct cmd_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t transition_to_running_state : 1; // Write 1 to transition the NPU to running state. Writing 0 has no effect - uint32_t clear_irq : 1; // Write 1 to clear the IRQ status in the STATUS register. Writing 0 has no effect - uint32_t clock_q_enable : 1; // Write 1 to this bit to enable clock off using clock q-interface and enable the requester clock gate - uint32_t power_q_enable : 1; // Write 1 to this bit to enable power off using power q-interface - uint32_t stop_request : 1; // Write 1 to this bit to request STOP after completing any already-started commands - uint32_t reserved0 : 11; - uint32_t clear_irq_history : 16; // Clears the IRQ history mask - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR cmd_r() : - word0(12) - {} - CONSTEXPR cmd_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - cmd_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_transition_to_running_state() const - { - auto v = ((1U << 1) - 1) & (word0 >> 0); - return v; - } - CONSTEXPR cmd_r& set_transition_to_running_state(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - CONSTEXPR uint32_t get_clear_irq() const - { - auto v = ((1U << 1) - 1) & (word0 >> 1); - return v; - } - CONSTEXPR cmd_r& set_clear_irq(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - CONSTEXPR uint32_t get_clock_q_enable() const - { - auto v = ((1U << 1) - 1) & (word0 >> 2); - return v; - } - CONSTEXPR cmd_r& set_clock_q_enable(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - CONSTEXPR uint32_t get_power_q_enable() const - { - auto v = ((1U << 1) - 1) & (word0 >> 3); - return v; - } - CONSTEXPR cmd_r& set_power_q_enable(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - CONSTEXPR uint32_t get_stop_request() const - { - auto v = ((1U << 1) - 1) & (word0 >> 4); - return v; - } - CONSTEXPR cmd_r& set_stop_request(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<4) & word0) | ((((1U << 1) - 1) & value) << 4); - return *this; - } - CONSTEXPR uint32_t get_clear_irq_history() const - { - auto v = ((1U << 16) - 1) & (word0 >> 16); - return v; - } - CONSTEXPR cmd_r& set_clear_irq_history(uint32_t value) - { - word0 = (~(((1U << 16) - 1)<<16) & word0) | ((((1U << 16) - 1) & value) << 16); - return *this; - } -#endif -}; - -// reset_r - Request reset and new security mode -struct reset_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t pending_CPL : 1; // Current privilege level. 0 = User and 1 = Privileged - uint32_t pending_CSL : 1; // Current security level. 0 = Secure and 1 = Non-secure - uint32_t reserved0 : 30; - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR reset_r() : - word0(0) - {} - CONSTEXPR reset_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - reset_r copy() - { - return *this; - } - CONSTEXPR NPU_NAMESPACE::privilege_level get_pending_CPL() const - { - auto v = ((1U << 1) - 1) & (word0 >> 0); - assert(v <= 1); - return static_cast(v); - } - CONSTEXPR reset_r& set_pending_CPL(NPU_NAMESPACE::privilege_level value) - { - word0 = (~(((1U << 1) - 1)<<0) & word0) | ((((1U << 1) - 1) & static_cast(value)) << 0); - return *this; - } - CONSTEXPR NPU_NAMESPACE::security_level get_pending_CSL() const - { - auto v = ((1U << 1) - 1) & (word0 >> 1); - assert(v <= 1); - return static_cast(v); - } - CONSTEXPR reset_r& set_pending_CSL(NPU_NAMESPACE::security_level value) - { - word0 = (~(((1U << 1) - 1)<<1) & word0) | ((((1U << 1) - 1) & static_cast(value)) << 1); - return *this; - } -#endif -}; - -// qbase_r - The base address of the command stream in bytes -struct qbase_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t offset_LO : 32; // Offset - LSB - uint32_t offset_HI : 8; // Offset - MSB - uint32_t reserved0 : 24; - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR qbase_r() : - word0(0), - word1(0) - {} - CONSTEXPR qbase_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - qbase_r copy() - { - return *this; - } -#endif -}; - -// qread_r - The read offset in the command stream in bytes. Multiple of four in the range 0-16MB -struct qread_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t QREAD : 32; // The read offset of the current command under execution - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR qread_r() : - word0(0) - {} - CONSTEXPR qread_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - qread_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_QREAD() const - { - auto v = word0; - return v; - } - CONSTEXPR qread_r& set_QREAD(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// qconfig_r - The AXI configuration for the command stream in the range 0-3. Same encoding as for REGIONCFG -struct qconfig_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t cmd_region0 : 2; // The command region configuration number - uint32_t reserved0 : 30; - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR qconfig_r() : - word0(0) - {} - CONSTEXPR qconfig_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - qconfig_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_cmd_region0() const - { - auto v = ((1U << 2) - 1) & (word0 >> 0); - return v; - } - CONSTEXPR qconfig_r& set_cmd_region0(uint32_t value) - { - word0 = (~(((1U << 2) - 1)<<0) & word0) | ((((1U << 2) - 1) & value) << 0); - return *this; - } -#endif -}; - -// qsize_r - The size of the command stream in bytes. Multiple of four in the range 0-16MB -struct qsize_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t QSIZE : 32; // The size of the next command stream to be executed by the NPU - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR qsize_r() : - word0(0) - {} - CONSTEXPR qsize_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - qsize_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_QSIZE() const - { - auto v = word0; - return v; - } - CONSTEXPR qsize_r& set_QSIZE(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// prot_r - The protection level configured for the NPU when acting as an AXI Requester -struct prot_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t active_CPL : 1; // The current privilege level. 0 = User and 1 = Privileged - uint32_t active_CSL : 1; // The current security level 0=Secure 1=Non secure - uint32_t reserved0 : 30; - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR prot_r() : - word0(0) - {} - CONSTEXPR prot_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - prot_r copy() - { - return *this; - } - CONSTEXPR NPU_NAMESPACE::privilege_level get_active_CPL() const - { - auto v = ((1U << 1) - 1) & (word0 >> 0); - assert(v <= 1); - return static_cast(v); - } - CONSTEXPR prot_r& set_active_CPL(NPU_NAMESPACE::privilege_level value) - { - word0 = (~(((1U << 1) - 1)<<0) & word0) | ((((1U << 1) - 1) & static_cast(value)) << 0); - return *this; - } - CONSTEXPR NPU_NAMESPACE::security_level get_active_CSL() const - { - auto v = ((1U << 1) - 1) & (word0 >> 1); - assert(v <= 1); - return static_cast(v); - } - CONSTEXPR prot_r& set_active_CSL(NPU_NAMESPACE::security_level value) - { - word0 = (~(((1U << 1) - 1)<<1) & word0) | ((((1U << 1) - 1) & static_cast(value)) << 1); - return *this; - } -#endif -}; - -// config_r - RTL configuration -struct config_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t macs_per_cc : 4; // The log2(macs/clock cycle) - uint32_t cmd_stream_version : 4; // The command stream version accepted by this NPU - uint32_t num_axi_sram : 2; // The log2 of the number of AXI SRAM interfaces - uint32_t num_axi_ext : 1; // The log2 of the number of AXI External memory interfaces - uint32_t reserved0 : 1; - uint32_t num_wd : 2; // The log2 of the number of standard weight decoders - uint32_t reserved1 : 13; - uint32_t custom_dma : 1; // The custom DMA configuration - uint32_t product : 4; // The product configuration - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR config_r() : - word0(536870928) - {} - CONSTEXPR config_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - config_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_macs_per_cc() const - { - auto v = ((1U << 4) - 1) & (word0 >> 0); - return v; - } - CONSTEXPR config_r& set_macs_per_cc(uint32_t value) - { - word0 = (~(((1U << 4) - 1)<<0) & word0) | ((((1U << 4) - 1) & value) << 0); - return *this; - } - CONSTEXPR uint32_t get_cmd_stream_version() const - { - auto v = ((1U << 4) - 1) & (word0 >> 4); - return v; - } - CONSTEXPR config_r& set_cmd_stream_version(uint32_t value) - { - word0 = (~(((1U << 4) - 1)<<4) & word0) | ((((1U << 4) - 1) & value) << 4); - return *this; - } - CONSTEXPR uint32_t get_num_axi_sram() const - { - auto v = ((1U << 2) - 1) & (word0 >> 8); - return v; - } - CONSTEXPR config_r& set_num_axi_sram(uint32_t value) - { - word0 = (~(((1U << 2) - 1)<<8) & word0) | ((((1U << 2) - 1) & value) << 8); - return *this; - } - CONSTEXPR uint32_t get_num_axi_ext() const - { - auto v = ((1U << 1) - 1) & (word0 >> 10); - return v; - } - CONSTEXPR config_r& set_num_axi_ext(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<10) & word0) | ((((1U << 1) - 1) & value) << 10); - return *this; - } - CONSTEXPR uint32_t get_num_wd() const - { - auto v = ((1U << 2) - 1) & (word0 >> 12); - return v; - } - CONSTEXPR config_r& set_num_wd(uint32_t value) - { - word0 = (~(((1U << 2) - 1)<<12) & word0) | ((((1U << 2) - 1) & value) << 12); - return *this; - } - CONSTEXPR NPU_NAMESPACE::custom_dma get_custom_dma() const - { - auto v = ((1U << 1) - 1) & (word0 >> 27); - assert(v <= 1); - return static_cast(v); - } - CONSTEXPR config_r& set_custom_dma(NPU_NAMESPACE::custom_dma value) - { - word0 = (~(((1U << 1) - 1)<<27) & word0) | ((((1U << 1) - 1) & static_cast(value)) << 27); - return *this; - } - CONSTEXPR uint32_t get_product() const - { - auto v = ((1U << 4) - 1) & (word0 >> 28); - return v; - } - CONSTEXPR config_r& set_product(uint32_t value) - { - word0 = (~(((1U << 4) - 1)<<28) & word0) | ((((1U << 4) - 1) & value) << 28); - return *this; - } -#endif -}; - -// cond_status_r - Condition status of the NPU -struct cond_status_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t result_flag : 1; // The tensor result flag. For OFM with a single element, this is bit 0 of the value. Otherwise UNPREDICTABLE - uint32_t reserved0 : 31; - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR cond_status_r() : - word0(0) - {} - CONSTEXPR cond_status_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - cond_status_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_result_flag() const - { - auto v = ((1U << 1) - 1) & (word0 >> 0); - return v; - } - CONSTEXPR cond_status_r& set_result_flag(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } -#endif -}; - -// power_ctrl_r - Power control register -struct power_ctrl_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t mac_step_cycles : 6; // MAC power ramping up/down control - uint32_t reserved0 : 26; - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR power_ctrl_r() : - word0(0) - {} - CONSTEXPR power_ctrl_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - power_ctrl_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_mac_step_cycles() const - { - auto v = ((1U << 6) - 1) & (word0 >> 0); - return v; - } - CONSTEXPR power_ctrl_r& set_mac_step_cycles(uint32_t value) - { - word0 = (~(((1U << 6) - 1)<<0) & word0) | ((((1U << 6) - 1) & value) << 0); - return *this; - } -#endif -}; - -// regioncfg_r - Specify which MEM_ATTR register applies to each region -struct regioncfg_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t region0 : 2; // Bits for Region0 Configuration - uint32_t region1 : 2; // Bits for Region1 Configuration - uint32_t region2 : 2; // Bits for Region2 Configuration - uint32_t region3 : 2; // Bits for Region3 Configuration - uint32_t region4 : 2; // Bits for Region4 Configuration - uint32_t region5 : 2; // Bits for Region5 Configuration - uint32_t region6 : 2; // Bits for Region6 Configuration - uint32_t region7 : 2; // Bits for Region7 Configuration - uint32_t reserved0 : 16; - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR regioncfg_r() : - word0(0) - {} - CONSTEXPR regioncfg_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - regioncfg_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_region0() const - { - auto v = ((1U << 2) - 1) & (word0 >> 0); - return v; - } - CONSTEXPR regioncfg_r& set_region0(uint32_t value) - { - word0 = (~(((1U << 2) - 1)<<0) & word0) | ((((1U << 2) - 1) & value) << 0); - return *this; - } - CONSTEXPR uint32_t get_region1() const - { - auto v = ((1U << 2) - 1) & (word0 >> 2); - return v; - } - CONSTEXPR regioncfg_r& set_region1(uint32_t value) - { - word0 = (~(((1U << 2) - 1)<<2) & word0) | ((((1U << 2) - 1) & value) << 2); - return *this; - } - CONSTEXPR uint32_t get_region2() const - { - auto v = ((1U << 2) - 1) & (word0 >> 4); - return v; - } - CONSTEXPR regioncfg_r& set_region2(uint32_t value) - { - word0 = (~(((1U << 2) - 1)<<4) & word0) | ((((1U << 2) - 1) & value) << 4); - return *this; - } - CONSTEXPR uint32_t get_region3() const - { - auto v = ((1U << 2) - 1) & (word0 >> 6); - return v; - } - CONSTEXPR regioncfg_r& set_region3(uint32_t value) - { - word0 = (~(((1U << 2) - 1)<<6) & word0) | ((((1U << 2) - 1) & value) << 6); - return *this; - } - CONSTEXPR uint32_t get_region4() const - { - auto v = ((1U << 2) - 1) & (word0 >> 8); - return v; - } - CONSTEXPR regioncfg_r& set_region4(uint32_t value) - { - word0 = (~(((1U << 2) - 1)<<8) & word0) | ((((1U << 2) - 1) & value) << 8); - return *this; - } - CONSTEXPR uint32_t get_region5() const - { - auto v = ((1U << 2) - 1) & (word0 >> 10); - return v; - } - CONSTEXPR regioncfg_r& set_region5(uint32_t value) - { - word0 = (~(((1U << 2) - 1)<<10) & word0) | ((((1U << 2) - 1) & value) << 10); - return *this; - } - CONSTEXPR uint32_t get_region6() const - { - auto v = ((1U << 2) - 1) & (word0 >> 12); - return v; - } - CONSTEXPR regioncfg_r& set_region6(uint32_t value) - { - word0 = (~(((1U << 2) - 1)<<12) & word0) | ((((1U << 2) - 1) & value) << 12); - return *this; - } - CONSTEXPR uint32_t get_region7() const - { - auto v = ((1U << 2) - 1) & (word0 >> 14); - return v; - } - CONSTEXPR regioncfg_r& set_region7(uint32_t value) - { - word0 = (~(((1U << 2) - 1)<<14) & word0) | ((((1U << 2) - 1) & value) << 14); - return *this; - } -#endif -}; - -// mem_attr_r - Memory attributes 0 -struct mem_attr_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t mem_domain : 2; // Memory domain - uint32_t axi_port : 1; // AXI port select - uint32_t reserved0 : 1; - uint32_t memtype : 4; // Memtype to be used to encode AxCACHE signals - uint32_t reserved1 : 24; - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR mem_attr_r() : - word0(0) - {} - CONSTEXPR mem_attr_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - mem_attr_r copy() - { - return *this; - } - CONSTEXPR NPU_NAMESPACE::axi_mem_domain get_mem_domain() const - { - auto v = ((1U << 2) - 1) & (word0 >> 0); - assert(v <= 3); - return static_cast(v); - } - CONSTEXPR mem_attr_r& set_mem_domain(NPU_NAMESPACE::axi_mem_domain value) - { - word0 = (~(((1U << 2) - 1)<<0) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 0); - return *this; - } - CONSTEXPR NPU_NAMESPACE::axi_port get_axi_port() const - { - auto v = ((1U << 1) - 1) & (word0 >> 2); - assert(v <= 1); - return static_cast(v); - } - CONSTEXPR mem_attr_r& set_axi_port(NPU_NAMESPACE::axi_port value) - { - word0 = (~(((1U << 1) - 1)<<2) & word0) | ((((1U << 1) - 1) & static_cast(value)) << 2); - return *this; - } - CONSTEXPR NPU_NAMESPACE::axi_mem_encoding get_memtype() const - { - auto v = ((1U << 4) - 1) & (word0 >> 4); - assert(v <= 11); - return static_cast(v); - } - CONSTEXPR mem_attr_r& set_memtype(NPU_NAMESPACE::axi_mem_encoding value) - { - word0 = (~(((1U << 4) - 1)<<4) & word0) | ((((1U << 4) - 1) & static_cast(value)) << 4); - return *this; - } -#endif -}; - -// axi_sram_r - The AXI configuration for SRAM ports -struct axi_sram_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t max_outstanding_read_m1 : 6; // Maximum number of outstanding AXI read transactions per port - 1 - uint32_t reserved0 : 2; - uint32_t max_outstanding_write_m1 : 5; // Maximum number of outstanding AXI write transactions per port - 1 - uint32_t reserved1 : 3; - uint32_t max_beats : 2; // Burst split alignment - uint32_t reserved2 : 14; - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR axi_sram_r() : - word0(0) - {} - CONSTEXPR axi_sram_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - axi_sram_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_max_outstanding_read_m1() const - { - auto v = ((1U << 6) - 1) & (word0 >> 0); - return v; - } - CONSTEXPR axi_sram_r& set_max_outstanding_read_m1(uint32_t value) - { - word0 = (~(((1U << 6) - 1)<<0) & word0) | ((((1U << 6) - 1) & value) << 0); - return *this; - } - CONSTEXPR uint32_t get_max_outstanding_write_m1() const - { - auto v = ((1U << 5) - 1) & (word0 >> 8); - return v; - } - CONSTEXPR axi_sram_r& set_max_outstanding_write_m1(uint32_t value) - { - word0 = (~(((1U << 5) - 1)<<8) & word0) | ((((1U << 5) - 1) & value) << 8); - return *this; - } - CONSTEXPR NPU_NAMESPACE::max_beats get_max_beats() const - { - auto v = ((1U << 2) - 1) & (word0 >> 16); - assert(v <= 2); - return static_cast(v); - } - CONSTEXPR axi_sram_r& set_max_beats(NPU_NAMESPACE::max_beats value) - { - word0 = (~(((1U << 2) - 1)<<16) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 16); - return *this; - } -#endif -}; - -// axi_ext_r - The AXI configuration for EXT ports -struct axi_ext_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t max_outstanding_read_m1 : 6; // Maximum number of outstanding AXI read transactions per port - 1 - uint32_t reserved0 : 2; - uint32_t max_outstanding_write_m1 : 5; // Maximum number of outstanding AXI write transactions per port - 1 - uint32_t reserved1 : 3; - uint32_t max_beats : 2; // Burst split alignment - uint32_t reserved2 : 14; - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR axi_ext_r() : - word0(0) - {} - CONSTEXPR axi_ext_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - axi_ext_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_max_outstanding_read_m1() const - { - auto v = ((1U << 6) - 1) & (word0 >> 0); - return v; - } - CONSTEXPR axi_ext_r& set_max_outstanding_read_m1(uint32_t value) - { - word0 = (~(((1U << 6) - 1)<<0) & word0) | ((((1U << 6) - 1) & value) << 0); - return *this; - } - CONSTEXPR uint32_t get_max_outstanding_write_m1() const - { - auto v = ((1U << 5) - 1) & (word0 >> 8); - return v; - } - CONSTEXPR axi_ext_r& set_max_outstanding_write_m1(uint32_t value) - { - word0 = (~(((1U << 5) - 1)<<8) & word0) | ((((1U << 5) - 1) & value) << 8); - return *this; - } - CONSTEXPR NPU_NAMESPACE::max_beats get_max_beats() const - { - auto v = ((1U << 2) - 1) & (word0 >> 16); - assert(v <= 2); - return static_cast(v); - } - CONSTEXPR axi_ext_r& set_max_beats(NPU_NAMESPACE::max_beats value) - { - word0 = (~(((1U << 2) - 1)<<16) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 16); - return *this; - } -#endif -}; - -// cfg_sram_cap_r - The value of the CFGSRAMCAP pins, SRAM AXI ports cap -struct cfg_sram_cap_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t max_outstanding_read_m1 : 6; // Maximum number of outstanding AXI read transactions per port - 1 - uint32_t reserved0 : 2; - uint32_t max_outstanding_write_m1 : 5; // Maximum number of outstanding AXI write transactions per port - 1 - uint32_t reserved1 : 3; - uint32_t max_beats : 2; // Burst split alignment - uint32_t reserved2 : 14; - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR cfg_sram_cap_r() : - word0(0) - {} - CONSTEXPR cfg_sram_cap_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - cfg_sram_cap_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_max_outstanding_read_m1() const - { - auto v = ((1U << 6) - 1) & (word0 >> 0); - return v; - } - CONSTEXPR cfg_sram_cap_r& set_max_outstanding_read_m1(uint32_t value) - { - word0 = (~(((1U << 6) - 1)<<0) & word0) | ((((1U << 6) - 1) & value) << 0); - return *this; - } - CONSTEXPR uint32_t get_max_outstanding_write_m1() const - { - auto v = ((1U << 5) - 1) & (word0 >> 8); - return v; - } - CONSTEXPR cfg_sram_cap_r& set_max_outstanding_write_m1(uint32_t value) - { - word0 = (~(((1U << 5) - 1)<<8) & word0) | ((((1U << 5) - 1) & value) << 8); - return *this; - } - CONSTEXPR NPU_NAMESPACE::max_beats get_max_beats() const - { - auto v = ((1U << 2) - 1) & (word0 >> 16); - assert(v <= 2); - return static_cast(v); - } - CONSTEXPR cfg_sram_cap_r& set_max_beats(NPU_NAMESPACE::max_beats value) - { - word0 = (~(((1U << 2) - 1)<<16) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 16); - return *this; - } -#endif -}; - -// cfg_ext_cap_r - The value of the CFGEXTCAP pins, EXT AXI ports cap -struct cfg_ext_cap_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t max_outstanding_read_m1 : 6; // Maximum number of outstanding AXI read transactions per port - 1 - uint32_t reserved0 : 2; - uint32_t max_outstanding_write_m1 : 5; // Maximum number of outstanding AXI write transactions per port - 1 - uint32_t reserved1 : 3; - uint32_t max_beats : 2; // Burst split alignment - uint32_t reserved2 : 14; - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR cfg_ext_cap_r() : - word0(0) - {} - CONSTEXPR cfg_ext_cap_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - cfg_ext_cap_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_max_outstanding_read_m1() const - { - auto v = ((1U << 6) - 1) & (word0 >> 0); - return v; - } - CONSTEXPR cfg_ext_cap_r& set_max_outstanding_read_m1(uint32_t value) - { - word0 = (~(((1U << 6) - 1)<<0) & word0) | ((((1U << 6) - 1) & value) << 0); - return *this; - } - CONSTEXPR uint32_t get_max_outstanding_write_m1() const - { - auto v = ((1U << 5) - 1) & (word0 >> 8); - return v; - } - CONSTEXPR cfg_ext_cap_r& set_max_outstanding_write_m1(uint32_t value) - { - word0 = (~(((1U << 5) - 1)<<8) & word0) | ((((1U << 5) - 1) & value) << 8); - return *this; - } - CONSTEXPR NPU_NAMESPACE::max_beats get_max_beats() const - { - auto v = ((1U << 2) - 1) & (word0 >> 16); - assert(v <= 2); - return static_cast(v); - } - CONSTEXPR cfg_ext_cap_r& set_max_beats(NPU_NAMESPACE::max_beats value) - { - word0 = (~(((1U << 2) - 1)<<16) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 16); - return *this; - } -#endif -}; - -// cfg_sram_hash0_r - The value of the CFGSRAMHASH0 pins, SRAM AXI port select bit 0 hash -struct cfg_sram_hash0_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t zero : 6; // Must be zero - uint32_t hash_LO : 26; // Hash function - LSB - uint32_t hash_HI : 8; // Hash function - MSB - uint32_t reserved0 : 24; - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR cfg_sram_hash0_r() : - word0(0), - word1(0) - {} - CONSTEXPR cfg_sram_hash0_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - cfg_sram_hash0_r copy() - { - return *this; - } -#endif -}; - -// cfg_sram_hash1_r - The value of the CFGSRAMHASH1 pins, SRAM AXI port select bit 1 hash -struct cfg_sram_hash1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t zero : 6; // Must be zero - uint32_t hash_LO : 26; // Hash function - LSB - uint32_t hash_HI : 8; // Hash function - MSB - uint32_t reserved0 : 24; - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR cfg_sram_hash1_r() : - word0(0), - word1(0) - {} - CONSTEXPR cfg_sram_hash1_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - cfg_sram_hash1_r copy() - { - return *this; - } -#endif -}; - -// cfg_ext_hash0_r - The value of the CFGEXTHASH0 pins, EXT AXI port select bit 0 hash -struct cfg_ext_hash0_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t zero : 6; // Must be zero - uint32_t hash_LO : 26; // Hash function - LSB - uint32_t hash_HI : 8; // Hash function - MSB - uint32_t reserved0 : 24; - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR cfg_ext_hash0_r() : - word0(0), - word1(0) - {} - CONSTEXPR cfg_ext_hash0_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - cfg_ext_hash0_r copy() - { - return *this; - } -#endif -}; - -// basep_r - AXI base address of the respective region number 0 - 7 -struct basep_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t offset_LO : 32; // Offset - LSB - uint32_t offset_HI : 8; // Offset - MSB - uint32_t reserved0 : 24; - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR basep_r() : - word0(0), - word1(0) - {} - CONSTEXPR basep_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - basep_r copy() - { - return *this; - } -#endif -}; - -// clkforce_r - Force clocks on for clock gating -struct clkforce_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t top_level_clk : 1; // set to 1 to force on TOP level clock - uint32_t cc_clk : 1; // set to 1 to force on CC clock - uint32_t dma_clk : 1; // set to 1 to force on DMA clock - uint32_t mac_clk : 1; // set to 1 to force on MAC clock - uint32_t ao_clk : 1; // set to 1 to force on AO clock - uint32_t wd_clk : 1; // set to 1 to force on WD clock - uint32_t reserved0 : 26; - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR clkforce_r() : - word0(0) - {} - CONSTEXPR clkforce_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - clkforce_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_top_level_clk() const - { - auto v = ((1U << 1) - 1) & (word0 >> 0); - return v; - } - CONSTEXPR clkforce_r& set_top_level_clk(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - CONSTEXPR uint32_t get_cc_clk() const - { - auto v = ((1U << 1) - 1) & (word0 >> 1); - return v; - } - CONSTEXPR clkforce_r& set_cc_clk(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - CONSTEXPR uint32_t get_dma_clk() const - { - auto v = ((1U << 1) - 1) & (word0 >> 2); - return v; - } - CONSTEXPR clkforce_r& set_dma_clk(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - CONSTEXPR uint32_t get_mac_clk() const - { - auto v = ((1U << 1) - 1) & (word0 >> 3); - return v; - } - CONSTEXPR clkforce_r& set_mac_clk(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - CONSTEXPR uint32_t get_ao_clk() const - { - auto v = ((1U << 1) - 1) & (word0 >> 4); - return v; - } - CONSTEXPR clkforce_r& set_ao_clk(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<4) & word0) | ((((1U << 1) - 1) & value) << 4); - return *this; - } - CONSTEXPR uint32_t get_wd_clk() const - { - auto v = ((1U << 1) - 1) & (word0 >> 5); - return v; - } - CONSTEXPR clkforce_r& set_wd_clk(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<5) & word0) | ((((1U << 1) - 1) & value) << 5); - return *this; - } -#endif -}; - -// debug_address_r - Set debug address for register reads 0x400-0x7FF. The address must be 1KB aligned -struct debug_address_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t addr : 28; // Address in the RAM, 1KB aligned - uint32_t ram_id : 4; // RAM to access - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR debug_address_r() : - word0(0) - {} - CONSTEXPR debug_address_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - debug_address_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_addr() const - { - auto v = ((1U << 28) - 1) & (word0 >> 0); - return v; - } - CONSTEXPR debug_address_r& set_addr(uint32_t value) - { - word0 = (~(((1U << 28) - 1)<<0) & word0) | ((((1U << 28) - 1) & value) << 0); - return *this; - } - CONSTEXPR NPU_NAMESPACE::ram_id get_ram_id() const - { - auto v = ((1U << 4) - 1) & (word0 >> 28); - assert(v <= 4); - return static_cast(v); - } - CONSTEXPR debug_address_r& set_ram_id(NPU_NAMESPACE::ram_id value) - { - word0 = (~(((1U << 4) - 1)<<28) & word0) | ((((1U << 4) - 1) & static_cast(value)) << 28); - return *this; - } -#endif -}; - -// debug_misc_r - 32-bit read/write register for driver debug use. This does not affect NPU function -struct debug_misc_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t misc : 32; // Debug misc - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR debug_misc_r() : - word0(0) - {} - CONSTEXPR debug_misc_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - debug_misc_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_misc() const - { - auto v = word0; - return v; - } - CONSTEXPR debug_misc_r& set_misc(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// feature_disable_r - Disable micro-architectural features -struct feature_disable_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t ib_reuse_kd_disable : 1; // Setting to 1 will disable the optimization to reuse IFM data when using kernel decomposition for large kernels - uint32_t ib_reuse_ifm_depth_disable : 1; // Setting to 1 will disable the optimization to reuse IFM data when performing convolution operations - uint32_t reserved0 : 30; - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR feature_disable_r() : - word0(0) - {} - CONSTEXPR feature_disable_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - feature_disable_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_ib_reuse_kd_disable() const - { - auto v = ((1U << 1) - 1) & (word0 >> 0); - return v; - } - CONSTEXPR feature_disable_r& set_ib_reuse_kd_disable(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - CONSTEXPR uint32_t get_ib_reuse_ifm_depth_disable() const - { - auto v = ((1U << 1) - 1) & (word0 >> 1); - return v; - } - CONSTEXPR feature_disable_r& set_ib_reuse_ifm_depth_disable(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } -#endif -}; - -// dma_ifm_src_r - DMA IFM channel source position on AXI -struct dma_ifm_src_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t offset_LO : 32; // Offset - LSB - uint32_t offset_HI : 8; // Offset - MSB - uint32_t reserved0 : 24; - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR dma_ifm_src_r() : - word0(0), - word1(0) - {} - CONSTEXPR dma_ifm_src_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - dma_ifm_src_r copy() - { - return *this; - } -#endif -}; - -// dma_ofm_dst_r - DMA OFM channel destination position on AXI -struct dma_ofm_dst_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t offset_LO : 32; // Offset - LSB - uint32_t offset_HI : 8; // Offset - MSB - uint32_t reserved0 : 24; - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR dma_ofm_dst_r() : - word0(0), - word1(0) - {} - CONSTEXPR dma_ofm_dst_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - dma_ofm_dst_r copy() - { - return *this; - } -#endif -}; - -// dma_weight_src_r - DMA weight channel source position on AXI -struct dma_weight_src_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t offset_LO : 32; // Offset - LSB - uint32_t offset_HI : 8; // Offset - MSB - uint32_t reserved0 : 24; - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR dma_weight_src_r() : - word0(0), - word1(0) - {} - CONSTEXPR dma_weight_src_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - dma_weight_src_r copy() - { - return *this; - } -#endif -}; - -// dma_cmd_src_r - DMA command channel source position on AXI -struct dma_cmd_src_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t offset_LO : 32; // Offset - LSB - uint32_t offset_HI : 8; // Offset - MSB - uint32_t reserved0 : 24; - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR dma_cmd_src_r() : - word0(0), - word1(0) - {} - CONSTEXPR dma_cmd_src_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - dma_cmd_src_r copy() - { - return *this; - } -#endif -}; - -// dma_cmd_size_r - DMA command channel number of bytes buffered -struct dma_cmd_size_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR dma_cmd_size_r() : - word0(0) - {} - CONSTEXPR dma_cmd_size_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - dma_cmd_size_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - auto v = word0; - return v; - } - CONSTEXPR dma_cmd_size_r& set_value(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// dma_m2m_src_r - DMA memory to memory source position on AXI -struct dma_m2m_src_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t offset_LO : 32; // Offset - LSB - uint32_t offset_HI : 8; // Offset - MSB - uint32_t reserved0 : 24; - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR dma_m2m_src_r() : - word0(0), - word1(0) - {} - CONSTEXPR dma_m2m_src_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - dma_m2m_src_r copy() - { - return *this; - } -#endif -}; - -// dma_m2m_dst_r - DMA memory to memory destination position on AXI -struct dma_m2m_dst_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t offset_LO : 32; // Offset - LSB - uint32_t offset_HI : 8; // Offset - MSB - uint32_t reserved0 : 24; - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR dma_m2m_dst_r() : - word0(0), - word1(0) - {} - CONSTEXPR dma_m2m_dst_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - dma_m2m_dst_r copy() - { - return *this; - } -#endif -}; - -// current_qread_r - QREAD position being issued (rather than completed) -struct current_qread_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR current_qread_r() : - word0(0) - {} - CONSTEXPR current_qread_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - current_qread_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - auto v = word0; - return v; - } - CONSTEXPR current_qread_r& set_value(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// dma_scale_src_r - DMA scale and bias channel source position on AXI -struct dma_scale_src_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t offset_LO : 32; // Offset - LSB - uint32_t offset_HI : 8; // Offset - MSB - uint32_t reserved0 : 24; - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR dma_scale_src_r() : - word0(0), - word1(0) - {} - CONSTEXPR dma_scale_src_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - dma_scale_src_r copy() - { - return *this; - } -#endif -}; - -// dma_weight1_src_r - DMA weight1 channel source position on AXI -struct dma_weight1_src_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t offset_LO : 32; // Offset - LSB - uint32_t offset_HI : 8; // Offset - MSB - uint32_t reserved0 : 24; - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR dma_weight1_src_r() : - word0(0), - word1(0) - {} - CONSTEXPR dma_weight1_src_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - dma_weight1_src_r copy() - { - return *this; - } -#endif -}; - -// dma_weight2_src_r - DMA weight2 channel source position on AXI -struct dma_weight2_src_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t offset_LO : 32; // Offset - LSB - uint32_t offset_HI : 8; // Offset - MSB - uint32_t reserved0 : 24; - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR dma_weight2_src_r() : - word0(0), - word1(0) - {} - CONSTEXPR dma_weight2_src_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - dma_weight2_src_r copy() - { - return *this; - } -#endif -}; - -// dma_weight3_src_r - DMA weight3 channel source position on AXI -struct dma_weight3_src_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t offset_LO : 32; // Offset - LSB - uint32_t offset_HI : 8; // Offset - MSB - uint32_t reserved0 : 24; - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR dma_weight3_src_r() : - word0(0), - word1(0) - {} - CONSTEXPR dma_weight3_src_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - dma_weight3_src_r copy() - { - return *this; - } -#endif -}; - -// current_op_r - Latest NPU OP command issued by the parser -struct current_op_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR current_op_r() : - word0(0) - {} - CONSTEXPR current_op_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - current_op_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - auto v = word0; - return v; - } - CONSTEXPR current_op_r& set_value(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// current_cmd_r - Current 32-bit command being parsed by the command stream parser -struct current_cmd_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR current_cmd_r() : - word0(0) - {} - CONSTEXPR current_cmd_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - current_cmd_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - auto v = word0; - return v; - } - CONSTEXPR current_cmd_r& set_value(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// internal_memory_r - 1KB window onto internal memory as set by DEBUG_ADDRESS -struct internal_memory_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t mem_word : 32; // Memory word - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR internal_memory_r() : - word0(0) - {} - CONSTEXPR internal_memory_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - internal_memory_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_mem_word() const - { - auto v = word0; - return v; - } - CONSTEXPR internal_memory_r& set_mem_word(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// ifm_pad_top_r - State managed by NPU_SET_IFM_PAD_TOP -struct ifm_pad_top_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR ifm_pad_top_r() : - word0(0) - {} - CONSTEXPR ifm_pad_top_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - ifm_pad_top_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - auto v = word0; - return v; - } - CONSTEXPR ifm_pad_top_r& set_value(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// ifm_pad_left_r - State managed by NPU_SET_IFM_PAD_LEFT -struct ifm_pad_left_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR ifm_pad_left_r() : - word0(0) - {} - CONSTEXPR ifm_pad_left_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - ifm_pad_left_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - auto v = word0; - return v; - } - CONSTEXPR ifm_pad_left_r& set_value(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// ifm_pad_right_r - State managed by NPU_SET_IFM_PAD_RIGHT -struct ifm_pad_right_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR ifm_pad_right_r() : - word0(0) - {} - CONSTEXPR ifm_pad_right_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - ifm_pad_right_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - auto v = word0; - return v; - } - CONSTEXPR ifm_pad_right_r& set_value(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// ifm_pad_bottom_r - State managed by NPU_SET_IFM_PAD_BOTTOM -struct ifm_pad_bottom_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR ifm_pad_bottom_r() : - word0(0) - {} - CONSTEXPR ifm_pad_bottom_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - ifm_pad_bottom_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - auto v = word0; - return v; - } - CONSTEXPR ifm_pad_bottom_r& set_value(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// ifm_depth_m1_r - State managed by NPU_SET_IFM_DEPTH_M1 -struct ifm_depth_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR ifm_depth_m1_r() : - word0(0) - {} - CONSTEXPR ifm_depth_m1_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - ifm_depth_m1_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - auto v = word0; - return v; - } - CONSTEXPR ifm_depth_m1_r& set_value(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// ifm_precision_r - State managed by NPU_SET_IFM_PRECISION -struct ifm_precision_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR ifm_precision_r() : - word0(0) - {} - CONSTEXPR ifm_precision_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - ifm_precision_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - auto v = word0; - return v; - } - CONSTEXPR ifm_precision_r& set_value(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// ifm_upscale_r - State managed by NPU_SET_IFM_UPSCALE -struct ifm_upscale_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR ifm_upscale_r() : - word0(0) - {} - CONSTEXPR ifm_upscale_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - ifm_upscale_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - auto v = word0; - return v; - } - CONSTEXPR ifm_upscale_r& set_value(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// ifm_broadcast_r - State managed by NPU_SET_IFM_BROADCAST -struct ifm_broadcast_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR ifm_broadcast_r() : - word0(0) - {} - CONSTEXPR ifm_broadcast_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - ifm_broadcast_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - auto v = word0; - return v; - } - CONSTEXPR ifm_broadcast_r& set_value(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// ifm_zero_point_r - State managed by NPU_SET_IFM_ZERO_POINT -struct ifm_zero_point_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR ifm_zero_point_r() : - word0(0) - {} - CONSTEXPR ifm_zero_point_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - ifm_zero_point_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - auto v = word0; - return v; - } - CONSTEXPR ifm_zero_point_r& set_value(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// ifm_width0_m1_r - State managed by NPU_SET_IFM_WIDTH0_M1 -struct ifm_width0_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR ifm_width0_m1_r() : - word0(0) - {} - CONSTEXPR ifm_width0_m1_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - ifm_width0_m1_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - auto v = word0; - return v; - } - CONSTEXPR ifm_width0_m1_r& set_value(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// ifm_height0_m1_r - State managed by NPU_SET_IFM_HEIGHT0_M1 -struct ifm_height0_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR ifm_height0_m1_r() : - word0(0) - {} - CONSTEXPR ifm_height0_m1_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - ifm_height0_m1_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - auto v = word0; - return v; - } - CONSTEXPR ifm_height0_m1_r& set_value(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// ifm_height1_m1_r - State managed by NPU_SET_IFM_HEIGHT1_M1 -struct ifm_height1_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR ifm_height1_m1_r() : - word0(0) - {} - CONSTEXPR ifm_height1_m1_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - ifm_height1_m1_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - auto v = word0; - return v; - } - CONSTEXPR ifm_height1_m1_r& set_value(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// ifm_region_r - State managed by NPU_SET_IFM_REGION -struct ifm_region_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR ifm_region_r() : - word0(0) - {} - CONSTEXPR ifm_region_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - ifm_region_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - auto v = word0; - return v; - } - CONSTEXPR ifm_region_r& set_value(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// ofm_width_m1_r - State managed by NPU_SET_OFM_WIDTH_M1 -struct ofm_width_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR ofm_width_m1_r() : - word0(0) - {} - CONSTEXPR ofm_width_m1_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - ofm_width_m1_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - auto v = word0; - return v; - } - CONSTEXPR ofm_width_m1_r& set_value(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// ofm_height_m1_r - State managed by NPU_SET_OFM_HEIGHT_M1 -struct ofm_height_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR ofm_height_m1_r() : - word0(0) - {} - CONSTEXPR ofm_height_m1_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - ofm_height_m1_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - auto v = word0; - return v; - } - CONSTEXPR ofm_height_m1_r& set_value(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// ofm_depth_m1_r - State managed by NPU_SET_OFM_DEPTH_M1 -struct ofm_depth_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR ofm_depth_m1_r() : - word0(0) - {} - CONSTEXPR ofm_depth_m1_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - ofm_depth_m1_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - auto v = word0; - return v; - } - CONSTEXPR ofm_depth_m1_r& set_value(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// ofm_precision_r - State managed by NPU_SET_OFM_PRECISION -struct ofm_precision_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR ofm_precision_r() : - word0(0) - {} - CONSTEXPR ofm_precision_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - ofm_precision_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - auto v = word0; - return v; - } - CONSTEXPR ofm_precision_r& set_value(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// ofm_blk_width_m1_r - State managed by NPU_SET_OFM_BLK_WIDTH_M1 -struct ofm_blk_width_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR ofm_blk_width_m1_r() : - word0(0) - {} - CONSTEXPR ofm_blk_width_m1_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - ofm_blk_width_m1_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - auto v = word0; - return v; - } - CONSTEXPR ofm_blk_width_m1_r& set_value(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// ofm_blk_height_m1_r - State managed by NPU_SET_OFM_BLK_HEIGHT_M1 -struct ofm_blk_height_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR ofm_blk_height_m1_r() : - word0(0) - {} - CONSTEXPR ofm_blk_height_m1_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - ofm_blk_height_m1_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - auto v = word0; - return v; - } - CONSTEXPR ofm_blk_height_m1_r& set_value(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// ofm_blk_depth_m1_r - State managed by NPU_SET_OFM_BLK_DEPTH_M1 -struct ofm_blk_depth_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR ofm_blk_depth_m1_r() : - word0(0) - {} - CONSTEXPR ofm_blk_depth_m1_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - ofm_blk_depth_m1_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - auto v = word0; - return v; - } - CONSTEXPR ofm_blk_depth_m1_r& set_value(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// ofm_zero_point_r - State managed by NPU_SET_OFM_ZERO_POINT -struct ofm_zero_point_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR ofm_zero_point_r() : - word0(0) - {} - CONSTEXPR ofm_zero_point_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - ofm_zero_point_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - auto v = word0; - return v; - } - CONSTEXPR ofm_zero_point_r& set_value(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// ofm_width0_m1_r - State managed by NPU_SET_OFM_WIDTH0_M1 -struct ofm_width0_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR ofm_width0_m1_r() : - word0(0) - {} - CONSTEXPR ofm_width0_m1_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - ofm_width0_m1_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - auto v = word0; - return v; - } - CONSTEXPR ofm_width0_m1_r& set_value(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// ofm_height0_m1_r - State managed by NPU_SET_OFM_HEIGHT0_M1 -struct ofm_height0_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR ofm_height0_m1_r() : - word0(0) - {} - CONSTEXPR ofm_height0_m1_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - ofm_height0_m1_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - auto v = word0; - return v; - } - CONSTEXPR ofm_height0_m1_r& set_value(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// ofm_height1_m1_r - State managed by NPU_SET_OFM_HEIGHT1_M1 -struct ofm_height1_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR ofm_height1_m1_r() : - word0(0) - {} - CONSTEXPR ofm_height1_m1_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - ofm_height1_m1_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - auto v = word0; - return v; - } - CONSTEXPR ofm_height1_m1_r& set_value(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// ofm_region_r - State managed by NPU_SET_OFM_REGION -struct ofm_region_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR ofm_region_r() : - word0(0) - {} - CONSTEXPR ofm_region_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - ofm_region_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - auto v = word0; - return v; - } - CONSTEXPR ofm_region_r& set_value(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// kernel_width_m1_r - State managed by NPU_SET_KERNEL_WIDTH_M1 -struct kernel_width_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR kernel_width_m1_r() : - word0(0) - {} - CONSTEXPR kernel_width_m1_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - kernel_width_m1_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - auto v = word0; - return v; - } - CONSTEXPR kernel_width_m1_r& set_value(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// kernel_height_m1_r - State managed by NPU_SET_KERNEL_HEIGHT_M1 -struct kernel_height_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR kernel_height_m1_r() : - word0(0) - {} - CONSTEXPR kernel_height_m1_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - kernel_height_m1_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - auto v = word0; - return v; - } - CONSTEXPR kernel_height_m1_r& set_value(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// kernel_stride_r - State managed by NPU_SET_KERNEL_STRIDE -struct kernel_stride_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR kernel_stride_r() : - word0(0) - {} - CONSTEXPR kernel_stride_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - kernel_stride_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - auto v = word0; - return v; - } - CONSTEXPR kernel_stride_r& set_value(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// acc_format_r - State managed by NPU_SET_ACC_FORMAT -struct acc_format_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR acc_format_r() : - word0(0) - {} - CONSTEXPR acc_format_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - acc_format_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - auto v = word0; - return v; - } - CONSTEXPR acc_format_r& set_value(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// activation_r - State managed by NPU_SET_ACTIVATION -struct activation_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR activation_r() : - word0(0) - {} - CONSTEXPR activation_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - activation_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - auto v = word0; - return v; - } - CONSTEXPR activation_r& set_value(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// activation_min_r - State managed by NPU_SET_ACTIVATION_MIN -struct activation_min_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR activation_min_r() : - word0(0) - {} - CONSTEXPR activation_min_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - activation_min_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - auto v = word0; - return v; - } - CONSTEXPR activation_min_r& set_value(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// activation_max_r - State managed by NPU_SET_ACTIVATION_MAX -struct activation_max_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR activation_max_r() : - word0(0) - {} - CONSTEXPR activation_max_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - activation_max_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - auto v = word0; - return v; - } - CONSTEXPR activation_max_r& set_value(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// weight_region_r - State managed by NPU_SET_WEIGHT_REGION -struct weight_region_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR weight_region_r() : - word0(0) - {} - CONSTEXPR weight_region_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - weight_region_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - auto v = word0; - return v; - } - CONSTEXPR weight_region_r& set_value(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// scale_region_r - State managed by NPU_SET_SCALE_REGION -struct scale_region_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR scale_region_r() : - word0(0) - {} - CONSTEXPR scale_region_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - scale_region_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - auto v = word0; - return v; - } - CONSTEXPR scale_region_r& set_value(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// resize_x_scale_n_m1_r - State managed by NPU_SET_RESIZE_X_SCALE_N_M1 -struct resize_x_scale_n_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR resize_x_scale_n_m1_r() : - word0(0) - {} - CONSTEXPR resize_x_scale_n_m1_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - resize_x_scale_n_m1_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - auto v = word0; - return v; - } - CONSTEXPR resize_x_scale_n_m1_r& set_value(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// resize_y_scale_n_m1_r - State managed by NPU_SET_RESIZE_Y_SCALE_N_M1 -struct resize_y_scale_n_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR resize_y_scale_n_m1_r() : - word0(0) - {} - CONSTEXPR resize_y_scale_n_m1_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - resize_y_scale_n_m1_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - auto v = word0; - return v; - } - CONSTEXPR resize_y_scale_n_m1_r& set_value(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// resize_x_offset_r - State managed by NPU_SET_RESIZE_X_OFFSET -struct resize_x_offset_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR resize_x_offset_r() : - word0(0) - {} - CONSTEXPR resize_x_offset_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - resize_x_offset_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - auto v = word0; - return v; - } - CONSTEXPR resize_x_offset_r& set_value(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// resize_y_offset_r - State managed by NPU_SET_RESIZE_Y_OFFSET -struct resize_y_offset_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR resize_y_offset_r() : - word0(0) - {} - CONSTEXPR resize_y_offset_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - resize_y_offset_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - auto v = word0; - return v; - } - CONSTEXPR resize_y_offset_r& set_value(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// weight_format_r - State managed by NPU_SET_WEIGHT_FORMAT -struct weight_format_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR weight_format_r() : - word0(0) - {} - CONSTEXPR weight_format_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - weight_format_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - auto v = word0; - return v; - } - CONSTEXPR weight_format_r& set_value(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// blockdep_r - State managed by NPU_SET_BLOCKDEP -struct blockdep_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR blockdep_r() : - word0(0) - {} - CONSTEXPR blockdep_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - blockdep_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - auto v = word0; - return v; - } - CONSTEXPR blockdep_r& set_value(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// dma0_src_region_r - State managed by NPU_SET_DMA0_SRC_REGION -struct dma0_src_region_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR dma0_src_region_r() : - word0(0) - {} - CONSTEXPR dma0_src_region_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - dma0_src_region_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - auto v = word0; - return v; - } - CONSTEXPR dma0_src_region_r& set_value(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// dma0_dst_region_r - State managed by NPU_SET_DMA0_DST_REGION -struct dma0_dst_region_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR dma0_dst_region_r() : - word0(0) - {} - CONSTEXPR dma0_dst_region_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - dma0_dst_region_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - auto v = word0; - return v; - } - CONSTEXPR dma0_dst_region_r& set_value(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// dma0_size0_r - State managed by NPU_SET_DMA0_SIZE0 -struct dma0_size0_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR dma0_size0_r() : - word0(0) - {} - CONSTEXPR dma0_size0_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - dma0_size0_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - auto v = word0; - return v; - } - CONSTEXPR dma0_size0_r& set_value(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// dma0_size1_r - State managed by NPU_SET_DMA0_SIZE1 -struct dma0_size1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR dma0_size1_r() : - word0(0) - {} - CONSTEXPR dma0_size1_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - dma0_size1_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - auto v = word0; - return v; - } - CONSTEXPR dma0_size1_r& set_value(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// dma0_idx_region_r - State managed by NPU_SET_DMA0_IDX_REGION -struct dma0_idx_region_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR dma0_idx_region_r() : - word0(0) - {} - CONSTEXPR dma0_idx_region_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - dma0_idx_region_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - auto v = word0; - return v; - } - CONSTEXPR dma0_idx_region_r& set_value(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// ifm2_broadcast_r - State managed by NPU_SET_IFM2_BROADCAST -struct ifm2_broadcast_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR ifm2_broadcast_r() : - word0(0) - {} - CONSTEXPR ifm2_broadcast_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - ifm2_broadcast_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - auto v = word0; - return v; - } - CONSTEXPR ifm2_broadcast_r& set_value(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// ifm2_precision_r - State managed by NPU_SET_IFM2_PRECISION -struct ifm2_precision_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR ifm2_precision_r() : - word0(0) - {} - CONSTEXPR ifm2_precision_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - ifm2_precision_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - auto v = word0; - return v; - } - CONSTEXPR ifm2_precision_r& set_value(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// ifm2_zero_point_r - State managed by NPU_SET_IFM2_ZERO_POINT -struct ifm2_zero_point_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR ifm2_zero_point_r() : - word0(0) - {} - CONSTEXPR ifm2_zero_point_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - ifm2_zero_point_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - auto v = word0; - return v; - } - CONSTEXPR ifm2_zero_point_r& set_value(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// ifm2_width0_m1_r - State managed by NPU_SET_IFM2_WIDTH0_M1 -struct ifm2_width0_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR ifm2_width0_m1_r() : - word0(0) - {} - CONSTEXPR ifm2_width0_m1_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - ifm2_width0_m1_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - auto v = word0; - return v; - } - CONSTEXPR ifm2_width0_m1_r& set_value(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// ifm2_height0_m1_r - State managed by NPU_SET_IFM2_HEIGHT0_M1 -struct ifm2_height0_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR ifm2_height0_m1_r() : - word0(0) - {} - CONSTEXPR ifm2_height0_m1_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - ifm2_height0_m1_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - auto v = word0; - return v; - } - CONSTEXPR ifm2_height0_m1_r& set_value(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// ifm2_height1_m1_r - State managed by NPU_SET_IFM2_HEIGHT1_M1 -struct ifm2_height1_m1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR ifm2_height1_m1_r() : - word0(0) - {} - CONSTEXPR ifm2_height1_m1_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - ifm2_height1_m1_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - auto v = word0; - return v; - } - CONSTEXPR ifm2_height1_m1_r& set_value(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// ifm2_region_r - State managed by NPU_SET_IFM2_REGION -struct ifm2_region_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR ifm2_region_r() : - word0(0) - {} - CONSTEXPR ifm2_region_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - ifm2_region_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - auto v = word0; - return v; - } - CONSTEXPR ifm2_region_r& set_value(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// ifm_base0_r - State managed by NPU_SET_IFM_BASE0 -struct ifm_base0_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR ifm_base0_r() : - word0(0), - word1(0) - {} - CONSTEXPR ifm_base0_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - ifm_base0_r copy() - { - return *this; - } -#endif -}; - -// ifm_base1_r - State managed by NPU_SET_IFM_BASE1 -struct ifm_base1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR ifm_base1_r() : - word0(0), - word1(0) - {} - CONSTEXPR ifm_base1_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - ifm_base1_r copy() - { - return *this; - } -#endif -}; - -// ifm_base2_r - State managed by NPU_SET_IFM_BASE2 -struct ifm_base2_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR ifm_base2_r() : - word0(0), - word1(0) - {} - CONSTEXPR ifm_base2_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - ifm_base2_r copy() - { - return *this; - } -#endif -}; - -// ifm_base3_r - State managed by NPU_SET_IFM_BASE3 -struct ifm_base3_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR ifm_base3_r() : - word0(0), - word1(0) - {} - CONSTEXPR ifm_base3_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - ifm_base3_r copy() - { - return *this; - } -#endif -}; - -// ifm_stride_x_r - State managed by NPU_SET_IFM_STRIDE_X -struct ifm_stride_x_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR ifm_stride_x_r() : - word0(0), - word1(0) - {} - CONSTEXPR ifm_stride_x_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - ifm_stride_x_r copy() - { - return *this; - } -#endif -}; - -// ifm_stride_y_r - State managed by NPU_SET_IFM_STRIDE_Y -struct ifm_stride_y_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR ifm_stride_y_r() : - word0(0), - word1(0) - {} - CONSTEXPR ifm_stride_y_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - ifm_stride_y_r copy() - { - return *this; - } -#endif -}; - -// ifm_stride_c_r - State managed by NPU_SET_IFM_STRIDE_C -struct ifm_stride_c_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR ifm_stride_c_r() : - word0(0), - word1(0) - {} - CONSTEXPR ifm_stride_c_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - ifm_stride_c_r copy() - { - return *this; - } -#endif -}; - -// ofm_base0_r - State managed by NPU_SET_OFM_BASE0 -struct ofm_base0_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR ofm_base0_r() : - word0(0), - word1(0) - {} - CONSTEXPR ofm_base0_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - ofm_base0_r copy() - { - return *this; - } -#endif -}; - -// ofm_base1_r - State managed by NPU_SET_OFM_BASE1 -struct ofm_base1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR ofm_base1_r() : - word0(0), - word1(0) - {} - CONSTEXPR ofm_base1_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - ofm_base1_r copy() - { - return *this; - } -#endif -}; - -// ofm_base2_r - State managed by NPU_SET_OFM_BASE2 -struct ofm_base2_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR ofm_base2_r() : - word0(0), - word1(0) - {} - CONSTEXPR ofm_base2_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - ofm_base2_r copy() - { - return *this; - } -#endif -}; - -// ofm_base3_r - State managed by NPU_SET_OFM_BASE3 -struct ofm_base3_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR ofm_base3_r() : - word0(0), - word1(0) - {} - CONSTEXPR ofm_base3_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - ofm_base3_r copy() - { - return *this; - } -#endif -}; - -// ofm_stride_x_r - State managed by NPU_SET_OFM_STRIDE_X -struct ofm_stride_x_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR ofm_stride_x_r() : - word0(0), - word1(0) - {} - CONSTEXPR ofm_stride_x_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - ofm_stride_x_r copy() - { - return *this; - } -#endif -}; - -// ofm_stride_y_r - State managed by NPU_SET_OFM_STRIDE_Y -struct ofm_stride_y_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR ofm_stride_y_r() : - word0(0), - word1(0) - {} - CONSTEXPR ofm_stride_y_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - ofm_stride_y_r copy() - { - return *this; - } -#endif -}; - -// ofm_stride_c_r - State managed by NPU_SET_OFM_STRIDE_C -struct ofm_stride_c_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR ofm_stride_c_r() : - word0(0), - word1(0) - {} - CONSTEXPR ofm_stride_c_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - ofm_stride_c_r copy() - { - return *this; - } -#endif -}; - -// weight_base_r - State managed by NPU_SET_WEIGHT_BASE -struct weight_base_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR weight_base_r() : - word0(0), - word1(0) - {} - CONSTEXPR weight_base_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - weight_base_r copy() - { - return *this; - } -#endif -}; - -// weight_length_r - State managed by NPU_SET_WEIGHT_LENGTH -struct weight_length_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR weight_length_r() : - word0(0), - word1(0) - {} - CONSTEXPR weight_length_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - weight_length_r copy() - { - return *this; - } -#endif -}; - -// scale_base_r - State managed by NPU_SET_SCALE_BASE -struct scale_base_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR scale_base_r() : - word0(0), - word1(0) - {} - CONSTEXPR scale_base_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - scale_base_r copy() - { - return *this; - } -#endif -}; - -// scale_length_r - State managed by NPU_SET_SCALE_LENGTH -struct scale_length_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR scale_length_r() : - word0(0), - word1(0) - {} - CONSTEXPR scale_length_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - scale_length_r copy() - { - return *this; - } -#endif -}; - -// ofm_scale_r - State managed by NPU_SET_OFM_SCALE -struct ofm_scale_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR ofm_scale_r() : - word0(0), - word1(0) - {} - CONSTEXPR ofm_scale_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - ofm_scale_r copy() - { - return *this; - } -#endif -}; - -// ifm_scale_r - State managed by NPU_SET_IFM_SCALE -struct ifm_scale_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR ifm_scale_r() : - word0(0), - word1(0) - {} - CONSTEXPR ifm_scale_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - ifm_scale_r copy() - { - return *this; - } -#endif -}; - -// ifm2_scale_r - State managed by NPU_SET_IFM2_SCALE -struct ifm2_scale_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR ifm2_scale_r() : - word0(0), - word1(0) - {} - CONSTEXPR ifm2_scale_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - ifm2_scale_r copy() - { - return *this; - } -#endif -}; - -// op_scalar_r - State managed by NPU_SET_OP_SCALAR -struct op_scalar_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR op_scalar_r() : - word0(0), - word1(0) - {} - CONSTEXPR op_scalar_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - op_scalar_r copy() - { - return *this; - } -#endif -}; - -// dma0_src_r - State managed by NPU_SET_DMA0_SRC -struct dma0_src_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR dma0_src_r() : - word0(0), - word1(0) - {} - CONSTEXPR dma0_src_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - dma0_src_r copy() - { - return *this; - } -#endif -}; - -// dma0_dst_r - State managed by NPU_SET_DMA0_DST -struct dma0_dst_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR dma0_dst_r() : - word0(0), - word1(0) - {} - CONSTEXPR dma0_dst_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - dma0_dst_r copy() - { - return *this; - } -#endif -}; - -// dma0_len_r - State managed by NPU_SET_DMA0_LEN -struct dma0_len_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR dma0_len_r() : - word0(0), - word1(0) - {} - CONSTEXPR dma0_len_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - dma0_len_r copy() - { - return *this; - } -#endif -}; - -// dma0_src_stride0_r - State managed by NPU_SET_DMA0_SRC_STRIDE0 -struct dma0_src_stride0_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR dma0_src_stride0_r() : - word0(0), - word1(0) - {} - CONSTEXPR dma0_src_stride0_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - dma0_src_stride0_r copy() - { - return *this; - } -#endif -}; - -// dma0_src_stride1_r - State managed by NPU_SET_DMA0_SRC_STRIDE1 -struct dma0_src_stride1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR dma0_src_stride1_r() : - word0(0), - word1(0) - {} - CONSTEXPR dma0_src_stride1_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - dma0_src_stride1_r copy() - { - return *this; - } -#endif -}; - -// dma0_dst_stride0_r - State managed by NPU_SET_DMA0_DST_STRIDE0 -struct dma0_dst_stride0_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR dma0_dst_stride0_r() : - word0(0), - word1(0) - {} - CONSTEXPR dma0_dst_stride0_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - dma0_dst_stride0_r copy() - { - return *this; - } -#endif -}; - -// dma0_dst_stride1_r - State managed by NPU_SET_DMA0_DST_STRIDE1 -struct dma0_dst_stride1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR dma0_dst_stride1_r() : - word0(0), - word1(0) - {} - CONSTEXPR dma0_dst_stride1_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - dma0_dst_stride1_r copy() - { - return *this; - } -#endif -}; - -// dma0_idx_r - State managed by NPU_SET_DMA0_IDX -struct dma0_idx_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR dma0_idx_r() : - word0(0), - word1(0) - {} - CONSTEXPR dma0_idx_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - dma0_idx_r copy() - { - return *this; - } -#endif -}; - -// ifm2_base0_r - State managed by NPU_SET_IFM2_BASE0 -struct ifm2_base0_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR ifm2_base0_r() : - word0(0), - word1(0) - {} - CONSTEXPR ifm2_base0_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - ifm2_base0_r copy() - { - return *this; - } -#endif -}; - -// ifm2_base1_r - State managed by NPU_SET_IFM2_BASE1 -struct ifm2_base1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR ifm2_base1_r() : - word0(0), - word1(0) - {} - CONSTEXPR ifm2_base1_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - ifm2_base1_r copy() - { - return *this; - } -#endif -}; - -// ifm2_base2_r - State managed by NPU_SET_IFM2_BASE2 -struct ifm2_base2_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR ifm2_base2_r() : - word0(0), - word1(0) - {} - CONSTEXPR ifm2_base2_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - ifm2_base2_r copy() - { - return *this; - } -#endif -}; - -// ifm2_base3_r - State managed by NPU_SET_IFM2_BASE3 -struct ifm2_base3_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR ifm2_base3_r() : - word0(0), - word1(0) - {} - CONSTEXPR ifm2_base3_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - ifm2_base3_r copy() - { - return *this; - } -#endif -}; - -// ifm2_stride_x_r - State managed by NPU_SET_IFM2_STRIDE_X -struct ifm2_stride_x_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR ifm2_stride_x_r() : - word0(0), - word1(0) - {} - CONSTEXPR ifm2_stride_x_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - ifm2_stride_x_r copy() - { - return *this; - } -#endif -}; - -// ifm2_stride_y_r - State managed by NPU_SET_IFM2_STRIDE_Y -struct ifm2_stride_y_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR ifm2_stride_y_r() : - word0(0), - word1(0) - {} - CONSTEXPR ifm2_stride_y_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - ifm2_stride_y_r copy() - { - return *this; - } -#endif -}; - -// ifm2_stride_c_r - State managed by NPU_SET_IFM2_STRIDE_C -struct ifm2_stride_c_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR ifm2_stride_c_r() : - word0(0), - word1(0) - {} - CONSTEXPR ifm2_stride_c_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - ifm2_stride_c_r copy() - { - return *this; - } -#endif -}; - -// weight1_base_r - State managed by NPU_SET_WEIGHT1_BASE -struct weight1_base_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR weight1_base_r() : - word0(0), - word1(0) - {} - CONSTEXPR weight1_base_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - weight1_base_r copy() - { - return *this; - } -#endif -}; - -// weight1_length_r - State managed by NPU_SET_WEIGHT1_LENGTH -struct weight1_length_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR weight1_length_r() : - word0(0), - word1(0) - {} - CONSTEXPR weight1_length_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - weight1_length_r copy() - { - return *this; - } -#endif -}; - -// weight2_base_r - State managed by NPU_SET_WEIGHT2_BASE -struct weight2_base_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR weight2_base_r() : - word0(0), - word1(0) - {} - CONSTEXPR weight2_base_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - weight2_base_r copy() - { - return *this; - } -#endif -}; - -// weight2_length_r - State managed by NPU_SET_WEIGHT2_LENGTH -struct weight2_length_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR weight2_length_r() : - word0(0), - word1(0) - {} - CONSTEXPR weight2_length_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - weight2_length_r copy() - { - return *this; - } -#endif -}; - -// weight3_base_r - State managed by NPU_SET_WEIGHT3_BASE -struct weight3_base_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR weight3_base_r() : - word0(0), - word1(0) - {} - CONSTEXPR weight3_base_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - weight3_base_r copy() - { - return *this; - } -#endif -}; - -// weight3_length_r - State managed by NPU_SET_WEIGHT3_LENGTH -struct weight3_length_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR weight3_length_r() : - word0(0), - word1(0) - {} - CONSTEXPR weight3_length_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - weight3_length_r copy() - { - return *this; - } -#endif -}; - -// resize_x_step_r - State managed by NPU_SET_RESIZE_X_STEP -struct resize_x_step_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR resize_x_step_r() : - word0(0), - word1(0) - {} - CONSTEXPR resize_x_step_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - resize_x_step_r copy() - { - return *this; - } -#endif -}; - -// resize_y_step_r - State managed by NPU_SET_RESIZE_Y_STEP -struct resize_y_step_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR resize_y_step_r() : - word0(0), - word1(0) - {} - CONSTEXPR resize_y_step_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - resize_y_step_r copy() - { - return *this; - } -#endif -}; - -// dma0_idx_max_r - State managed by NPU_SET_DMA0_IDX_MAX -struct dma0_idx_max_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR dma0_idx_max_r() : - word0(0), - word1(0) - {} - CONSTEXPR dma0_idx_max_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - dma0_idx_max_r copy() - { - return *this; - } -#endif -}; - -// dma0_idx_skip1_r - State managed by NPU_SET_DMA0_IDX_SKIP1 -struct dma0_idx_skip1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value_LO : 32; // 64-bit register value - LSB - uint32_t value_HI : 32; // 64-bit register value - MSB - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR dma0_idx_skip1_r() : - word0(0), - word1(0) - {} - CONSTEXPR dma0_idx_skip1_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - dma0_idx_skip1_r copy() - { - return *this; - } -#endif -}; - -// revision_r - Internal FPGA build revision: first 32 bits of the Ultan git hash used for the build -struct revision_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t value : 32; // 32-bit register value - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR revision_r() : - word0(0) - {} - CONSTEXPR revision_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - revision_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_value() const - { - auto v = word0; - return v; - } - CONSTEXPR revision_r& set_value(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// pid4_r - Peripheral ID byte 4 (Arm=code 4) -struct pid4_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t PID4 : 32; // Byte 4 of Peripheral ID (Lower 8 bits valid) - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR pid4_r() : - word0(4) - {} - CONSTEXPR pid4_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - pid4_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_PID4() const - { - auto v = word0; - return v; - } - CONSTEXPR pid4_r& set_PID4(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// pid5_r - Peripheral ID byte 5 (reserved) -struct pid5_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t PID5 : 32; // Byte 5 of Peripheral ID (Lower 8 bits valid) - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR pid5_r() : - word0(0) - {} - CONSTEXPR pid5_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - pid5_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_PID5() const - { - auto v = word0; - return v; - } - CONSTEXPR pid5_r& set_PID5(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// pid6_r - Peripheral ID byte 6 (reserved) -struct pid6_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t PID6 : 32; // Byte 6 of Peripheral ID (Lower 8 bits valid) - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR pid6_r() : - word0(0) - {} - CONSTEXPR pid6_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - pid6_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_PID6() const - { - auto v = word0; - return v; - } - CONSTEXPR pid6_r& set_PID6(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// pid7_r - Peripheral ID byte 7 (reserved) -struct pid7_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t PID7 : 32; // Byte 7 of Peripheral ID (Lower 8 bits valid) - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR pid7_r() : - word0(0) - {} - CONSTEXPR pid7_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - pid7_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_PID7() const - { - auto v = word0; - return v; - } - CONSTEXPR pid7_r& set_PID7(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// pid0_r - Peripheral ID byte 0. This is bits[7:0] of the part number -struct pid0_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t PID0 : 32; // Byte 0 of Peripheral ID (Lower 8 bits valid) - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR pid0_r() : - word0(130) - {} - CONSTEXPR pid0_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - pid0_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_PID0() const - { - auto v = word0; - return v; - } - CONSTEXPR pid0_r& set_PID0(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// pid1_r - Peripheral ID byte 1. This is bits[11:8] of the part number in bits[3:0], and bits[3:0] of the Arm ID in bits[7:4] -struct pid1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t PID1 : 32; // Byte 1 of Peripheral ID (Lower 8 bits valid) - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR pid1_r() : - word0(181) - {} - CONSTEXPR pid1_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - pid1_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_PID1() const - { - auto v = word0; - return v; - } - CONSTEXPR pid1_r& set_PID1(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// pid2_r - Peripheral ID byte 2. This is bits[6:4] of the Arm ID in bits[2:0], and bit 3 indicates format B -struct pid2_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t PID2 : 32; // Byte 2 of Peripheral ID (Lower 8 bits valid) - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR pid2_r() : - word0(11) - {} - CONSTEXPR pid2_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - pid2_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_PID2() const - { - auto v = word0; - return v; - } - CONSTEXPR pid2_r& set_PID2(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// pid3_r - Peripheral ID byte 3 -struct pid3_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t PID3 : 32; // Byte 1 of Peripheral ID (Lower 8 bits valid) - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR pid3_r() : - word0(0) - {} - CONSTEXPR pid3_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - pid3_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_PID3() const - { - auto v = word0; - return v; - } - CONSTEXPR pid3_r& set_PID3(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// cid0_r - Component ID byte 0 -struct cid0_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t CID0 : 32; // Byte 0 of Component ID (Lower 8 bits valid) - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR cid0_r() : - word0(13) - {} - CONSTEXPR cid0_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - cid0_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_CID0() const - { - auto v = word0; - return v; - } - CONSTEXPR cid0_r& set_CID0(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// cid1_r - Component ID byte 1 -struct cid1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t CID1 : 32; // Byte 1 of Component ID (Lower 8 bits valid) - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR cid1_r() : - word0(240) - {} - CONSTEXPR cid1_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - cid1_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_CID1() const - { - auto v = word0; - return v; - } - CONSTEXPR cid1_r& set_CID1(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// cid2_r - Component ID byte 2 -struct cid2_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t CID2 : 32; // Byte 2 of Component ID (Lower 8 bits valid) - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR cid2_r() : - word0(5) - {} - CONSTEXPR cid2_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - cid2_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_CID2() const - { - auto v = word0; - return v; - } - CONSTEXPR cid2_r& set_CID2(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// cid3_r - Component ID byte 3 -struct cid3_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t CID3 : 32; // Byte 3 of Component ID (Lower 8 bits valid) - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR cid3_r() : - word0(177) - {} - CONSTEXPR cid3_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - cid3_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_CID3() const - { - auto v = word0; - return v; - } - CONSTEXPR cid3_r& set_CID3(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// wd_status_r - WD_STATUS -struct wd_status_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t ctrl_idle : 1; // All stripe jobs idle (all weights consumed) - uint32_t reserved0 : 1; - uint32_t active_core : 2; // WD active core - uint32_t sc0_idle : 1; // Standard core 0 idle - uint32_t sc1_idle : 1; // Standard core 1 idle - uint32_t sc2_idle : 1; // Standard core 2 idle - uint32_t sc3_idle : 1; // Standard core 3 idle - uint32_t fc_idle : 1; // Fast core idle - uint32_t tc_idle : 1; // Tensor core (IFM input) idle - uint32_t reserved1 : 6; - uint32_t wbuf0_valid : 1; // Weight buffer 0 full - uint32_t wbuf0_idle : 1; // Weight buffer 0 empty - uint32_t wbuf1_valid : 1; // Weight buffer 1 full - uint32_t wbuf1_idle : 1; // Weight buffer 1 empty - uint32_t wbuf2_valid : 1; // Weight buffer 2 full - uint32_t wbuf2_idle : 1; // Weight buffer 2 empty - uint32_t wbuf3_valid : 1; // Weight buffer 3 full - uint32_t wbuf3_idle : 1; // Weight buffer 3 empty - uint32_t stalled_by_ws_sc0 : 1; // WD stalled by lack of standard core 0 weight stream data - uint32_t stalled_by_ws_sc1 : 1; // WD stalled by lack of standard core 1 weight stream data - uint32_t stalled_by_ws_sc2 : 1; // WD stalled by lack of standard core 2 weight stream data - uint32_t stalled_by_ws_sc3 : 1; // WD stalled by lack of standard core 3 weight stream data - uint32_t stalled_by_ws_fc : 1; // WD stalled by lack of fast core weight stream data - uint32_t stalled_by_ws_tc : 1; // WD stalled by lack of tensor core IFM stream data - uint32_t stalled_by_wd_buf : 1; // WD stalled by lack of free WD buffer (blocked by MAC) - uint32_t reserved2 : 1; - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR wd_status_r() : - word0(0) - {} - CONSTEXPR wd_status_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - wd_status_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_ctrl_idle() const - { - auto v = ((1U << 1) - 1) & (word0 >> 0); - return v; - } - CONSTEXPR wd_status_r& set_ctrl_idle(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - CONSTEXPR NPU_NAMESPACE::wd_active_core get_active_core() const - { - auto v = ((1U << 2) - 1) & (word0 >> 2); - assert(v <= 3); - return static_cast(v); - } - CONSTEXPR wd_status_r& set_active_core(NPU_NAMESPACE::wd_active_core value) - { - word0 = (~(((1U << 2) - 1)<<2) & word0) | ((((1U << 2) - 1) & static_cast(value)) << 2); - return *this; - } - CONSTEXPR uint32_t get_sc0_idle() const - { - auto v = ((1U << 1) - 1) & (word0 >> 4); - return v; - } - CONSTEXPR wd_status_r& set_sc0_idle(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<4) & word0) | ((((1U << 1) - 1) & value) << 4); - return *this; - } - CONSTEXPR uint32_t get_sc1_idle() const - { - auto v = ((1U << 1) - 1) & (word0 >> 5); - return v; - } - CONSTEXPR wd_status_r& set_sc1_idle(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<5) & word0) | ((((1U << 1) - 1) & value) << 5); - return *this; - } - CONSTEXPR uint32_t get_sc2_idle() const - { - auto v = ((1U << 1) - 1) & (word0 >> 6); - return v; - } - CONSTEXPR wd_status_r& set_sc2_idle(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<6) & word0) | ((((1U << 1) - 1) & value) << 6); - return *this; - } - CONSTEXPR uint32_t get_sc3_idle() const - { - auto v = ((1U << 1) - 1) & (word0 >> 7); - return v; - } - CONSTEXPR wd_status_r& set_sc3_idle(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<7) & word0) | ((((1U << 1) - 1) & value) << 7); - return *this; - } - CONSTEXPR uint32_t get_fc_idle() const - { - auto v = ((1U << 1) - 1) & (word0 >> 8); - return v; - } - CONSTEXPR wd_status_r& set_fc_idle(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<8) & word0) | ((((1U << 1) - 1) & value) << 8); - return *this; - } - CONSTEXPR uint32_t get_tc_idle() const - { - auto v = ((1U << 1) - 1) & (word0 >> 9); - return v; - } - CONSTEXPR wd_status_r& set_tc_idle(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<9) & word0) | ((((1U << 1) - 1) & value) << 9); - return *this; - } - CONSTEXPR uint32_t get_wbuf0_valid() const - { - auto v = ((1U << 1) - 1) & (word0 >> 16); - return v; - } - CONSTEXPR wd_status_r& set_wbuf0_valid(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<16) & word0) | ((((1U << 1) - 1) & value) << 16); - return *this; - } - CONSTEXPR uint32_t get_wbuf0_idle() const - { - auto v = ((1U << 1) - 1) & (word0 >> 17); - return v; - } - CONSTEXPR wd_status_r& set_wbuf0_idle(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<17) & word0) | ((((1U << 1) - 1) & value) << 17); - return *this; - } - CONSTEXPR uint32_t get_wbuf1_valid() const - { - auto v = ((1U << 1) - 1) & (word0 >> 18); - return v; - } - CONSTEXPR wd_status_r& set_wbuf1_valid(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<18) & word0) | ((((1U << 1) - 1) & value) << 18); - return *this; - } - CONSTEXPR uint32_t get_wbuf1_idle() const - { - auto v = ((1U << 1) - 1) & (word0 >> 19); - return v; - } - CONSTEXPR wd_status_r& set_wbuf1_idle(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<19) & word0) | ((((1U << 1) - 1) & value) << 19); - return *this; - } - CONSTEXPR uint32_t get_wbuf2_valid() const - { - auto v = ((1U << 1) - 1) & (word0 >> 20); - return v; - } - CONSTEXPR wd_status_r& set_wbuf2_valid(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<20) & word0) | ((((1U << 1) - 1) & value) << 20); - return *this; - } - CONSTEXPR uint32_t get_wbuf2_idle() const - { - auto v = ((1U << 1) - 1) & (word0 >> 21); - return v; - } - CONSTEXPR wd_status_r& set_wbuf2_idle(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<21) & word0) | ((((1U << 1) - 1) & value) << 21); - return *this; - } - CONSTEXPR uint32_t get_wbuf3_valid() const - { - auto v = ((1U << 1) - 1) & (word0 >> 22); - return v; - } - CONSTEXPR wd_status_r& set_wbuf3_valid(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<22) & word0) | ((((1U << 1) - 1) & value) << 22); - return *this; - } - CONSTEXPR uint32_t get_wbuf3_idle() const - { - auto v = ((1U << 1) - 1) & (word0 >> 23); - return v; - } - CONSTEXPR wd_status_r& set_wbuf3_idle(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<23) & word0) | ((((1U << 1) - 1) & value) << 23); - return *this; - } - CONSTEXPR uint32_t get_stalled_by_ws_sc0() const - { - auto v = ((1U << 1) - 1) & (word0 >> 24); - return v; - } - CONSTEXPR wd_status_r& set_stalled_by_ws_sc0(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<24) & word0) | ((((1U << 1) - 1) & value) << 24); - return *this; - } - CONSTEXPR uint32_t get_stalled_by_ws_sc1() const - { - auto v = ((1U << 1) - 1) & (word0 >> 25); - return v; - } - CONSTEXPR wd_status_r& set_stalled_by_ws_sc1(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<25) & word0) | ((((1U << 1) - 1) & value) << 25); - return *this; - } - CONSTEXPR uint32_t get_stalled_by_ws_sc2() const - { - auto v = ((1U << 1) - 1) & (word0 >> 26); - return v; - } - CONSTEXPR wd_status_r& set_stalled_by_ws_sc2(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<26) & word0) | ((((1U << 1) - 1) & value) << 26); - return *this; - } - CONSTEXPR uint32_t get_stalled_by_ws_sc3() const - { - auto v = ((1U << 1) - 1) & (word0 >> 27); - return v; - } - CONSTEXPR wd_status_r& set_stalled_by_ws_sc3(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<27) & word0) | ((((1U << 1) - 1) & value) << 27); - return *this; - } - CONSTEXPR uint32_t get_stalled_by_ws_fc() const - { - auto v = ((1U << 1) - 1) & (word0 >> 28); - return v; - } - CONSTEXPR wd_status_r& set_stalled_by_ws_fc(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<28) & word0) | ((((1U << 1) - 1) & value) << 28); - return *this; - } - CONSTEXPR uint32_t get_stalled_by_ws_tc() const - { - auto v = ((1U << 1) - 1) & (word0 >> 29); - return v; - } - CONSTEXPR wd_status_r& set_stalled_by_ws_tc(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<29) & word0) | ((((1U << 1) - 1) & value) << 29); - return *this; - } - CONSTEXPR uint32_t get_stalled_by_wd_buf() const - { - auto v = ((1U << 1) - 1) & (word0 >> 30); - return v; - } - CONSTEXPR wd_status_r& set_stalled_by_wd_buf(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<30) & word0) | ((((1U << 1) - 1) & value) << 30); - return *this; - } -#endif -}; - -// mac_status_r - MAC_STATUS -struct mac_status_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t mac_active : 1; // Valid block command and not stalled - uint32_t reserved0 : 2; - uint32_t mac_dpu_active : 1; // At least one DPU is active - uint32_t mac_stalled_by_w_or_acc : 1; // MAC stalled by WB or AB (not IB) - uint32_t mac_stalled_by_w : 1; // MAC stalled by WB (not IB) - uint32_t mac_stalled_by_acc : 1; // MAC stalled by AB (not IB) - uint32_t mac_stalled_by_ib : 1; // MAC stalled by IB - uint32_t reserved1 : 24; - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR mac_status_r() : - word0(0) - {} - CONSTEXPR mac_status_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - mac_status_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_mac_active() const - { - auto v = ((1U << 1) - 1) & (word0 >> 0); - return v; - } - CONSTEXPR mac_status_r& set_mac_active(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - CONSTEXPR uint32_t get_mac_dpu_active() const - { - auto v = ((1U << 1) - 1) & (word0 >> 3); - return v; - } - CONSTEXPR mac_status_r& set_mac_dpu_active(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - CONSTEXPR uint32_t get_mac_stalled_by_w_or_acc() const - { - auto v = ((1U << 1) - 1) & (word0 >> 4); - return v; - } - CONSTEXPR mac_status_r& set_mac_stalled_by_w_or_acc(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<4) & word0) | ((((1U << 1) - 1) & value) << 4); - return *this; - } - CONSTEXPR uint32_t get_mac_stalled_by_w() const - { - auto v = ((1U << 1) - 1) & (word0 >> 5); - return v; - } - CONSTEXPR mac_status_r& set_mac_stalled_by_w(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<5) & word0) | ((((1U << 1) - 1) & value) << 5); - return *this; - } - CONSTEXPR uint32_t get_mac_stalled_by_acc() const - { - auto v = ((1U << 1) - 1) & (word0 >> 6); - return v; - } - CONSTEXPR mac_status_r& set_mac_stalled_by_acc(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<6) & word0) | ((((1U << 1) - 1) & value) << 6); - return *this; - } - CONSTEXPR uint32_t get_mac_stalled_by_ib() const - { - auto v = ((1U << 1) - 1) & (word0 >> 7); - return v; - } - CONSTEXPR mac_status_r& set_mac_stalled_by_ib(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<7) & word0) | ((((1U << 1) - 1) & value) << 7); - return *this; - } -#endif -}; - -// ao_status_r - AO_STATUS -struct ao_status_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t ao_active : 1; // Valid block command and not stalled - uint32_t reserved0 : 2; - uint32_t ao_stalled_by_bs_or_ob : 1; // Stalled by bias scale data or output block - uint32_t ao_stalled_by_bs : 1; // Stalled by bias scale data - uint32_t ao_stalled_by_ob : 1; // Stalled by output block - uint32_t ao_stalled_by_ab_or_cb : 1; // Stalled by accumulator or chaining buffer - uint32_t ao_stalled_by_ab : 1; // Stalled by accumulator buffer - uint32_t ao_stalled_by_cb : 1; // Stalled by chaining buffer - uint32_t reserved1 : 23; - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR ao_status_r() : - word0(0) - {} - CONSTEXPR ao_status_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - ao_status_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_ao_active() const - { - auto v = ((1U << 1) - 1) & (word0 >> 0); - return v; - } - CONSTEXPR ao_status_r& set_ao_active(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - CONSTEXPR uint32_t get_ao_stalled_by_bs_or_ob() const - { - auto v = ((1U << 1) - 1) & (word0 >> 3); - return v; - } - CONSTEXPR ao_status_r& set_ao_stalled_by_bs_or_ob(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - CONSTEXPR uint32_t get_ao_stalled_by_bs() const - { - auto v = ((1U << 1) - 1) & (word0 >> 4); - return v; - } - CONSTEXPR ao_status_r& set_ao_stalled_by_bs(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<4) & word0) | ((((1U << 1) - 1) & value) << 4); - return *this; - } - CONSTEXPR uint32_t get_ao_stalled_by_ob() const - { - auto v = ((1U << 1) - 1) & (word0 >> 5); - return v; - } - CONSTEXPR ao_status_r& set_ao_stalled_by_ob(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<5) & word0) | ((((1U << 1) - 1) & value) << 5); - return *this; - } - CONSTEXPR uint32_t get_ao_stalled_by_ab_or_cb() const - { - auto v = ((1U << 1) - 1) & (word0 >> 6); - return v; - } - CONSTEXPR ao_status_r& set_ao_stalled_by_ab_or_cb(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<6) & word0) | ((((1U << 1) - 1) & value) << 6); - return *this; - } - CONSTEXPR uint32_t get_ao_stalled_by_ab() const - { - auto v = ((1U << 1) - 1) & (word0 >> 7); - return v; - } - CONSTEXPR ao_status_r& set_ao_stalled_by_ab(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<7) & word0) | ((((1U << 1) - 1) & value) << 7); - return *this; - } - CONSTEXPR uint32_t get_ao_stalled_by_cb() const - { - auto v = ((1U << 1) - 1) & (word0 >> 8); - return v; - } - CONSTEXPR ao_status_r& set_ao_stalled_by_cb(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<8) & word0) | ((((1U << 1) - 1) & value) << 8); - return *this; - } -#endif -}; - -// dma_status0_r - DMA_STATUS0 -struct dma_status0_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t cmd_ch_idle : 1; // When this bit is high means that the CMD channel is not busy in generating addresses for a CMD job - uint32_t ifm0_ch_idle : 1; // When this bit is high means that there are no ongoing IFM MAC jobs - uint32_t ifm1_ch_idle : 1; // When this bit is high means that there are no ongoing IFM STREAM jobs - uint32_t wgt_ch_idle : 1; // When this bit is high means that the WGT channel is not busy in generating addresses for a WGT job - uint32_t bas_ch_idle : 1; // When this bit is high means that the BAS channel is not busy in generating addresses for a BAS job - uint32_t m2m_ch_idle : 1; // When this bit is high means that there are no ongoing M2M jobs - uint32_t ofm_ch_idle : 1; // When this bit is high means that there are no ongoing OFM jobs - uint32_t axi_halt_req : 1; // CPM has requested to HALT AXI bus before soft reset - uint32_t axi_halt_ack : 1; // DMA is in condition to halt the AXI bus since there are no pending transactions - uint32_t axi_pause_req : 1; // CC has requested to pause the AXI - uint32_t axi_pause_ack : 1; // DMA is in condition to pause the AXI bus since there are no pending transactions - uint32_t cmd_abort_ack : 1; // CC has requested to abort a CMD channel job - uint32_t cmd_abort_req : 1; // DMA has acknowledged the request of aborting a CMD channel job - uint32_t ifm_mac_if_stall : 1; // Valid high and Ready low for IFM MAC interface - uint32_t ifm_tc_if_stall : 1; // Valid high and Ready low for IFM WD Tensor Core interface - uint32_t ifm_ao_if_stall : 1; // Valid high and Ready low for IFM AO interface - uint32_t ofm_if_stall : 1; // Valid high and Ready low for OFM interface between AO and DMA - uint32_t cmd_if_stall : 1; // Valid high and Ready low for CMD interface between DMA and CC - uint32_t wd_sc0_if_stall : 1; // Valid high and Ready low for SC0 bitstream interface toward WD - uint32_t wd_sc1_if_stall : 1; // Valid high and Ready low for SC1 bitstream interface toward WD - uint32_t wd_sc2_if_stall : 1; // Valid high and Ready low for SC2 bitstream interface toward WD - uint32_t wd_sc3_if_stall : 1; // Valid high and Ready low for SC2 bitstream interface toward WD - uint32_t wd_fc_if_stall : 1; // Valid high and Ready low for FC bitstream interface toward WD - uint32_t bs_if_stall : 1; // Valid high and Ready low for BAS interface between DMA and AO - uint32_t lutcfg_if_stall : 1; // Valid high and Ready low for LUTCFG interface between DMA and AO - uint32_t reserved0 : 7; - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR dma_status0_r() : - word0(0) - {} - CONSTEXPR dma_status0_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - dma_status0_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_cmd_ch_idle() const - { - auto v = ((1U << 1) - 1) & (word0 >> 0); - return v; - } - CONSTEXPR dma_status0_r& set_cmd_ch_idle(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - CONSTEXPR uint32_t get_ifm0_ch_idle() const - { - auto v = ((1U << 1) - 1) & (word0 >> 1); - return v; - } - CONSTEXPR dma_status0_r& set_ifm0_ch_idle(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - CONSTEXPR uint32_t get_ifm1_ch_idle() const - { - auto v = ((1U << 1) - 1) & (word0 >> 2); - return v; - } - CONSTEXPR dma_status0_r& set_ifm1_ch_idle(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - CONSTEXPR uint32_t get_wgt_ch_idle() const - { - auto v = ((1U << 1) - 1) & (word0 >> 3); - return v; - } - CONSTEXPR dma_status0_r& set_wgt_ch_idle(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - CONSTEXPR uint32_t get_bas_ch_idle() const - { - auto v = ((1U << 1) - 1) & (word0 >> 4); - return v; - } - CONSTEXPR dma_status0_r& set_bas_ch_idle(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<4) & word0) | ((((1U << 1) - 1) & value) << 4); - return *this; - } - CONSTEXPR uint32_t get_m2m_ch_idle() const - { - auto v = ((1U << 1) - 1) & (word0 >> 5); - return v; - } - CONSTEXPR dma_status0_r& set_m2m_ch_idle(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<5) & word0) | ((((1U << 1) - 1) & value) << 5); - return *this; - } - CONSTEXPR uint32_t get_ofm_ch_idle() const - { - auto v = ((1U << 1) - 1) & (word0 >> 6); - return v; - } - CONSTEXPR dma_status0_r& set_ofm_ch_idle(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<6) & word0) | ((((1U << 1) - 1) & value) << 6); - return *this; - } - CONSTEXPR uint32_t get_axi_halt_req() const - { - auto v = ((1U << 1) - 1) & (word0 >> 7); - return v; - } - CONSTEXPR dma_status0_r& set_axi_halt_req(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<7) & word0) | ((((1U << 1) - 1) & value) << 7); - return *this; - } - CONSTEXPR uint32_t get_axi_halt_ack() const - { - auto v = ((1U << 1) - 1) & (word0 >> 8); - return v; - } - CONSTEXPR dma_status0_r& set_axi_halt_ack(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<8) & word0) | ((((1U << 1) - 1) & value) << 8); - return *this; - } - CONSTEXPR uint32_t get_axi_pause_req() const - { - auto v = ((1U << 1) - 1) & (word0 >> 9); - return v; - } - CONSTEXPR dma_status0_r& set_axi_pause_req(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<9) & word0) | ((((1U << 1) - 1) & value) << 9); - return *this; - } - CONSTEXPR uint32_t get_axi_pause_ack() const - { - auto v = ((1U << 1) - 1) & (word0 >> 10); - return v; - } - CONSTEXPR dma_status0_r& set_axi_pause_ack(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<10) & word0) | ((((1U << 1) - 1) & value) << 10); - return *this; - } - CONSTEXPR uint32_t get_cmd_abort_ack() const - { - auto v = ((1U << 1) - 1) & (word0 >> 11); - return v; - } - CONSTEXPR dma_status0_r& set_cmd_abort_ack(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<11) & word0) | ((((1U << 1) - 1) & value) << 11); - return *this; - } - CONSTEXPR uint32_t get_cmd_abort_req() const - { - auto v = ((1U << 1) - 1) & (word0 >> 12); - return v; - } - CONSTEXPR dma_status0_r& set_cmd_abort_req(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<12) & word0) | ((((1U << 1) - 1) & value) << 12); - return *this; - } - CONSTEXPR uint32_t get_ifm_mac_if_stall() const - { - auto v = ((1U << 1) - 1) & (word0 >> 13); - return v; - } - CONSTEXPR dma_status0_r& set_ifm_mac_if_stall(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<13) & word0) | ((((1U << 1) - 1) & value) << 13); - return *this; - } - CONSTEXPR uint32_t get_ifm_tc_if_stall() const - { - auto v = ((1U << 1) - 1) & (word0 >> 14); - return v; - } - CONSTEXPR dma_status0_r& set_ifm_tc_if_stall(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<14) & word0) | ((((1U << 1) - 1) & value) << 14); - return *this; - } - CONSTEXPR uint32_t get_ifm_ao_if_stall() const - { - auto v = ((1U << 1) - 1) & (word0 >> 15); - return v; - } - CONSTEXPR dma_status0_r& set_ifm_ao_if_stall(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<15) & word0) | ((((1U << 1) - 1) & value) << 15); - return *this; - } - CONSTEXPR uint32_t get_ofm_if_stall() const - { - auto v = ((1U << 1) - 1) & (word0 >> 16); - return v; - } - CONSTEXPR dma_status0_r& set_ofm_if_stall(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<16) & word0) | ((((1U << 1) - 1) & value) << 16); - return *this; - } - CONSTEXPR uint32_t get_cmd_if_stall() const - { - auto v = ((1U << 1) - 1) & (word0 >> 17); - return v; - } - CONSTEXPR dma_status0_r& set_cmd_if_stall(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<17) & word0) | ((((1U << 1) - 1) & value) << 17); - return *this; - } - CONSTEXPR uint32_t get_wd_sc0_if_stall() const - { - auto v = ((1U << 1) - 1) & (word0 >> 18); - return v; - } - CONSTEXPR dma_status0_r& set_wd_sc0_if_stall(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<18) & word0) | ((((1U << 1) - 1) & value) << 18); - return *this; - } - CONSTEXPR uint32_t get_wd_sc1_if_stall() const - { - auto v = ((1U << 1) - 1) & (word0 >> 19); - return v; - } - CONSTEXPR dma_status0_r& set_wd_sc1_if_stall(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<19) & word0) | ((((1U << 1) - 1) & value) << 19); - return *this; - } - CONSTEXPR uint32_t get_wd_sc2_if_stall() const - { - auto v = ((1U << 1) - 1) & (word0 >> 20); - return v; - } - CONSTEXPR dma_status0_r& set_wd_sc2_if_stall(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<20) & word0) | ((((1U << 1) - 1) & value) << 20); - return *this; - } - CONSTEXPR uint32_t get_wd_sc3_if_stall() const - { - auto v = ((1U << 1) - 1) & (word0 >> 21); - return v; - } - CONSTEXPR dma_status0_r& set_wd_sc3_if_stall(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<21) & word0) | ((((1U << 1) - 1) & value) << 21); - return *this; - } - CONSTEXPR uint32_t get_wd_fc_if_stall() const - { - auto v = ((1U << 1) - 1) & (word0 >> 22); - return v; - } - CONSTEXPR dma_status0_r& set_wd_fc_if_stall(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<22) & word0) | ((((1U << 1) - 1) & value) << 22); - return *this; - } - CONSTEXPR uint32_t get_bs_if_stall() const - { - auto v = ((1U << 1) - 1) & (word0 >> 23); - return v; - } - CONSTEXPR dma_status0_r& set_bs_if_stall(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<23) & word0) | ((((1U << 1) - 1) & value) << 23); - return *this; - } - CONSTEXPR uint32_t get_lutcfg_if_stall() const - { - auto v = ((1U << 1) - 1) & (word0 >> 24); - return v; - } - CONSTEXPR dma_status0_r& set_lutcfg_if_stall(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<24) & word0) | ((((1U << 1) - 1) & value) << 24); - return *this; - } -#endif -}; - -// dma_status1_r - DMA_STATUS1 -struct dma_status1_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t axi_sram0_ar_stalled : 1; // Read transfer request stalled on arready low AXI SRAM0 (due to memory system) - uint32_t axi_sram0_rd_limit_stall : 1; // Read stalled due to one AXI SRAM0 limit counter being reached - uint32_t axi_sram0_aw_stalled : 1; // Write transfer request stalled on awready low AXI SRAM0 (due to memory system) - uint32_t axi_sram0_w_stalled : 1; // Write transfer stalled on awready low AXI SRAM0 (due to memory system) - uint32_t axi_sram0_wr_limit_stall : 1; // Write stalled due to one AXI SRAM0 limit counter being reached - uint32_t axi_sram1_ar_stalled : 1; // Read transfer request stalled on arready low AXI SRAM1 (due to memory system) - uint32_t axi_sram1_rd_limit_stall : 1; // Read stalled due to one AXI SRAM1 limit counter being reached - uint32_t axi_sram1_aw_stalled : 1; // Write transfer request stalled on awready low AXI SRAM1 (due to memory system) - uint32_t axi_sram1_w_stalled : 1; // Write transfer stalled on awready low AXI SRAM1 (due to memory system) - uint32_t axi_sram1_wr_limit_stall : 1; // Write stalled due to one AXI SRAM1 limit counter being reached - uint32_t axi_sram2_ar_stalled : 1; // Read transfer request stalled on arready low AXI SRAM2 (due to memory system) - uint32_t axi_sram2_rd_limit_stall : 1; // Read stalled due to one AXI SRAM2 limit counter being reached - uint32_t axi_sram2_aw_stalled : 1; // Write transfer request stalled on awready low AXI SRAM2 (due to memory system) - uint32_t axi_sram2_w_stalled : 1; // Write transfer stalled on awready low AXI SRAM2 (due to memory system) - uint32_t axi_sram2_wr_limit_stall : 1; // Write stalled due to one AXI SRAM2 limit counter being reached - uint32_t axi_sram3_ar_stalled : 1; // Read transfer request stalled on arready low AXI SRAM3 (due to memory system) - uint32_t axi_sram3_rd_limit_stall : 1; // Read stalled due to one AXI SRAM3 limit counter being reached - uint32_t axi_sram3_aw_stalled : 1; // Write transfer request stalled on awready low AXI SRAM3 (due to memory system) - uint32_t axi_sram3_w_stalled : 1; // Write transfer stalled on awready low AXI SRAM3 (due to memory system) - uint32_t axi_sram3_wr_limit_stall : 1; // Write stalled due to one AXI SRAM3 limit counter being reached - uint32_t axi_ext0_ar_stalled : 1; // Read transfer request stalled on arready low AXI EXT0 (due to memory system) - uint32_t axi_ext0_rd_limit_stall : 1; // Read stalled due to one AXI EXT0 limit counter being reached - uint32_t axi_ext0_aw_stalled : 1; // Write transfer request stalled on awready low AXI EXT0 (due to memory system) - uint32_t axi_ext0_w_stalled : 1; // Write transfer stalled on awready low AXI EXT0 (due to memory system) - uint32_t axi_ext0_wr_limit_stall : 1; // Write stalled due to one AXI EXT0 limit counter being reached - uint32_t axi_ext1_ar_stalled : 1; // Read transfer request stalled on arready low AXI EXT1 (due to memory system) - uint32_t axi_ext1_rd_limit_stall : 1; // Read stalled due to one AXI EXT1 limit counter being reached - uint32_t axi_ext1_aw_stalled : 1; // Write transfer request stalled on awready low AXI EXT1 (due to memory system) - uint32_t axi_ext1_w_stalled : 1; // Write transfer stalled on awready low AXI EXT1 (due to memory system) - uint32_t axi_ext1_wr_limit_stall : 1; // Write stalled due to one AXI EXT1 limit counter being reached - uint32_t reserved0 : 2; - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR dma_status1_r() : - word0(0) - {} - CONSTEXPR dma_status1_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - dma_status1_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_axi_sram0_ar_stalled() const - { - auto v = ((1U << 1) - 1) & (word0 >> 0); - return v; - } - CONSTEXPR dma_status1_r& set_axi_sram0_ar_stalled(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - CONSTEXPR uint32_t get_axi_sram0_rd_limit_stall() const - { - auto v = ((1U << 1) - 1) & (word0 >> 1); - return v; - } - CONSTEXPR dma_status1_r& set_axi_sram0_rd_limit_stall(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - CONSTEXPR uint32_t get_axi_sram0_aw_stalled() const - { - auto v = ((1U << 1) - 1) & (word0 >> 2); - return v; - } - CONSTEXPR dma_status1_r& set_axi_sram0_aw_stalled(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - CONSTEXPR uint32_t get_axi_sram0_w_stalled() const - { - auto v = ((1U << 1) - 1) & (word0 >> 3); - return v; - } - CONSTEXPR dma_status1_r& set_axi_sram0_w_stalled(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - CONSTEXPR uint32_t get_axi_sram0_wr_limit_stall() const - { - auto v = ((1U << 1) - 1) & (word0 >> 4); - return v; - } - CONSTEXPR dma_status1_r& set_axi_sram0_wr_limit_stall(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<4) & word0) | ((((1U << 1) - 1) & value) << 4); - return *this; - } - CONSTEXPR uint32_t get_axi_sram1_ar_stalled() const - { - auto v = ((1U << 1) - 1) & (word0 >> 5); - return v; - } - CONSTEXPR dma_status1_r& set_axi_sram1_ar_stalled(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<5) & word0) | ((((1U << 1) - 1) & value) << 5); - return *this; - } - CONSTEXPR uint32_t get_axi_sram1_rd_limit_stall() const - { - auto v = ((1U << 1) - 1) & (word0 >> 6); - return v; - } - CONSTEXPR dma_status1_r& set_axi_sram1_rd_limit_stall(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<6) & word0) | ((((1U << 1) - 1) & value) << 6); - return *this; - } - CONSTEXPR uint32_t get_axi_sram1_aw_stalled() const - { - auto v = ((1U << 1) - 1) & (word0 >> 7); - return v; - } - CONSTEXPR dma_status1_r& set_axi_sram1_aw_stalled(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<7) & word0) | ((((1U << 1) - 1) & value) << 7); - return *this; - } - CONSTEXPR uint32_t get_axi_sram1_w_stalled() const - { - auto v = ((1U << 1) - 1) & (word0 >> 8); - return v; - } - CONSTEXPR dma_status1_r& set_axi_sram1_w_stalled(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<8) & word0) | ((((1U << 1) - 1) & value) << 8); - return *this; - } - CONSTEXPR uint32_t get_axi_sram1_wr_limit_stall() const - { - auto v = ((1U << 1) - 1) & (word0 >> 9); - return v; - } - CONSTEXPR dma_status1_r& set_axi_sram1_wr_limit_stall(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<9) & word0) | ((((1U << 1) - 1) & value) << 9); - return *this; - } - CONSTEXPR uint32_t get_axi_sram2_ar_stalled() const - { - auto v = ((1U << 1) - 1) & (word0 >> 10); - return v; - } - CONSTEXPR dma_status1_r& set_axi_sram2_ar_stalled(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<10) & word0) | ((((1U << 1) - 1) & value) << 10); - return *this; - } - CONSTEXPR uint32_t get_axi_sram2_rd_limit_stall() const - { - auto v = ((1U << 1) - 1) & (word0 >> 11); - return v; - } - CONSTEXPR dma_status1_r& set_axi_sram2_rd_limit_stall(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<11) & word0) | ((((1U << 1) - 1) & value) << 11); - return *this; - } - CONSTEXPR uint32_t get_axi_sram2_aw_stalled() const - { - auto v = ((1U << 1) - 1) & (word0 >> 12); - return v; - } - CONSTEXPR dma_status1_r& set_axi_sram2_aw_stalled(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<12) & word0) | ((((1U << 1) - 1) & value) << 12); - return *this; - } - CONSTEXPR uint32_t get_axi_sram2_w_stalled() const - { - auto v = ((1U << 1) - 1) & (word0 >> 13); - return v; - } - CONSTEXPR dma_status1_r& set_axi_sram2_w_stalled(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<13) & word0) | ((((1U << 1) - 1) & value) << 13); - return *this; - } - CONSTEXPR uint32_t get_axi_sram2_wr_limit_stall() const - { - auto v = ((1U << 1) - 1) & (word0 >> 14); - return v; - } - CONSTEXPR dma_status1_r& set_axi_sram2_wr_limit_stall(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<14) & word0) | ((((1U << 1) - 1) & value) << 14); - return *this; - } - CONSTEXPR uint32_t get_axi_sram3_ar_stalled() const - { - auto v = ((1U << 1) - 1) & (word0 >> 15); - return v; - } - CONSTEXPR dma_status1_r& set_axi_sram3_ar_stalled(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<15) & word0) | ((((1U << 1) - 1) & value) << 15); - return *this; - } - CONSTEXPR uint32_t get_axi_sram3_rd_limit_stall() const - { - auto v = ((1U << 1) - 1) & (word0 >> 16); - return v; - } - CONSTEXPR dma_status1_r& set_axi_sram3_rd_limit_stall(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<16) & word0) | ((((1U << 1) - 1) & value) << 16); - return *this; - } - CONSTEXPR uint32_t get_axi_sram3_aw_stalled() const - { - auto v = ((1U << 1) - 1) & (word0 >> 17); - return v; - } - CONSTEXPR dma_status1_r& set_axi_sram3_aw_stalled(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<17) & word0) | ((((1U << 1) - 1) & value) << 17); - return *this; - } - CONSTEXPR uint32_t get_axi_sram3_w_stalled() const - { - auto v = ((1U << 1) - 1) & (word0 >> 18); - return v; - } - CONSTEXPR dma_status1_r& set_axi_sram3_w_stalled(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<18) & word0) | ((((1U << 1) - 1) & value) << 18); - return *this; - } - CONSTEXPR uint32_t get_axi_sram3_wr_limit_stall() const - { - auto v = ((1U << 1) - 1) & (word0 >> 19); - return v; - } - CONSTEXPR dma_status1_r& set_axi_sram3_wr_limit_stall(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<19) & word0) | ((((1U << 1) - 1) & value) << 19); - return *this; - } - CONSTEXPR uint32_t get_axi_ext0_ar_stalled() const - { - auto v = ((1U << 1) - 1) & (word0 >> 20); - return v; - } - CONSTEXPR dma_status1_r& set_axi_ext0_ar_stalled(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<20) & word0) | ((((1U << 1) - 1) & value) << 20); - return *this; - } - CONSTEXPR uint32_t get_axi_ext0_rd_limit_stall() const - { - auto v = ((1U << 1) - 1) & (word0 >> 21); - return v; - } - CONSTEXPR dma_status1_r& set_axi_ext0_rd_limit_stall(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<21) & word0) | ((((1U << 1) - 1) & value) << 21); - return *this; - } - CONSTEXPR uint32_t get_axi_ext0_aw_stalled() const - { - auto v = ((1U << 1) - 1) & (word0 >> 22); - return v; - } - CONSTEXPR dma_status1_r& set_axi_ext0_aw_stalled(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<22) & word0) | ((((1U << 1) - 1) & value) << 22); - return *this; - } - CONSTEXPR uint32_t get_axi_ext0_w_stalled() const - { - auto v = ((1U << 1) - 1) & (word0 >> 23); - return v; - } - CONSTEXPR dma_status1_r& set_axi_ext0_w_stalled(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<23) & word0) | ((((1U << 1) - 1) & value) << 23); - return *this; - } - CONSTEXPR uint32_t get_axi_ext0_wr_limit_stall() const - { - auto v = ((1U << 1) - 1) & (word0 >> 24); - return v; - } - CONSTEXPR dma_status1_r& set_axi_ext0_wr_limit_stall(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<24) & word0) | ((((1U << 1) - 1) & value) << 24); - return *this; - } - CONSTEXPR uint32_t get_axi_ext1_ar_stalled() const - { - auto v = ((1U << 1) - 1) & (word0 >> 25); - return v; - } - CONSTEXPR dma_status1_r& set_axi_ext1_ar_stalled(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<25) & word0) | ((((1U << 1) - 1) & value) << 25); - return *this; - } - CONSTEXPR uint32_t get_axi_ext1_rd_limit_stall() const - { - auto v = ((1U << 1) - 1) & (word0 >> 26); - return v; - } - CONSTEXPR dma_status1_r& set_axi_ext1_rd_limit_stall(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<26) & word0) | ((((1U << 1) - 1) & value) << 26); - return *this; - } - CONSTEXPR uint32_t get_axi_ext1_aw_stalled() const - { - auto v = ((1U << 1) - 1) & (word0 >> 27); - return v; - } - CONSTEXPR dma_status1_r& set_axi_ext1_aw_stalled(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<27) & word0) | ((((1U << 1) - 1) & value) << 27); - return *this; - } - CONSTEXPR uint32_t get_axi_ext1_w_stalled() const - { - auto v = ((1U << 1) - 1) & (word0 >> 28); - return v; - } - CONSTEXPR dma_status1_r& set_axi_ext1_w_stalled(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<28) & word0) | ((((1U << 1) - 1) & value) << 28); - return *this; - } - CONSTEXPR uint32_t get_axi_ext1_wr_limit_stall() const - { - auto v = ((1U << 1) - 1) & (word0 >> 29); - return v; - } - CONSTEXPR dma_status1_r& set_axi_ext1_wr_limit_stall(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<29) & word0) | ((((1U << 1) - 1) & value) << 29); - return *this; - } -#endif -}; - -// pmcr_r - PMU register control -struct pmcr_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t cnt_en : 1; // Enable counter - uint32_t event_cnt_rst : 1; // Reset event counter - uint32_t cycle_cnt_rst : 1; // Reset cycle counter - uint32_t mask_en : 1; // PMU can be enabled/disabled by command stream operation NPU_OP_PMU_MASK - uint32_t reserved0 : 7; - uint32_t num_event_cnt : 5; // Number of event counters - uint32_t reserved1 : 16; - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR pmcr_r() : - word0(16384) - {} - CONSTEXPR pmcr_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - pmcr_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_cnt_en() const - { - auto v = ((1U << 1) - 1) & (word0 >> 0); - return v; - } - CONSTEXPR pmcr_r& set_cnt_en(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - CONSTEXPR uint32_t get_event_cnt_rst() const - { - auto v = ((1U << 1) - 1) & (word0 >> 1); - return v; - } - CONSTEXPR pmcr_r& set_event_cnt_rst(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - CONSTEXPR uint32_t get_cycle_cnt_rst() const - { - auto v = ((1U << 1) - 1) & (word0 >> 2); - return v; - } - CONSTEXPR pmcr_r& set_cycle_cnt_rst(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - CONSTEXPR uint32_t get_mask_en() const - { - auto v = ((1U << 1) - 1) & (word0 >> 3); - return v; - } - CONSTEXPR pmcr_r& set_mask_en(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - CONSTEXPR uint32_t get_num_event_cnt() const - { - auto v = ((1U << 5) - 1) & (word0 >> 11); - return v; - } - CONSTEXPR pmcr_r& set_num_event_cnt(uint32_t value) - { - word0 = (~(((1U << 5) - 1)<<11) & word0) | ((((1U << 5) - 1) & value) << 11); - return *this; - } -#endif -}; - -// pmcntenset_r - Count enable set register -struct pmcntenset_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t EVENT_CNT_0 : 1; // Event counter enable bit for PMEVCNTR0 - uint32_t EVENT_CNT_1 : 1; // Event counter enable bit for PMEVCNTR1 - uint32_t EVENT_CNT_2 : 1; // Event counter enable bit for PMEVCNTR2 - uint32_t EVENT_CNT_3 : 1; // Event counter enable bit for PMEVCNTR3 - uint32_t EVENT_CNT_4 : 1; // Event counter enable bit for PMEVCNTR4 - uint32_t EVENT_CNT_5 : 1; // Event counter enable bit for PMEVCNTR5 - uint32_t EVENT_CNT_6 : 1; // Event counter enable bit for PMEVCNTR6 - uint32_t EVENT_CNT_7 : 1; // Event counter enable bit for PMEVCNTR7 - uint32_t reserved0 : 23; - uint32_t CYCLE_CNT : 1; // PMCCNTR enable bit - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR pmcntenset_r() : - word0(0) - {} - CONSTEXPR pmcntenset_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - pmcntenset_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_0() const - { - auto v = ((1U << 1) - 1) & (word0 >> 0); - return v; - } - CONSTEXPR pmcntenset_r& set_EVENT_CNT_0(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_1() const - { - auto v = ((1U << 1) - 1) & (word0 >> 1); - return v; - } - CONSTEXPR pmcntenset_r& set_EVENT_CNT_1(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_2() const - { - auto v = ((1U << 1) - 1) & (word0 >> 2); - return v; - } - CONSTEXPR pmcntenset_r& set_EVENT_CNT_2(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_3() const - { - auto v = ((1U << 1) - 1) & (word0 >> 3); - return v; - } - CONSTEXPR pmcntenset_r& set_EVENT_CNT_3(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_4() const - { - auto v = ((1U << 1) - 1) & (word0 >> 4); - return v; - } - CONSTEXPR pmcntenset_r& set_EVENT_CNT_4(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<4) & word0) | ((((1U << 1) - 1) & value) << 4); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_5() const - { - auto v = ((1U << 1) - 1) & (word0 >> 5); - return v; - } - CONSTEXPR pmcntenset_r& set_EVENT_CNT_5(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<5) & word0) | ((((1U << 1) - 1) & value) << 5); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_6() const - { - auto v = ((1U << 1) - 1) & (word0 >> 6); - return v; - } - CONSTEXPR pmcntenset_r& set_EVENT_CNT_6(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<6) & word0) | ((((1U << 1) - 1) & value) << 6); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_7() const - { - auto v = ((1U << 1) - 1) & (word0 >> 7); - return v; - } - CONSTEXPR pmcntenset_r& set_EVENT_CNT_7(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<7) & word0) | ((((1U << 1) - 1) & value) << 7); - return *this; - } - CONSTEXPR uint32_t get_CYCLE_CNT() const - { - auto v = ((1U << 1) - 1) & (word0 >> 31); - return v; - } - CONSTEXPR pmcntenset_r& set_CYCLE_CNT(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<31) & word0) | ((((1U << 1) - 1) & value) << 31); - return *this; - } -#endif -}; - -// pmcntenclr_r - Count enable clear register -struct pmcntenclr_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t EVENT_CNT_0 : 1; // Event counter disable bit for PMEVCNTR0 - uint32_t EVENT_CNT_1 : 1; // Event counter disable bit for PMEVCNTR1 - uint32_t EVENT_CNT_2 : 1; // Event counter disable bit for PMEVCNTR2 - uint32_t EVENT_CNT_3 : 1; // Event counter disable bit for PMEVCNTR3 - uint32_t EVENT_CNT_4 : 1; // Event counter disable bit for PMEVCNTR4 - uint32_t EVENT_CNT_5 : 1; // Event counter disable bit for PMEVCNTR5 - uint32_t EVENT_CNT_6 : 1; // Event counter disable bit for PMEVCNTR6 - uint32_t EVENT_CNT_7 : 1; // Event counter disable bit for PMEVCNTR7 - uint32_t reserved0 : 23; - uint32_t CYCLE_CNT : 1; // PMCCNTR disable bit - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR pmcntenclr_r() : - word0(0) - {} - CONSTEXPR pmcntenclr_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - pmcntenclr_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_0() const - { - auto v = ((1U << 1) - 1) & (word0 >> 0); - return v; - } - CONSTEXPR pmcntenclr_r& set_EVENT_CNT_0(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_1() const - { - auto v = ((1U << 1) - 1) & (word0 >> 1); - return v; - } - CONSTEXPR pmcntenclr_r& set_EVENT_CNT_1(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_2() const - { - auto v = ((1U << 1) - 1) & (word0 >> 2); - return v; - } - CONSTEXPR pmcntenclr_r& set_EVENT_CNT_2(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_3() const - { - auto v = ((1U << 1) - 1) & (word0 >> 3); - return v; - } - CONSTEXPR pmcntenclr_r& set_EVENT_CNT_3(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_4() const - { - auto v = ((1U << 1) - 1) & (word0 >> 4); - return v; - } - CONSTEXPR pmcntenclr_r& set_EVENT_CNT_4(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<4) & word0) | ((((1U << 1) - 1) & value) << 4); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_5() const - { - auto v = ((1U << 1) - 1) & (word0 >> 5); - return v; - } - CONSTEXPR pmcntenclr_r& set_EVENT_CNT_5(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<5) & word0) | ((((1U << 1) - 1) & value) << 5); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_6() const - { - auto v = ((1U << 1) - 1) & (word0 >> 6); - return v; - } - CONSTEXPR pmcntenclr_r& set_EVENT_CNT_6(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<6) & word0) | ((((1U << 1) - 1) & value) << 6); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_7() const - { - auto v = ((1U << 1) - 1) & (word0 >> 7); - return v; - } - CONSTEXPR pmcntenclr_r& set_EVENT_CNT_7(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<7) & word0) | ((((1U << 1) - 1) & value) << 7); - return *this; - } - CONSTEXPR uint32_t get_CYCLE_CNT() const - { - auto v = ((1U << 1) - 1) & (word0 >> 31); - return v; - } - CONSTEXPR pmcntenclr_r& set_CYCLE_CNT(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<31) & word0) | ((((1U << 1) - 1) & value) << 31); - return *this; - } -#endif -}; - -// pmovsset_r - Overflow flag status set register -struct pmovsset_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t EVENT_CNT_0_OVF : 1; // Event counter overflow set bit for PMEVCNTR0 - uint32_t EVENT_CNT_1_OVF : 1; // Event counter overflow set bit for PMEVCNTR1 - uint32_t EVENT_CNT_2_OVF : 1; // Event counter overflow set bit for PMEVCNTR2 - uint32_t EVENT_CNT_3_OVF : 1; // Event counter overflow set bit for PMEVCNTR3 - uint32_t EVENT_CNT_4_OVF : 1; // Event counter overflow set bit for PMEVCNTR4 - uint32_t EVENT_CNT_5_OVF : 1; // Event counter overflow set bit for PMEVCNTR5 - uint32_t EVENT_CNT_6_OVF : 1; // Event counter overflow set bit for PMEVCNTR6 - uint32_t EVENT_CNT_7_OVF : 1; // Event counter overflow set bit for PMEVCNTR7 - uint32_t reserved0 : 23; - uint32_t CYCLE_CNT_OVF : 1; // PMCCNTR overflow set bit - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR pmovsset_r() : - word0(0) - {} - CONSTEXPR pmovsset_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - pmovsset_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_0_OVF() const - { - auto v = ((1U << 1) - 1) & (word0 >> 0); - return v; - } - CONSTEXPR pmovsset_r& set_EVENT_CNT_0_OVF(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_1_OVF() const - { - auto v = ((1U << 1) - 1) & (word0 >> 1); - return v; - } - CONSTEXPR pmovsset_r& set_EVENT_CNT_1_OVF(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_2_OVF() const - { - auto v = ((1U << 1) - 1) & (word0 >> 2); - return v; - } - CONSTEXPR pmovsset_r& set_EVENT_CNT_2_OVF(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_3_OVF() const - { - auto v = ((1U << 1) - 1) & (word0 >> 3); - return v; - } - CONSTEXPR pmovsset_r& set_EVENT_CNT_3_OVF(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_4_OVF() const - { - auto v = ((1U << 1) - 1) & (word0 >> 4); - return v; - } - CONSTEXPR pmovsset_r& set_EVENT_CNT_4_OVF(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<4) & word0) | ((((1U << 1) - 1) & value) << 4); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_5_OVF() const - { - auto v = ((1U << 1) - 1) & (word0 >> 5); - return v; - } - CONSTEXPR pmovsset_r& set_EVENT_CNT_5_OVF(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<5) & word0) | ((((1U << 1) - 1) & value) << 5); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_6_OVF() const - { - auto v = ((1U << 1) - 1) & (word0 >> 6); - return v; - } - CONSTEXPR pmovsset_r& set_EVENT_CNT_6_OVF(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<6) & word0) | ((((1U << 1) - 1) & value) << 6); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_7_OVF() const - { - auto v = ((1U << 1) - 1) & (word0 >> 7); - return v; - } - CONSTEXPR pmovsset_r& set_EVENT_CNT_7_OVF(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<7) & word0) | ((((1U << 1) - 1) & value) << 7); - return *this; - } - CONSTEXPR uint32_t get_CYCLE_CNT_OVF() const - { - auto v = ((1U << 1) - 1) & (word0 >> 31); - return v; - } - CONSTEXPR pmovsset_r& set_CYCLE_CNT_OVF(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<31) & word0) | ((((1U << 1) - 1) & value) << 31); - return *this; - } -#endif -}; - -// pmovsclr_r - Overflow flag status clear register -struct pmovsclr_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t EVENT_CNT_0_OVF : 1; // Event counter overflow clear bit for PMEVCNTR0 - uint32_t EVENT_CNT_1_OVF : 1; // Event counter overflow clear bit for PMEVCNTR1 - uint32_t EVENT_CNT_2_OVF : 1; // Event counter overflow clear bit for PMEVCNTR2 - uint32_t EVENT_CNT_3_OVF : 1; // Event counter overflow clear bit for PMEVCNTR3 - uint32_t EVENT_CNT_4_OVF : 1; // Event counter overflow clear bit for PMEVCNTR4 - uint32_t EVENT_CNT_5_OVF : 1; // Event counter overflow clear bit for PMEVCNTR5 - uint32_t EVENT_CNT_6_OVF : 1; // Event counter overflow clear bit for PMEVCNTR6 - uint32_t EVENT_CNT_7_OVF : 1; // Event counter overflow clear bit for PMEVCNTR7 - uint32_t reserved0 : 23; - uint32_t CYCLE_CNT_OVF : 1; // PMCCNTR overflow clear bit - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR pmovsclr_r() : - word0(0) - {} - CONSTEXPR pmovsclr_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - pmovsclr_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_0_OVF() const - { - auto v = ((1U << 1) - 1) & (word0 >> 0); - return v; - } - CONSTEXPR pmovsclr_r& set_EVENT_CNT_0_OVF(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_1_OVF() const - { - auto v = ((1U << 1) - 1) & (word0 >> 1); - return v; - } - CONSTEXPR pmovsclr_r& set_EVENT_CNT_1_OVF(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_2_OVF() const - { - auto v = ((1U << 1) - 1) & (word0 >> 2); - return v; - } - CONSTEXPR pmovsclr_r& set_EVENT_CNT_2_OVF(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_3_OVF() const - { - auto v = ((1U << 1) - 1) & (word0 >> 3); - return v; - } - CONSTEXPR pmovsclr_r& set_EVENT_CNT_3_OVF(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_4_OVF() const - { - auto v = ((1U << 1) - 1) & (word0 >> 4); - return v; - } - CONSTEXPR pmovsclr_r& set_EVENT_CNT_4_OVF(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<4) & word0) | ((((1U << 1) - 1) & value) << 4); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_5_OVF() const - { - auto v = ((1U << 1) - 1) & (word0 >> 5); - return v; - } - CONSTEXPR pmovsclr_r& set_EVENT_CNT_5_OVF(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<5) & word0) | ((((1U << 1) - 1) & value) << 5); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_6_OVF() const - { - auto v = ((1U << 1) - 1) & (word0 >> 6); - return v; - } - CONSTEXPR pmovsclr_r& set_EVENT_CNT_6_OVF(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<6) & word0) | ((((1U << 1) - 1) & value) << 6); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_7_OVF() const - { - auto v = ((1U << 1) - 1) & (word0 >> 7); - return v; - } - CONSTEXPR pmovsclr_r& set_EVENT_CNT_7_OVF(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<7) & word0) | ((((1U << 1) - 1) & value) << 7); - return *this; - } - CONSTEXPR uint32_t get_CYCLE_CNT_OVF() const - { - auto v = ((1U << 1) - 1) & (word0 >> 31); - return v; - } - CONSTEXPR pmovsclr_r& set_CYCLE_CNT_OVF(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<31) & word0) | ((((1U << 1) - 1) & value) << 31); - return *this; - } -#endif -}; - -// pmintset_r - Interrupt enable set register -struct pmintset_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t EVENT_CNT_0_INT : 1; // Event counter overflow interrupt request enable bit for PMEVCNTR0 - uint32_t EVENT_CNT_1_INT : 1; // Event counter overflow interrupt request enable bit for PMEVCNTR1 - uint32_t EVENT_CNT_2_INT : 1; // Event counter overflow interrupt request enable bit for PMEVCNTR2 - uint32_t EVENT_CNT_3_INT : 1; // Event counter overflow interrupt request enable bit for PMEVCNTR3 - uint32_t EVENT_CNT_4_INT : 1; // Event counter overflow interrupt request enable bit for PMEVCNTR4 - uint32_t EVENT_CNT_5_INT : 1; // Event counter overflow interrupt request enable bit for PMEVCNTR5 - uint32_t EVENT_CNT_6_INT : 1; // Event counter overflow interrupt request enable bit for PMEVCNTR6 - uint32_t EVENT_CNT_7_INT : 1; // Event counter overflow interrupt request enable bit for PMEVCNTR7 - uint32_t reserved0 : 23; - uint32_t CYCLE_CNT_INT : 1; // PMCCNTR overflow interrupt request enable bit - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR pmintset_r() : - word0(0) - {} - CONSTEXPR pmintset_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - pmintset_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_0_INT() const - { - auto v = ((1U << 1) - 1) & (word0 >> 0); - return v; - } - CONSTEXPR pmintset_r& set_EVENT_CNT_0_INT(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_1_INT() const - { - auto v = ((1U << 1) - 1) & (word0 >> 1); - return v; - } - CONSTEXPR pmintset_r& set_EVENT_CNT_1_INT(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_2_INT() const - { - auto v = ((1U << 1) - 1) & (word0 >> 2); - return v; - } - CONSTEXPR pmintset_r& set_EVENT_CNT_2_INT(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_3_INT() const - { - auto v = ((1U << 1) - 1) & (word0 >> 3); - return v; - } - CONSTEXPR pmintset_r& set_EVENT_CNT_3_INT(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_4_INT() const - { - auto v = ((1U << 1) - 1) & (word0 >> 4); - return v; - } - CONSTEXPR pmintset_r& set_EVENT_CNT_4_INT(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<4) & word0) | ((((1U << 1) - 1) & value) << 4); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_5_INT() const - { - auto v = ((1U << 1) - 1) & (word0 >> 5); - return v; - } - CONSTEXPR pmintset_r& set_EVENT_CNT_5_INT(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<5) & word0) | ((((1U << 1) - 1) & value) << 5); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_6_INT() const - { - auto v = ((1U << 1) - 1) & (word0 >> 6); - return v; - } - CONSTEXPR pmintset_r& set_EVENT_CNT_6_INT(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<6) & word0) | ((((1U << 1) - 1) & value) << 6); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_7_INT() const - { - auto v = ((1U << 1) - 1) & (word0 >> 7); - return v; - } - CONSTEXPR pmintset_r& set_EVENT_CNT_7_INT(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<7) & word0) | ((((1U << 1) - 1) & value) << 7); - return *this; - } - CONSTEXPR uint32_t get_CYCLE_CNT_INT() const - { - auto v = ((1U << 1) - 1) & (word0 >> 31); - return v; - } - CONSTEXPR pmintset_r& set_CYCLE_CNT_INT(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<31) & word0) | ((((1U << 1) - 1) & value) << 31); - return *this; - } -#endif -}; - -// pmintclr_r - Interrupt enable clear register -struct pmintclr_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t EVENT_CNT_0_INT : 1; // Event counter overflow interrupt request disable bit for PMEVCNTR0 - uint32_t EVENT_CNT_1_INT : 1; // Event counter overflow interrupt request disable bit for PMEVCNTR1 - uint32_t EVENT_CNT_2_INT : 1; // Event counter overflow interrupt request disable bit for PMEVCNTR2 - uint32_t EVENT_CNT_3_INT : 1; // Event counter overflow interrupt request disable bit for PMEVCNTR3 - uint32_t EVENT_CNT_4_INT : 1; // Event counter overflow interrupt request disable bit for PMEVCNTR4 - uint32_t EVENT_CNT_5_INT : 1; // Event counter overflow interrupt request disable bit for PMEVCNTR5 - uint32_t EVENT_CNT_6_INT : 1; // Event counter overflow interrupt request disable bit for PMEVCNTR6 - uint32_t EVENT_CNT_7_INT : 1; // Event counter overflow interrupt request disable bit for PMEVCNTR7 - uint32_t reserved0 : 23; - uint32_t CYCLE_CNT_INT : 1; // PMCCNTR overflow interrupt request disable bit - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR pmintclr_r() : - word0(0) - {} - CONSTEXPR pmintclr_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - pmintclr_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_0_INT() const - { - auto v = ((1U << 1) - 1) & (word0 >> 0); - return v; - } - CONSTEXPR pmintclr_r& set_EVENT_CNT_0_INT(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_1_INT() const - { - auto v = ((1U << 1) - 1) & (word0 >> 1); - return v; - } - CONSTEXPR pmintclr_r& set_EVENT_CNT_1_INT(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<1) & word0) | ((((1U << 1) - 1) & value) << 1); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_2_INT() const - { - auto v = ((1U << 1) - 1) & (word0 >> 2); - return v; - } - CONSTEXPR pmintclr_r& set_EVENT_CNT_2_INT(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<2) & word0) | ((((1U << 1) - 1) & value) << 2); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_3_INT() const - { - auto v = ((1U << 1) - 1) & (word0 >> 3); - return v; - } - CONSTEXPR pmintclr_r& set_EVENT_CNT_3_INT(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<3) & word0) | ((((1U << 1) - 1) & value) << 3); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_4_INT() const - { - auto v = ((1U << 1) - 1) & (word0 >> 4); - return v; - } - CONSTEXPR pmintclr_r& set_EVENT_CNT_4_INT(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<4) & word0) | ((((1U << 1) - 1) & value) << 4); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_5_INT() const - { - auto v = ((1U << 1) - 1) & (word0 >> 5); - return v; - } - CONSTEXPR pmintclr_r& set_EVENT_CNT_5_INT(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<5) & word0) | ((((1U << 1) - 1) & value) << 5); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_6_INT() const - { - auto v = ((1U << 1) - 1) & (word0 >> 6); - return v; - } - CONSTEXPR pmintclr_r& set_EVENT_CNT_6_INT(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<6) & word0) | ((((1U << 1) - 1) & value) << 6); - return *this; - } - CONSTEXPR uint32_t get_EVENT_CNT_7_INT() const - { - auto v = ((1U << 1) - 1) & (word0 >> 7); - return v; - } - CONSTEXPR pmintclr_r& set_EVENT_CNT_7_INT(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<7) & word0) | ((((1U << 1) - 1) & value) << 7); - return *this; - } - CONSTEXPR uint32_t get_CYCLE_CNT_INT() const - { - auto v = ((1U << 1) - 1) & (word0 >> 31); - return v; - } - CONSTEXPR pmintclr_r& set_CYCLE_CNT_INT(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<31) & word0) | ((((1U << 1) - 1) & value) << 31); - return *this; - } -#endif -}; - -// pmccntr_r - Performance monitor cycle count register -struct pmccntr_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t CYCLE_CNT_LO : 32; // Cycle count - LSB - uint32_t CYCLE_CNT_HI : 16; // Cycle count - MSB - uint32_t reserved0 : 16; - }; - uint32_t word[2]; - }; -#else -private: - uint32_t word0; - uint32_t word1; -public: - CONSTEXPR pmccntr_r() : - word0(0), - word1(0) - {} - CONSTEXPR pmccntr_r(uint64_t init) : - word0(static_cast((init) & static_cast(std::numeric_limits::max()))), - word1(static_cast((init >> 32) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR void operator=(uint64_t value) - { - word0 = static_cast((value) & static_cast(std::numeric_limits::max())); word1 = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); - } - CONSTEXPR operator uint64_t() - { - return (static_cast(word1) << 32) | word0; - } - pmccntr_r copy() - { - return *this; - } -#endif -}; - -// pmccntr_cfg_r - Set start/stop event on the cycle counter -struct pmccntr_cfg_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t CYCLE_CNT_CFG_START : 10; // Cycle counter start event - uint32_t reserved0 : 2; - uint32_t S0 : 1; // Start disabled for AXI port 0 - uint32_t S1 : 1; // Start disabled for AXI port 1 - uint32_t S2 : 1; // Start disabled for AXI port 2 - uint32_t S3 : 1; // Start disabled for AXI port 3 - uint32_t CYCLE_CNT_CFG_STOP : 10; // Cycle counter stop event - uint32_t reserved1 : 2; - uint32_t E0 : 1; // End disabled for AXI port 0 - uint32_t E1 : 1; // End disabled for AXI port 1 - uint32_t E2 : 1; // End disabled for AXI port 2 - uint32_t E3 : 1; // End disabled for AXI port 3 - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR pmccntr_cfg_r() : - word0(0) - {} - CONSTEXPR pmccntr_cfg_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - pmccntr_cfg_r copy() - { - return *this; - } - CONSTEXPR NPU_NAMESPACE::pmu_event get_CYCLE_CNT_CFG_START() const - { - auto v = ((1U << 10) - 1) & (word0 >> 0); - assert(v <= 671); - return static_cast(v); - } - CONSTEXPR pmccntr_cfg_r& set_CYCLE_CNT_CFG_START(NPU_NAMESPACE::pmu_event value) - { - word0 = (~(((1U << 10) - 1)<<0) & word0) | ((((1U << 10) - 1) & static_cast(value)) << 0); - return *this; - } - CONSTEXPR NPU_NAMESPACE::pmu_port_disable get_S0() const - { - auto v = ((1U << 1) - 1) & (word0 >> 12); - assert(v <= 1); - return static_cast(v); - } - CONSTEXPR pmccntr_cfg_r& set_S0(NPU_NAMESPACE::pmu_port_disable value) - { - word0 = (~(((1U << 1) - 1)<<12) & word0) | ((((1U << 1) - 1) & static_cast(value)) << 12); - return *this; - } - CONSTEXPR NPU_NAMESPACE::pmu_port_disable get_S1() const - { - auto v = ((1U << 1) - 1) & (word0 >> 13); - assert(v <= 1); - return static_cast(v); - } - CONSTEXPR pmccntr_cfg_r& set_S1(NPU_NAMESPACE::pmu_port_disable value) - { - word0 = (~(((1U << 1) - 1)<<13) & word0) | ((((1U << 1) - 1) & static_cast(value)) << 13); - return *this; - } - CONSTEXPR NPU_NAMESPACE::pmu_port_disable get_S2() const - { - auto v = ((1U << 1) - 1) & (word0 >> 14); - assert(v <= 1); - return static_cast(v); - } - CONSTEXPR pmccntr_cfg_r& set_S2(NPU_NAMESPACE::pmu_port_disable value) - { - word0 = (~(((1U << 1) - 1)<<14) & word0) | ((((1U << 1) - 1) & static_cast(value)) << 14); - return *this; - } - CONSTEXPR NPU_NAMESPACE::pmu_port_disable get_S3() const - { - auto v = ((1U << 1) - 1) & (word0 >> 15); - assert(v <= 1); - return static_cast(v); - } - CONSTEXPR pmccntr_cfg_r& set_S3(NPU_NAMESPACE::pmu_port_disable value) - { - word0 = (~(((1U << 1) - 1)<<15) & word0) | ((((1U << 1) - 1) & static_cast(value)) << 15); - return *this; - } - CONSTEXPR NPU_NAMESPACE::pmu_event get_CYCLE_CNT_CFG_STOP() const - { - auto v = ((1U << 10) - 1) & (word0 >> 16); - assert(v <= 671); - return static_cast(v); - } - CONSTEXPR pmccntr_cfg_r& set_CYCLE_CNT_CFG_STOP(NPU_NAMESPACE::pmu_event value) - { - word0 = (~(((1U << 10) - 1)<<16) & word0) | ((((1U << 10) - 1) & static_cast(value)) << 16); - return *this; - } - CONSTEXPR NPU_NAMESPACE::pmu_port_disable get_E0() const - { - auto v = ((1U << 1) - 1) & (word0 >> 28); - assert(v <= 1); - return static_cast(v); - } - CONSTEXPR pmccntr_cfg_r& set_E0(NPU_NAMESPACE::pmu_port_disable value) - { - word0 = (~(((1U << 1) - 1)<<28) & word0) | ((((1U << 1) - 1) & static_cast(value)) << 28); - return *this; - } - CONSTEXPR NPU_NAMESPACE::pmu_port_disable get_E1() const - { - auto v = ((1U << 1) - 1) & (word0 >> 29); - assert(v <= 1); - return static_cast(v); - } - CONSTEXPR pmccntr_cfg_r& set_E1(NPU_NAMESPACE::pmu_port_disable value) - { - word0 = (~(((1U << 1) - 1)<<29) & word0) | ((((1U << 1) - 1) & static_cast(value)) << 29); - return *this; - } - CONSTEXPR NPU_NAMESPACE::pmu_port_disable get_E2() const - { - auto v = ((1U << 1) - 1) & (word0 >> 30); - assert(v <= 1); - return static_cast(v); - } - CONSTEXPR pmccntr_cfg_r& set_E2(NPU_NAMESPACE::pmu_port_disable value) - { - word0 = (~(((1U << 1) - 1)<<30) & word0) | ((((1U << 1) - 1) & static_cast(value)) << 30); - return *this; - } - CONSTEXPR NPU_NAMESPACE::pmu_port_disable get_E3() const - { - auto v = ((1U << 1) - 1) & (word0 >> 31); - assert(v <= 1); - return static_cast(v); - } - CONSTEXPR pmccntr_cfg_r& set_E3(NPU_NAMESPACE::pmu_port_disable value) - { - word0 = (~(((1U << 1) - 1)<<31) & word0) | ((((1U << 1) - 1) & static_cast(value)) << 31); - return *this; - } -#endif -}; - -// pmcaxi_chan_r - Set which AXI channel to monitor for latency measurements in PMU -struct pmcaxi_chan_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t CH_SEL : 4; // Channel select for latency measurements - uint32_t reserved0 : 4; - uint32_t AXI_SEL : 1; // AXI port select for latency measurements - uint32_t reserved1 : 1; - uint32_t BW_CH_SEL_EN : 1; // Bandwidth channel selector - uint32_t reserved2 : 21; - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR pmcaxi_chan_r() : - word0(0) - {} - CONSTEXPR pmcaxi_chan_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - pmcaxi_chan_r copy() - { - return *this; - } - CONSTEXPR NPU_NAMESPACE::pmu_axi_channel get_CH_SEL() const - { - auto v = ((1U << 4) - 1) & (word0 >> 0); - assert(v <= 9); - return static_cast(v); - } - CONSTEXPR pmcaxi_chan_r& set_CH_SEL(NPU_NAMESPACE::pmu_axi_channel value) - { - word0 = (~(((1U << 4) - 1)<<0) & word0) | ((((1U << 4) - 1) & static_cast(value)) << 0); - return *this; - } - CONSTEXPR NPU_NAMESPACE::axi_port get_AXI_SEL() const - { - auto v = ((1U << 1) - 1) & (word0 >> 8); - assert(v <= 1); - return static_cast(v); - } - CONSTEXPR pmcaxi_chan_r& set_AXI_SEL(NPU_NAMESPACE::axi_port value) - { - word0 = (~(((1U << 1) - 1)<<8) & word0) | ((((1U << 1) - 1) & static_cast(value)) << 8); - return *this; - } - CONSTEXPR uint32_t get_BW_CH_SEL_EN() const - { - auto v = ((1U << 1) - 1) & (word0 >> 10); - return v; - } - CONSTEXPR pmcaxi_chan_r& set_BW_CH_SEL_EN(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<10) & word0) | ((((1U << 1) - 1) & value) << 10); - return *this; - } -#endif -}; - -// pmclut_r - Performance monitor control for lookup table -struct pmclut_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t PCM_LUT_EN_0 : 1; // PMU lookup table enable for event counter 0 - uint32_t reserved0 : 15; - uint32_t PMC_LUT_0 : 16; // PMU lookup table for event counter 0 - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR pmclut_r() : - word0(0) - {} - CONSTEXPR pmclut_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - pmclut_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_PCM_LUT_EN_0() const - { - auto v = ((1U << 1) - 1) & (word0 >> 0); - return v; - } - CONSTEXPR pmclut_r& set_PCM_LUT_EN_0(uint32_t value) - { - word0 = (~(((1U << 1) - 1)<<0) & word0) | ((((1U << 1) - 1) & value) << 0); - return *this; - } - CONSTEXPR uint32_t get_PMC_LUT_0() const - { - auto v = ((1U << 16) - 1) & (word0 >> 16); - return v; - } - CONSTEXPR pmclut_r& set_PMC_LUT_0(uint32_t value) - { - word0 = (~(((1U << 16) - 1)<<16) & word0) | ((((1U << 16) - 1) & value) << 16); - return *this; - } -#endif -}; - -// pmevcntr_r - Performance monitor event 0 count register -struct pmevcntr_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t count : 32; // Count word - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR pmevcntr_r() : - word0(0) - {} - CONSTEXPR pmevcntr_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - pmevcntr_r copy() - { - return *this; - } - CONSTEXPR uint32_t get_count() const - { - auto v = word0; - return v; - } - CONSTEXPR pmevcntr_r& set_count(uint32_t value) - { - word0 = value; - return *this; - } -#endif -}; - -// pmevtyper_r - Performance monitor event type register 0 -struct pmevtyper_r -{ -#ifndef __cplusplus - union - { - struct - { - uint32_t EV_TYPE : 10; // Event Type - uint32_t reserved0 : 2; - uint32_t D0 : 1; // Counting disabled for AXI port 0 - uint32_t D1 : 1; // Counting disabled for AXI port 1 - uint32_t D2 : 1; // Counting disabled for AXI port 2 - uint32_t D3 : 1; // Counting disabled for AXI port 3 - uint32_t reserved1 : 16; - }; - uint32_t word; - }; -#else -private: - uint32_t word0; -public: - CONSTEXPR pmevtyper_r() : - word0(0) - {} - CONSTEXPR pmevtyper_r(uint32_t init) : - word0(init) - {} - CONSTEXPR void operator=(uint32_t value) - { - word0 = value; - } - CONSTEXPR operator uint32_t() - { - return word0; - } - pmevtyper_r copy() - { - return *this; - } - CONSTEXPR NPU_NAMESPACE::pmu_event get_EV_TYPE() const - { - auto v = ((1U << 10) - 1) & (word0 >> 0); - assert(v <= 671); - return static_cast(v); - } - CONSTEXPR pmevtyper_r& set_EV_TYPE(NPU_NAMESPACE::pmu_event value) - { - word0 = (~(((1U << 10) - 1)<<0) & word0) | ((((1U << 10) - 1) & static_cast(value)) << 0); - return *this; - } - CONSTEXPR NPU_NAMESPACE::pmu_port_disable get_D0() const - { - auto v = ((1U << 1) - 1) & (word0 >> 12); - assert(v <= 1); - return static_cast(v); - } - CONSTEXPR pmevtyper_r& set_D0(NPU_NAMESPACE::pmu_port_disable value) - { - word0 = (~(((1U << 1) - 1)<<12) & word0) | ((((1U << 1) - 1) & static_cast(value)) << 12); - return *this; - } - CONSTEXPR NPU_NAMESPACE::pmu_port_disable get_D1() const - { - auto v = ((1U << 1) - 1) & (word0 >> 13); - assert(v <= 1); - return static_cast(v); - } - CONSTEXPR pmevtyper_r& set_D1(NPU_NAMESPACE::pmu_port_disable value) - { - word0 = (~(((1U << 1) - 1)<<13) & word0) | ((((1U << 1) - 1) & static_cast(value)) << 13); - return *this; - } - CONSTEXPR NPU_NAMESPACE::pmu_port_disable get_D2() const - { - auto v = ((1U << 1) - 1) & (word0 >> 14); - assert(v <= 1); - return static_cast(v); - } - CONSTEXPR pmevtyper_r& set_D2(NPU_NAMESPACE::pmu_port_disable value) - { - word0 = (~(((1U << 1) - 1)<<14) & word0) | ((((1U << 1) - 1) & static_cast(value)) << 14); - return *this; - } - CONSTEXPR NPU_NAMESPACE::pmu_port_disable get_D3() const - { - auto v = ((1U << 1) - 1) & (word0 >> 15); - assert(v <= 1); - return static_cast(v); - } - CONSTEXPR pmevtyper_r& set_D3(NPU_NAMESPACE::pmu_port_disable value) - { - word0 = (~(((1U << 1) - 1)<<15) & word0) | ((((1U << 1) - 1) & static_cast(value)) << 15); - return *this; - } -#endif -}; - -struct NPU_REG -{ - STRUCT id_r ID; // 0x0000 - STRUCT status_r STATUS; // 0x0004 - STRUCT cmd_r CMD; // 0x0008 - STRUCT reset_r RESET; // 0x000C - STRUCT qbase_r QBASE; // 0x0010 - STRUCT qread_r QREAD; // 0x0018 - STRUCT qconfig_r QCONFIG; // 0x001C - STRUCT qsize_r QSIZE; // 0x0020 - STRUCT prot_r PROT; // 0x0024 - STRUCT config_r CONFIG; // 0x0028 - uint32_t unused0[1]; - STRUCT cond_status_r COND_STATUS; // 0x0030 - uint32_t unused1[1]; - STRUCT power_ctrl_r POWER_CTRL; // 0x0038 - STRUCT regioncfg_r REGIONCFG; // 0x003C - STRUCT mem_attr_r MEM_ATTR[4]; // 0x0040 - STRUCT axi_sram_r AXI_SRAM; // 0x0050 - STRUCT axi_ext_r AXI_EXT; // 0x0054 - uint32_t unused2[2]; - STRUCT cfg_sram_cap_r CFG_SRAM_CAP; // 0x0060 - STRUCT cfg_ext_cap_r CFG_EXT_CAP; // 0x0064 - STRUCT cfg_sram_hash0_r CFG_SRAM_HASH0; // 0x0068 - STRUCT cfg_sram_hash1_r CFG_SRAM_HASH1; // 0x0070 - STRUCT cfg_ext_hash0_r CFG_EXT_HASH0; // 0x0078 - STRUCT basep_r BASEP[8]; // 0x0080 - uint32_t unused3[32]; - STRUCT clkforce_r CLKFORCE; // 0x0140 - STRUCT debug_address_r DEBUG_ADDRESS; // 0x0144 - STRUCT debug_misc_r DEBUG_MISC; // 0x0148 - uint32_t unused4[2]; - STRUCT feature_disable_r FEATURE_DISABLE; // 0x0154 - uint32_t unused5[58]; - STRUCT dma_ifm_src_r DMA_IFM_SRC; // 0x0240 - uint32_t unused6[2]; - STRUCT dma_ofm_dst_r DMA_OFM_DST; // 0x0250 - STRUCT dma_weight_src_r DMA_WEIGHT_SRC; // 0x0258 - STRUCT dma_cmd_src_r DMA_CMD_SRC; // 0x0260 - STRUCT dma_cmd_size_r DMA_CMD_SIZE; // 0x0268 - STRUCT dma_m2m_src_r DMA_M2M_SRC; // 0x026C - STRUCT dma_m2m_dst_r DMA_M2M_DST; // 0x0274 - STRUCT current_qread_r CURRENT_QREAD; // 0x027C - STRUCT dma_scale_src_r DMA_SCALE_SRC; // 0x0280 - STRUCT dma_weight1_src_r DMA_WEIGHT1_SRC; // 0x0288 - STRUCT dma_weight2_src_r DMA_WEIGHT2_SRC; // 0x0290 - STRUCT dma_weight3_src_r DMA_WEIGHT3_SRC; // 0x0298 - uint32_t unused7[6]; - STRUCT current_op_r CURRENT_OP; // 0x02B8 - STRUCT current_cmd_r CURRENT_CMD; // 0x02BC - uint32_t unused8[80]; - STRUCT internal_memory_r INTERNAL_MEMORY[256]; // 0x0400 - STRUCT ifm_pad_top_r IFM_PAD_TOP; // 0x0800 - STRUCT ifm_pad_left_r IFM_PAD_LEFT; // 0x0804 - STRUCT ifm_pad_right_r IFM_PAD_RIGHT; // 0x0808 - STRUCT ifm_pad_bottom_r IFM_PAD_BOTTOM; // 0x080C - STRUCT ifm_depth_m1_r IFM_DEPTH_M1; // 0x0810 - STRUCT ifm_precision_r IFM_PRECISION; // 0x0814 - uint32_t unused9[1]; - STRUCT ifm_upscale_r IFM_UPSCALE; // 0x081C - STRUCT ifm_broadcast_r IFM_BROADCAST; // 0x0820 - STRUCT ifm_zero_point_r IFM_ZERO_POINT; // 0x0824 - STRUCT ifm_width0_m1_r IFM_WIDTH0_M1; // 0x0828 - STRUCT ifm_height0_m1_r IFM_HEIGHT0_M1; // 0x082C - STRUCT ifm_height1_m1_r IFM_HEIGHT1_M1; // 0x0830 - uint32_t unused10[2]; - STRUCT ifm_region_r IFM_REGION; // 0x083C - uint32_t unused11[1]; - STRUCT ofm_width_m1_r OFM_WIDTH_M1; // 0x0844 - STRUCT ofm_height_m1_r OFM_HEIGHT_M1; // 0x0848 - STRUCT ofm_depth_m1_r OFM_DEPTH_M1; // 0x084C - STRUCT ofm_precision_r OFM_PRECISION; // 0x0850 - STRUCT ofm_blk_width_m1_r OFM_BLK_WIDTH_M1; // 0x0854 - STRUCT ofm_blk_height_m1_r OFM_BLK_HEIGHT_M1; // 0x0858 - STRUCT ofm_blk_depth_m1_r OFM_BLK_DEPTH_M1; // 0x085C - STRUCT ofm_zero_point_r OFM_ZERO_POINT; // 0x0860 - uint32_t unused12[1]; - STRUCT ofm_width0_m1_r OFM_WIDTH0_M1; // 0x0868 - STRUCT ofm_height0_m1_r OFM_HEIGHT0_M1; // 0x086C - STRUCT ofm_height1_m1_r OFM_HEIGHT1_M1; // 0x0870 - uint32_t unused13[2]; - STRUCT ofm_region_r OFM_REGION; // 0x087C - STRUCT kernel_width_m1_r KERNEL_WIDTH_M1; // 0x0880 - STRUCT kernel_height_m1_r KERNEL_HEIGHT_M1; // 0x0884 - STRUCT kernel_stride_r KERNEL_STRIDE; // 0x0888 - uint32_t unused14[1]; - STRUCT acc_format_r ACC_FORMAT; // 0x0890 - STRUCT activation_r ACTIVATION; // 0x0894 - STRUCT activation_min_r ACTIVATION_MIN; // 0x0898 - STRUCT activation_max_r ACTIVATION_MAX; // 0x089C - STRUCT weight_region_r WEIGHT_REGION; // 0x08A0 - STRUCT scale_region_r SCALE_REGION; // 0x08A4 - STRUCT resize_x_scale_n_m1_r RESIZE_X_SCALE_N_M1; // 0x08A8 - STRUCT resize_y_scale_n_m1_r RESIZE_Y_SCALE_N_M1; // 0x08AC - STRUCT resize_x_offset_r RESIZE_X_OFFSET; // 0x08B0 - STRUCT resize_y_offset_r RESIZE_Y_OFFSET; // 0x08B4 - STRUCT weight_format_r WEIGHT_FORMAT; // 0x08B8 - STRUCT blockdep_r BLOCKDEP; // 0x08BC - STRUCT dma0_src_region_r DMA0_SRC_REGION; // 0x08C0 - STRUCT dma0_dst_region_r DMA0_DST_REGION; // 0x08C4 - STRUCT dma0_size0_r DMA0_SIZE0; // 0x08C8 - STRUCT dma0_size1_r DMA0_SIZE1; // 0x08CC - STRUCT dma0_idx_region_r DMA0_IDX_REGION; // 0x08D0 - uint32_t unused15[11]; - STRUCT ifm2_broadcast_r IFM2_BROADCAST; // 0x0900 - uint32_t unused16[4]; - STRUCT ifm2_precision_r IFM2_PRECISION; // 0x0914 - uint32_t unused17[3]; - STRUCT ifm2_zero_point_r IFM2_ZERO_POINT; // 0x0924 - STRUCT ifm2_width0_m1_r IFM2_WIDTH0_M1; // 0x0928 - STRUCT ifm2_height0_m1_r IFM2_HEIGHT0_M1; // 0x092C - STRUCT ifm2_height1_m1_r IFM2_HEIGHT1_M1; // 0x0930 - uint32_t unused18[2]; - STRUCT ifm2_region_r IFM2_REGION; // 0x093C - uint32_t unused19[48]; - STRUCT ifm_base0_r IFM_BASE0; // 0x0A00 - STRUCT ifm_base1_r IFM_BASE1; // 0x0A08 - STRUCT ifm_base2_r IFM_BASE2; // 0x0A10 - STRUCT ifm_base3_r IFM_BASE3; // 0x0A18 - STRUCT ifm_stride_x_r IFM_STRIDE_X; // 0x0A20 - STRUCT ifm_stride_y_r IFM_STRIDE_Y; // 0x0A28 - STRUCT ifm_stride_c_r IFM_STRIDE_C; // 0x0A30 - uint32_t unused20[2]; - STRUCT ofm_base0_r OFM_BASE0; // 0x0A40 - STRUCT ofm_base1_r OFM_BASE1; // 0x0A48 - STRUCT ofm_base2_r OFM_BASE2; // 0x0A50 - STRUCT ofm_base3_r OFM_BASE3; // 0x0A58 - STRUCT ofm_stride_x_r OFM_STRIDE_X; // 0x0A60 - STRUCT ofm_stride_y_r OFM_STRIDE_Y; // 0x0A68 - STRUCT ofm_stride_c_r OFM_STRIDE_C; // 0x0A70 - uint32_t unused21[2]; - STRUCT weight_base_r WEIGHT_BASE; // 0x0A80 - STRUCT weight_length_r WEIGHT_LENGTH; // 0x0A88 - STRUCT scale_base_r SCALE_BASE; // 0x0A90 - STRUCT scale_length_r SCALE_LENGTH; // 0x0A98 - STRUCT ofm_scale_r OFM_SCALE; // 0x0AA0 - STRUCT ifm_scale_r IFM_SCALE; // 0x0AA8 - STRUCT ifm2_scale_r IFM2_SCALE; // 0x0AB0 - STRUCT op_scalar_r OP_SCALAR; // 0x0AB8 - STRUCT dma0_src_r DMA0_SRC; // 0x0AC0 - STRUCT dma0_dst_r DMA0_DST; // 0x0AC8 - STRUCT dma0_len_r DMA0_LEN; // 0x0AD0 - STRUCT dma0_src_stride0_r DMA0_SRC_STRIDE0; // 0x0AD8 - STRUCT dma0_src_stride1_r DMA0_SRC_STRIDE1; // 0x0AE0 - STRUCT dma0_dst_stride0_r DMA0_DST_STRIDE0; // 0x0AE8 - STRUCT dma0_dst_stride1_r DMA0_DST_STRIDE1; // 0x0AF0 - STRUCT dma0_idx_r DMA0_IDX; // 0x0AF8 - STRUCT ifm2_base0_r IFM2_BASE0; // 0x0B00 - STRUCT ifm2_base1_r IFM2_BASE1; // 0x0B08 - STRUCT ifm2_base2_r IFM2_BASE2; // 0x0B10 - STRUCT ifm2_base3_r IFM2_BASE3; // 0x0B18 - STRUCT ifm2_stride_x_r IFM2_STRIDE_X; // 0x0B20 - STRUCT ifm2_stride_y_r IFM2_STRIDE_Y; // 0x0B28 - STRUCT ifm2_stride_c_r IFM2_STRIDE_C; // 0x0B30 - uint32_t unused22[2]; - STRUCT weight1_base_r WEIGHT1_BASE; // 0x0B40 - STRUCT weight1_length_r WEIGHT1_LENGTH; // 0x0B48 - STRUCT weight2_base_r WEIGHT2_BASE; // 0x0B50 - STRUCT weight2_length_r WEIGHT2_LENGTH; // 0x0B58 - STRUCT weight3_base_r WEIGHT3_BASE; // 0x0B60 - STRUCT weight3_length_r WEIGHT3_LENGTH; // 0x0B68 - STRUCT resize_x_step_r RESIZE_X_STEP; // 0x0B70 - STRUCT resize_y_step_r RESIZE_Y_STEP; // 0x0B78 - uint32_t unused23[16]; - STRUCT dma0_idx_max_r DMA0_IDX_MAX; // 0x0BC0 - STRUCT dma0_idx_skip1_r DMA0_IDX_SKIP1; // 0x0BC8 - uint32_t unused24[252]; - STRUCT revision_r REVISION; // 0x0FC0 - uint32_t unused25[3]; - STRUCT pid4_r PID4; // 0x0FD0 - STRUCT pid5_r PID5; // 0x0FD4 - STRUCT pid6_r PID6; // 0x0FD8 - STRUCT pid7_r PID7; // 0x0FDC - STRUCT pid0_r PID0; // 0x0FE0 - STRUCT pid1_r PID1; // 0x0FE4 - STRUCT pid2_r PID2; // 0x0FE8 - STRUCT pid3_r PID3; // 0x0FEC - STRUCT cid0_r CID0; // 0x0FF0 - STRUCT cid1_r CID1; // 0x0FF4 - STRUCT cid2_r CID2; // 0x0FF8 - STRUCT cid3_r CID3; // 0x0FFC - uint32_t unused26[64]; - STRUCT wd_status_r WD_STATUS; // 0x1100 - STRUCT mac_status_r MAC_STATUS; // 0x1104 - STRUCT ao_status_r AO_STATUS; // 0x1108 - uint32_t unused27[1]; - STRUCT dma_status0_r DMA_STATUS0; // 0x1110 - STRUCT dma_status1_r DMA_STATUS1; // 0x1114 - uint32_t unused28[26]; - STRUCT pmcr_r PMCR; // 0x1180 - STRUCT pmcntenset_r PMCNTENSET; // 0x1184 - STRUCT pmcntenclr_r PMCNTENCLR; // 0x1188 - STRUCT pmovsset_r PMOVSSET; // 0x118C - STRUCT pmovsclr_r PMOVSCLR; // 0x1190 - STRUCT pmintset_r PMINTSET; // 0x1194 - STRUCT pmintclr_r PMINTCLR; // 0x1198 - uint32_t unused29[1]; - STRUCT pmccntr_r PMCCNTR; // 0x11A0 - STRUCT pmccntr_cfg_r PMCCNTR_CFG; // 0x11A8 - STRUCT pmcaxi_chan_r PMCAXI_CHAN; // 0x11AC - STRUCT pmclut_r PMCLUT; // 0x11B0 - uint32_t unused30[83]; - STRUCT pmevcntr_r PMEVCNTR[8]; // 0x1300 - uint32_t unused31[24]; - STRUCT pmevtyper_r PMEVTYPER[8]; // 0x1380 - -#ifdef __cplusplus - enum class access_type_t : uint8_t { RW, RO, WO }; - NPU_REG() - { - reset(); - } - void reset() - { - ID = 536899585; - STATUS = 8; - CMD = 12; - RESET = 0; - QBASE = 0; - QREAD = 0; - QCONFIG = 0; - QSIZE = 0; - PROT = 0; - CONFIG = 536870928; - COND_STATUS = 0; - POWER_CTRL = 0; - REGIONCFG = 0; - for (size_t i = 0; i < (sizeof(MEM_ATTR) / sizeof(MEM_ATTR[0])); ++i) - MEM_ATTR[i] = 0; - AXI_SRAM = 0; - AXI_EXT = 0; - CFG_SRAM_CAP = 0; - CFG_EXT_CAP = 0; - CFG_SRAM_HASH0 = 0; - CFG_SRAM_HASH1 = 0; - CFG_EXT_HASH0 = 0; - for (size_t i = 0; i < (sizeof(BASEP) / sizeof(BASEP[0])); ++i) - BASEP[i] = 0; - CLKFORCE = 0; - DEBUG_ADDRESS = 0; - DEBUG_MISC = 0; - FEATURE_DISABLE = 0; - DMA_IFM_SRC = 0; - DMA_OFM_DST = 0; - DMA_WEIGHT_SRC = 0; - DMA_CMD_SRC = 0; - DMA_CMD_SIZE = 0; - DMA_M2M_SRC = 0; - DMA_M2M_DST = 0; - CURRENT_QREAD = 0; - DMA_SCALE_SRC = 0; - DMA_WEIGHT1_SRC = 0; - DMA_WEIGHT2_SRC = 0; - DMA_WEIGHT3_SRC = 0; - CURRENT_OP = 0; - CURRENT_CMD = 0; - for (size_t i = 0; i < (sizeof(INTERNAL_MEMORY) / sizeof(INTERNAL_MEMORY[0])); ++i) - INTERNAL_MEMORY[i] = 0; - IFM_PAD_TOP = 0; - IFM_PAD_LEFT = 0; - IFM_PAD_RIGHT = 0; - IFM_PAD_BOTTOM = 0; - IFM_DEPTH_M1 = 0; - IFM_PRECISION = 0; - IFM_UPSCALE = 0; - IFM_BROADCAST = 0; - IFM_ZERO_POINT = 0; - IFM_WIDTH0_M1 = 0; - IFM_HEIGHT0_M1 = 0; - IFM_HEIGHT1_M1 = 0; - IFM_REGION = 0; - OFM_WIDTH_M1 = 0; - OFM_HEIGHT_M1 = 0; - OFM_DEPTH_M1 = 0; - OFM_PRECISION = 0; - OFM_BLK_WIDTH_M1 = 0; - OFM_BLK_HEIGHT_M1 = 0; - OFM_BLK_DEPTH_M1 = 0; - OFM_ZERO_POINT = 0; - OFM_WIDTH0_M1 = 0; - OFM_HEIGHT0_M1 = 0; - OFM_HEIGHT1_M1 = 0; - OFM_REGION = 0; - KERNEL_WIDTH_M1 = 0; - KERNEL_HEIGHT_M1 = 0; - KERNEL_STRIDE = 0; - ACC_FORMAT = 0; - ACTIVATION = 0; - ACTIVATION_MIN = 0; - ACTIVATION_MAX = 0; - WEIGHT_REGION = 0; - SCALE_REGION = 0; - RESIZE_X_SCALE_N_M1 = 0; - RESIZE_Y_SCALE_N_M1 = 0; - RESIZE_X_OFFSET = 0; - RESIZE_Y_OFFSET = 0; - WEIGHT_FORMAT = 0; - BLOCKDEP = 0; - DMA0_SRC_REGION = 0; - DMA0_DST_REGION = 0; - DMA0_SIZE0 = 0; - DMA0_SIZE1 = 0; - DMA0_IDX_REGION = 0; - IFM2_BROADCAST = 0; - IFM2_PRECISION = 0; - IFM2_ZERO_POINT = 0; - IFM2_WIDTH0_M1 = 0; - IFM2_HEIGHT0_M1 = 0; - IFM2_HEIGHT1_M1 = 0; - IFM2_REGION = 0; - IFM_BASE0 = 0; - IFM_BASE1 = 0; - IFM_BASE2 = 0; - IFM_BASE3 = 0; - IFM_STRIDE_X = 0; - IFM_STRIDE_Y = 0; - IFM_STRIDE_C = 0; - OFM_BASE0 = 0; - OFM_BASE1 = 0; - OFM_BASE2 = 0; - OFM_BASE3 = 0; - OFM_STRIDE_X = 0; - OFM_STRIDE_Y = 0; - OFM_STRIDE_C = 0; - WEIGHT_BASE = 0; - WEIGHT_LENGTH = 0; - SCALE_BASE = 0; - SCALE_LENGTH = 0; - OFM_SCALE = 0; - IFM_SCALE = 0; - IFM2_SCALE = 0; - OP_SCALAR = 0; - DMA0_SRC = 0; - DMA0_DST = 0; - DMA0_LEN = 0; - DMA0_SRC_STRIDE0 = 0; - DMA0_SRC_STRIDE1 = 0; - DMA0_DST_STRIDE0 = 0; - DMA0_DST_STRIDE1 = 0; - DMA0_IDX = 0; - IFM2_BASE0 = 0; - IFM2_BASE1 = 0; - IFM2_BASE2 = 0; - IFM2_BASE3 = 0; - IFM2_STRIDE_X = 0; - IFM2_STRIDE_Y = 0; - IFM2_STRIDE_C = 0; - WEIGHT1_BASE = 0; - WEIGHT1_LENGTH = 0; - WEIGHT2_BASE = 0; - WEIGHT2_LENGTH = 0; - WEIGHT3_BASE = 0; - WEIGHT3_LENGTH = 0; - RESIZE_X_STEP = 0; - RESIZE_Y_STEP = 0; - DMA0_IDX_MAX = 0; - DMA0_IDX_SKIP1 = 0; - REVISION = 0; - PID4 = 4; - PID5 = 0; - PID6 = 0; - PID7 = 0; - PID0 = 130; - PID1 = 181; - PID2 = 11; - PID3 = 0; - CID0 = 13; - CID1 = 240; - CID2 = 5; - CID3 = 177; - WD_STATUS = 0; - MAC_STATUS = 0; - AO_STATUS = 0; - DMA_STATUS0 = 0; - DMA_STATUS1 = 0; - PMCR = 16384; - PMCNTENSET = 0; - PMCNTENCLR = 0; - PMOVSSET = 0; - PMOVSCLR = 0; - PMINTSET = 0; - PMINTCLR = 0; - PMCCNTR = 0; - PMCCNTR_CFG = 0; - PMCAXI_CHAN = 0; - PMCLUT = 0; - for (size_t i = 0; i < (sizeof(PMEVCNTR) / sizeof(PMEVCNTR[0])); ++i) - PMEVCNTR[i] = 0; - for (size_t i = 0; i < (sizeof(PMEVTYPER) / sizeof(PMEVTYPER[0])); ++i) - PMEVTYPER[i] = 0; - } - uint32_t& operator[](const int addr_offset) - { - return reinterpret_cast(this)[addr_offset / 4]; - } - access_type_t get_access_type(uint32_t offset) - { - switch (offset) - { - case 0: return access_type_t::RO; - case 4: return access_type_t::RO; - case 8: return access_type_t::RW; - case 12: return access_type_t::RW; - case 16: return access_type_t::RW; - case 24: return access_type_t::RO; - case 28: return access_type_t::RW; - case 32: return access_type_t::RW; - case 36: return access_type_t::RO; - case 40: return access_type_t::RO; - case 48: return access_type_t::RO; - case 56: return access_type_t::RW; - case 60: return access_type_t::RW; - case 64: return access_type_t::RW; - case 68: return access_type_t::RW; - case 72: return access_type_t::RW; - case 76: return access_type_t::RW; - case 80: return access_type_t::RW; - case 84: return access_type_t::RW; - case 96: return access_type_t::RO; - case 100: return access_type_t::RO; - case 104: return access_type_t::RO; - case 112: return access_type_t::RO; - case 120: return access_type_t::RO; - case 128: return access_type_t::RW; - case 136: return access_type_t::RW; - case 144: return access_type_t::RW; - case 152: return access_type_t::RW; - case 160: return access_type_t::RW; - case 168: return access_type_t::RW; - case 176: return access_type_t::RW; - case 184: return access_type_t::RW; - case 320: return access_type_t::RW; - case 324: return access_type_t::RW; - case 328: return access_type_t::RW; - case 340: return access_type_t::RW; - case 576: return access_type_t::RO; - case 592: return access_type_t::RO; - case 600: return access_type_t::RO; - case 608: return access_type_t::RO; - case 616: return access_type_t::RO; - case 620: return access_type_t::RO; - case 628: return access_type_t::RO; - case 636: return access_type_t::RO; - case 640: return access_type_t::RO; - case 648: return access_type_t::RO; - case 656: return access_type_t::RO; - case 664: return access_type_t::RO; - case 696: return access_type_t::RO; - case 700: return access_type_t::RO; - case 1024: return access_type_t::RW; - case 1028: return access_type_t::RW; - case 1032: return access_type_t::RW; - case 1036: return access_type_t::RW; - case 1040: return access_type_t::RW; - case 1044: return access_type_t::RW; - case 1048: return access_type_t::RW; - case 1052: return access_type_t::RW; - case 1056: return access_type_t::RW; - case 1060: return access_type_t::RW; - case 1064: return access_type_t::RW; - case 1068: return access_type_t::RW; - case 1072: return access_type_t::RW; - case 1076: return access_type_t::RW; - case 1080: return access_type_t::RW; - case 1084: return access_type_t::RW; - case 1088: return access_type_t::RW; - case 1092: return access_type_t::RW; - case 1096: return access_type_t::RW; - case 1100: return access_type_t::RW; - case 1104: return access_type_t::RW; - case 1108: return access_type_t::RW; - case 1112: return access_type_t::RW; - case 1116: return access_type_t::RW; - case 1120: return access_type_t::RW; - case 1124: return access_type_t::RW; - case 1128: return access_type_t::RW; - case 1132: return access_type_t::RW; - case 1136: return access_type_t::RW; - case 1140: return access_type_t::RW; - case 1144: return access_type_t::RW; - case 1148: return access_type_t::RW; - case 1152: return access_type_t::RW; - case 1156: return access_type_t::RW; - case 1160: return access_type_t::RW; - case 1164: return access_type_t::RW; - case 1168: return access_type_t::RW; - case 1172: return access_type_t::RW; - case 1176: return access_type_t::RW; - case 1180: return access_type_t::RW; - case 1184: return access_type_t::RW; - case 1188: return access_type_t::RW; - case 1192: return access_type_t::RW; - case 1196: return access_type_t::RW; - case 1200: return access_type_t::RW; - case 1204: return access_type_t::RW; - case 1208: return access_type_t::RW; - case 1212: return access_type_t::RW; - case 1216: return access_type_t::RW; - case 1220: return access_type_t::RW; - case 1224: return access_type_t::RW; - case 1228: return access_type_t::RW; - case 1232: return access_type_t::RW; - case 1236: return access_type_t::RW; - case 1240: return access_type_t::RW; - case 1244: return access_type_t::RW; - case 1248: return access_type_t::RW; - case 1252: return access_type_t::RW; - case 1256: return access_type_t::RW; - case 1260: return access_type_t::RW; - case 1264: return access_type_t::RW; - case 1268: return access_type_t::RW; - case 1272: return access_type_t::RW; - case 1276: return access_type_t::RW; - case 1280: return access_type_t::RW; - case 1284: return access_type_t::RW; - case 1288: return access_type_t::RW; - case 1292: return access_type_t::RW; - case 1296: return access_type_t::RW; - case 1300: return access_type_t::RW; - case 1304: return access_type_t::RW; - case 1308: return access_type_t::RW; - case 1312: return access_type_t::RW; - case 1316: return access_type_t::RW; - case 1320: return access_type_t::RW; - case 1324: return access_type_t::RW; - case 1328: return access_type_t::RW; - case 1332: return access_type_t::RW; - case 1336: return access_type_t::RW; - case 1340: return access_type_t::RW; - case 1344: return access_type_t::RW; - case 1348: return access_type_t::RW; - case 1352: return access_type_t::RW; - case 1356: return access_type_t::RW; - case 1360: return access_type_t::RW; - case 1364: return access_type_t::RW; - case 1368: return access_type_t::RW; - case 1372: return access_type_t::RW; - case 1376: return access_type_t::RW; - case 1380: return access_type_t::RW; - case 1384: return access_type_t::RW; - case 1388: return access_type_t::RW; - case 1392: return access_type_t::RW; - case 1396: return access_type_t::RW; - case 1400: return access_type_t::RW; - case 1404: return access_type_t::RW; - case 1408: return access_type_t::RW; - case 1412: return access_type_t::RW; - case 1416: return access_type_t::RW; - case 1420: return access_type_t::RW; - case 1424: return access_type_t::RW; - case 1428: return access_type_t::RW; - case 1432: return access_type_t::RW; - case 1436: return access_type_t::RW; - case 1440: return access_type_t::RW; - case 1444: return access_type_t::RW; - case 1448: return access_type_t::RW; - case 1452: return access_type_t::RW; - case 1456: return access_type_t::RW; - case 1460: return access_type_t::RW; - case 1464: return access_type_t::RW; - case 1468: return access_type_t::RW; - case 1472: return access_type_t::RW; - case 1476: return access_type_t::RW; - case 1480: return access_type_t::RW; - case 1484: return access_type_t::RW; - case 1488: return access_type_t::RW; - case 1492: return access_type_t::RW; - case 1496: return access_type_t::RW; - case 1500: return access_type_t::RW; - case 1504: return access_type_t::RW; - case 1508: return access_type_t::RW; - case 1512: return access_type_t::RW; - case 1516: return access_type_t::RW; - case 1520: return access_type_t::RW; - case 1524: return access_type_t::RW; - case 1528: return access_type_t::RW; - case 1532: return access_type_t::RW; - case 1536: return access_type_t::RW; - case 1540: return access_type_t::RW; - case 1544: return access_type_t::RW; - case 1548: return access_type_t::RW; - case 1552: return access_type_t::RW; - case 1556: return access_type_t::RW; - case 1560: return access_type_t::RW; - case 1564: return access_type_t::RW; - case 1568: return access_type_t::RW; - case 1572: return access_type_t::RW; - case 1576: return access_type_t::RW; - case 1580: return access_type_t::RW; - case 1584: return access_type_t::RW; - case 1588: return access_type_t::RW; - case 1592: return access_type_t::RW; - case 1596: return access_type_t::RW; - case 1600: return access_type_t::RW; - case 1604: return access_type_t::RW; - case 1608: return access_type_t::RW; - case 1612: return access_type_t::RW; - case 1616: return access_type_t::RW; - case 1620: return access_type_t::RW; - case 1624: return access_type_t::RW; - case 1628: return access_type_t::RW; - case 1632: return access_type_t::RW; - case 1636: return access_type_t::RW; - case 1640: return access_type_t::RW; - case 1644: return access_type_t::RW; - case 1648: return access_type_t::RW; - case 1652: return access_type_t::RW; - case 1656: return access_type_t::RW; - case 1660: return access_type_t::RW; - case 1664: return access_type_t::RW; - case 1668: return access_type_t::RW; - case 1672: return access_type_t::RW; - case 1676: return access_type_t::RW; - case 1680: return access_type_t::RW; - case 1684: return access_type_t::RW; - case 1688: return access_type_t::RW; - case 1692: return access_type_t::RW; - case 1696: return access_type_t::RW; - case 1700: return access_type_t::RW; - case 1704: return access_type_t::RW; - case 1708: return access_type_t::RW; - case 1712: return access_type_t::RW; - case 1716: return access_type_t::RW; - case 1720: return access_type_t::RW; - case 1724: return access_type_t::RW; - case 1728: return access_type_t::RW; - case 1732: return access_type_t::RW; - case 1736: return access_type_t::RW; - case 1740: return access_type_t::RW; - case 1744: return access_type_t::RW; - case 1748: return access_type_t::RW; - case 1752: return access_type_t::RW; - case 1756: return access_type_t::RW; - case 1760: return access_type_t::RW; - case 1764: return access_type_t::RW; - case 1768: return access_type_t::RW; - case 1772: return access_type_t::RW; - case 1776: return access_type_t::RW; - case 1780: return access_type_t::RW; - case 1784: return access_type_t::RW; - case 1788: return access_type_t::RW; - case 1792: return access_type_t::RW; - case 1796: return access_type_t::RW; - case 1800: return access_type_t::RW; - case 1804: return access_type_t::RW; - case 1808: return access_type_t::RW; - case 1812: return access_type_t::RW; - case 1816: return access_type_t::RW; - case 1820: return access_type_t::RW; - case 1824: return access_type_t::RW; - case 1828: return access_type_t::RW; - case 1832: return access_type_t::RW; - case 1836: return access_type_t::RW; - case 1840: return access_type_t::RW; - case 1844: return access_type_t::RW; - case 1848: return access_type_t::RW; - case 1852: return access_type_t::RW; - case 1856: return access_type_t::RW; - case 1860: return access_type_t::RW; - case 1864: return access_type_t::RW; - case 1868: return access_type_t::RW; - case 1872: return access_type_t::RW; - case 1876: return access_type_t::RW; - case 1880: return access_type_t::RW; - case 1884: return access_type_t::RW; - case 1888: return access_type_t::RW; - case 1892: return access_type_t::RW; - case 1896: return access_type_t::RW; - case 1900: return access_type_t::RW; - case 1904: return access_type_t::RW; - case 1908: return access_type_t::RW; - case 1912: return access_type_t::RW; - case 1916: return access_type_t::RW; - case 1920: return access_type_t::RW; - case 1924: return access_type_t::RW; - case 1928: return access_type_t::RW; - case 1932: return access_type_t::RW; - case 1936: return access_type_t::RW; - case 1940: return access_type_t::RW; - case 1944: return access_type_t::RW; - case 1948: return access_type_t::RW; - case 1952: return access_type_t::RW; - case 1956: return access_type_t::RW; - case 1960: return access_type_t::RW; - case 1964: return access_type_t::RW; - case 1968: return access_type_t::RW; - case 1972: return access_type_t::RW; - case 1976: return access_type_t::RW; - case 1980: return access_type_t::RW; - case 1984: return access_type_t::RW; - case 1988: return access_type_t::RW; - case 1992: return access_type_t::RW; - case 1996: return access_type_t::RW; - case 2000: return access_type_t::RW; - case 2004: return access_type_t::RW; - case 2008: return access_type_t::RW; - case 2012: return access_type_t::RW; - case 2016: return access_type_t::RW; - case 2020: return access_type_t::RW; - case 2024: return access_type_t::RW; - case 2028: return access_type_t::RW; - case 2032: return access_type_t::RW; - case 2036: return access_type_t::RW; - case 2040: return access_type_t::RW; - case 2044: return access_type_t::RW; - case 2048: return access_type_t::RW; - case 2052: return access_type_t::RW; - case 2056: return access_type_t::RW; - case 2060: return access_type_t::RW; - case 2064: return access_type_t::RW; - case 2068: return access_type_t::RW; - case 2076: return access_type_t::RW; - case 2080: return access_type_t::RW; - case 2084: return access_type_t::RW; - case 2088: return access_type_t::RW; - case 2092: return access_type_t::RW; - case 2096: return access_type_t::RW; - case 2108: return access_type_t::RW; - case 2116: return access_type_t::RW; - case 2120: return access_type_t::RW; - case 2124: return access_type_t::RW; - case 2128: return access_type_t::RW; - case 2132: return access_type_t::RW; - case 2136: return access_type_t::RW; - case 2140: return access_type_t::RW; - case 2144: return access_type_t::RW; - case 2152: return access_type_t::RW; - case 2156: return access_type_t::RW; - case 2160: return access_type_t::RW; - case 2172: return access_type_t::RW; - case 2176: return access_type_t::RW; - case 2180: return access_type_t::RW; - case 2184: return access_type_t::RW; - case 2192: return access_type_t::RW; - case 2196: return access_type_t::RW; - case 2200: return access_type_t::RW; - case 2204: return access_type_t::RW; - case 2208: return access_type_t::RW; - case 2212: return access_type_t::RW; - case 2216: return access_type_t::RW; - case 2220: return access_type_t::RW; - case 2224: return access_type_t::RW; - case 2228: return access_type_t::RW; - case 2232: return access_type_t::RW; - case 2236: return access_type_t::RW; - case 2240: return access_type_t::RW; - case 2244: return access_type_t::RW; - case 2248: return access_type_t::RW; - case 2252: return access_type_t::RW; - case 2256: return access_type_t::RW; - case 2304: return access_type_t::RW; - case 2324: return access_type_t::RW; - case 2340: return access_type_t::RW; - case 2344: return access_type_t::RW; - case 2348: return access_type_t::RW; - case 2352: return access_type_t::RW; - case 2364: return access_type_t::RW; - case 2560: return access_type_t::RW; - case 2568: return access_type_t::RW; - case 2576: return access_type_t::RW; - case 2584: return access_type_t::RW; - case 2592: return access_type_t::RW; - case 2600: return access_type_t::RW; - case 2608: return access_type_t::RW; - case 2624: return access_type_t::RW; - case 2632: return access_type_t::RW; - case 2640: return access_type_t::RW; - case 2648: return access_type_t::RW; - case 2656: return access_type_t::RW; - case 2664: return access_type_t::RW; - case 2672: return access_type_t::RW; - case 2688: return access_type_t::RW; - case 2696: return access_type_t::RW; - case 2704: return access_type_t::RW; - case 2712: return access_type_t::RW; - case 2720: return access_type_t::RW; - case 2728: return access_type_t::RW; - case 2736: return access_type_t::RW; - case 2744: return access_type_t::RW; - case 2752: return access_type_t::RW; - case 2760: return access_type_t::RW; - case 2768: return access_type_t::RW; - case 2776: return access_type_t::RW; - case 2784: return access_type_t::RW; - case 2792: return access_type_t::RW; - case 2800: return access_type_t::RW; - case 2808: return access_type_t::RW; - case 2816: return access_type_t::RW; - case 2824: return access_type_t::RW; - case 2832: return access_type_t::RW; - case 2840: return access_type_t::RW; - case 2848: return access_type_t::RW; - case 2856: return access_type_t::RW; - case 2864: return access_type_t::RW; - case 2880: return access_type_t::RW; - case 2888: return access_type_t::RW; - case 2896: return access_type_t::RW; - case 2904: return access_type_t::RW; - case 2912: return access_type_t::RW; - case 2920: return access_type_t::RW; - case 2928: return access_type_t::RW; - case 2936: return access_type_t::RW; - case 3008: return access_type_t::RW; - case 3016: return access_type_t::RW; - case 4032: return access_type_t::RO; - case 4048: return access_type_t::RO; - case 4052: return access_type_t::RO; - case 4056: return access_type_t::RO; - case 4060: return access_type_t::RO; - case 4064: return access_type_t::RO; - case 4068: return access_type_t::RO; - case 4072: return access_type_t::RO; - case 4076: return access_type_t::RO; - case 4080: return access_type_t::RO; - case 4084: return access_type_t::RO; - case 4088: return access_type_t::RO; - case 4092: return access_type_t::RO; - case 4352: return access_type_t::RO; - case 4356: return access_type_t::RO; - case 4360: return access_type_t::RO; - case 4368: return access_type_t::RO; - case 4372: return access_type_t::RO; - case 4480: return access_type_t::RW; - case 4484: return access_type_t::RW; - case 4488: return access_type_t::RW; - case 4492: return access_type_t::RW; - case 4496: return access_type_t::RW; - case 4500: return access_type_t::RW; - case 4504: return access_type_t::RW; - case 4512: return access_type_t::RW; - case 4520: return access_type_t::RW; - case 4524: return access_type_t::RW; - case 4528: return access_type_t::RW; - case 4864: return access_type_t::RW; - case 4868: return access_type_t::RW; - case 4872: return access_type_t::RW; - case 4876: return access_type_t::RW; - case 4880: return access_type_t::RW; - case 4884: return access_type_t::RW; - case 4888: return access_type_t::RW; - case 4892: return access_type_t::RW; - case 4992: return access_type_t::RW; - case 4996: return access_type_t::RW; - case 5000: return access_type_t::RW; - case 5004: return access_type_t::RW; - case 5008: return access_type_t::RW; - case 5012: return access_type_t::RW; - case 5016: return access_type_t::RW; - case 5020: return access_type_t::RW; - default: return access_type_t::RO; - } - } -#endif -}; - -#ifdef __cplusplus -struct isa -{ -#ifdef NPU_DISASSEMBLE -static int disassemble(const uint32_t* in, std::string& op, std::vector>& fields) -{ - switch (*in & 0xffff) - { - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_STOP): - { - const npu_op_stop_t& v = *reinterpret_cast(in); - op = "NPU_OP_STOP"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_IRQ): - { - const npu_op_irq_t& v = *reinterpret_cast(in); - op = "NPU_OP_IRQ"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_CONV): - { - const npu_op_conv_t& v = *reinterpret_cast(in); - op = "NPU_OP_CONV"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_DEPTHWISE): - { - const npu_op_depthwise_t& v = *reinterpret_cast(in); - op = "NPU_OP_DEPTHWISE"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_POOL): - { - const npu_op_pool_t& v = *reinterpret_cast(in); - op = "NPU_OP_POOL"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_ELEMENTWISE): - { - const npu_op_elementwise_t& v = *reinterpret_cast(in); - op = "NPU_OP_ELEMENTWISE"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_RESIZE): - { - const npu_op_resize_t& v = *reinterpret_cast(in); - op = "NPU_OP_RESIZE"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_DMA_START): - { - const npu_op_dma_start_t& v = *reinterpret_cast(in); - op = "NPU_OP_DMA_START"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_DMA_WAIT): - { - const npu_op_dma_wait_t& v = *reinterpret_cast(in); - op = "NPU_OP_DMA_WAIT"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_KERNEL_WAIT): - { - const npu_op_kernel_wait_t& v = *reinterpret_cast(in); - op = "NPU_OP_KERNEL_WAIT"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_PMU_MASK): - { - const npu_op_pmu_mask_t& v = *reinterpret_cast(in); - op = "NPU_OP_PMU_MASK"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PAD_TOP): - { - const npu_set_ifm_pad_top_t& v = *reinterpret_cast(in); - op = "NPU_SET_IFM_PAD_TOP"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PAD_LEFT): - { - const npu_set_ifm_pad_left_t& v = *reinterpret_cast(in); - op = "NPU_SET_IFM_PAD_LEFT"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PAD_RIGHT): - { - const npu_set_ifm_pad_right_t& v = *reinterpret_cast(in); - op = "NPU_SET_IFM_PAD_RIGHT"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PAD_BOTTOM): - { - const npu_set_ifm_pad_bottom_t& v = *reinterpret_cast(in); - op = "NPU_SET_IFM_PAD_BOTTOM"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_DEPTH_M1): - { - const npu_set_ifm_depth_m1_t& v = *reinterpret_cast(in); - op = "NPU_SET_IFM_DEPTH_M1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PRECISION): - { - const npu_set_ifm_precision_t& v = *reinterpret_cast(in); - op = "NPU_SET_IFM_PRECISION"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_UPSCALE): - { - const npu_set_ifm_upscale_t& v = *reinterpret_cast(in); - op = "NPU_SET_IFM_UPSCALE"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_ZERO_POINT): - { - const npu_set_ifm_zero_point_t& v = *reinterpret_cast(in); - op = "NPU_SET_IFM_ZERO_POINT"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_WIDTH0_M1): - { - const npu_set_ifm_width0_m1_t& v = *reinterpret_cast(in); - op = "NPU_SET_IFM_WIDTH0_M1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_HEIGHT0_M1): - { - const npu_set_ifm_height0_m1_t& v = *reinterpret_cast(in); - op = "NPU_SET_IFM_HEIGHT0_M1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_HEIGHT1_M1): - { - const npu_set_ifm_height1_m1_t& v = *reinterpret_cast(in); - op = "NPU_SET_IFM_HEIGHT1_M1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_REGION): - { - const npu_set_ifm_region_t& v = *reinterpret_cast(in); - op = "NPU_SET_IFM_REGION"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_BROADCAST): - { - const npu_set_ifm_broadcast_t& v = *reinterpret_cast(in); - op = "NPU_SET_IFM_BROADCAST"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_WIDTH_M1): - { - const npu_set_ofm_width_m1_t& v = *reinterpret_cast(in); - op = "NPU_SET_OFM_WIDTH_M1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_HEIGHT_M1): - { - const npu_set_ofm_height_m1_t& v = *reinterpret_cast(in); - op = "NPU_SET_OFM_HEIGHT_M1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_DEPTH_M1): - { - const npu_set_ofm_depth_m1_t& v = *reinterpret_cast(in); - op = "NPU_SET_OFM_DEPTH_M1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_PRECISION): - { - const npu_set_ofm_precision_t& v = *reinterpret_cast(in); - op = "NPU_SET_OFM_PRECISION"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_BLK_WIDTH_M1): - { - const npu_set_ofm_blk_width_m1_t& v = *reinterpret_cast(in); - op = "NPU_SET_OFM_BLK_WIDTH_M1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_BLK_HEIGHT_M1): - { - const npu_set_ofm_blk_height_m1_t& v = *reinterpret_cast(in); - op = "NPU_SET_OFM_BLK_HEIGHT_M1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_BLK_DEPTH_M1): - { - const npu_set_ofm_blk_depth_m1_t& v = *reinterpret_cast(in); - op = "NPU_SET_OFM_BLK_DEPTH_M1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_ZERO_POINT): - { - const npu_set_ofm_zero_point_t& v = *reinterpret_cast(in); - op = "NPU_SET_OFM_ZERO_POINT"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_WIDTH0_M1): - { - const npu_set_ofm_width0_m1_t& v = *reinterpret_cast(in); - op = "NPU_SET_OFM_WIDTH0_M1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_HEIGHT0_M1): - { - const npu_set_ofm_height0_m1_t& v = *reinterpret_cast(in); - op = "NPU_SET_OFM_HEIGHT0_M1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_HEIGHT1_M1): - { - const npu_set_ofm_height1_m1_t& v = *reinterpret_cast(in); - op = "NPU_SET_OFM_HEIGHT1_M1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_REGION): - { - const npu_set_ofm_region_t& v = *reinterpret_cast(in); - op = "NPU_SET_OFM_REGION"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_KERNEL_WIDTH_M1): - { - const npu_set_kernel_width_m1_t& v = *reinterpret_cast(in); - op = "NPU_SET_KERNEL_WIDTH_M1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_KERNEL_HEIGHT_M1): - { - const npu_set_kernel_height_m1_t& v = *reinterpret_cast(in); - op = "NPU_SET_KERNEL_HEIGHT_M1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_KERNEL_STRIDE): - { - const npu_set_kernel_stride_t& v = *reinterpret_cast(in); - op = "NPU_SET_KERNEL_STRIDE"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_ACC_FORMAT): - { - const npu_set_acc_format_t& v = *reinterpret_cast(in); - op = "NPU_SET_ACC_FORMAT"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_ACTIVATION): - { - const npu_set_activation_t& v = *reinterpret_cast(in); - op = "NPU_SET_ACTIVATION"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_ACTIVATION_MIN): - { - const npu_set_activation_min_t& v = *reinterpret_cast(in); - op = "NPU_SET_ACTIVATION_MIN"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_ACTIVATION_MAX): - { - const npu_set_activation_max_t& v = *reinterpret_cast(in); - op = "NPU_SET_ACTIVATION_MAX"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_WEIGHT_REGION): - { - const npu_set_weight_region_t& v = *reinterpret_cast(in); - op = "NPU_SET_WEIGHT_REGION"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_SCALE_REGION): - { - const npu_set_scale_region_t& v = *reinterpret_cast(in); - op = "NPU_SET_SCALE_REGION"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_WEIGHT_FORMAT): - { - const npu_set_weight_format_t& v = *reinterpret_cast(in); - op = "NPU_SET_WEIGHT_FORMAT"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_BLOCKDEP): - { - const npu_set_blockdep_t& v = *reinterpret_cast(in); - op = "NPU_SET_BLOCKDEP"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_RESIZE_X_SCALE_N_M1): - { - const npu_set_resize_x_scale_n_m1_t& v = *reinterpret_cast(in); - op = "NPU_SET_RESIZE_X_SCALE_N_M1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_RESIZE_Y_SCALE_N_M1): - { - const npu_set_resize_y_scale_n_m1_t& v = *reinterpret_cast(in); - op = "NPU_SET_RESIZE_Y_SCALE_N_M1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_RESIZE_X_OFFSET): - { - const npu_set_resize_x_offset_t& v = *reinterpret_cast(in); - op = "NPU_SET_RESIZE_X_OFFSET"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_RESIZE_Y_OFFSET): - { - const npu_set_resize_y_offset_t& v = *reinterpret_cast(in); - op = "NPU_SET_RESIZE_Y_OFFSET"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_SRC_REGION): - { - const npu_set_dma0_src_region_t& v = *reinterpret_cast(in); - op = "NPU_SET_DMA0_SRC_REGION"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_DST_REGION): - { - const npu_set_dma0_dst_region_t& v = *reinterpret_cast(in); - op = "NPU_SET_DMA0_DST_REGION"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_SIZE0): - { - const npu_set_dma0_size0_t& v = *reinterpret_cast(in); - op = "NPU_SET_DMA0_SIZE0"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_SIZE1): - { - const npu_set_dma0_size1_t& v = *reinterpret_cast(in); - op = "NPU_SET_DMA0_SIZE1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_IDX_REGION): - { - const npu_set_dma0_idx_region_t& v = *reinterpret_cast(in); - op = "NPU_SET_DMA0_IDX_REGION"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_BROADCAST): - { - const npu_set_ifm2_broadcast_t& v = *reinterpret_cast(in); - op = "NPU_SET_IFM2_BROADCAST"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_PRECISION): - { - const npu_set_ifm2_precision_t& v = *reinterpret_cast(in); - op = "NPU_SET_IFM2_PRECISION"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_ZERO_POINT): - { - const npu_set_ifm2_zero_point_t& v = *reinterpret_cast(in); - op = "NPU_SET_IFM2_ZERO_POINT"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_WIDTH0_M1): - { - const npu_set_ifm2_width0_m1_t& v = *reinterpret_cast(in); - op = "NPU_SET_IFM2_WIDTH0_M1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_HEIGHT0_M1): - { - const npu_set_ifm2_height0_m1_t& v = *reinterpret_cast(in); - op = "NPU_SET_IFM2_HEIGHT0_M1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_HEIGHT1_M1): - { - const npu_set_ifm2_height1_m1_t& v = *reinterpret_cast(in); - op = "NPU_SET_IFM2_HEIGHT1_M1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_REGION): - { - const npu_set_ifm2_region_t& v = *reinterpret_cast(in); - op = "NPU_SET_IFM2_REGION"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_BASE0): - { - const npu_set_ifm_base0_t& v = *reinterpret_cast(in); - op = "NPU_SET_IFM_BASE0"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_BASE1): - { - const npu_set_ifm_base1_t& v = *reinterpret_cast(in); - op = "NPU_SET_IFM_BASE1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_BASE2): - { - const npu_set_ifm_base2_t& v = *reinterpret_cast(in); - op = "NPU_SET_IFM_BASE2"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_BASE3): - { - const npu_set_ifm_base3_t& v = *reinterpret_cast(in); - op = "NPU_SET_IFM_BASE3"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_STRIDE_X): - { - const npu_set_ifm_stride_x_t& v = *reinterpret_cast(in); - op = "NPU_SET_IFM_STRIDE_X"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_STRIDE_Y): - { - const npu_set_ifm_stride_y_t& v = *reinterpret_cast(in); - op = "NPU_SET_IFM_STRIDE_Y"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_STRIDE_C): - { - const npu_set_ifm_stride_c_t& v = *reinterpret_cast(in); - op = "NPU_SET_IFM_STRIDE_C"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_BASE0): - { - const npu_set_ofm_base0_t& v = *reinterpret_cast(in); - op = "NPU_SET_OFM_BASE0"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_BASE1): - { - const npu_set_ofm_base1_t& v = *reinterpret_cast(in); - op = "NPU_SET_OFM_BASE1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_BASE2): - { - const npu_set_ofm_base2_t& v = *reinterpret_cast(in); - op = "NPU_SET_OFM_BASE2"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_BASE3): - { - const npu_set_ofm_base3_t& v = *reinterpret_cast(in); - op = "NPU_SET_OFM_BASE3"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_STRIDE_X): - { - const npu_set_ofm_stride_x_t& v = *reinterpret_cast(in); - op = "NPU_SET_OFM_STRIDE_X"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_STRIDE_Y): - { - const npu_set_ofm_stride_y_t& v = *reinterpret_cast(in); - op = "NPU_SET_OFM_STRIDE_Y"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_STRIDE_C): - { - const npu_set_ofm_stride_c_t& v = *reinterpret_cast(in); - op = "NPU_SET_OFM_STRIDE_C"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT_BASE): - { - const npu_set_weight_base_t& v = *reinterpret_cast(in); - op = "NPU_SET_WEIGHT_BASE"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT_LENGTH): - { - const npu_set_weight_length_t& v = *reinterpret_cast(in); - op = "NPU_SET_WEIGHT_LENGTH"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_SCALE_BASE): - { - const npu_set_scale_base_t& v = *reinterpret_cast(in); - op = "NPU_SET_SCALE_BASE"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_SCALE_LENGTH): - { - const npu_set_scale_length_t& v = *reinterpret_cast(in); - op = "NPU_SET_SCALE_LENGTH"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_SCALE): - { - const npu_set_ofm_scale_t& v = *reinterpret_cast(in); - op = "NPU_SET_OFM_SCALE"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_SCALE): - { - const npu_set_ifm_scale_t& v = *reinterpret_cast(in); - op = "NPU_SET_IFM_SCALE"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_SCALE): - { - const npu_set_ifm2_scale_t& v = *reinterpret_cast(in); - op = "NPU_SET_IFM2_SCALE"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OP_SCALAR): - { - const npu_set_op_scalar_t& v = *reinterpret_cast(in); - op = "NPU_SET_OP_SCALAR"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_SRC): - { - const npu_set_dma0_src_t& v = *reinterpret_cast(in); - op = "NPU_SET_DMA0_SRC"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_DST): - { - const npu_set_dma0_dst_t& v = *reinterpret_cast(in); - op = "NPU_SET_DMA0_DST"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_LEN): - { - const npu_set_dma0_len_t& v = *reinterpret_cast(in); - op = "NPU_SET_DMA0_LEN"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_SRC_STRIDE0): - { - const npu_set_dma0_src_stride0_t& v = *reinterpret_cast(in); - op = "NPU_SET_DMA0_SRC_STRIDE0"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_SRC_STRIDE1): - { - const npu_set_dma0_src_stride1_t& v = *reinterpret_cast(in); - op = "NPU_SET_DMA0_SRC_STRIDE1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_DST_STRIDE0): - { - const npu_set_dma0_dst_stride0_t& v = *reinterpret_cast(in); - op = "NPU_SET_DMA0_DST_STRIDE0"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_DST_STRIDE1): - { - const npu_set_dma0_dst_stride1_t& v = *reinterpret_cast(in); - op = "NPU_SET_DMA0_DST_STRIDE1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_IDX): - { - const npu_set_dma0_idx_t& v = *reinterpret_cast(in); - op = "NPU_SET_DMA0_IDX"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_IDX_MAX): - { - const npu_set_dma0_idx_max_t& v = *reinterpret_cast(in); - op = "NPU_SET_DMA0_IDX_MAX"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_IDX_SKIP1): - { - const npu_set_dma0_idx_skip1_t& v = *reinterpret_cast(in); - op = "NPU_SET_DMA0_IDX_SKIP1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_BASE0): - { - const npu_set_ifm2_base0_t& v = *reinterpret_cast(in); - op = "NPU_SET_IFM2_BASE0"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_BASE1): - { - const npu_set_ifm2_base1_t& v = *reinterpret_cast(in); - op = "NPU_SET_IFM2_BASE1"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_BASE2): - { - const npu_set_ifm2_base2_t& v = *reinterpret_cast(in); - op = "NPU_SET_IFM2_BASE2"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_BASE3): - { - const npu_set_ifm2_base3_t& v = *reinterpret_cast(in); - op = "NPU_SET_IFM2_BASE3"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_STRIDE_X): - { - const npu_set_ifm2_stride_x_t& v = *reinterpret_cast(in); - op = "NPU_SET_IFM2_STRIDE_X"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_STRIDE_Y): - { - const npu_set_ifm2_stride_y_t& v = *reinterpret_cast(in); - op = "NPU_SET_IFM2_STRIDE_Y"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_STRIDE_C): - { - const npu_set_ifm2_stride_c_t& v = *reinterpret_cast(in); - op = "NPU_SET_IFM2_STRIDE_C"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT1_BASE): - { - const npu_set_weight1_base_t& v = *reinterpret_cast(in); - op = "NPU_SET_WEIGHT1_BASE"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT1_LENGTH): - { - const npu_set_weight1_length_t& v = *reinterpret_cast(in); - op = "NPU_SET_WEIGHT1_LENGTH"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT2_BASE): - { - const npu_set_weight2_base_t& v = *reinterpret_cast(in); - op = "NPU_SET_WEIGHT2_BASE"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT2_LENGTH): - { - const npu_set_weight2_length_t& v = *reinterpret_cast(in); - op = "NPU_SET_WEIGHT2_LENGTH"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT3_BASE): - { - const npu_set_weight3_base_t& v = *reinterpret_cast(in); - op = "NPU_SET_WEIGHT3_BASE"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT3_LENGTH): - { - const npu_set_weight3_length_t& v = *reinterpret_cast(in); - op = "NPU_SET_WEIGHT3_LENGTH"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_RESIZE_X): - { - const npu_set_resize_x_step_t& v = *reinterpret_cast(in); - op = "NPU_SET_RESIZE_X_STEP"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_RESIZE_Y): - { - const npu_set_resize_y_step_t& v = *reinterpret_cast(in); - op = "NPU_SET_RESIZE_Y_STEP"; - v.disassemble(fields); - break; - } - case (static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL) << 14) | static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_OP_BRANCH): - { - const npu_op_branch_t& v = *reinterpret_cast(in); - op = "NPU_OP_BRANCH"; - v.disassemble(fields); - break; - } - default: break; - } - return (*in & (3<<14)) != 0 ? 2 : 1; -} -#endif -#endif -// Signal the end of command stream -struct npu_op_stop_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t mask:16; // Encoding for 16-bit mask value -#ifdef __cplusplus -public: - npu_op_stop_t(uint32_t _mask) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_STOP)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - mask(_mask & ((1U << 16)-1)) - {} - CONSTEXPR npu_op_stop_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_STOP)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - mask(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_STOP) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_STOP); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - word |= uint32_t(mask) << 16; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_op_stop_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_op_stop_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR uint32_t get_mask() const - { - return static_cast(mask); - } - CONSTEXPR npu_op_stop_t& set_mask(uint32_t value) - { - assert((value >> 16) == 0); - mask = static_cast(value & ((1U << 16)-1)); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("mask", std::to_string(mask))); - } -#endif -#endif -}; -// Raises an IRQ to the host -struct npu_op_irq_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t mask:16; // Encoding for 16-bit mask value -#ifdef __cplusplus -public: - npu_op_irq_t(uint32_t _mask) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_IRQ)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - mask(_mask & ((1U << 16)-1)) - {} - CONSTEXPR npu_op_irq_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_IRQ)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - mask(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_IRQ) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_IRQ); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - word |= uint32_t(mask) << 16; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_op_irq_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_op_irq_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR uint32_t get_mask() const - { - return static_cast(mask); - } - CONSTEXPR npu_op_irq_t& set_mask(uint32_t value) - { - assert((value >> 16) == 0); - mask = static_cast(value & ((1U << 16)-1)); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("mask", std::to_string(mask))); - } -#endif -#endif -}; -// 2D convolution -struct npu_op_conv_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t weights_ifm2:1; // Read weights from IFM2 rather than a static compressed stream - uint32_t reserved1:15; -#ifdef __cplusplus -public: - npu_op_conv_t(uint32_t _weights_ifm2) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_CONV)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - weights_ifm2(_weights_ifm2 & ((1U << 1)-1)), - reserved1(0) - {} - CONSTEXPR npu_op_conv_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_CONV)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - weights_ifm2(0), - reserved1(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_CONV) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_CONV); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - word |= uint32_t(weights_ifm2) << 16; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_op_conv_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_op_conv_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR uint32_t get_weights_ifm2() const - { - return static_cast(weights_ifm2); - } - CONSTEXPR npu_op_conv_t& set_weights_ifm2(uint32_t value) - { - assert((value >> 1) == 0); - weights_ifm2 = static_cast(value & ((1U << 1)-1)); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("weights_ifm2", std::to_string(weights_ifm2))); - } -#endif -#endif -}; -// Depth-wise 2D convolution -struct npu_op_depthwise_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t reserved1:16; -#ifdef __cplusplus -public: - CONSTEXPR npu_op_depthwise_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_DEPTHWISE)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - reserved1(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_DEPTHWISE) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_DEPTHWISE); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_op_depthwise_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_op_depthwise_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>&) const - { - } -#endif -#endif -}; -// Pooling -struct npu_op_pool_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t pooling_mode:3; // Pooling mode - uint32_t reserved1:13; -#ifdef __cplusplus -public: - npu_op_pool_t(NPU_NAMESPACE::pooling_mode _pooling_mode) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_POOL)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - pooling_mode(static_cast(_pooling_mode) & ((1U << 3)-1)), - reserved1(0) - {} - CONSTEXPR npu_op_pool_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_POOL)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - pooling_mode(0), - reserved1(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_POOL) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_POOL); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - word |= uint32_t(pooling_mode) << 16; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_op_pool_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_op_pool_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::pooling_mode get_pooling_mode() const - { - return static_cast(pooling_mode); - } - CONSTEXPR npu_op_pool_t& set_pooling_mode(NPU_NAMESPACE::pooling_mode value) - { - pooling_mode = static_cast(value) & ((1U << 3)-1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("pooling_mode", (pooling_mode < (sizeof(pooling_mode_str)/sizeof(pooling_mode_str[0])) ? pooling_mode_str[pooling_mode] : "****"))); - } -#endif -#endif -}; -// Elementwise operation -struct npu_op_elementwise_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t elementwise_mode:6; // Elementwise mode - uint32_t reserved1:10; -#ifdef __cplusplus -public: - npu_op_elementwise_t(NPU_NAMESPACE::elementwise_mode _elementwise_mode) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_ELEMENTWISE)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - elementwise_mode(static_cast(_elementwise_mode) & ((1U << 6)-1)), - reserved1(0) - {} - CONSTEXPR npu_op_elementwise_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_ELEMENTWISE)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - elementwise_mode(0), - reserved1(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_ELEMENTWISE) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_ELEMENTWISE); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - word |= uint32_t(elementwise_mode) << 16; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_op_elementwise_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_op_elementwise_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::elementwise_mode get_elementwise_mode() const - { - return static_cast(elementwise_mode); - } - CONSTEXPR npu_op_elementwise_t& set_elementwise_mode(NPU_NAMESPACE::elementwise_mode value) - { - elementwise_mode = static_cast(value) & ((1U << 6)-1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("elementwise_mode", (elementwise_mode < (sizeof(elementwise_mode_str)/sizeof(elementwise_mode_str[0])) ? elementwise_mode_str[elementwise_mode] : "****"))); - } -#endif -#endif -}; -// Resize operation -struct npu_op_resize_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t resize_mode:2; // Resize mode - uint32_t reserved1:14; -#ifdef __cplusplus -public: - npu_op_resize_t(NPU_NAMESPACE::resize_mode _resize_mode) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_RESIZE)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - resize_mode(static_cast(_resize_mode) & ((1U << 2)-1)), - reserved1(0) - {} - CONSTEXPR npu_op_resize_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_RESIZE)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - resize_mode(0), - reserved1(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_RESIZE) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_RESIZE); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - word |= uint32_t(resize_mode) << 16; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_op_resize_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_op_resize_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::resize_mode get_resize_mode() const - { - return static_cast(resize_mode); - } - CONSTEXPR npu_op_resize_t& set_resize_mode(NPU_NAMESPACE::resize_mode value) - { - resize_mode = static_cast(value) & ((1U << 2)-1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("resize_mode", (resize_mode < (sizeof(resize_mode_str)/sizeof(resize_mode_str[0])) ? resize_mode_str[resize_mode] : "****"))); - } -#endif -#endif -}; -// Queue new DMA for the given channel -struct npu_op_dma_start_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t reserved1:16; -#ifdef __cplusplus -public: - CONSTEXPR npu_op_dma_start_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_DMA_START)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - reserved1(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_DMA_START) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_DMA_START); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_op_dma_start_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_op_dma_start_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>&) const - { - } -#endif -#endif -}; -// Wait for the mem2mem DMA channel to have k or fewer active descriptors outstanding -struct npu_op_dma_wait_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t k:2; // Number of outstanding descriptors - uint32_t reserved1:14; -#ifdef __cplusplus -public: - npu_op_dma_wait_t(uint32_t _k) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_DMA_WAIT)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - k(_k & ((1U << 2)-1)), - reserved1(0) - {} - CONSTEXPR npu_op_dma_wait_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_DMA_WAIT)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - k(0), - reserved1(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_DMA_WAIT) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_DMA_WAIT); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - word |= uint32_t(k) << 16; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_op_dma_wait_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_op_dma_wait_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR uint32_t get_k() const - { - return static_cast(k); - } - CONSTEXPR npu_op_dma_wait_t& set_k(uint32_t value) - { - assert((value >> 2) == 0); - k = static_cast(value & ((1U << 2)-1)); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("k", std::to_string(k))); - } -#endif -#endif -}; -// Wait for kernel operations to complete -struct npu_op_kernel_wait_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t n:1; // Number of kernel operations - uint32_t reserved1:15; -#ifdef __cplusplus -public: - npu_op_kernel_wait_t(uint32_t _n) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_KERNEL_WAIT)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - n(_n & ((1U << 1)-1)), - reserved1(0) - {} - CONSTEXPR npu_op_kernel_wait_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_KERNEL_WAIT)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - n(0), - reserved1(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_KERNEL_WAIT) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_KERNEL_WAIT); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - word |= uint32_t(n) << 16; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_op_kernel_wait_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_op_kernel_wait_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR uint32_t get_n() const - { - return static_cast(n); - } - CONSTEXPR npu_op_kernel_wait_t& set_n(uint32_t value) - { - assert((value >> 1) == 0); - n = static_cast(value & ((1U << 1)-1)); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("n", std::to_string(n))); - } -#endif -#endif -}; -// Enable or disable PMU counting (debug feature only) -struct npu_op_pmu_mask_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t enable:1; // Enable or disable PMU mask - uint32_t reserved1:15; -#ifdef __cplusplus -public: - npu_op_pmu_mask_t(uint32_t _enable) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_PMU_MASK)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - enable(_enable & ((1U << 1)-1)), - reserved1(0) - {} - CONSTEXPR npu_op_pmu_mask_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_PMU_MASK)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - enable(0), - reserved1(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_PMU_MASK) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_OP_PMU_MASK); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - word |= uint32_t(enable) << 16; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_op_pmu_mask_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_op_pmu_mask_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR uint32_t get_enable() const - { - return static_cast(enable); - } - CONSTEXPR npu_op_pmu_mask_t& set_enable(uint32_t value) - { - assert((value >> 1) == 0); - enable = static_cast(value & ((1U << 1)-1)); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("enable", std::to_string(enable))); - } -#endif -#endif -}; -// IFM top pad -struct npu_set_ifm_pad_top_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t pad:7; // IFM top pad - uint32_t reserved1:9; -#ifdef __cplusplus -public: - npu_set_ifm_pad_top_t(uint32_t _pad) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PAD_TOP)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - pad(_pad & ((1U << 7)-1)), - reserved1(0) - {} - CONSTEXPR npu_set_ifm_pad_top_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PAD_TOP)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - pad(0), - reserved1(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PAD_TOP) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PAD_TOP); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - word |= uint32_t(pad) << 16; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm_pad_top_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm_pad_top_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR uint32_t get_pad() const - { - return static_cast(pad); - } - CONSTEXPR npu_set_ifm_pad_top_t& set_pad(uint32_t value) - { - assert((value >> 7) == 0); - pad = static_cast(value & ((1U << 7)-1)); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("pad", std::to_string(pad))); - } -#endif -#endif -}; -// IFM left pad -struct npu_set_ifm_pad_left_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t pad:7; // IFM left pad - uint32_t reserved1:9; -#ifdef __cplusplus -public: - npu_set_ifm_pad_left_t(uint32_t _pad) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PAD_LEFT)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - pad(_pad & ((1U << 7)-1)), - reserved1(0) - {} - CONSTEXPR npu_set_ifm_pad_left_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PAD_LEFT)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - pad(0), - reserved1(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PAD_LEFT) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PAD_LEFT); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - word |= uint32_t(pad) << 16; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm_pad_left_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm_pad_left_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR uint32_t get_pad() const - { - return static_cast(pad); - } - CONSTEXPR npu_set_ifm_pad_left_t& set_pad(uint32_t value) - { - assert((value >> 7) == 0); - pad = static_cast(value & ((1U << 7)-1)); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("pad", std::to_string(pad))); - } -#endif -#endif -}; -// IFM right pad -struct npu_set_ifm_pad_right_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t pad:8; // IFM right pad. Max value is 128 - uint32_t reserved1:8; -#ifdef __cplusplus -public: - npu_set_ifm_pad_right_t(uint32_t _pad) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PAD_RIGHT)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - pad(_pad & ((1U << 8)-1)), - reserved1(0) - {} - CONSTEXPR npu_set_ifm_pad_right_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PAD_RIGHT)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - pad(0), - reserved1(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PAD_RIGHT) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PAD_RIGHT); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - word |= uint32_t(pad) << 16; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm_pad_right_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm_pad_right_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR uint32_t get_pad() const - { - return static_cast(pad); - } - CONSTEXPR npu_set_ifm_pad_right_t& set_pad(uint32_t value) - { - assert((value >> 8) == 0); - pad = static_cast(value & ((1U << 8)-1)); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("pad", std::to_string(pad))); - } -#endif -#endif -}; -// IFM bottom pad -struct npu_set_ifm_pad_bottom_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t pad:8; // IFM bottom pad. Max value is 128 - uint32_t reserved1:8; -#ifdef __cplusplus -public: - npu_set_ifm_pad_bottom_t(uint32_t _pad) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PAD_BOTTOM)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - pad(_pad & ((1U << 8)-1)), - reserved1(0) - {} - CONSTEXPR npu_set_ifm_pad_bottom_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PAD_BOTTOM)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - pad(0), - reserved1(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PAD_BOTTOM) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PAD_BOTTOM); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - word |= uint32_t(pad) << 16; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm_pad_bottom_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm_pad_bottom_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR uint32_t get_pad() const - { - return static_cast(pad); - } - CONSTEXPR npu_set_ifm_pad_bottom_t& set_pad(uint32_t value) - { - assert((value >> 8) == 0); - pad = static_cast(value & ((1U << 8)-1)); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("pad", std::to_string(pad))); - } -#endif -#endif -}; -// Number of input channels for convolution -struct npu_set_ifm_depth_m1_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t depth_m1:16; // Number of input channels for convolution -#ifdef __cplusplus -public: - npu_set_ifm_depth_m1_t(uint32_t _depth_m1) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_DEPTH_M1)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - depth_m1(_depth_m1 & ((1U << 16)-1)) - {} - CONSTEXPR npu_set_ifm_depth_m1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_DEPTH_M1)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - depth_m1(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_DEPTH_M1) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_DEPTH_M1); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - word |= uint32_t(depth_m1) << 16; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm_depth_m1_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm_depth_m1_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR uint32_t get_depth_m1() const - { - return static_cast(depth_m1); - } - CONSTEXPR npu_set_ifm_depth_m1_t& set_depth_m1(uint32_t value) - { - assert((value >> 16) == 0); - depth_m1 = static_cast(value & ((1U << 16)-1)); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("depth_m1", std::to_string(depth_m1))); - } -#endif -#endif -}; -// IFM Precision -struct npu_set_ifm_precision_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t activation_type:1; // IFM type - uint32_t reserved1:1; - uint32_t activation_precision:2; // IFM precision - uint32_t reserved2:2; - uint32_t activation_format:2; // IFM format - uint32_t reserved3:6; - uint32_t activation_storage:2; // IFM storage mode -#ifdef __cplusplus -public: - npu_set_ifm_precision_t(NPU_NAMESPACE::activation_type _activation_type, NPU_NAMESPACE::activation_precision _activation_precision, NPU_NAMESPACE::activation_format _activation_format, NPU_NAMESPACE::activation_storage _activation_storage) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PRECISION)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - activation_type(static_cast(_activation_type) & ((1U << 1)-1)), - reserved1(0), - activation_precision(static_cast(_activation_precision) & ((1U << 2)-1)), - reserved2(0), - activation_format(static_cast(_activation_format) & ((1U << 2)-1)), - reserved3(0), - activation_storage(static_cast(_activation_storage) & ((1U << 2)-1)) - {} - CONSTEXPR npu_set_ifm_precision_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PRECISION)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - activation_type(0), - reserved1(0), - activation_precision(0), - reserved2(0), - activation_format(0), - reserved3(0), - activation_storage(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PRECISION) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_PRECISION); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - word |= uint32_t(activation_type) << 16; - word |= uint32_t(activation_precision) << 18; - word |= uint32_t(activation_format) << 22; - word |= uint32_t(activation_storage) << 30; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm_precision_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm_precision_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::activation_type get_activation_type() const - { - return static_cast(activation_type); - } - CONSTEXPR npu_set_ifm_precision_t& set_activation_type(NPU_NAMESPACE::activation_type value) - { - activation_type = static_cast(value) & ((1U << 1)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::activation_precision get_activation_precision() const - { - return static_cast(activation_precision); - } - CONSTEXPR npu_set_ifm_precision_t& set_activation_precision(NPU_NAMESPACE::activation_precision value) - { - activation_precision = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::activation_format get_activation_format() const - { - return static_cast(activation_format); - } - CONSTEXPR npu_set_ifm_precision_t& set_activation_format(NPU_NAMESPACE::activation_format value) - { - activation_format = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::activation_storage get_activation_storage() const - { - return static_cast(activation_storage); - } - CONSTEXPR npu_set_ifm_precision_t& set_activation_storage(NPU_NAMESPACE::activation_storage value) - { - activation_storage = static_cast(value) & ((1U << 2)-1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("activation_type", (activation_type < (sizeof(activation_type_str)/sizeof(activation_type_str[0])) ? activation_type_str[activation_type] : "****"))); - fields.push_back(std::make_pair("activation_precision", (activation_precision < (sizeof(activation_precision_str)/sizeof(activation_precision_str[0])) ? activation_precision_str[activation_precision] : "****"))); - fields.push_back(std::make_pair("activation_format", (activation_format < (sizeof(activation_format_str)/sizeof(activation_format_str[0])) ? activation_format_str[activation_format] : "****"))); - fields.push_back(std::make_pair("activation_storage", (activation_storage < (sizeof(activation_storage_str)/sizeof(activation_storage_str[0])) ? activation_storage_str[activation_storage] : "****"))); - } -#endif -#endif -}; -// IFM upscale mode -struct npu_set_ifm_upscale_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t mode:2; // IFM upscale mode - uint32_t reserved1:14; -#ifdef __cplusplus -public: - npu_set_ifm_upscale_t(NPU_NAMESPACE::ifm_upscale_mode _mode) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_UPSCALE)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - mode(static_cast(_mode) & ((1U << 2)-1)), - reserved1(0) - {} - CONSTEXPR npu_set_ifm_upscale_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_UPSCALE)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - mode(0), - reserved1(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_UPSCALE) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_UPSCALE); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - word |= uint32_t(mode) << 16; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm_upscale_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm_upscale_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::ifm_upscale_mode get_mode() const - { - return static_cast(mode); - } - CONSTEXPR npu_set_ifm_upscale_t& set_mode(NPU_NAMESPACE::ifm_upscale_mode value) - { - mode = static_cast(value) & ((1U << 2)-1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("mode", (mode < (sizeof(ifm_upscale_mode_str)/sizeof(ifm_upscale_mode_str[0])) ? ifm_upscale_mode_str[mode] : "****"))); - } -#endif -#endif -}; -// IFM zero point -struct npu_set_ifm_zero_point_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t zero_point:16; // Zero point offset -#ifdef __cplusplus -public: - npu_set_ifm_zero_point_t(uint32_t _zero_point) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_ZERO_POINT)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - zero_point(_zero_point & ((1U << 16)-1)) - {} - CONSTEXPR npu_set_ifm_zero_point_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_ZERO_POINT)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - zero_point(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_ZERO_POINT) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_ZERO_POINT); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - word |= uint32_t(zero_point) << 16; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm_zero_point_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm_zero_point_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR uint32_t get_zero_point() const - { - return static_cast(zero_point); - } - CONSTEXPR npu_set_ifm_zero_point_t& set_zero_point(uint32_t value) - { - assert((value >> 16) == 0); - zero_point = static_cast(value & ((1U << 16)-1)); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("zero_point", std::to_string(zero_point))); - } -#endif -#endif -}; -// IFM Tile 0 and Tile 2 width -struct npu_set_ifm_width0_m1_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t width_m1:16; // IFM Tile 0 and tile 2 width -#ifdef __cplusplus -public: - npu_set_ifm_width0_m1_t(uint32_t _width_m1) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_WIDTH0_M1)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - width_m1(_width_m1 & ((1U << 16)-1)) - {} - CONSTEXPR npu_set_ifm_width0_m1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_WIDTH0_M1)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - width_m1(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_WIDTH0_M1) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_WIDTH0_M1); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - word |= uint32_t(width_m1) << 16; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm_width0_m1_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm_width0_m1_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR uint32_t get_width_m1() const - { - return static_cast(width_m1); - } - CONSTEXPR npu_set_ifm_width0_m1_t& set_width_m1(uint32_t value) - { - assert((value >> 16) == 0); - width_m1 = static_cast(value & ((1U << 16)-1)); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("width_m1", std::to_string(width_m1))); - } -#endif -#endif -}; -// IFM Tile 0 height -struct npu_set_ifm_height0_m1_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t height_m1:16; // IFM Tile 0 height -#ifdef __cplusplus -public: - npu_set_ifm_height0_m1_t(uint32_t _height_m1) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_HEIGHT0_M1)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - height_m1(_height_m1 & ((1U << 16)-1)) - {} - CONSTEXPR npu_set_ifm_height0_m1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_HEIGHT0_M1)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - height_m1(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_HEIGHT0_M1) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_HEIGHT0_M1); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - word |= uint32_t(height_m1) << 16; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm_height0_m1_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm_height0_m1_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR uint32_t get_height_m1() const - { - return static_cast(height_m1); - } - CONSTEXPR npu_set_ifm_height0_m1_t& set_height_m1(uint32_t value) - { - assert((value >> 16) == 0); - height_m1 = static_cast(value & ((1U << 16)-1)); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("height_m1", std::to_string(height_m1))); - } -#endif -#endif -}; -// IFM Tile 1 height -struct npu_set_ifm_height1_m1_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t height_m1:16; // IFM Tile 1 height -#ifdef __cplusplus -public: - npu_set_ifm_height1_m1_t(uint32_t _height_m1) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_HEIGHT1_M1)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - height_m1(_height_m1 & ((1U << 16)-1)) - {} - CONSTEXPR npu_set_ifm_height1_m1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_HEIGHT1_M1)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - height_m1(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_HEIGHT1_M1) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_HEIGHT1_M1); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - word |= uint32_t(height_m1) << 16; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm_height1_m1_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm_height1_m1_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR uint32_t get_height_m1() const - { - return static_cast(height_m1); - } - CONSTEXPR npu_set_ifm_height1_m1_t& set_height_m1(uint32_t value) - { - assert((value >> 16) == 0); - height_m1 = static_cast(value & ((1U << 16)-1)); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("height_m1", std::to_string(height_m1))); - } -#endif -#endif -}; -// Index n for IFM access -struct npu_set_ifm_region_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t region:3; // Region number for external memory accesses - uint32_t reserved1:13; -#ifdef __cplusplus -public: - npu_set_ifm_region_t(uint32_t _region) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_REGION)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - region(_region & ((1U << 3)-1)), - reserved1(0) - {} - CONSTEXPR npu_set_ifm_region_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_REGION)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - region(0), - reserved1(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_REGION) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_REGION); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - word |= uint32_t(region) << 16; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm_region_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm_region_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR uint32_t get_region() const - { - return static_cast(region); - } - CONSTEXPR npu_set_ifm_region_t& set_region(uint32_t value) - { - assert((value >> 3) == 0); - region = static_cast(value & ((1U << 3)-1)); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("region", std::to_string(region))); - } -#endif -#endif -}; -// IFM broadcast configuration -struct npu_set_ifm_broadcast_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t broadcast_mode:4; // Broadcast mode for IFM - uint32_t reserved1:12; -#ifdef __cplusplus -public: - npu_set_ifm_broadcast_t(NPU_NAMESPACE::broadcast_mode _broadcast_mode) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_BROADCAST)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - broadcast_mode(static_cast(_broadcast_mode) & ((1U << 4)-1)), - reserved1(0) - {} - CONSTEXPR npu_set_ifm_broadcast_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_BROADCAST)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - broadcast_mode(0), - reserved1(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_BROADCAST) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM_BROADCAST); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - word |= uint32_t(broadcast_mode) << 16; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm_broadcast_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm_broadcast_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::broadcast_mode get_broadcast_mode() const - { - return static_cast(broadcast_mode); - } - CONSTEXPR npu_set_ifm_broadcast_t& set_broadcast_mode(NPU_NAMESPACE::broadcast_mode value) - { - broadcast_mode = static_cast(value) & ((1U << 4)-1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("broadcast_mode", (broadcast_mode < (sizeof(broadcast_mode_str)/sizeof(broadcast_mode_str[0])) ? broadcast_mode_str[broadcast_mode] : "****"))); - } -#endif -#endif -}; -// Output feature map width -struct npu_set_ofm_width_m1_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t width_m1:16; // Output feature map width -#ifdef __cplusplus -public: - npu_set_ofm_width_m1_t(uint32_t _width_m1) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_WIDTH_M1)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - width_m1(_width_m1 & ((1U << 16)-1)) - {} - CONSTEXPR npu_set_ofm_width_m1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_WIDTH_M1)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - width_m1(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_WIDTH_M1) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_WIDTH_M1); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - word |= uint32_t(width_m1) << 16; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ofm_width_m1_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ofm_width_m1_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR uint32_t get_width_m1() const - { - return static_cast(width_m1); - } - CONSTEXPR npu_set_ofm_width_m1_t& set_width_m1(uint32_t value) - { - assert((value >> 16) == 0); - width_m1 = static_cast(value & ((1U << 16)-1)); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("width_m1", std::to_string(width_m1))); - } -#endif -#endif -}; -// Output feature map height -struct npu_set_ofm_height_m1_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t height_m1:16; // Output feature map height -#ifdef __cplusplus -public: - npu_set_ofm_height_m1_t(uint32_t _height_m1) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_HEIGHT_M1)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - height_m1(_height_m1 & ((1U << 16)-1)) - {} - CONSTEXPR npu_set_ofm_height_m1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_HEIGHT_M1)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - height_m1(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_HEIGHT_M1) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_HEIGHT_M1); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - word |= uint32_t(height_m1) << 16; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ofm_height_m1_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ofm_height_m1_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR uint32_t get_height_m1() const - { - return static_cast(height_m1); - } - CONSTEXPR npu_set_ofm_height_m1_t& set_height_m1(uint32_t value) - { - assert((value >> 16) == 0); - height_m1 = static_cast(value & ((1U << 16)-1)); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("height_m1", std::to_string(height_m1))); - } -#endif -#endif -}; -// Output feature map depth -struct npu_set_ofm_depth_m1_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t depth_m1:16; // Output feature map depth -#ifdef __cplusplus -public: - npu_set_ofm_depth_m1_t(uint32_t _depth_m1) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_DEPTH_M1)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - depth_m1(_depth_m1 & ((1U << 16)-1)) - {} - CONSTEXPR npu_set_ofm_depth_m1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_DEPTH_M1)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - depth_m1(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_DEPTH_M1) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_DEPTH_M1); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - word |= uint32_t(depth_m1) << 16; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ofm_depth_m1_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ofm_depth_m1_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR uint32_t get_depth_m1() const - { - return static_cast(depth_m1); - } - CONSTEXPR npu_set_ofm_depth_m1_t& set_depth_m1(uint32_t value) - { - assert((value >> 16) == 0); - depth_m1 = static_cast(value & ((1U << 16)-1)); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("depth_m1", std::to_string(depth_m1))); - } -#endif -#endif -}; -// OFM Precision -struct npu_set_ofm_precision_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t activation_type:1; // OFM type - uint32_t activation_precision:2; // OFM precision - uint32_t reserved1:3; - uint32_t activation_format:2; // OFM format - uint32_t scale_mode:1; // OFM scale mode - uint32_t activation_reverse:2; // OFM reverse - uint32_t activation_transpose:3; // OFM transpose - uint32_t activation_storage:2; // OFM storage mode -#ifdef __cplusplus -public: - npu_set_ofm_precision_t(NPU_NAMESPACE::activation_type _activation_type, NPU_NAMESPACE::activation_precision _activation_precision, NPU_NAMESPACE::activation_format _activation_format, NPU_NAMESPACE::ofm_scale_mode _scale_mode, NPU_NAMESPACE::activation_reverse _activation_reverse, NPU_NAMESPACE::activation_transpose _activation_transpose, NPU_NAMESPACE::activation_storage _activation_storage) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_PRECISION)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - activation_type(static_cast(_activation_type) & ((1U << 1)-1)), - activation_precision(static_cast(_activation_precision) & ((1U << 2)-1)), - reserved1(0), - activation_format(static_cast(_activation_format) & ((1U << 2)-1)), - scale_mode(static_cast(_scale_mode) & ((1U << 1)-1)), - activation_reverse(static_cast(_activation_reverse) & ((1U << 2)-1)), - activation_transpose(static_cast(_activation_transpose) & ((1U << 3)-1)), - activation_storage(static_cast(_activation_storage) & ((1U << 2)-1)) - {} - CONSTEXPR npu_set_ofm_precision_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_PRECISION)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - activation_type(0), - activation_precision(0), - reserved1(0), - activation_format(0), - scale_mode(0), - activation_reverse(0), - activation_transpose(0), - activation_storage(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_PRECISION) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_PRECISION); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - word |= uint32_t(activation_type) << 16; - word |= uint32_t(activation_precision) << 17; - word |= uint32_t(activation_format) << 22; - word |= uint32_t(scale_mode) << 24; - word |= uint32_t(activation_reverse) << 25; - word |= uint32_t(activation_transpose) << 27; - word |= uint32_t(activation_storage) << 30; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ofm_precision_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ofm_precision_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::activation_type get_activation_type() const - { - return static_cast(activation_type); - } - CONSTEXPR npu_set_ofm_precision_t& set_activation_type(NPU_NAMESPACE::activation_type value) - { - activation_type = static_cast(value) & ((1U << 1)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::activation_precision get_activation_precision() const - { - return static_cast(activation_precision); - } - CONSTEXPR npu_set_ofm_precision_t& set_activation_precision(NPU_NAMESPACE::activation_precision value) - { - activation_precision = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::activation_format get_activation_format() const - { - return static_cast(activation_format); - } - CONSTEXPR npu_set_ofm_precision_t& set_activation_format(NPU_NAMESPACE::activation_format value) - { - activation_format = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::ofm_scale_mode get_scale_mode() const - { - return static_cast(scale_mode); - } - CONSTEXPR npu_set_ofm_precision_t& set_scale_mode(NPU_NAMESPACE::ofm_scale_mode value) - { - scale_mode = static_cast(value) & ((1U << 1)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::activation_reverse get_activation_reverse() const - { - return static_cast(activation_reverse); - } - CONSTEXPR npu_set_ofm_precision_t& set_activation_reverse(NPU_NAMESPACE::activation_reverse value) - { - activation_reverse = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::activation_transpose get_activation_transpose() const - { - return static_cast(activation_transpose); - } - CONSTEXPR npu_set_ofm_precision_t& set_activation_transpose(NPU_NAMESPACE::activation_transpose value) - { - activation_transpose = static_cast(value) & ((1U << 3)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::activation_storage get_activation_storage() const - { - return static_cast(activation_storage); - } - CONSTEXPR npu_set_ofm_precision_t& set_activation_storage(NPU_NAMESPACE::activation_storage value) - { - activation_storage = static_cast(value) & ((1U << 2)-1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("activation_type", (activation_type < (sizeof(activation_type_str)/sizeof(activation_type_str[0])) ? activation_type_str[activation_type] : "****"))); - fields.push_back(std::make_pair("activation_precision", (activation_precision < (sizeof(activation_precision_str)/sizeof(activation_precision_str[0])) ? activation_precision_str[activation_precision] : "****"))); - fields.push_back(std::make_pair("activation_format", (activation_format < (sizeof(activation_format_str)/sizeof(activation_format_str[0])) ? activation_format_str[activation_format] : "****"))); - fields.push_back(std::make_pair("scale_mode", (scale_mode < (sizeof(ofm_scale_mode_str)/sizeof(ofm_scale_mode_str[0])) ? ofm_scale_mode_str[scale_mode] : "****"))); - fields.push_back(std::make_pair("activation_reverse", (activation_reverse < (sizeof(activation_reverse_str)/sizeof(activation_reverse_str[0])) ? activation_reverse_str[activation_reverse] : "****"))); - fields.push_back(std::make_pair("activation_transpose", (activation_transpose < (sizeof(activation_transpose_str)/sizeof(activation_transpose_str[0])) ? activation_transpose_str[activation_transpose] : "****"))); - fields.push_back(std::make_pair("activation_storage", (activation_storage < (sizeof(activation_storage_str)/sizeof(activation_storage_str[0])) ? activation_storage_str[activation_storage] : "****"))); - } -#endif -#endif -}; -// OFM block width -struct npu_set_ofm_blk_width_m1_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t width_m1:7; // OFM block width - uint32_t reserved1:9; -#ifdef __cplusplus -public: - npu_set_ofm_blk_width_m1_t(uint32_t _width_m1) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_BLK_WIDTH_M1)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - width_m1(_width_m1 & ((1U << 7)-1)), - reserved1(0) - {} - CONSTEXPR npu_set_ofm_blk_width_m1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_BLK_WIDTH_M1)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - width_m1(0), - reserved1(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_BLK_WIDTH_M1) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_BLK_WIDTH_M1); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - word |= uint32_t(width_m1) << 16; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ofm_blk_width_m1_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ofm_blk_width_m1_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR uint32_t get_width_m1() const - { - return static_cast(width_m1); - } - CONSTEXPR npu_set_ofm_blk_width_m1_t& set_width_m1(uint32_t value) - { - assert((value >> 7) == 0); - width_m1 = static_cast(value & ((1U << 7)-1)); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("width_m1", std::to_string(width_m1))); - } -#endif -#endif -}; -// OFM block height -struct npu_set_ofm_blk_height_m1_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t height_m1:7; // OFM block height - uint32_t reserved1:9; -#ifdef __cplusplus -public: - npu_set_ofm_blk_height_m1_t(uint32_t _height_m1) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_BLK_HEIGHT_M1)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - height_m1(_height_m1 & ((1U << 7)-1)), - reserved1(0) - {} - CONSTEXPR npu_set_ofm_blk_height_m1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_BLK_HEIGHT_M1)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - height_m1(0), - reserved1(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_BLK_HEIGHT_M1) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_BLK_HEIGHT_M1); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - word |= uint32_t(height_m1) << 16; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ofm_blk_height_m1_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ofm_blk_height_m1_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR uint32_t get_height_m1() const - { - return static_cast(height_m1); - } - CONSTEXPR npu_set_ofm_blk_height_m1_t& set_height_m1(uint32_t value) - { - assert((value >> 7) == 0); - height_m1 = static_cast(value & ((1U << 7)-1)); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("height_m1", std::to_string(height_m1))); - } -#endif -#endif -}; -// OFM block depth -struct npu_set_ofm_blk_depth_m1_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t depth_m1:10; // OFM block depth - uint32_t reserved1:6; -#ifdef __cplusplus -public: - npu_set_ofm_blk_depth_m1_t(uint32_t _depth_m1) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_BLK_DEPTH_M1)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - depth_m1(_depth_m1 & ((1U << 10)-1)), - reserved1(0) - {} - CONSTEXPR npu_set_ofm_blk_depth_m1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_BLK_DEPTH_M1)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - depth_m1(0), - reserved1(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_BLK_DEPTH_M1) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_BLK_DEPTH_M1); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - word |= uint32_t(depth_m1) << 16; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ofm_blk_depth_m1_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ofm_blk_depth_m1_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR uint32_t get_depth_m1() const - { - return static_cast(depth_m1); - } - CONSTEXPR npu_set_ofm_blk_depth_m1_t& set_depth_m1(uint32_t value) - { - assert((value >> 10) == 0); - depth_m1 = static_cast(value & ((1U << 10)-1)); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("depth_m1", std::to_string(depth_m1))); - } -#endif -#endif -}; -// OFM zero point -struct npu_set_ofm_zero_point_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t zero_point:16; // Zero point offset -#ifdef __cplusplus -public: - npu_set_ofm_zero_point_t(uint32_t _zero_point) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_ZERO_POINT)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - zero_point(_zero_point & ((1U << 16)-1)) - {} - CONSTEXPR npu_set_ofm_zero_point_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_ZERO_POINT)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - zero_point(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_ZERO_POINT) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_ZERO_POINT); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - word |= uint32_t(zero_point) << 16; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ofm_zero_point_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ofm_zero_point_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR uint32_t get_zero_point() const - { - return static_cast(zero_point); - } - CONSTEXPR npu_set_ofm_zero_point_t& set_zero_point(uint32_t value) - { - assert((value >> 16) == 0); - zero_point = static_cast(value & ((1U << 16)-1)); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("zero_point", std::to_string(zero_point))); - } -#endif -#endif -}; -// OFM Tile 0 and tile 2 width -struct npu_set_ofm_width0_m1_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t width_m1:16; // OFM Tile 0 and tile 2 width -#ifdef __cplusplus -public: - npu_set_ofm_width0_m1_t(uint32_t _width_m1) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_WIDTH0_M1)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - width_m1(_width_m1 & ((1U << 16)-1)) - {} - CONSTEXPR npu_set_ofm_width0_m1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_WIDTH0_M1)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - width_m1(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_WIDTH0_M1) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_WIDTH0_M1); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - word |= uint32_t(width_m1) << 16; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ofm_width0_m1_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ofm_width0_m1_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR uint32_t get_width_m1() const - { - return static_cast(width_m1); - } - CONSTEXPR npu_set_ofm_width0_m1_t& set_width_m1(uint32_t value) - { - assert((value >> 16) == 0); - width_m1 = static_cast(value & ((1U << 16)-1)); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("width_m1", std::to_string(width_m1))); - } -#endif -#endif -}; -// OFM Tile 0 height -struct npu_set_ofm_height0_m1_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t height_m1:16; // OFM Tile 0 height -#ifdef __cplusplus -public: - npu_set_ofm_height0_m1_t(uint32_t _height_m1) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_HEIGHT0_M1)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - height_m1(_height_m1 & ((1U << 16)-1)) - {} - CONSTEXPR npu_set_ofm_height0_m1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_HEIGHT0_M1)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - height_m1(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_HEIGHT0_M1) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_HEIGHT0_M1); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - word |= uint32_t(height_m1) << 16; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ofm_height0_m1_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ofm_height0_m1_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR uint32_t get_height_m1() const - { - return static_cast(height_m1); - } - CONSTEXPR npu_set_ofm_height0_m1_t& set_height_m1(uint32_t value) - { - assert((value >> 16) == 0); - height_m1 = static_cast(value & ((1U << 16)-1)); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("height_m1", std::to_string(height_m1))); - } -#endif -#endif -}; -// OFM Tile 1 height -struct npu_set_ofm_height1_m1_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t height_m1:16; // OFM Tile 1 height -#ifdef __cplusplus -public: - npu_set_ofm_height1_m1_t(uint32_t _height_m1) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_HEIGHT1_M1)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - height_m1(_height_m1 & ((1U << 16)-1)) - {} - CONSTEXPR npu_set_ofm_height1_m1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_HEIGHT1_M1)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - height_m1(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_HEIGHT1_M1) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_HEIGHT1_M1); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - word |= uint32_t(height_m1) << 16; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ofm_height1_m1_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ofm_height1_m1_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR uint32_t get_height_m1() const - { - return static_cast(height_m1); - } - CONSTEXPR npu_set_ofm_height1_m1_t& set_height_m1(uint32_t value) - { - assert((value >> 16) == 0); - height_m1 = static_cast(value & ((1U << 16)-1)); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("height_m1", std::to_string(height_m1))); - } -#endif -#endif -}; -// Index n for OFM access -struct npu_set_ofm_region_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t region:3; // Region number for external memory accesses - uint32_t reserved1:13; -#ifdef __cplusplus -public: - npu_set_ofm_region_t(uint32_t _region) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_REGION)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - region(_region & ((1U << 3)-1)), - reserved1(0) - {} - CONSTEXPR npu_set_ofm_region_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_REGION)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - region(0), - reserved1(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_REGION) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_OFM_REGION); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - word |= uint32_t(region) << 16; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ofm_region_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ofm_region_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR uint32_t get_region() const - { - return static_cast(region); - } - CONSTEXPR npu_set_ofm_region_t& set_region(uint32_t value) - { - assert((value >> 3) == 0); - region = static_cast(value & ((1U << 3)-1)); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("region", std::to_string(region))); - } -#endif -#endif -}; -// Kernel width -struct npu_set_kernel_width_m1_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t width_m1:16; // Kernel width -#ifdef __cplusplus -public: - npu_set_kernel_width_m1_t(uint32_t _width_m1) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_KERNEL_WIDTH_M1)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - width_m1(_width_m1 & ((1U << 16)-1)) - {} - CONSTEXPR npu_set_kernel_width_m1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_KERNEL_WIDTH_M1)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - width_m1(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_KERNEL_WIDTH_M1) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_KERNEL_WIDTH_M1); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - word |= uint32_t(width_m1) << 16; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_kernel_width_m1_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_kernel_width_m1_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR uint32_t get_width_m1() const - { - return static_cast(width_m1); - } - CONSTEXPR npu_set_kernel_width_m1_t& set_width_m1(uint32_t value) - { - assert((value >> 16) == 0); - width_m1 = static_cast(value & ((1U << 16)-1)); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("width_m1", std::to_string(width_m1))); - } -#endif -#endif -}; -// Kernel height -struct npu_set_kernel_height_m1_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t height_m1:16; // Kernel height -#ifdef __cplusplus -public: - npu_set_kernel_height_m1_t(uint32_t _height_m1) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_KERNEL_HEIGHT_M1)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - height_m1(_height_m1 & ((1U << 16)-1)) - {} - CONSTEXPR npu_set_kernel_height_m1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_KERNEL_HEIGHT_M1)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - height_m1(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_KERNEL_HEIGHT_M1) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_KERNEL_HEIGHT_M1); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - word |= uint32_t(height_m1) << 16; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_kernel_height_m1_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_kernel_height_m1_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR uint32_t get_height_m1() const - { - return static_cast(height_m1); - } - CONSTEXPR npu_set_kernel_height_m1_t& set_height_m1(uint32_t value) - { - assert((value >> 16) == 0); - height_m1 = static_cast(value & ((1U << 16)-1)); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("height_m1", std::to_string(height_m1))); - } -#endif -#endif -}; -// Kernel stride -struct npu_set_kernel_stride_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t stride_x_lsb:1; // Stride x LSB. (kernel_x_stride - 1)[0] - uint32_t stride_y_lsb:1; // Stride y LSB. (kernel_y_stride - 1)[0] - uint32_t weight_order:1; // Weight ordering mode - uint32_t dilation_x:1; // Kernel x dilation - uint32_t dilation_y:1; // Kernel y dilation - uint32_t decomposition:1; // Kernel decomposition - uint32_t stride_x_msb:1; // Stride x MSB. (kernel_x_stride - 1) >> 1 - uint32_t reserved1:2; - uint32_t stride_y_msb:1; // Stride y MSB. (kernel_y_stride - 1) >> 1 - uint32_t reserved2:6; -#ifdef __cplusplus -public: - npu_set_kernel_stride_t(uint32_t _stride_x_lsb, uint32_t _stride_y_lsb, NPU_NAMESPACE::weight_order _weight_order, NPU_NAMESPACE::kernel_dilation _dilation_x, NPU_NAMESPACE::kernel_dilation _dilation_y, NPU_NAMESPACE::kernel_decomposition _decomposition, uint32_t _stride_x_msb, uint32_t _stride_y_msb) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_KERNEL_STRIDE)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - stride_x_lsb(_stride_x_lsb & ((1U << 1)-1)), - stride_y_lsb(_stride_y_lsb & ((1U << 1)-1)), - weight_order(static_cast(_weight_order) & ((1U << 1)-1)), - dilation_x(static_cast(_dilation_x) & ((1U << 1)-1)), - dilation_y(static_cast(_dilation_y) & ((1U << 1)-1)), - decomposition(static_cast(_decomposition) & ((1U << 1)-1)), - stride_x_msb(_stride_x_msb & ((1U << 1)-1)), - reserved1(0), - stride_y_msb(_stride_y_msb & ((1U << 1)-1)), - reserved2(0) - {} - CONSTEXPR npu_set_kernel_stride_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_KERNEL_STRIDE)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - stride_x_lsb(0), - stride_y_lsb(0), - weight_order(0), - dilation_x(0), - dilation_y(0), - decomposition(0), - stride_x_msb(0), - reserved1(0), - stride_y_msb(0), - reserved2(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_KERNEL_STRIDE) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_KERNEL_STRIDE); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - word |= uint32_t(stride_x_lsb) << 16; - word |= uint32_t(stride_y_lsb) << 17; - word |= uint32_t(weight_order) << 18; - word |= uint32_t(dilation_x) << 19; - word |= uint32_t(dilation_y) << 20; - word |= uint32_t(decomposition) << 21; - word |= uint32_t(stride_x_msb) << 22; - word |= uint32_t(stride_y_msb) << 25; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_kernel_stride_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_kernel_stride_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR uint32_t get_stride_x_lsb() const - { - return static_cast(stride_x_lsb); - } - CONSTEXPR npu_set_kernel_stride_t& set_stride_x_lsb(uint32_t value) - { - assert((value >> 1) == 0); - stride_x_lsb = static_cast(value & ((1U << 1)-1)); - return *this; - } - CONSTEXPR uint32_t get_stride_y_lsb() const - { - return static_cast(stride_y_lsb); - } - CONSTEXPR npu_set_kernel_stride_t& set_stride_y_lsb(uint32_t value) - { - assert((value >> 1) == 0); - stride_y_lsb = static_cast(value & ((1U << 1)-1)); - return *this; - } - CONSTEXPR NPU_NAMESPACE::weight_order get_weight_order() const - { - return static_cast(weight_order); - } - CONSTEXPR npu_set_kernel_stride_t& set_weight_order(NPU_NAMESPACE::weight_order value) - { - weight_order = static_cast(value) & ((1U << 1)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::kernel_dilation get_dilation_x() const - { - return static_cast(dilation_x); - } - CONSTEXPR npu_set_kernel_stride_t& set_dilation_x(NPU_NAMESPACE::kernel_dilation value) - { - dilation_x = static_cast(value) & ((1U << 1)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::kernel_dilation get_dilation_y() const - { - return static_cast(dilation_y); - } - CONSTEXPR npu_set_kernel_stride_t& set_dilation_y(NPU_NAMESPACE::kernel_dilation value) - { - dilation_y = static_cast(value) & ((1U << 1)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::kernel_decomposition get_decomposition() const - { - return static_cast(decomposition); - } - CONSTEXPR npu_set_kernel_stride_t& set_decomposition(NPU_NAMESPACE::kernel_decomposition value) - { - decomposition = static_cast(value) & ((1U << 1)-1); - return *this; - } - CONSTEXPR uint32_t get_stride_x_msb() const - { - return static_cast(stride_x_msb); - } - CONSTEXPR npu_set_kernel_stride_t& set_stride_x_msb(uint32_t value) - { - assert((value >> 1) == 0); - stride_x_msb = static_cast(value & ((1U << 1)-1)); - return *this; - } - CONSTEXPR uint32_t get_stride_y_msb() const - { - return static_cast(stride_y_msb); - } - CONSTEXPR npu_set_kernel_stride_t& set_stride_y_msb(uint32_t value) - { - assert((value >> 1) == 0); - stride_y_msb = static_cast(value & ((1U << 1)-1)); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("stride_x_lsb", std::to_string(stride_x_lsb))); - fields.push_back(std::make_pair("stride_y_lsb", std::to_string(stride_y_lsb))); - fields.push_back(std::make_pair("weight_order", (weight_order < (sizeof(weight_order_str)/sizeof(weight_order_str[0])) ? weight_order_str[weight_order] : "****"))); - fields.push_back(std::make_pair("dilation_x", (dilation_x < (sizeof(kernel_dilation_str)/sizeof(kernel_dilation_str[0])) ? kernel_dilation_str[dilation_x] : "****"))); - fields.push_back(std::make_pair("dilation_y", (dilation_y < (sizeof(kernel_dilation_str)/sizeof(kernel_dilation_str[0])) ? kernel_dilation_str[dilation_y] : "****"))); - fields.push_back(std::make_pair("decomposition", (decomposition < (sizeof(kernel_decomposition_str)/sizeof(kernel_decomposition_str[0])) ? kernel_decomposition_str[decomposition] : "****"))); - fields.push_back(std::make_pair("stride_x_msb", std::to_string(stride_x_msb))); - fields.push_back(std::make_pair("stride_y_msb", std::to_string(stride_y_msb))); - } -#endif -#endif -}; -// Accumulator format -struct npu_set_acc_format_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t acc_format:2; // Accumulator format - uint32_t reserved1:2; - uint32_t acc_input:2; // Accumulator input - uint32_t acc_output:1; // Accumulator output - uint32_t reserved2:1; - uint32_t microblock:3; // Accumulator microblock size - uint32_t reserved3:5; -#ifdef __cplusplus -public: - npu_set_acc_format_t(NPU_NAMESPACE::acc_format _acc_format, NPU_NAMESPACE::acc_input _acc_input, NPU_NAMESPACE::acc_output _acc_output, NPU_NAMESPACE::microblock _microblock) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_ACC_FORMAT)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - acc_format(static_cast(_acc_format) & ((1U << 2)-1)), - reserved1(0), - acc_input(static_cast(_acc_input) & ((1U << 2)-1)), - acc_output(static_cast(_acc_output) & ((1U << 1)-1)), - reserved2(0), - microblock(static_cast(_microblock) & ((1U << 3)-1)), - reserved3(0) - {} - CONSTEXPR npu_set_acc_format_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_ACC_FORMAT)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - acc_format(0), - reserved1(0), - acc_input(0), - acc_output(0), - reserved2(0), - microblock(0), - reserved3(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_ACC_FORMAT) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_ACC_FORMAT); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - word |= uint32_t(acc_format) << 16; - word |= uint32_t(acc_input) << 20; - word |= uint32_t(acc_output) << 22; - word |= uint32_t(microblock) << 24; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_acc_format_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_acc_format_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::acc_format get_acc_format() const - { - return static_cast(acc_format); - } - CONSTEXPR npu_set_acc_format_t& set_acc_format(NPU_NAMESPACE::acc_format value) - { - acc_format = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::acc_input get_acc_input() const - { - return static_cast(acc_input); - } - CONSTEXPR npu_set_acc_format_t& set_acc_input(NPU_NAMESPACE::acc_input value) - { - acc_input = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::acc_output get_acc_output() const - { - return static_cast(acc_output); - } - CONSTEXPR npu_set_acc_format_t& set_acc_output(NPU_NAMESPACE::acc_output value) - { - acc_output = static_cast(value) & ((1U << 1)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::microblock get_microblock() const - { - return static_cast(microblock); - } - CONSTEXPR npu_set_acc_format_t& set_microblock(NPU_NAMESPACE::microblock value) - { - microblock = static_cast(value) & ((1U << 3)-1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("acc_format", (acc_format < (sizeof(acc_format_str)/sizeof(acc_format_str[0])) ? acc_format_str[acc_format] : "****"))); - fields.push_back(std::make_pair("acc_input", (acc_input < (sizeof(acc_input_str)/sizeof(acc_input_str[0])) ? acc_input_str[acc_input] : "****"))); - fields.push_back(std::make_pair("acc_output", (acc_output < (sizeof(acc_output_str)/sizeof(acc_output_str[0])) ? acc_output_str[acc_output] : "****"))); - fields.push_back(std::make_pair("microblock", (microblock < (sizeof(microblock_str)/sizeof(microblock_str[0])) ? microblock_str[microblock] : "****"))); - } -#endif -#endif -}; -// Activation function and clip range -struct npu_set_activation_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t activation_function:5; // Activation function to apply - uint32_t table:3; // Table number to use for LUT - uint32_t reserved1:4; - uint32_t activation_clip_range:1; // Activation clip to apply - uint32_t reserved2:3; -#ifdef __cplusplus -public: - npu_set_activation_t(NPU_NAMESPACE::activation_function _activation_function, uint32_t _table, NPU_NAMESPACE::activation_clip_range _activation_clip_range) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_ACTIVATION)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - activation_function(static_cast(_activation_function) & ((1U << 5)-1)), - table(_table & ((1U << 3)-1)), - reserved1(0), - activation_clip_range(static_cast(_activation_clip_range) & ((1U << 1)-1)), - reserved2(0) - {} - CONSTEXPR npu_set_activation_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_ACTIVATION)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - activation_function(0), - table(0), - reserved1(0), - activation_clip_range(0), - reserved2(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_ACTIVATION) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_ACTIVATION); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - word |= uint32_t(activation_function) << 16; - word |= uint32_t(table) << 21; - word |= uint32_t(activation_clip_range) << 28; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_activation_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_activation_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::activation_function get_activation_function() const - { - return static_cast(activation_function); - } - CONSTEXPR npu_set_activation_t& set_activation_function(NPU_NAMESPACE::activation_function value) - { - activation_function = static_cast(value) & ((1U << 5)-1); - return *this; - } - CONSTEXPR uint32_t get_table() const - { - return static_cast(table); - } - CONSTEXPR npu_set_activation_t& set_table(uint32_t value) - { - assert((value >> 3) == 0); - table = static_cast(value & ((1U << 3)-1)); - return *this; - } - CONSTEXPR NPU_NAMESPACE::activation_clip_range get_activation_clip_range() const - { - return static_cast(activation_clip_range); - } - CONSTEXPR npu_set_activation_t& set_activation_clip_range(NPU_NAMESPACE::activation_clip_range value) - { - activation_clip_range = static_cast(value) & ((1U << 1)-1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("activation_function", (activation_function < (sizeof(activation_function_str)/sizeof(activation_function_str[0])) ? activation_function_str[activation_function] : "****"))); - fields.push_back(std::make_pair("table", std::to_string(table))); - fields.push_back(std::make_pair("activation_clip_range", (activation_clip_range < (sizeof(activation_clip_range_str)/sizeof(activation_clip_range_str[0])) ? activation_clip_range_str[activation_clip_range] : "****"))); - } -#endif -#endif -}; -// Lower bound clip -struct npu_set_activation_min_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t clip_boundary:16; // Clip boundary for OFM activations -#ifdef __cplusplus -public: - npu_set_activation_min_t(uint32_t _clip_boundary) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_ACTIVATION_MIN)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - clip_boundary(_clip_boundary & ((1U << 16)-1)) - {} - CONSTEXPR npu_set_activation_min_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_ACTIVATION_MIN)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - clip_boundary(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_ACTIVATION_MIN) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_ACTIVATION_MIN); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - word |= uint32_t(clip_boundary) << 16; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_activation_min_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_activation_min_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR uint32_t get_clip_boundary() const - { - return static_cast(clip_boundary); - } - CONSTEXPR npu_set_activation_min_t& set_clip_boundary(uint32_t value) - { - assert((value >> 16) == 0); - clip_boundary = static_cast(value & ((1U << 16)-1)); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("clip_boundary", std::to_string(clip_boundary))); - } -#endif -#endif -}; -// Upper bound clip -struct npu_set_activation_max_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t clip_boundary:16; // Clip boundary for OFM activations -#ifdef __cplusplus -public: - npu_set_activation_max_t(uint32_t _clip_boundary) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_ACTIVATION_MAX)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - clip_boundary(_clip_boundary & ((1U << 16)-1)) - {} - CONSTEXPR npu_set_activation_max_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_ACTIVATION_MAX)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - clip_boundary(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_ACTIVATION_MAX) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_ACTIVATION_MAX); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - word |= uint32_t(clip_boundary) << 16; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_activation_max_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_activation_max_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR uint32_t get_clip_boundary() const - { - return static_cast(clip_boundary); - } - CONSTEXPR npu_set_activation_max_t& set_clip_boundary(uint32_t value) - { - assert((value >> 16) == 0); - clip_boundary = static_cast(value & ((1U << 16)-1)); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("clip_boundary", std::to_string(clip_boundary))); - } -#endif -#endif -}; -// Index n for weight stream access -struct npu_set_weight_region_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t region:3; // Index n for weight stream access - uint32_t reserved1:13; -#ifdef __cplusplus -public: - npu_set_weight_region_t(uint32_t _region) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_WEIGHT_REGION)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - region(_region & ((1U << 3)-1)), - reserved1(0) - {} - CONSTEXPR npu_set_weight_region_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_WEIGHT_REGION)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - region(0), - reserved1(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_WEIGHT_REGION) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_WEIGHT_REGION); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - word |= uint32_t(region) << 16; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_weight_region_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_weight_region_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR uint32_t get_region() const - { - return static_cast(region); - } - CONSTEXPR npu_set_weight_region_t& set_region(uint32_t value) - { - assert((value >> 3) == 0); - region = static_cast(value & ((1U << 3)-1)); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("region", std::to_string(region))); - } -#endif -#endif -}; -// Index n for scale stream access -struct npu_set_scale_region_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t region:3; // Index n for scale stream access - uint32_t reserved1:13; -#ifdef __cplusplus -public: - npu_set_scale_region_t(uint32_t _region) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_SCALE_REGION)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - region(_region & ((1U << 3)-1)), - reserved1(0) - {} - CONSTEXPR npu_set_scale_region_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_SCALE_REGION)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - region(0), - reserved1(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_SCALE_REGION) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_SCALE_REGION); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - word |= uint32_t(region) << 16; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_scale_region_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_scale_region_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR uint32_t get_region() const - { - return static_cast(region); - } - CONSTEXPR npu_set_scale_region_t& set_region(uint32_t value) - { - assert((value >> 3) == 0); - region = static_cast(value & ((1U << 3)-1)); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("region", std::to_string(region))); - } -#endif -#endif -}; -// Set weight stream format -struct npu_set_weight_format_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t weight_format:1; // Weight stream format - uint32_t reserved1:3; - uint32_t weight_sparsity:1; // Weight sparsity type - uint32_t reserved2:11; -#ifdef __cplusplus -public: - npu_set_weight_format_t(NPU_NAMESPACE::weight_format _weight_format, NPU_NAMESPACE::weight_sparsity _weight_sparsity) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_WEIGHT_FORMAT)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - weight_format(static_cast(_weight_format) & ((1U << 1)-1)), - reserved1(0), - weight_sparsity(static_cast(_weight_sparsity) & ((1U << 1)-1)), - reserved2(0) - {} - CONSTEXPR npu_set_weight_format_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_WEIGHT_FORMAT)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - weight_format(0), - reserved1(0), - weight_sparsity(0), - reserved2(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_WEIGHT_FORMAT) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_WEIGHT_FORMAT); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - word |= uint32_t(weight_format) << 16; - word |= uint32_t(weight_sparsity) << 20; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_weight_format_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_weight_format_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::weight_format get_weight_format() const - { - return static_cast(weight_format); - } - CONSTEXPR npu_set_weight_format_t& set_weight_format(NPU_NAMESPACE::weight_format value) - { - weight_format = static_cast(value) & ((1U << 1)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::weight_sparsity get_weight_sparsity() const - { - return static_cast(weight_sparsity); - } - CONSTEXPR npu_set_weight_format_t& set_weight_sparsity(NPU_NAMESPACE::weight_sparsity value) - { - weight_sparsity = static_cast(value) & ((1U << 1)-1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("weight_format", (weight_format < (sizeof(weight_format_str)/sizeof(weight_format_str[0])) ? weight_format_str[weight_format] : "****"))); - fields.push_back(std::make_pair("weight_sparsity", (weight_sparsity < (sizeof(weight_sparsity_str)/sizeof(weight_sparsity_str[0])) ? weight_sparsity_str[weight_sparsity] : "****"))); - } -#endif -#endif -}; -// Block number of blocks dependency -struct npu_set_blockdep_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t blockdep:3; // Block number of blocks dependency between kernel operations - uint32_t reserved1:13; -#ifdef __cplusplus -public: - npu_set_blockdep_t(uint32_t _blockdep) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_BLOCKDEP)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - blockdep(_blockdep & ((1U << 3)-1)), - reserved1(0) - {} - CONSTEXPR npu_set_blockdep_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_BLOCKDEP)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - blockdep(0), - reserved1(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_BLOCKDEP) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_BLOCKDEP); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - word |= uint32_t(blockdep) << 16; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_blockdep_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_blockdep_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR uint32_t get_blockdep() const - { - return static_cast(blockdep); - } - CONSTEXPR npu_set_blockdep_t& set_blockdep(uint32_t value) - { - assert((value >> 3) == 0); - blockdep = static_cast(value & ((1U << 3)-1)); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("blockdep", std::to_string(blockdep))); - } -#endif -#endif -}; -// Set resize scale X numerator -struct npu_set_resize_x_scale_n_m1_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t resize_x_scale_n_m1:11; // Resize X scale numerator - uint32_t reserved1:5; -#ifdef __cplusplus -public: - npu_set_resize_x_scale_n_m1_t(uint32_t _resize_x_scale_n_m1) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_RESIZE_X_SCALE_N_M1)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - resize_x_scale_n_m1(_resize_x_scale_n_m1 & ((1U << 11)-1)), - reserved1(0) - {} - CONSTEXPR npu_set_resize_x_scale_n_m1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_RESIZE_X_SCALE_N_M1)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - resize_x_scale_n_m1(0), - reserved1(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_RESIZE_X_SCALE_N_M1) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_RESIZE_X_SCALE_N_M1); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - word |= uint32_t(resize_x_scale_n_m1) << 16; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_resize_x_scale_n_m1_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_resize_x_scale_n_m1_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR uint32_t get_resize_x_scale_n_m1() const - { - return static_cast(resize_x_scale_n_m1); - } - CONSTEXPR npu_set_resize_x_scale_n_m1_t& set_resize_x_scale_n_m1(uint32_t value) - { - assert((value >> 11) == 0); - resize_x_scale_n_m1 = static_cast(value & ((1U << 11)-1)); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("resize_x_scale_n_m1", std::to_string(resize_x_scale_n_m1))); - } -#endif -#endif -}; -// Set resize scale Y numerator -struct npu_set_resize_y_scale_n_m1_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t resize_y_scale_n_m1:11; // Resize Y scale numerator - uint32_t reserved1:5; -#ifdef __cplusplus -public: - npu_set_resize_y_scale_n_m1_t(uint32_t _resize_y_scale_n_m1) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_RESIZE_Y_SCALE_N_M1)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - resize_y_scale_n_m1(_resize_y_scale_n_m1 & ((1U << 11)-1)), - reserved1(0) - {} - CONSTEXPR npu_set_resize_y_scale_n_m1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_RESIZE_Y_SCALE_N_M1)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - resize_y_scale_n_m1(0), - reserved1(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_RESIZE_Y_SCALE_N_M1) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_RESIZE_Y_SCALE_N_M1); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - word |= uint32_t(resize_y_scale_n_m1) << 16; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_resize_y_scale_n_m1_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_resize_y_scale_n_m1_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR uint32_t get_resize_y_scale_n_m1() const - { - return static_cast(resize_y_scale_n_m1); - } - CONSTEXPR npu_set_resize_y_scale_n_m1_t& set_resize_y_scale_n_m1(uint32_t value) - { - assert((value >> 11) == 0); - resize_y_scale_n_m1 = static_cast(value & ((1U << 11)-1)); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("resize_y_scale_n_m1", std::to_string(resize_y_scale_n_m1))); - } -#endif -#endif -}; -// Set resize offset X -struct npu_set_resize_x_offset_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t resize_x_offset:12; // Resize X offset - uint32_t reserved1:4; -#ifdef __cplusplus -public: - npu_set_resize_x_offset_t(uint32_t _resize_x_offset) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_RESIZE_X_OFFSET)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - resize_x_offset(_resize_x_offset & ((1U << 12)-1)), - reserved1(0) - {} - CONSTEXPR npu_set_resize_x_offset_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_RESIZE_X_OFFSET)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - resize_x_offset(0), - reserved1(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_RESIZE_X_OFFSET) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_RESIZE_X_OFFSET); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - word |= uint32_t(resize_x_offset) << 16; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_resize_x_offset_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_resize_x_offset_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR uint32_t get_resize_x_offset() const - { - return static_cast(resize_x_offset); - } - CONSTEXPR npu_set_resize_x_offset_t& set_resize_x_offset(uint32_t value) - { - assert((value >> 12) == 0); - resize_x_offset = static_cast(value & ((1U << 12)-1)); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("resize_x_offset", std::to_string(((resize_x_offset <= std::numeric_limits::max() ? static_cast(resize_x_offset) : resize_x_offset - std::numeric_limits::min() + std::numeric_limits::max()) << 20) >> 20))); - } -#endif -#endif -}; -// Set resize offset Y -struct npu_set_resize_y_offset_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t resize_y_offset:12; // Resize Y offset - uint32_t reserved1:4; -#ifdef __cplusplus -public: - npu_set_resize_y_offset_t(uint32_t _resize_y_offset) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_RESIZE_Y_OFFSET)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - resize_y_offset(_resize_y_offset & ((1U << 12)-1)), - reserved1(0) - {} - CONSTEXPR npu_set_resize_y_offset_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_RESIZE_Y_OFFSET)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - resize_y_offset(0), - reserved1(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_RESIZE_Y_OFFSET) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_RESIZE_Y_OFFSET); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - word |= uint32_t(resize_y_offset) << 16; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_resize_y_offset_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_resize_y_offset_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR uint32_t get_resize_y_offset() const - { - return static_cast(resize_y_offset); - } - CONSTEXPR npu_set_resize_y_offset_t& set_resize_y_offset(uint32_t value) - { - assert((value >> 12) == 0); - resize_y_offset = static_cast(value & ((1U << 12)-1)); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("resize_y_offset", std::to_string(((resize_y_offset <= std::numeric_limits::max() ? static_cast(resize_y_offset) : resize_y_offset - std::numeric_limits::min() + std::numeric_limits::max()) << 20) >> 20))); - } -#endif -#endif -}; -// DMA0 source region -struct npu_set_dma0_src_region_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t region:3; // Region number for external memory accesses - uint32_t reserved1:5; - uint32_t region_mode:1; // Region mode - uint32_t stride_mode:2; // Stride mode - uint32_t idx_mode:1; // Index mode for gather or scatter - uint32_t reserved2:4; -#ifdef __cplusplus -public: - npu_set_dma0_src_region_t(uint32_t _region, NPU_NAMESPACE::dma_region_mode _region_mode, NPU_NAMESPACE::dma_stride_mode _stride_mode, NPU_NAMESPACE::dma_idx_mode _idx_mode) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_SRC_REGION)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - region(_region & ((1U << 3)-1)), - reserved1(0), - region_mode(static_cast(_region_mode) & ((1U << 1)-1)), - stride_mode(static_cast(_stride_mode) & ((1U << 2)-1)), - idx_mode(static_cast(_idx_mode) & ((1U << 1)-1)), - reserved2(0) - {} - CONSTEXPR npu_set_dma0_src_region_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_SRC_REGION)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - region(0), - reserved1(0), - region_mode(0), - stride_mode(0), - idx_mode(0), - reserved2(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_SRC_REGION) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_SRC_REGION); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - word |= uint32_t(region) << 16; - word |= uint32_t(region_mode) << 24; - word |= uint32_t(stride_mode) << 25; - word |= uint32_t(idx_mode) << 27; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_dma0_src_region_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_dma0_src_region_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR uint32_t get_region() const - { - return static_cast(region); - } - CONSTEXPR npu_set_dma0_src_region_t& set_region(uint32_t value) - { - assert((value >> 3) == 0); - region = static_cast(value & ((1U << 3)-1)); - return *this; - } - CONSTEXPR NPU_NAMESPACE::dma_region_mode get_region_mode() const - { - return static_cast(region_mode); - } - CONSTEXPR npu_set_dma0_src_region_t& set_region_mode(NPU_NAMESPACE::dma_region_mode value) - { - region_mode = static_cast(value) & ((1U << 1)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::dma_stride_mode get_stride_mode() const - { - return static_cast(stride_mode); - } - CONSTEXPR npu_set_dma0_src_region_t& set_stride_mode(NPU_NAMESPACE::dma_stride_mode value) - { - stride_mode = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::dma_idx_mode get_idx_mode() const - { - return static_cast(idx_mode); - } - CONSTEXPR npu_set_dma0_src_region_t& set_idx_mode(NPU_NAMESPACE::dma_idx_mode value) - { - idx_mode = static_cast(value) & ((1U << 1)-1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("region", std::to_string(region))); - fields.push_back(std::make_pair("region_mode", (region_mode < (sizeof(dma_region_mode_str)/sizeof(dma_region_mode_str[0])) ? dma_region_mode_str[region_mode] : "****"))); - fields.push_back(std::make_pair("stride_mode", (stride_mode < (sizeof(dma_stride_mode_str)/sizeof(dma_stride_mode_str[0])) ? dma_stride_mode_str[stride_mode] : "****"))); - fields.push_back(std::make_pair("idx_mode", (idx_mode < (sizeof(dma_idx_mode_str)/sizeof(dma_idx_mode_str[0])) ? dma_idx_mode_str[idx_mode] : "****"))); - } -#endif -#endif -}; -// DMA0 destination region -struct npu_set_dma0_dst_region_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t region:3; // Region number for memory accesses - uint32_t reserved1:5; - uint32_t region_mode:1; // Region mode - uint32_t reserved2:2; - uint32_t idx_mode:1; // Index mode for gather or scatter - uint32_t reserved3:4; -#ifdef __cplusplus -public: - npu_set_dma0_dst_region_t(uint32_t _region, NPU_NAMESPACE::dma_region_mode _region_mode, NPU_NAMESPACE::dma_idx_mode _idx_mode) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_DST_REGION)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - region(_region & ((1U << 3)-1)), - reserved1(0), - region_mode(static_cast(_region_mode) & ((1U << 1)-1)), - reserved2(0), - idx_mode(static_cast(_idx_mode) & ((1U << 1)-1)), - reserved3(0) - {} - CONSTEXPR npu_set_dma0_dst_region_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_DST_REGION)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - region(0), - reserved1(0), - region_mode(0), - reserved2(0), - idx_mode(0), - reserved3(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_DST_REGION) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_DST_REGION); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - word |= uint32_t(region) << 16; - word |= uint32_t(region_mode) << 24; - word |= uint32_t(idx_mode) << 27; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_dma0_dst_region_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_dma0_dst_region_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR uint32_t get_region() const - { - return static_cast(region); - } - CONSTEXPR npu_set_dma0_dst_region_t& set_region(uint32_t value) - { - assert((value >> 3) == 0); - region = static_cast(value & ((1U << 3)-1)); - return *this; - } - CONSTEXPR NPU_NAMESPACE::dma_region_mode get_region_mode() const - { - return static_cast(region_mode); - } - CONSTEXPR npu_set_dma0_dst_region_t& set_region_mode(NPU_NAMESPACE::dma_region_mode value) - { - region_mode = static_cast(value) & ((1U << 1)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::dma_idx_mode get_idx_mode() const - { - return static_cast(idx_mode); - } - CONSTEXPR npu_set_dma0_dst_region_t& set_idx_mode(NPU_NAMESPACE::dma_idx_mode value) - { - idx_mode = static_cast(value) & ((1U << 1)-1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("region", std::to_string(region))); - fields.push_back(std::make_pair("region_mode", (region_mode < (sizeof(dma_region_mode_str)/sizeof(dma_region_mode_str[0])) ? dma_region_mode_str[region_mode] : "****"))); - fields.push_back(std::make_pair("idx_mode", (idx_mode < (sizeof(dma_idx_mode_str)/sizeof(dma_idx_mode_str[0])) ? dma_idx_mode_str[idx_mode] : "****"))); - } -#endif -#endif -}; -// Size of second dimension for 2D/3D transfers -struct npu_set_dma0_size0_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t size:16; // Size of second dimension for 2D/3D transfers -#ifdef __cplusplus -public: - npu_set_dma0_size0_t(uint32_t _size) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_SIZE0)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - size(_size & ((1U << 16)-1)) - {} - CONSTEXPR npu_set_dma0_size0_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_SIZE0)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - size(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_SIZE0) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_SIZE0); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - word |= uint32_t(size) << 16; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_dma0_size0_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_dma0_size0_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR uint32_t get_size() const - { - return static_cast(size); - } - CONSTEXPR npu_set_dma0_size0_t& set_size(uint32_t value) - { - assert((value >> 16) == 0); - size = static_cast(value & ((1U << 16)-1)); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("size", std::to_string(size))); - } -#endif -#endif -}; -// Size of third dimension for 3D transfers -struct npu_set_dma0_size1_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t size:16; // Size of third dimension for 3D transfers -#ifdef __cplusplus -public: - npu_set_dma0_size1_t(uint32_t _size) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_SIZE1)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - size(_size & ((1U << 16)-1)) - {} - CONSTEXPR npu_set_dma0_size1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_SIZE1)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - size(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_SIZE1) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_SIZE1); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - word |= uint32_t(size) << 16; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_dma0_size1_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_dma0_size1_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR uint32_t get_size() const - { - return static_cast(size); - } - CONSTEXPR npu_set_dma0_size1_t& set_size(uint32_t value) - { - assert((value >> 16) == 0); - size = static_cast(value & ((1U << 16)-1)); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("size", std::to_string(size))); - } -#endif -#endif -}; -// DMA0 index region -struct npu_set_dma0_idx_region_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t region:3; // Region number for external memory accesses - uint32_t reserved1:13; -#ifdef __cplusplus -public: - npu_set_dma0_idx_region_t(uint32_t _region) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_IDX_REGION)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - region(_region & ((1U << 3)-1)), - reserved1(0) - {} - CONSTEXPR npu_set_dma0_idx_region_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_IDX_REGION)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - region(0), - reserved1(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_IDX_REGION) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_DMA0_IDX_REGION); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - word |= uint32_t(region) << 16; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_dma0_idx_region_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_dma0_idx_region_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR uint32_t get_region() const - { - return static_cast(region); - } - CONSTEXPR npu_set_dma0_idx_region_t& set_region(uint32_t value) - { - assert((value >> 3) == 0); - region = static_cast(value & ((1U << 3)-1)); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("region", std::to_string(region))); - } -#endif -#endif -}; -// IFM2 broadcast configuration -struct npu_set_ifm2_broadcast_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t broadcast_mode:4; // Broadcast mode for IFM2 - uint32_t reserved1:12; -#ifdef __cplusplus -public: - npu_set_ifm2_broadcast_t(NPU_NAMESPACE::broadcast_mode _broadcast_mode) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_BROADCAST)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - broadcast_mode(static_cast(_broadcast_mode) & ((1U << 4)-1)), - reserved1(0) - {} - CONSTEXPR npu_set_ifm2_broadcast_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_BROADCAST)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - broadcast_mode(0), - reserved1(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_BROADCAST) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_BROADCAST); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - word |= uint32_t(broadcast_mode) << 16; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm2_broadcast_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm2_broadcast_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::broadcast_mode get_broadcast_mode() const - { - return static_cast(broadcast_mode); - } - CONSTEXPR npu_set_ifm2_broadcast_t& set_broadcast_mode(NPU_NAMESPACE::broadcast_mode value) - { - broadcast_mode = static_cast(value) & ((1U << 4)-1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("broadcast_mode", (broadcast_mode < (sizeof(broadcast_mode_str)/sizeof(broadcast_mode_str[0])) ? broadcast_mode_str[broadcast_mode] : "****"))); - } -#endif -#endif -}; -// IFM2 Precision -struct npu_set_ifm2_precision_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t activation_type:1; // IFM type - uint32_t reserved1:1; - uint32_t activation_precision:2; // IFM precision - uint32_t reserved2:2; - uint32_t activation_format:2; // IFM format - uint32_t reserved3:6; - uint32_t activation_storage:2; // IFM storage mode -#ifdef __cplusplus -public: - npu_set_ifm2_precision_t(NPU_NAMESPACE::activation_type _activation_type, NPU_NAMESPACE::activation_precision _activation_precision, NPU_NAMESPACE::activation_format _activation_format, NPU_NAMESPACE::activation_storage _activation_storage) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_PRECISION)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - activation_type(static_cast(_activation_type) & ((1U << 1)-1)), - reserved1(0), - activation_precision(static_cast(_activation_precision) & ((1U << 2)-1)), - reserved2(0), - activation_format(static_cast(_activation_format) & ((1U << 2)-1)), - reserved3(0), - activation_storage(static_cast(_activation_storage) & ((1U << 2)-1)) - {} - CONSTEXPR npu_set_ifm2_precision_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_PRECISION)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - activation_type(0), - reserved1(0), - activation_precision(0), - reserved2(0), - activation_format(0), - reserved3(0), - activation_storage(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_PRECISION) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_PRECISION); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - word |= uint32_t(activation_type) << 16; - word |= uint32_t(activation_precision) << 18; - word |= uint32_t(activation_format) << 22; - word |= uint32_t(activation_storage) << 30; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm2_precision_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm2_precision_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::activation_type get_activation_type() const - { - return static_cast(activation_type); - } - CONSTEXPR npu_set_ifm2_precision_t& set_activation_type(NPU_NAMESPACE::activation_type value) - { - activation_type = static_cast(value) & ((1U << 1)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::activation_precision get_activation_precision() const - { - return static_cast(activation_precision); - } - CONSTEXPR npu_set_ifm2_precision_t& set_activation_precision(NPU_NAMESPACE::activation_precision value) - { - activation_precision = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::activation_format get_activation_format() const - { - return static_cast(activation_format); - } - CONSTEXPR npu_set_ifm2_precision_t& set_activation_format(NPU_NAMESPACE::activation_format value) - { - activation_format = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::activation_storage get_activation_storage() const - { - return static_cast(activation_storage); - } - CONSTEXPR npu_set_ifm2_precision_t& set_activation_storage(NPU_NAMESPACE::activation_storage value) - { - activation_storage = static_cast(value) & ((1U << 2)-1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("activation_type", (activation_type < (sizeof(activation_type_str)/sizeof(activation_type_str[0])) ? activation_type_str[activation_type] : "****"))); - fields.push_back(std::make_pair("activation_precision", (activation_precision < (sizeof(activation_precision_str)/sizeof(activation_precision_str[0])) ? activation_precision_str[activation_precision] : "****"))); - fields.push_back(std::make_pair("activation_format", (activation_format < (sizeof(activation_format_str)/sizeof(activation_format_str[0])) ? activation_format_str[activation_format] : "****"))); - fields.push_back(std::make_pair("activation_storage", (activation_storage < (sizeof(activation_storage_str)/sizeof(activation_storage_str[0])) ? activation_storage_str[activation_storage] : "****"))); - } -#endif -#endif -}; -// IFM2 zero point -struct npu_set_ifm2_zero_point_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t zero_point:16; // Zero point offset -#ifdef __cplusplus -public: - npu_set_ifm2_zero_point_t(uint32_t _zero_point) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_ZERO_POINT)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - zero_point(_zero_point & ((1U << 16)-1)) - {} - CONSTEXPR npu_set_ifm2_zero_point_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_ZERO_POINT)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - zero_point(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_ZERO_POINT) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_ZERO_POINT); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - word |= uint32_t(zero_point) << 16; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm2_zero_point_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm2_zero_point_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR uint32_t get_zero_point() const - { - return static_cast(zero_point); - } - CONSTEXPR npu_set_ifm2_zero_point_t& set_zero_point(uint32_t value) - { - assert((value >> 16) == 0); - zero_point = static_cast(value & ((1U << 16)-1)); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("zero_point", std::to_string(zero_point))); - } -#endif -#endif -}; -// IFM2 Tile 0 and Tile 2 width -struct npu_set_ifm2_width0_m1_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t width_m1:16; // IFM2 Tile 0 and tile 2 width -#ifdef __cplusplus -public: - npu_set_ifm2_width0_m1_t(uint32_t _width_m1) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_WIDTH0_M1)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - width_m1(_width_m1 & ((1U << 16)-1)) - {} - CONSTEXPR npu_set_ifm2_width0_m1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_WIDTH0_M1)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - width_m1(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_WIDTH0_M1) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_WIDTH0_M1); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - word |= uint32_t(width_m1) << 16; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm2_width0_m1_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm2_width0_m1_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR uint32_t get_width_m1() const - { - return static_cast(width_m1); - } - CONSTEXPR npu_set_ifm2_width0_m1_t& set_width_m1(uint32_t value) - { - assert((value >> 16) == 0); - width_m1 = static_cast(value & ((1U << 16)-1)); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("width_m1", std::to_string(width_m1))); - } -#endif -#endif -}; -// IFM2 Tile 0 height -struct npu_set_ifm2_height0_m1_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t height_m1:16; // IFM2 Tile 0 height -#ifdef __cplusplus -public: - npu_set_ifm2_height0_m1_t(uint32_t _height_m1) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_HEIGHT0_M1)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - height_m1(_height_m1 & ((1U << 16)-1)) - {} - CONSTEXPR npu_set_ifm2_height0_m1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_HEIGHT0_M1)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - height_m1(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_HEIGHT0_M1) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_HEIGHT0_M1); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - word |= uint32_t(height_m1) << 16; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm2_height0_m1_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm2_height0_m1_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR uint32_t get_height_m1() const - { - return static_cast(height_m1); - } - CONSTEXPR npu_set_ifm2_height0_m1_t& set_height_m1(uint32_t value) - { - assert((value >> 16) == 0); - height_m1 = static_cast(value & ((1U << 16)-1)); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("height_m1", std::to_string(height_m1))); - } -#endif -#endif -}; -// IFM2 Tile 1 height -struct npu_set_ifm2_height1_m1_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t height_m1:16; // IFM2 Tile 1 height -#ifdef __cplusplus -public: - npu_set_ifm2_height1_m1_t(uint32_t _height_m1) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_HEIGHT1_M1)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - height_m1(_height_m1 & ((1U << 16)-1)) - {} - CONSTEXPR npu_set_ifm2_height1_m1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_HEIGHT1_M1)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - height_m1(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_HEIGHT1_M1) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_HEIGHT1_M1); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - word |= uint32_t(height_m1) << 16; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm2_height1_m1_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm2_height1_m1_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR uint32_t get_height_m1() const - { - return static_cast(height_m1); - } - CONSTEXPR npu_set_ifm2_height1_m1_t& set_height_m1(uint32_t value) - { - assert((value >> 16) == 0); - height_m1 = static_cast(value & ((1U << 16)-1)); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("height_m1", std::to_string(height_m1))); - } -#endif -#endif -}; -// Index n for IFM2 access -struct npu_set_ifm2_region_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t region:3; // Region number for external memory accesses - uint32_t reserved1:13; -#ifdef __cplusplus -public: - npu_set_ifm2_region_t(uint32_t _region) : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_REGION)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - region(_region & ((1U << 3)-1)), - reserved1(0) - {} - CONSTEXPR npu_set_ifm2_region_t() : - opcode(static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_REGION)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL)), - region(0), - reserved1(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_REGION) && control == static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd0_opcode::NPU_SET_IFM2_REGION); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD0_CTRL); - } - operator uint32_t() - { - uint32_t word = 0; - word |= uint32_t(opcode) << 0; - word |= uint32_t(control) << 14; - word |= uint32_t(region) << 16; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd0_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm2_region_t& set_opcode(NPU_NAMESPACE::cmd0_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm2_region_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR uint32_t get_region() const - { - return static_cast(region); - } - CONSTEXPR npu_set_ifm2_region_t& set_region(uint32_t value) - { - assert((value >> 3) == 0); - region = static_cast(value & ((1U << 3)-1)); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("region", std::to_string(region))); - } -#endif -#endif -}; -// IFM Tile 0 address -struct npu_set_ifm_base0_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t addr_hi:8; // address extension - uint32_t reserved1:8; - uint32_t addr_lo:32; // address offset -#ifdef __cplusplus -public: - npu_set_ifm_base0_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_BASE0)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & static_cast(std::numeric_limits::max()))), - reserved1(0), - addr_lo(static_cast((_addr) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR npu_set_ifm_base0_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_BASE0)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(0), - reserved1(0), - addr_lo(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_BASE0) && control >= 1 && control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_BASE0); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word = 0; - word |= uint64_t(opcode) << 0; - word |= uint64_t(control) << 14; - word |= uint64_t(addr_hi) << 16; - word |= uint64_t(addr_lo) << 32; - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_ifm_base0_t& set_addr(uint64_t value) - { - addr_lo = static_cast((value) & static_cast(std::numeric_limits::max())); addr_hi = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - std::stringstream saddr; saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif -}; -// IFM Tile 1 address -struct npu_set_ifm_base1_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t addr_hi:8; // address extension - uint32_t reserved1:8; - uint32_t addr_lo:32; // address offset -#ifdef __cplusplus -public: - npu_set_ifm_base1_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_BASE1)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & static_cast(std::numeric_limits::max()))), - reserved1(0), - addr_lo(static_cast((_addr) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR npu_set_ifm_base1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_BASE1)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(0), - reserved1(0), - addr_lo(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_BASE1) && control >= 1 && control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_BASE1); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word = 0; - word |= uint64_t(opcode) << 0; - word |= uint64_t(control) << 14; - word |= uint64_t(addr_hi) << 16; - word |= uint64_t(addr_lo) << 32; - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_ifm_base1_t& set_addr(uint64_t value) - { - addr_lo = static_cast((value) & static_cast(std::numeric_limits::max())); addr_hi = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - std::stringstream saddr; saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif -}; -// IFM Tile 2 address -struct npu_set_ifm_base2_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t addr_hi:8; // address extension - uint32_t reserved1:8; - uint32_t addr_lo:32; // address offset -#ifdef __cplusplus -public: - npu_set_ifm_base2_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_BASE2)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & static_cast(std::numeric_limits::max()))), - reserved1(0), - addr_lo(static_cast((_addr) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR npu_set_ifm_base2_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_BASE2)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(0), - reserved1(0), - addr_lo(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_BASE2) && control >= 1 && control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_BASE2); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word = 0; - word |= uint64_t(opcode) << 0; - word |= uint64_t(control) << 14; - word |= uint64_t(addr_hi) << 16; - word |= uint64_t(addr_lo) << 32; - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_ifm_base2_t& set_addr(uint64_t value) - { - addr_lo = static_cast((value) & static_cast(std::numeric_limits::max())); addr_hi = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - std::stringstream saddr; saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif -}; -// IFM Tile 3 address -struct npu_set_ifm_base3_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t addr_hi:8; // address extension - uint32_t reserved1:8; - uint32_t addr_lo:32; // address offset -#ifdef __cplusplus -public: - npu_set_ifm_base3_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_BASE3)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & static_cast(std::numeric_limits::max()))), - reserved1(0), - addr_lo(static_cast((_addr) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR npu_set_ifm_base3_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_BASE3)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(0), - reserved1(0), - addr_lo(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_BASE3) && control >= 1 && control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_BASE3); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word = 0; - word |= uint64_t(opcode) << 0; - word |= uint64_t(control) << 14; - word |= uint64_t(addr_hi) << 16; - word |= uint64_t(addr_lo) << 32; - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_ifm_base3_t& set_addr(uint64_t value) - { - addr_lo = static_cast((value) & static_cast(std::numeric_limits::max())); addr_hi = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - std::stringstream saddr; saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif -}; -// IFM byte stride between horizontal values -struct npu_set_ifm_stride_x_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t addr_hi:8; // address extension - uint32_t reserved1:8; - uint32_t addr_lo:32; // address offset -#ifdef __cplusplus -public: - npu_set_ifm_stride_x_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_STRIDE_X)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & static_cast(std::numeric_limits::max()))), - reserved1(0), - addr_lo(static_cast((_addr) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR npu_set_ifm_stride_x_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_STRIDE_X)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(0), - reserved1(0), - addr_lo(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_STRIDE_X) && control >= 1 && control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_STRIDE_X); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word = 0; - word |= uint64_t(opcode) << 0; - word |= uint64_t(control) << 14; - word |= uint64_t(addr_hi) << 16; - word |= uint64_t(addr_lo) << 32; - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_ifm_stride_x_t& set_addr(uint64_t value) - { - addr_lo = static_cast((value) & static_cast(std::numeric_limits::max())); addr_hi = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - std::stringstream saddr; saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif -}; -// IFM byte stride between vertical values -struct npu_set_ifm_stride_y_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t addr_hi:8; // address extension - uint32_t reserved1:8; - uint32_t addr_lo:32; // address offset -#ifdef __cplusplus -public: - npu_set_ifm_stride_y_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_STRIDE_Y)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & static_cast(std::numeric_limits::max()))), - reserved1(0), - addr_lo(static_cast((_addr) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR npu_set_ifm_stride_y_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_STRIDE_Y)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(0), - reserved1(0), - addr_lo(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_STRIDE_Y) && control >= 1 && control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_STRIDE_Y); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word = 0; - word |= uint64_t(opcode) << 0; - word |= uint64_t(control) << 14; - word |= uint64_t(addr_hi) << 16; - word |= uint64_t(addr_lo) << 32; - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_ifm_stride_y_t& set_addr(uint64_t value) - { - addr_lo = static_cast((value) & static_cast(std::numeric_limits::max())); addr_hi = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - std::stringstream saddr; saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif -}; -// IFM byte stride between channel blocks -struct npu_set_ifm_stride_c_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t addr_hi:8; // address extension - uint32_t reserved1:8; - uint32_t addr_lo:32; // address offset -#ifdef __cplusplus -public: - npu_set_ifm_stride_c_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_STRIDE_C)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & static_cast(std::numeric_limits::max()))), - reserved1(0), - addr_lo(static_cast((_addr) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR npu_set_ifm_stride_c_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_STRIDE_C)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(0), - reserved1(0), - addr_lo(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_STRIDE_C) && control >= 1 && control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_STRIDE_C); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word = 0; - word |= uint64_t(opcode) << 0; - word |= uint64_t(control) << 14; - word |= uint64_t(addr_hi) << 16; - word |= uint64_t(addr_lo) << 32; - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_ifm_stride_c_t& set_addr(uint64_t value) - { - addr_lo = static_cast((value) & static_cast(std::numeric_limits::max())); addr_hi = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - std::stringstream saddr; saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif -}; -// OFM Tile 0 address -struct npu_set_ofm_base0_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t addr_hi:8; // address extension - uint32_t reserved1:8; - uint32_t addr_lo:32; // address offset -#ifdef __cplusplus -public: - npu_set_ofm_base0_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_BASE0)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & static_cast(std::numeric_limits::max()))), - reserved1(0), - addr_lo(static_cast((_addr) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR npu_set_ofm_base0_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_BASE0)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(0), - reserved1(0), - addr_lo(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_BASE0) && control >= 1 && control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_BASE0); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word = 0; - word |= uint64_t(opcode) << 0; - word |= uint64_t(control) << 14; - word |= uint64_t(addr_hi) << 16; - word |= uint64_t(addr_lo) << 32; - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_ofm_base0_t& set_addr(uint64_t value) - { - addr_lo = static_cast((value) & static_cast(std::numeric_limits::max())); addr_hi = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - std::stringstream saddr; saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif -}; -// OFM Tile 1 address -struct npu_set_ofm_base1_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t addr_hi:8; // address extension - uint32_t reserved1:8; - uint32_t addr_lo:32; // address offset -#ifdef __cplusplus -public: - npu_set_ofm_base1_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_BASE1)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & static_cast(std::numeric_limits::max()))), - reserved1(0), - addr_lo(static_cast((_addr) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR npu_set_ofm_base1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_BASE1)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(0), - reserved1(0), - addr_lo(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_BASE1) && control >= 1 && control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_BASE1); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word = 0; - word |= uint64_t(opcode) << 0; - word |= uint64_t(control) << 14; - word |= uint64_t(addr_hi) << 16; - word |= uint64_t(addr_lo) << 32; - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_ofm_base1_t& set_addr(uint64_t value) - { - addr_lo = static_cast((value) & static_cast(std::numeric_limits::max())); addr_hi = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - std::stringstream saddr; saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif -}; -// OFM Tile 2 address -struct npu_set_ofm_base2_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t addr_hi:8; // address extension - uint32_t reserved1:8; - uint32_t addr_lo:32; // address offset -#ifdef __cplusplus -public: - npu_set_ofm_base2_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_BASE2)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & static_cast(std::numeric_limits::max()))), - reserved1(0), - addr_lo(static_cast((_addr) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR npu_set_ofm_base2_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_BASE2)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(0), - reserved1(0), - addr_lo(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_BASE2) && control >= 1 && control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_BASE2); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word = 0; - word |= uint64_t(opcode) << 0; - word |= uint64_t(control) << 14; - word |= uint64_t(addr_hi) << 16; - word |= uint64_t(addr_lo) << 32; - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_ofm_base2_t& set_addr(uint64_t value) - { - addr_lo = static_cast((value) & static_cast(std::numeric_limits::max())); addr_hi = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - std::stringstream saddr; saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif -}; -// OFM Tile 3 address -struct npu_set_ofm_base3_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t addr_hi:8; // address extension - uint32_t reserved1:8; - uint32_t addr_lo:32; // address offset -#ifdef __cplusplus -public: - npu_set_ofm_base3_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_BASE3)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & static_cast(std::numeric_limits::max()))), - reserved1(0), - addr_lo(static_cast((_addr) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR npu_set_ofm_base3_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_BASE3)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(0), - reserved1(0), - addr_lo(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_BASE3) && control >= 1 && control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_BASE3); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word = 0; - word |= uint64_t(opcode) << 0; - word |= uint64_t(control) << 14; - word |= uint64_t(addr_hi) << 16; - word |= uint64_t(addr_lo) << 32; - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_ofm_base3_t& set_addr(uint64_t value) - { - addr_lo = static_cast((value) & static_cast(std::numeric_limits::max())); addr_hi = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - std::stringstream saddr; saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif -}; -// OFM byte stride between horizontal values -struct npu_set_ofm_stride_x_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t addr_hi:8; // address extension - uint32_t reserved1:8; - uint32_t addr_lo:32; // address offset -#ifdef __cplusplus -public: - npu_set_ofm_stride_x_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_STRIDE_X)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & static_cast(std::numeric_limits::max()))), - reserved1(0), - addr_lo(static_cast((_addr) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR npu_set_ofm_stride_x_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_STRIDE_X)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(0), - reserved1(0), - addr_lo(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_STRIDE_X) && control >= 1 && control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_STRIDE_X); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word = 0; - word |= uint64_t(opcode) << 0; - word |= uint64_t(control) << 14; - word |= uint64_t(addr_hi) << 16; - word |= uint64_t(addr_lo) << 32; - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_ofm_stride_x_t& set_addr(uint64_t value) - { - addr_lo = static_cast((value) & static_cast(std::numeric_limits::max())); addr_hi = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - std::stringstream saddr; saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif -}; -// OFM byte stride between vertical values -struct npu_set_ofm_stride_y_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t addr_hi:8; // address extension - uint32_t reserved1:8; - uint32_t addr_lo:32; // address offset -#ifdef __cplusplus -public: - npu_set_ofm_stride_y_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_STRIDE_Y)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & static_cast(std::numeric_limits::max()))), - reserved1(0), - addr_lo(static_cast((_addr) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR npu_set_ofm_stride_y_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_STRIDE_Y)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(0), - reserved1(0), - addr_lo(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_STRIDE_Y) && control >= 1 && control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_STRIDE_Y); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word = 0; - word |= uint64_t(opcode) << 0; - word |= uint64_t(control) << 14; - word |= uint64_t(addr_hi) << 16; - word |= uint64_t(addr_lo) << 32; - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_ofm_stride_y_t& set_addr(uint64_t value) - { - addr_lo = static_cast((value) & static_cast(std::numeric_limits::max())); addr_hi = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - std::stringstream saddr; saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif -}; -// OFM byte stride between channel blocks -struct npu_set_ofm_stride_c_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t addr_hi:8; // address extension - uint32_t reserved1:8; - uint32_t addr_lo:32; // address offset -#ifdef __cplusplus -public: - npu_set_ofm_stride_c_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_STRIDE_C)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & static_cast(std::numeric_limits::max()))), - reserved1(0), - addr_lo(static_cast((_addr) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR npu_set_ofm_stride_c_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_STRIDE_C)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(0), - reserved1(0), - addr_lo(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_STRIDE_C) && control >= 1 && control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_STRIDE_C); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word = 0; - word |= uint64_t(opcode) << 0; - word |= uint64_t(control) << 14; - word |= uint64_t(addr_hi) << 16; - word |= uint64_t(addr_lo) << 32; - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_ofm_stride_c_t& set_addr(uint64_t value) - { - addr_lo = static_cast((value) & static_cast(std::numeric_limits::max())); addr_hi = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - std::stringstream saddr; saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif -}; -// Weight stream byte offset in WEIGHT_REGION -struct npu_set_weight_base_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t addr_hi:8; // address extension - uint32_t reserved1:8; - uint32_t addr_lo:32; // address offset -#ifdef __cplusplus -public: - npu_set_weight_base_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT_BASE)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & static_cast(std::numeric_limits::max()))), - reserved1(0), - addr_lo(static_cast((_addr) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR npu_set_weight_base_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT_BASE)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(0), - reserved1(0), - addr_lo(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT_BASE) && control >= 1 && control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT_BASE); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word = 0; - word |= uint64_t(opcode) << 0; - word |= uint64_t(control) << 14; - word |= uint64_t(addr_hi) << 16; - word |= uint64_t(addr_lo) << 32; - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_weight_base_t& set_addr(uint64_t value) - { - addr_lo = static_cast((value) & static_cast(std::numeric_limits::max())); addr_hi = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - std::stringstream saddr; saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif -}; -// Weight stream byte length -struct npu_set_weight_length_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t reserved1:16; - uint32_t length:32; // Weight stream byte length -#ifdef __cplusplus -public: - npu_set_weight_length_t(uint32_t _length) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT_LENGTH)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - reserved1(0), - length(_length) - {} - CONSTEXPR npu_set_weight_length_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT_LENGTH)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - reserved1(0), - length(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT_LENGTH) && control >= 1 && control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT_LENGTH); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word = 0; - word |= uint64_t(opcode) << 0; - word |= uint64_t(control) << 14; - word |= uint64_t(length) << 32; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd1_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_weight_length_t& set_opcode(NPU_NAMESPACE::cmd1_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_weight_length_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR uint32_t get_length() const - { - return static_cast(length); - } - CONSTEXPR npu_set_weight_length_t& set_length(uint32_t value) - { - length = value; - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("length", std::to_string(length))); - } -#endif -#endif -}; -// Scale and bias stream input byte offset from SCALE_REGION -struct npu_set_scale_base_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t addr_hi:8; // address extension - uint32_t reserved1:8; - uint32_t addr_lo:32; // address offset -#ifdef __cplusplus -public: - npu_set_scale_base_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_SCALE_BASE)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & static_cast(std::numeric_limits::max()))), - reserved1(0), - addr_lo(static_cast((_addr) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR npu_set_scale_base_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_SCALE_BASE)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(0), - reserved1(0), - addr_lo(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_SCALE_BASE) && control >= 1 && control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_SCALE_BASE); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word = 0; - word |= uint64_t(opcode) << 0; - word |= uint64_t(control) << 14; - word |= uint64_t(addr_hi) << 16; - word |= uint64_t(addr_lo) << 32; - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_scale_base_t& set_addr(uint64_t value) - { - addr_lo = static_cast((value) & static_cast(std::numeric_limits::max())); addr_hi = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - std::stringstream saddr; saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif -}; -// Scale and bias stream input byte length -struct npu_set_scale_length_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t reserved1:16; - uint32_t length:20; // Scale and bias stream byte length - uint32_t reserved2:12; -#ifdef __cplusplus -public: - npu_set_scale_length_t(uint32_t _length) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_SCALE_LENGTH)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - reserved1(0), - length(_length & ((1U << 20)-1)), - reserved2(0) - {} - CONSTEXPR npu_set_scale_length_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_SCALE_LENGTH)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - reserved1(0), - length(0), - reserved2(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_SCALE_LENGTH) && control >= 1 && control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_SCALE_LENGTH); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word = 0; - word |= uint64_t(opcode) << 0; - word |= uint64_t(control) << 14; - word |= uint64_t(length) << 32; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd1_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_scale_length_t& set_opcode(NPU_NAMESPACE::cmd1_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_scale_length_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR uint32_t get_length() const - { - return static_cast(length); - } - CONSTEXPR npu_set_scale_length_t& set_length(uint32_t value) - { - assert((value >> 20) == 0); - length = value & ((1U << 20)-1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("length", std::to_string(length))); - } -#endif -#endif -}; -// OFM scale -struct npu_set_ofm_scale_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t shift:6; // Right shift (0 to 63) - uint32_t dbl_rnd:5; // Double rounding shift (0 to 30) - uint32_t reserved1:2; - uint32_t round_mode:3; // Rounding mode - uint32_t scale:31; // Scale value (uint31 = non-negative int32) - uint32_t reserved2:1; -#ifdef __cplusplus -public: - npu_set_ofm_scale_t(uint32_t _shift, uint32_t _dbl_rnd, NPU_NAMESPACE::round_mode_ofm _round_mode, uint32_t _scale) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_SCALE)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - shift(_shift & ((1U << 6)-1)), - dbl_rnd(_dbl_rnd & ((1U << 5)-1)), - reserved1(0), - round_mode(static_cast(_round_mode) & ((1U << 3)-1)), - scale(_scale & ((1U << 31)-1)), - reserved2(0) - {} - CONSTEXPR npu_set_ofm_scale_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_SCALE)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - shift(0), - dbl_rnd(0), - reserved1(0), - round_mode(0), - scale(0), - reserved2(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_SCALE) && control >= 1 && control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OFM_SCALE); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word = 0; - word |= uint64_t(opcode) << 0; - word |= uint64_t(control) << 14; - word |= uint64_t(shift) << 16; - word |= uint64_t(dbl_rnd) << 22; - word |= uint64_t(round_mode) << 29; - word |= uint64_t(scale) << 32; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd1_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ofm_scale_t& set_opcode(NPU_NAMESPACE::cmd1_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ofm_scale_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR uint32_t get_shift() const - { - return static_cast(shift); - } - CONSTEXPR npu_set_ofm_scale_t& set_shift(uint32_t value) - { - assert((value >> 6) == 0); - shift = static_cast(value & ((1U << 6)-1)); - return *this; - } - CONSTEXPR uint32_t get_dbl_rnd() const - { - return static_cast(dbl_rnd); - } - CONSTEXPR npu_set_ofm_scale_t& set_dbl_rnd(uint32_t value) - { - assert((value >> 5) == 0); - dbl_rnd = static_cast(value & ((1U << 5)-1)); - return *this; - } - CONSTEXPR NPU_NAMESPACE::round_mode_ofm get_round_mode() const - { - return static_cast(round_mode); - } - CONSTEXPR npu_set_ofm_scale_t& set_round_mode(NPU_NAMESPACE::round_mode_ofm value) - { - round_mode = static_cast(value) & ((1U << 3)-1); - return *this; - } - CONSTEXPR uint32_t get_scale() const - { - return static_cast(scale); - } - CONSTEXPR npu_set_ofm_scale_t& set_scale(uint32_t value) - { - assert((value >> 31) == 0); - scale = value & ((1U << 31)-1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("shift", std::to_string(shift))); - fields.push_back(std::make_pair("dbl_rnd", std::to_string(dbl_rnd))); - fields.push_back(std::make_pair("round_mode", (round_mode < (sizeof(round_mode_ofm_str)/sizeof(round_mode_ofm_str[0])) ? round_mode_ofm_str[round_mode] : "****"))); - fields.push_back(std::make_pair("scale", std::to_string(scale))); - } -#endif -#endif -}; -// IFM input scale -struct npu_set_ifm_scale_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t shift:6; // Right shift (0 to 63) - uint32_t dbl_rnd:5; // Double rounding shift (0 to 30) - uint32_t reserved1:2; - uint32_t round_mode:1; // Rounding mode - uint32_t reserved2:2; - uint32_t scale:31; // Scale value (uint31 = non-negative int32) - uint32_t reserved3:1; -#ifdef __cplusplus -public: - npu_set_ifm_scale_t(uint32_t _shift, uint32_t _dbl_rnd, NPU_NAMESPACE::round_mode_ifm _round_mode, uint32_t _scale) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_SCALE)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - shift(_shift & ((1U << 6)-1)), - dbl_rnd(_dbl_rnd & ((1U << 5)-1)), - reserved1(0), - round_mode(static_cast(_round_mode) & ((1U << 1)-1)), - reserved2(0), - scale(_scale & ((1U << 31)-1)), - reserved3(0) - {} - CONSTEXPR npu_set_ifm_scale_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_SCALE)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - shift(0), - dbl_rnd(0), - reserved1(0), - round_mode(0), - reserved2(0), - scale(0), - reserved3(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_SCALE) && control >= 1 && control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM_SCALE); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word = 0; - word |= uint64_t(opcode) << 0; - word |= uint64_t(control) << 14; - word |= uint64_t(shift) << 16; - word |= uint64_t(dbl_rnd) << 22; - word |= uint64_t(round_mode) << 29; - word |= uint64_t(scale) << 32; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd1_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm_scale_t& set_opcode(NPU_NAMESPACE::cmd1_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm_scale_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR uint32_t get_shift() const - { - return static_cast(shift); - } - CONSTEXPR npu_set_ifm_scale_t& set_shift(uint32_t value) - { - assert((value >> 6) == 0); - shift = static_cast(value & ((1U << 6)-1)); - return *this; - } - CONSTEXPR uint32_t get_dbl_rnd() const - { - return static_cast(dbl_rnd); - } - CONSTEXPR npu_set_ifm_scale_t& set_dbl_rnd(uint32_t value) - { - assert((value >> 5) == 0); - dbl_rnd = static_cast(value & ((1U << 5)-1)); - return *this; - } - CONSTEXPR NPU_NAMESPACE::round_mode_ifm get_round_mode() const - { - return static_cast(round_mode); - } - CONSTEXPR npu_set_ifm_scale_t& set_round_mode(NPU_NAMESPACE::round_mode_ifm value) - { - round_mode = static_cast(value) & ((1U << 1)-1); - return *this; - } - CONSTEXPR uint32_t get_scale() const - { - return static_cast(scale); - } - CONSTEXPR npu_set_ifm_scale_t& set_scale(uint32_t value) - { - assert((value >> 31) == 0); - scale = value & ((1U << 31)-1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("shift", std::to_string(shift))); - fields.push_back(std::make_pair("dbl_rnd", std::to_string(dbl_rnd))); - fields.push_back(std::make_pair("round_mode", (round_mode < (sizeof(round_mode_ifm_str)/sizeof(round_mode_ifm_str[0])) ? round_mode_ifm_str[round_mode] : "****"))); - fields.push_back(std::make_pair("scale", std::to_string(scale))); - } -#endif -#endif -}; -// IFM2 input scale -struct npu_set_ifm2_scale_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t shift:6; // Right shift (0 to 63) - uint32_t dbl_rnd:5; // Double rounding shift (0 to 30) - uint32_t reserved1:2; - uint32_t round_mode:1; // Rounding mode - uint32_t reserved2:2; - uint32_t scale:31; // Scale value (uint31 = non-negative int32) - uint32_t reserved3:1; -#ifdef __cplusplus -public: - npu_set_ifm2_scale_t(uint32_t _shift, uint32_t _dbl_rnd, NPU_NAMESPACE::round_mode_ifm _round_mode, uint32_t _scale) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_SCALE)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - shift(_shift & ((1U << 6)-1)), - dbl_rnd(_dbl_rnd & ((1U << 5)-1)), - reserved1(0), - round_mode(static_cast(_round_mode) & ((1U << 1)-1)), - reserved2(0), - scale(_scale & ((1U << 31)-1)), - reserved3(0) - {} - CONSTEXPR npu_set_ifm2_scale_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_SCALE)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - shift(0), - dbl_rnd(0), - reserved1(0), - round_mode(0), - reserved2(0), - scale(0), - reserved3(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_SCALE) && control >= 1 && control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_SCALE); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word = 0; - word |= uint64_t(opcode) << 0; - word |= uint64_t(control) << 14; - word |= uint64_t(shift) << 16; - word |= uint64_t(dbl_rnd) << 22; - word |= uint64_t(round_mode) << 29; - word |= uint64_t(scale) << 32; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd1_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_ifm2_scale_t& set_opcode(NPU_NAMESPACE::cmd1_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_ifm2_scale_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR uint32_t get_shift() const - { - return static_cast(shift); - } - CONSTEXPR npu_set_ifm2_scale_t& set_shift(uint32_t value) - { - assert((value >> 6) == 0); - shift = static_cast(value & ((1U << 6)-1)); - return *this; - } - CONSTEXPR uint32_t get_dbl_rnd() const - { - return static_cast(dbl_rnd); - } - CONSTEXPR npu_set_ifm2_scale_t& set_dbl_rnd(uint32_t value) - { - assert((value >> 5) == 0); - dbl_rnd = static_cast(value & ((1U << 5)-1)); - return *this; - } - CONSTEXPR NPU_NAMESPACE::round_mode_ifm get_round_mode() const - { - return static_cast(round_mode); - } - CONSTEXPR npu_set_ifm2_scale_t& set_round_mode(NPU_NAMESPACE::round_mode_ifm value) - { - round_mode = static_cast(value) & ((1U << 1)-1); - return *this; - } - CONSTEXPR uint32_t get_scale() const - { - return static_cast(scale); - } - CONSTEXPR npu_set_ifm2_scale_t& set_scale(uint32_t value) - { - assert((value >> 31) == 0); - scale = value & ((1U << 31)-1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("shift", std::to_string(shift))); - fields.push_back(std::make_pair("dbl_rnd", std::to_string(dbl_rnd))); - fields.push_back(std::make_pair("round_mode", (round_mode < (sizeof(round_mode_ifm_str)/sizeof(round_mode_ifm_str[0])) ? round_mode_ifm_str[round_mode] : "****"))); - fields.push_back(std::make_pair("scale", std::to_string(scale))); - } -#endif -#endif -}; -// Operation scalar value -struct npu_set_op_scalar_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t reserved1:16; - uint32_t scalar:32; // Scalar value (int32) -#ifdef __cplusplus -public: - npu_set_op_scalar_t(uint32_t _scalar) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OP_SCALAR)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - reserved1(0), - scalar(_scalar) - {} - CONSTEXPR npu_set_op_scalar_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OP_SCALAR)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - reserved1(0), - scalar(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OP_SCALAR) && control >= 1 && control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_OP_SCALAR); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word = 0; - word |= uint64_t(opcode) << 0; - word |= uint64_t(control) << 14; - word |= uint64_t(scalar) << 32; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd1_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_op_scalar_t& set_opcode(NPU_NAMESPACE::cmd1_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_op_scalar_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR uint32_t get_scalar() const - { - return static_cast(scalar); - } - CONSTEXPR npu_set_op_scalar_t& set_scalar(uint32_t value) - { - scalar = value; - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("scalar", std::to_string(((scalar <= std::numeric_limits::max() ? static_cast(scalar) : scalar - std::numeric_limits::min() + std::numeric_limits::max()) << 0) >> 0))); - } -#endif -#endif -}; -// DMA user channel 0 source byte offset from DMA0_SRC_REGION -struct npu_set_dma0_src_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t addr_hi:8; // address extension - uint32_t reserved1:8; - uint32_t addr_lo:32; // address offset -#ifdef __cplusplus -public: - npu_set_dma0_src_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_SRC)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & static_cast(std::numeric_limits::max()))), - reserved1(0), - addr_lo(static_cast((_addr) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR npu_set_dma0_src_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_SRC)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(0), - reserved1(0), - addr_lo(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_SRC) && control >= 1 && control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_SRC); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word = 0; - word |= uint64_t(opcode) << 0; - word |= uint64_t(control) << 14; - word |= uint64_t(addr_hi) << 16; - word |= uint64_t(addr_lo) << 32; - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_dma0_src_t& set_addr(uint64_t value) - { - addr_lo = static_cast((value) & static_cast(std::numeric_limits::max())); addr_hi = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - std::stringstream saddr; saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif -}; -// DMA user channel 0 destination byte offset from DMA0_DST_REGION -struct npu_set_dma0_dst_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t addr_hi:8; // address extension - uint32_t reserved1:8; - uint32_t addr_lo:32; // address offset -#ifdef __cplusplus -public: - npu_set_dma0_dst_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_DST)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & static_cast(std::numeric_limits::max()))), - reserved1(0), - addr_lo(static_cast((_addr) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR npu_set_dma0_dst_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_DST)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(0), - reserved1(0), - addr_lo(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_DST) && control >= 1 && control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_DST); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word = 0; - word |= uint64_t(opcode) << 0; - word |= uint64_t(control) << 14; - word |= uint64_t(addr_hi) << 16; - word |= uint64_t(addr_lo) << 32; - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_dma0_dst_t& set_addr(uint64_t value) - { - addr_lo = static_cast((value) & static_cast(std::numeric_limits::max())); addr_hi = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - std::stringstream saddr; saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif -}; -// DMA user channel 0 transfer length in bytes for each 1D transfer -struct npu_set_dma0_len_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t addr_hi:8; // address extension - uint32_t reserved1:8; - uint32_t addr_lo:32; // address offset -#ifdef __cplusplus -public: - npu_set_dma0_len_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_LEN)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & static_cast(std::numeric_limits::max()))), - reserved1(0), - addr_lo(static_cast((_addr) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR npu_set_dma0_len_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_LEN)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(0), - reserved1(0), - addr_lo(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_LEN) && control >= 1 && control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_LEN); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word = 0; - word |= uint64_t(opcode) << 0; - word |= uint64_t(control) << 14; - word |= uint64_t(addr_hi) << 16; - word |= uint64_t(addr_lo) << 32; - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_dma0_len_t& set_addr(uint64_t value) - { - addr_lo = static_cast((value) & static_cast(std::numeric_limits::max())); addr_hi = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - std::stringstream saddr; saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif -}; -// Source byte stride after each 1D transfer -struct npu_set_dma0_src_stride0_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t addr_hi:8; // address extension - uint32_t reserved1:8; - uint32_t addr_lo:32; // address offset -#ifdef __cplusplus -public: - npu_set_dma0_src_stride0_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_SRC_STRIDE0)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & static_cast(std::numeric_limits::max()))), - reserved1(0), - addr_lo(static_cast((_addr) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR npu_set_dma0_src_stride0_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_SRC_STRIDE0)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(0), - reserved1(0), - addr_lo(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_SRC_STRIDE0) && control >= 1 && control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_SRC_STRIDE0); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word = 0; - word |= uint64_t(opcode) << 0; - word |= uint64_t(control) << 14; - word |= uint64_t(addr_hi) << 16; - word |= uint64_t(addr_lo) << 32; - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_dma0_src_stride0_t& set_addr(uint64_t value) - { - addr_lo = static_cast((value) & static_cast(std::numeric_limits::max())); addr_hi = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - std::stringstream saddr; saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif -}; -// Source byte stride after each 2D transfer -struct npu_set_dma0_src_stride1_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t addr_hi:8; // address extension - uint32_t reserved1:8; - uint32_t addr_lo:32; // address offset -#ifdef __cplusplus -public: - npu_set_dma0_src_stride1_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_SRC_STRIDE1)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & static_cast(std::numeric_limits::max()))), - reserved1(0), - addr_lo(static_cast((_addr) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR npu_set_dma0_src_stride1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_SRC_STRIDE1)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(0), - reserved1(0), - addr_lo(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_SRC_STRIDE1) && control >= 1 && control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_SRC_STRIDE1); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word = 0; - word |= uint64_t(opcode) << 0; - word |= uint64_t(control) << 14; - word |= uint64_t(addr_hi) << 16; - word |= uint64_t(addr_lo) << 32; - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_dma0_src_stride1_t& set_addr(uint64_t value) - { - addr_lo = static_cast((value) & static_cast(std::numeric_limits::max())); addr_hi = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - std::stringstream saddr; saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif -}; -// Destination byte stride after each 1D transfer -struct npu_set_dma0_dst_stride0_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t addr_hi:8; // address extension - uint32_t reserved1:8; - uint32_t addr_lo:32; // address offset -#ifdef __cplusplus -public: - npu_set_dma0_dst_stride0_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_DST_STRIDE0)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & static_cast(std::numeric_limits::max()))), - reserved1(0), - addr_lo(static_cast((_addr) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR npu_set_dma0_dst_stride0_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_DST_STRIDE0)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(0), - reserved1(0), - addr_lo(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_DST_STRIDE0) && control >= 1 && control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_DST_STRIDE0); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word = 0; - word |= uint64_t(opcode) << 0; - word |= uint64_t(control) << 14; - word |= uint64_t(addr_hi) << 16; - word |= uint64_t(addr_lo) << 32; - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_dma0_dst_stride0_t& set_addr(uint64_t value) - { - addr_lo = static_cast((value) & static_cast(std::numeric_limits::max())); addr_hi = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - std::stringstream saddr; saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif -}; -// Destination byte stride after 2D transfer -struct npu_set_dma0_dst_stride1_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t addr_hi:8; // address extension - uint32_t reserved1:8; - uint32_t addr_lo:32; // address offset -#ifdef __cplusplus -public: - npu_set_dma0_dst_stride1_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_DST_STRIDE1)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & static_cast(std::numeric_limits::max()))), - reserved1(0), - addr_lo(static_cast((_addr) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR npu_set_dma0_dst_stride1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_DST_STRIDE1)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(0), - reserved1(0), - addr_lo(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_DST_STRIDE1) && control >= 1 && control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_DST_STRIDE1); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word = 0; - word |= uint64_t(opcode) << 0; - word |= uint64_t(control) << 14; - word |= uint64_t(addr_hi) << 16; - word |= uint64_t(addr_lo) << 32; - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_dma0_dst_stride1_t& set_addr(uint64_t value) - { - addr_lo = static_cast((value) & static_cast(std::numeric_limits::max())); addr_hi = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - std::stringstream saddr; saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif -}; -// DMA channel 0 index array address -struct npu_set_dma0_idx_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t addr_hi:8; // address extension - uint32_t reserved1:8; - uint32_t addr_lo:32; // address offset -#ifdef __cplusplus -public: - npu_set_dma0_idx_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_IDX)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & static_cast(std::numeric_limits::max()))), - reserved1(0), - addr_lo(static_cast((_addr) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR npu_set_dma0_idx_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_IDX)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(0), - reserved1(0), - addr_lo(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_IDX) && control >= 1 && control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_IDX); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word = 0; - word |= uint64_t(opcode) << 0; - word |= uint64_t(control) << 14; - word |= uint64_t(addr_hi) << 16; - word |= uint64_t(addr_lo) << 32; - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_dma0_idx_t& set_addr(uint64_t value) - { - addr_lo = static_cast((value) & static_cast(std::numeric_limits::max())); addr_hi = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - std::stringstream saddr; saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif -}; -// DMA channel 0 index maximum value -struct npu_set_dma0_idx_max_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t reserved1:16; - uint32_t idx_max:31; // maximum permitted index - uint32_t reserved2:1; -#ifdef __cplusplus -public: - npu_set_dma0_idx_max_t(uint32_t _idx_max) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_IDX_MAX)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - reserved1(0), - idx_max(_idx_max & ((1U << 31)-1)), - reserved2(0) - {} - CONSTEXPR npu_set_dma0_idx_max_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_IDX_MAX)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - reserved1(0), - idx_max(0), - reserved2(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_IDX_MAX) && control >= 1 && control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_IDX_MAX); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word = 0; - word |= uint64_t(opcode) << 0; - word |= uint64_t(control) << 14; - word |= uint64_t(idx_max) << 32; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd1_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_dma0_idx_max_t& set_opcode(NPU_NAMESPACE::cmd1_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_dma0_idx_max_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR uint32_t get_idx_max() const - { - return static_cast(idx_max); - } - CONSTEXPR npu_set_dma0_idx_max_t& set_idx_max(uint32_t value) - { - assert((value >> 31) == 0); - idx_max = value & ((1U << 31)-1); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("idx_max", std::to_string(idx_max))); - } -#endif -#endif -}; -// Index byte distance to skip in index after each 2D transfer -struct npu_set_dma0_idx_skip1_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t addr_hi:8; // address extension - uint32_t reserved1:8; - uint32_t addr_lo:32; // address offset -#ifdef __cplusplus -public: - npu_set_dma0_idx_skip1_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_IDX_SKIP1)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & static_cast(std::numeric_limits::max()))), - reserved1(0), - addr_lo(static_cast((_addr) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR npu_set_dma0_idx_skip1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_IDX_SKIP1)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(0), - reserved1(0), - addr_lo(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_IDX_SKIP1) && control >= 1 && control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_DMA0_IDX_SKIP1); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word = 0; - word |= uint64_t(opcode) << 0; - word |= uint64_t(control) << 14; - word |= uint64_t(addr_hi) << 16; - word |= uint64_t(addr_lo) << 32; - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_dma0_idx_skip1_t& set_addr(uint64_t value) - { - addr_lo = static_cast((value) & static_cast(std::numeric_limits::max())); addr_hi = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - std::stringstream saddr; saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif -}; -// IFM2 Tile 0 address -struct npu_set_ifm2_base0_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t addr_hi:8; // address extension - uint32_t reserved1:8; - uint32_t addr_lo:32; // address offset -#ifdef __cplusplus -public: - npu_set_ifm2_base0_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_BASE0)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & static_cast(std::numeric_limits::max()))), - reserved1(0), - addr_lo(static_cast((_addr) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR npu_set_ifm2_base0_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_BASE0)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(0), - reserved1(0), - addr_lo(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_BASE0) && control >= 1 && control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_BASE0); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word = 0; - word |= uint64_t(opcode) << 0; - word |= uint64_t(control) << 14; - word |= uint64_t(addr_hi) << 16; - word |= uint64_t(addr_lo) << 32; - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_ifm2_base0_t& set_addr(uint64_t value) - { - addr_lo = static_cast((value) & static_cast(std::numeric_limits::max())); addr_hi = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - std::stringstream saddr; saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif -}; -// IFM2 Tile 1 address -struct npu_set_ifm2_base1_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t addr_hi:8; // address extension - uint32_t reserved1:8; - uint32_t addr_lo:32; // address offset -#ifdef __cplusplus -public: - npu_set_ifm2_base1_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_BASE1)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & static_cast(std::numeric_limits::max()))), - reserved1(0), - addr_lo(static_cast((_addr) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR npu_set_ifm2_base1_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_BASE1)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(0), - reserved1(0), - addr_lo(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_BASE1) && control >= 1 && control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_BASE1); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word = 0; - word |= uint64_t(opcode) << 0; - word |= uint64_t(control) << 14; - word |= uint64_t(addr_hi) << 16; - word |= uint64_t(addr_lo) << 32; - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_ifm2_base1_t& set_addr(uint64_t value) - { - addr_lo = static_cast((value) & static_cast(std::numeric_limits::max())); addr_hi = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - std::stringstream saddr; saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif -}; -// IFM2 Tile 2 address -struct npu_set_ifm2_base2_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t addr_hi:8; // address extension - uint32_t reserved1:8; - uint32_t addr_lo:32; // address offset -#ifdef __cplusplus -public: - npu_set_ifm2_base2_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_BASE2)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & static_cast(std::numeric_limits::max()))), - reserved1(0), - addr_lo(static_cast((_addr) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR npu_set_ifm2_base2_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_BASE2)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(0), - reserved1(0), - addr_lo(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_BASE2) && control >= 1 && control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_BASE2); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word = 0; - word |= uint64_t(opcode) << 0; - word |= uint64_t(control) << 14; - word |= uint64_t(addr_hi) << 16; - word |= uint64_t(addr_lo) << 32; - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_ifm2_base2_t& set_addr(uint64_t value) - { - addr_lo = static_cast((value) & static_cast(std::numeric_limits::max())); addr_hi = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - std::stringstream saddr; saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif -}; -// IFM2 Tile 3 address -struct npu_set_ifm2_base3_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t addr_hi:8; // address extension - uint32_t reserved1:8; - uint32_t addr_lo:32; // address offset -#ifdef __cplusplus -public: - npu_set_ifm2_base3_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_BASE3)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & static_cast(std::numeric_limits::max()))), - reserved1(0), - addr_lo(static_cast((_addr) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR npu_set_ifm2_base3_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_BASE3)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(0), - reserved1(0), - addr_lo(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_BASE3) && control >= 1 && control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_BASE3); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word = 0; - word |= uint64_t(opcode) << 0; - word |= uint64_t(control) << 14; - word |= uint64_t(addr_hi) << 16; - word |= uint64_t(addr_lo) << 32; - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_ifm2_base3_t& set_addr(uint64_t value) - { - addr_lo = static_cast((value) & static_cast(std::numeric_limits::max())); addr_hi = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - std::stringstream saddr; saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif -}; -// IFM2 byte stride between horizontal values -struct npu_set_ifm2_stride_x_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t addr_hi:8; // address extension - uint32_t reserved1:8; - uint32_t addr_lo:32; // address offset -#ifdef __cplusplus -public: - npu_set_ifm2_stride_x_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_STRIDE_X)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & static_cast(std::numeric_limits::max()))), - reserved1(0), - addr_lo(static_cast((_addr) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR npu_set_ifm2_stride_x_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_STRIDE_X)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(0), - reserved1(0), - addr_lo(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_STRIDE_X) && control >= 1 && control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_STRIDE_X); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word = 0; - word |= uint64_t(opcode) << 0; - word |= uint64_t(control) << 14; - word |= uint64_t(addr_hi) << 16; - word |= uint64_t(addr_lo) << 32; - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_ifm2_stride_x_t& set_addr(uint64_t value) - { - addr_lo = static_cast((value) & static_cast(std::numeric_limits::max())); addr_hi = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - std::stringstream saddr; saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif -}; -// IFM2 byte stride between vertical values -struct npu_set_ifm2_stride_y_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t addr_hi:8; // address extension - uint32_t reserved1:8; - uint32_t addr_lo:32; // address offset -#ifdef __cplusplus -public: - npu_set_ifm2_stride_y_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_STRIDE_Y)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & static_cast(std::numeric_limits::max()))), - reserved1(0), - addr_lo(static_cast((_addr) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR npu_set_ifm2_stride_y_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_STRIDE_Y)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(0), - reserved1(0), - addr_lo(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_STRIDE_Y) && control >= 1 && control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_STRIDE_Y); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word = 0; - word |= uint64_t(opcode) << 0; - word |= uint64_t(control) << 14; - word |= uint64_t(addr_hi) << 16; - word |= uint64_t(addr_lo) << 32; - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_ifm2_stride_y_t& set_addr(uint64_t value) - { - addr_lo = static_cast((value) & static_cast(std::numeric_limits::max())); addr_hi = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - std::stringstream saddr; saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif -}; -// IFM2 byte stride between channel blocks -struct npu_set_ifm2_stride_c_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t addr_hi:8; // address extension - uint32_t reserved1:8; - uint32_t addr_lo:32; // address offset -#ifdef __cplusplus -public: - npu_set_ifm2_stride_c_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_STRIDE_C)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & static_cast(std::numeric_limits::max()))), - reserved1(0), - addr_lo(static_cast((_addr) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR npu_set_ifm2_stride_c_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_STRIDE_C)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(0), - reserved1(0), - addr_lo(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_STRIDE_C) && control >= 1 && control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_IFM2_STRIDE_C); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word = 0; - word |= uint64_t(opcode) << 0; - word |= uint64_t(control) << 14; - word |= uint64_t(addr_hi) << 16; - word |= uint64_t(addr_lo) << 32; - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_ifm2_stride_c_t& set_addr(uint64_t value) - { - addr_lo = static_cast((value) & static_cast(std::numeric_limits::max())); addr_hi = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - std::stringstream saddr; saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif -}; -// Weight stream byte offset in WEIGHT_REGION for weight decoder 1 -struct npu_set_weight1_base_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t addr_hi:8; // address extension - uint32_t reserved1:8; - uint32_t addr_lo:32; // address offset -#ifdef __cplusplus -public: - npu_set_weight1_base_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT1_BASE)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & static_cast(std::numeric_limits::max()))), - reserved1(0), - addr_lo(static_cast((_addr) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR npu_set_weight1_base_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT1_BASE)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(0), - reserved1(0), - addr_lo(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT1_BASE) && control >= 1 && control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT1_BASE); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word = 0; - word |= uint64_t(opcode) << 0; - word |= uint64_t(control) << 14; - word |= uint64_t(addr_hi) << 16; - word |= uint64_t(addr_lo) << 32; - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_weight1_base_t& set_addr(uint64_t value) - { - addr_lo = static_cast((value) & static_cast(std::numeric_limits::max())); addr_hi = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - std::stringstream saddr; saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif -}; -// Weight stream byte length for weight decoder 1 -struct npu_set_weight1_length_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t reserved1:16; - uint32_t length:32; // Weight stream byte length -#ifdef __cplusplus -public: - npu_set_weight1_length_t(uint32_t _length) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT1_LENGTH)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - reserved1(0), - length(_length) - {} - CONSTEXPR npu_set_weight1_length_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT1_LENGTH)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - reserved1(0), - length(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT1_LENGTH) && control >= 1 && control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT1_LENGTH); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word = 0; - word |= uint64_t(opcode) << 0; - word |= uint64_t(control) << 14; - word |= uint64_t(length) << 32; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd1_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_weight1_length_t& set_opcode(NPU_NAMESPACE::cmd1_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_weight1_length_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR uint32_t get_length() const - { - return static_cast(length); - } - CONSTEXPR npu_set_weight1_length_t& set_length(uint32_t value) - { - length = value; - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("length", std::to_string(length))); - } -#endif -#endif -}; -// Weight stream byte offset in WEIGHT_REGION for weight decoder 2 -struct npu_set_weight2_base_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t addr_hi:8; // address extension - uint32_t reserved1:8; - uint32_t addr_lo:32; // address offset -#ifdef __cplusplus -public: - npu_set_weight2_base_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT2_BASE)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & static_cast(std::numeric_limits::max()))), - reserved1(0), - addr_lo(static_cast((_addr) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR npu_set_weight2_base_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT2_BASE)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(0), - reserved1(0), - addr_lo(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT2_BASE) && control >= 1 && control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT2_BASE); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word = 0; - word |= uint64_t(opcode) << 0; - word |= uint64_t(control) << 14; - word |= uint64_t(addr_hi) << 16; - word |= uint64_t(addr_lo) << 32; - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_weight2_base_t& set_addr(uint64_t value) - { - addr_lo = static_cast((value) & static_cast(std::numeric_limits::max())); addr_hi = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - std::stringstream saddr; saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif -}; -// Weight stream byte length for weight decoder 2 -struct npu_set_weight2_length_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t reserved1:16; - uint32_t length:32; // Weight stream byte length -#ifdef __cplusplus -public: - npu_set_weight2_length_t(uint32_t _length) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT2_LENGTH)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - reserved1(0), - length(_length) - {} - CONSTEXPR npu_set_weight2_length_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT2_LENGTH)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - reserved1(0), - length(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT2_LENGTH) && control >= 1 && control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT2_LENGTH); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word = 0; - word |= uint64_t(opcode) << 0; - word |= uint64_t(control) << 14; - word |= uint64_t(length) << 32; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd1_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_weight2_length_t& set_opcode(NPU_NAMESPACE::cmd1_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_weight2_length_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR uint32_t get_length() const - { - return static_cast(length); - } - CONSTEXPR npu_set_weight2_length_t& set_length(uint32_t value) - { - length = value; - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("length", std::to_string(length))); - } -#endif -#endif -}; -// Weight stream byte offset in WEIGHT_REGION for weight decoder 3 -struct npu_set_weight3_base_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t addr_hi:8; // address extension - uint32_t reserved1:8; - uint32_t addr_lo:32; // address offset -#ifdef __cplusplus -public: - npu_set_weight3_base_t(uint64_t _addr) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT3_BASE)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(static_cast((_addr >> 32) & static_cast(std::numeric_limits::max()))), - reserved1(0), - addr_lo(static_cast((_addr) & static_cast(std::numeric_limits::max()))) - {} - CONSTEXPR npu_set_weight3_base_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT3_BASE)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - addr_hi(0), - reserved1(0), - addr_lo(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT3_BASE) && control >= 1 && control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT3_BASE); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word = 0; - word |= uint64_t(opcode) << 0; - word |= uint64_t(control) << 14; - word |= uint64_t(addr_hi) << 16; - word |= uint64_t(addr_lo) << 32; - return word; - } - CONSTEXPR uint64_t get_addr() const - { - return (static_cast(addr_hi) << 32) | addr_lo; - } - CONSTEXPR npu_set_weight3_base_t& set_addr(uint64_t value) - { - addr_lo = static_cast((value) & static_cast(std::numeric_limits::max())); addr_hi = static_cast((value >> 32) & static_cast(std::numeric_limits::max())); return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - std::stringstream saddr; saddr << std::hex << "0x" << get_addr(); - fields.push_back(std::make_pair("addr", saddr.str())); - } -#endif -#endif -}; -// Weight stream byte length for weight decoder 3 -struct npu_set_weight3_length_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t reserved1:16; - uint32_t length:32; // Weight stream byte length -#ifdef __cplusplus -public: - npu_set_weight3_length_t(uint32_t _length) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT3_LENGTH)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - reserved1(0), - length(_length) - {} - CONSTEXPR npu_set_weight3_length_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT3_LENGTH)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - reserved1(0), - length(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT3_LENGTH) && control >= 1 && control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_WEIGHT3_LENGTH); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word = 0; - word |= uint64_t(opcode) << 0; - word |= uint64_t(control) << 14; - word |= uint64_t(length) << 32; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd1_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_weight3_length_t& set_opcode(NPU_NAMESPACE::cmd1_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_weight3_length_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR uint32_t get_length() const - { - return static_cast(length); - } - CONSTEXPR npu_set_weight3_length_t& set_length(uint32_t value) - { - length = value; - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("length", std::to_string(length))); - } -#endif -#endif -}; -// Resize X axis step parameters -struct npu_set_resize_x_step_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t one_step_int:4; // (1*scale_d) / scale_n - uint32_t blk_step_int:11; // ((ofm_block_size-1)*scale_d) / scale_n - uint32_t reserved1:1; - uint32_t one_step_mod:11; // (1*scale_d) % scale_n - uint32_t reserved2:5; - uint32_t blk_step_mod:11; // ((ofm_block_size-1)*scale_d) % scale_n - uint32_t reserved3:5; -#ifdef __cplusplus -public: - npu_set_resize_x_step_t(uint32_t _one_step_int, uint32_t _blk_step_int, uint32_t _one_step_mod, uint32_t _blk_step_mod) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_RESIZE_X)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - one_step_int(_one_step_int & ((1U << 4)-1)), - blk_step_int(_blk_step_int & ((1U << 11)-1)), - reserved1(0), - one_step_mod(_one_step_mod & ((1U << 11)-1)), - reserved2(0), - blk_step_mod(_blk_step_mod & ((1U << 11)-1)), - reserved3(0) - {} - CONSTEXPR npu_set_resize_x_step_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_RESIZE_X)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - one_step_int(0), - blk_step_int(0), - reserved1(0), - one_step_mod(0), - reserved2(0), - blk_step_mod(0), - reserved3(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_RESIZE_X) && control >= 1 && control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_RESIZE_X); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word = 0; - word |= uint64_t(opcode) << 0; - word |= uint64_t(control) << 14; - word |= uint64_t(one_step_int) << 16; - word |= uint64_t(blk_step_int) << 20; - word |= uint64_t(one_step_mod) << 32; - word |= uint64_t(blk_step_mod) << 48; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd1_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_resize_x_step_t& set_opcode(NPU_NAMESPACE::cmd1_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_resize_x_step_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR uint32_t get_one_step_int() const - { - return static_cast(one_step_int); - } - CONSTEXPR npu_set_resize_x_step_t& set_one_step_int(uint32_t value) - { - assert((value >> 4) == 0); - one_step_int = static_cast(value & ((1U << 4)-1)); - return *this; - } - CONSTEXPR uint32_t get_blk_step_int() const - { - return static_cast(blk_step_int); - } - CONSTEXPR npu_set_resize_x_step_t& set_blk_step_int(uint32_t value) - { - assert((value >> 11) == 0); - blk_step_int = static_cast(value & ((1U << 11)-1)); - return *this; - } - CONSTEXPR uint32_t get_one_step_mod() const - { - return static_cast(one_step_mod); - } - CONSTEXPR npu_set_resize_x_step_t& set_one_step_mod(uint32_t value) - { - assert((value >> 11) == 0); - one_step_mod = static_cast(value & ((1U << 11)-1)); - return *this; - } - CONSTEXPR uint32_t get_blk_step_mod() const - { - return static_cast(blk_step_mod); - } - CONSTEXPR npu_set_resize_x_step_t& set_blk_step_mod(uint32_t value) - { - assert((value >> 11) == 0); - blk_step_mod = static_cast(value & ((1U << 11)-1)); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("one_step_int", std::to_string(one_step_int))); - fields.push_back(std::make_pair("blk_step_int", std::to_string(blk_step_int))); - fields.push_back(std::make_pair("one_step_mod", std::to_string(one_step_mod))); - fields.push_back(std::make_pair("blk_step_mod", std::to_string(blk_step_mod))); - } -#endif -#endif -}; -// Resize Y axis step parameters -struct npu_set_resize_y_step_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t one_step_int:4; // (1*scale_d) / scale_n - uint32_t blk_step_int:11; // ((ofm_block_size-1)*scale_d) / scale_n - uint32_t reserved1:1; - uint32_t one_step_mod:11; // (1*scale_d) % scale_n - uint32_t reserved2:5; - uint32_t blk_step_mod:11; // ((ofm_block_size-1)*scale_d) % scale_n - uint32_t reserved3:5; -#ifdef __cplusplus -public: - npu_set_resize_y_step_t(uint32_t _one_step_int, uint32_t _blk_step_int, uint32_t _one_step_mod, uint32_t _blk_step_mod) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_RESIZE_Y)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - one_step_int(_one_step_int & ((1U << 4)-1)), - blk_step_int(_blk_step_int & ((1U << 11)-1)), - reserved1(0), - one_step_mod(_one_step_mod & ((1U << 11)-1)), - reserved2(0), - blk_step_mod(_blk_step_mod & ((1U << 11)-1)), - reserved3(0) - {} - CONSTEXPR npu_set_resize_y_step_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_RESIZE_Y)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - one_step_int(0), - blk_step_int(0), - reserved1(0), - one_step_mod(0), - reserved2(0), - blk_step_mod(0), - reserved3(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_RESIZE_Y) && control >= 1 && control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_SET_RESIZE_Y); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word = 0; - word |= uint64_t(opcode) << 0; - word |= uint64_t(control) << 14; - word |= uint64_t(one_step_int) << 16; - word |= uint64_t(blk_step_int) << 20; - word |= uint64_t(one_step_mod) << 32; - word |= uint64_t(blk_step_mod) << 48; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd1_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_set_resize_y_step_t& set_opcode(NPU_NAMESPACE::cmd1_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_set_resize_y_step_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR uint32_t get_one_step_int() const - { - return static_cast(one_step_int); - } - CONSTEXPR npu_set_resize_y_step_t& set_one_step_int(uint32_t value) - { - assert((value >> 4) == 0); - one_step_int = static_cast(value & ((1U << 4)-1)); - return *this; - } - CONSTEXPR uint32_t get_blk_step_int() const - { - return static_cast(blk_step_int); - } - CONSTEXPR npu_set_resize_y_step_t& set_blk_step_int(uint32_t value) - { - assert((value >> 11) == 0); - blk_step_int = static_cast(value & ((1U << 11)-1)); - return *this; - } - CONSTEXPR uint32_t get_one_step_mod() const - { - return static_cast(one_step_mod); - } - CONSTEXPR npu_set_resize_y_step_t& set_one_step_mod(uint32_t value) - { - assert((value >> 11) == 0); - one_step_mod = static_cast(value & ((1U << 11)-1)); - return *this; - } - CONSTEXPR uint32_t get_blk_step_mod() const - { - return static_cast(blk_step_mod); - } - CONSTEXPR npu_set_resize_y_step_t& set_blk_step_mod(uint32_t value) - { - assert((value >> 11) == 0); - blk_step_mod = static_cast(value & ((1U << 11)-1)); - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("one_step_int", std::to_string(one_step_int))); - fields.push_back(std::make_pair("blk_step_int", std::to_string(blk_step_int))); - fields.push_back(std::make_pair("one_step_mod", std::to_string(one_step_mod))); - fields.push_back(std::make_pair("blk_step_mod", std::to_string(blk_step_mod))); - } -#endif -#endif -}; -// Branch to new location -struct npu_op_branch_t -{ -#ifdef __cplusplus -private: -#endif - uint32_t opcode:10; // opcode - uint32_t reserved0:4; - uint32_t control:2; // control - uint32_t branch_cond:1; // Branch condition - uint32_t reserved1:15; - uint32_t branch_target:32; // Branch target in bytes -#ifdef __cplusplus -public: - npu_op_branch_t(NPU_NAMESPACE::branch_cond _branch_cond, uint32_t _branch_target) : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_OP_BRANCH)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - branch_cond(static_cast(_branch_cond) & ((1U << 1)-1)), - reserved1(0), - branch_target(_branch_target) - {} - CONSTEXPR npu_op_branch_t() : - opcode(static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_OP_BRANCH)), - reserved0(0), - control(static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL)), - branch_cond(0), - reserved1(0), - branch_target(0) - {} - CONSTEXPR bool valid() const - { - return opcode == static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_OP_BRANCH) && control >= 1 && control <= 2; - } - CONSTEXPR void init() - { - opcode = static_cast(NPU_NAMESPACE::cmd1_opcode::NPU_OP_BRANCH); control = static_cast(NPU_NAMESPACE::cmd_ctrl::CMD1_CTRL); - } - operator uint64_t() - { - uint64_t word = 0; - word |= uint64_t(opcode) << 0; - word |= uint64_t(control) << 14; - word |= uint64_t(branch_cond) << 16; - word |= uint64_t(branch_target) << 32; - return word; - } - CONSTEXPR NPU_NAMESPACE::cmd1_opcode get_opcode() const - { - return static_cast(opcode); - } - CONSTEXPR npu_op_branch_t& set_opcode(NPU_NAMESPACE::cmd1_opcode value) - { - opcode = static_cast(value) & ((1U << 10)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::cmd_ctrl get_control() const - { - return static_cast(control); - } - CONSTEXPR npu_op_branch_t& set_control(NPU_NAMESPACE::cmd_ctrl value) - { - control = static_cast(value) & ((1U << 2)-1); - return *this; - } - CONSTEXPR NPU_NAMESPACE::branch_cond get_branch_cond() const - { - return static_cast(branch_cond); - } - CONSTEXPR npu_op_branch_t& set_branch_cond(NPU_NAMESPACE::branch_cond value) - { - branch_cond = static_cast(value) & ((1U << 1)-1); - return *this; - } - CONSTEXPR uint32_t get_branch_target() const - { - return static_cast(branch_target); - } - CONSTEXPR npu_op_branch_t& set_branch_target(uint32_t value) - { - branch_target = value; - return *this; - } -#ifdef NPU_DISASSEMBLE - void disassemble(std::vector>& fields) const - { - fields.push_back(std::make_pair("branch_cond", (branch_cond < (sizeof(branch_cond_str)/sizeof(branch_cond_str[0])) ? branch_cond_str[branch_cond] : "****"))); - fields.push_back(std::make_pair("branch_target", std::to_string(branch_target))); - } -#endif -#endif -}; -#ifdef __cplusplus -}; -#endif -#define NPU_OP_STRUCTS \ - NPU_OP_(stop) \ - NPU_OP_(irq) \ - NPU_OP_(conv) \ - NPU_OP_(depthwise) \ - NPU_OP_(pool) \ - NPU_OP_(elementwise) \ - NPU_OP_(resize) \ - NPU_OP_(dma_start) \ - NPU_OP_(dma_wait) \ - NPU_OP_(kernel_wait) \ - NPU_OP_(pmu_mask) \ - NPU_OP_(branch) - -#define NPU_SET_STRUCTS \ - NPU_SET_(ifm_pad_top) \ - NPU_SET_(ifm_pad_left) \ - NPU_SET_(ifm_pad_right) \ - NPU_SET_(ifm_pad_bottom) \ - NPU_SET_(ifm_depth_m1) \ - NPU_SET_(ifm_precision) \ - NPU_SET_(ifm_upscale) \ - NPU_SET_(ifm_zero_point) \ - NPU_SET_(ifm_width0_m1) \ - NPU_SET_(ifm_height0_m1) \ - NPU_SET_(ifm_height1_m1) \ - NPU_SET_(ifm_region) \ - NPU_SET_(ifm_broadcast) \ - NPU_SET_(ofm_width_m1) \ - NPU_SET_(ofm_height_m1) \ - NPU_SET_(ofm_depth_m1) \ - NPU_SET_(ofm_precision) \ - NPU_SET_(ofm_blk_width_m1) \ - NPU_SET_(ofm_blk_height_m1) \ - NPU_SET_(ofm_blk_depth_m1) \ - NPU_SET_(ofm_zero_point) \ - NPU_SET_(ofm_width0_m1) \ - NPU_SET_(ofm_height0_m1) \ - NPU_SET_(ofm_height1_m1) \ - NPU_SET_(ofm_region) \ - NPU_SET_(kernel_width_m1) \ - NPU_SET_(kernel_height_m1) \ - NPU_SET_(kernel_stride) \ - NPU_SET_(acc_format) \ - NPU_SET_(activation) \ - NPU_SET_(activation_min) \ - NPU_SET_(activation_max) \ - NPU_SET_(weight_region) \ - NPU_SET_(scale_region) \ - NPU_SET_(weight_format) \ - NPU_SET_(blockdep) \ - NPU_SET_(resize_x_scale_n_m1) \ - NPU_SET_(resize_y_scale_n_m1) \ - NPU_SET_(resize_x_offset) \ - NPU_SET_(resize_y_offset) \ - NPU_SET_(dma0_src_region) \ - NPU_SET_(dma0_dst_region) \ - NPU_SET_(dma0_size0) \ - NPU_SET_(dma0_size1) \ - NPU_SET_(dma0_idx_region) \ - NPU_SET_(ifm2_broadcast) \ - NPU_SET_(ifm2_precision) \ - NPU_SET_(ifm2_zero_point) \ - NPU_SET_(ifm2_width0_m1) \ - NPU_SET_(ifm2_height0_m1) \ - NPU_SET_(ifm2_height1_m1) \ - NPU_SET_(ifm2_region) \ - NPU_SET_(ifm_base0) \ - NPU_SET_(ifm_base1) \ - NPU_SET_(ifm_base2) \ - NPU_SET_(ifm_base3) \ - NPU_SET_(ifm_stride_x) \ - NPU_SET_(ifm_stride_y) \ - NPU_SET_(ifm_stride_c) \ - NPU_SET_(ofm_base0) \ - NPU_SET_(ofm_base1) \ - NPU_SET_(ofm_base2) \ - NPU_SET_(ofm_base3) \ - NPU_SET_(ofm_stride_x) \ - NPU_SET_(ofm_stride_y) \ - NPU_SET_(ofm_stride_c) \ - NPU_SET_(weight_base) \ - NPU_SET_(weight_length) \ - NPU_SET_(scale_base) \ - NPU_SET_(scale_length) \ - NPU_SET_(ofm_scale) \ - NPU_SET_(ifm_scale) \ - NPU_SET_(ifm2_scale) \ - NPU_SET_(op_scalar) \ - NPU_SET_(dma0_src) \ - NPU_SET_(dma0_dst) \ - NPU_SET_(dma0_len) \ - NPU_SET_(dma0_src_stride0) \ - NPU_SET_(dma0_src_stride1) \ - NPU_SET_(dma0_dst_stride0) \ - NPU_SET_(dma0_dst_stride1) \ - NPU_SET_(dma0_idx) \ - NPU_SET_(dma0_idx_max) \ - NPU_SET_(dma0_idx_skip1) \ - NPU_SET_(ifm2_base0) \ - NPU_SET_(ifm2_base1) \ - NPU_SET_(ifm2_base2) \ - NPU_SET_(ifm2_base3) \ - NPU_SET_(ifm2_stride_x) \ - NPU_SET_(ifm2_stride_y) \ - NPU_SET_(ifm2_stride_c) \ - NPU_SET_(weight1_base) \ - NPU_SET_(weight1_length) \ - NPU_SET_(weight2_base) \ - NPU_SET_(weight2_length) \ - NPU_SET_(weight3_base) \ - NPU_SET_(weight3_length) \ - NPU_SET_(resize_x_step) \ - NPU_SET_(resize_y_step) - -#define EXPAND_ACC_FORMAT(FUNC, SEP) \ - FUNC(acc_format, I32) SEP \ - FUNC(acc_format, I48) - -#define EXPAND_ACC_INPUT(FUNC, SEP) \ - FUNC(acc_input, RESET) SEP \ - FUNC(acc_input, KEEP) SEP \ - FUNC(acc_input, IFM2) - -#define EXPAND_ACC_OUTPUT(FUNC, SEP) \ - FUNC(acc_output, ENABLE) SEP \ - FUNC(acc_output, DISABLE) - -#define EXPAND_ACTIVATION_CLIP_RANGE(FUNC, SEP) \ - FUNC(activation_clip_range, B16) SEP \ - FUNC(activation_clip_range, NONE) - -#define EXPAND_ACTIVATION_FORMAT(FUNC, SEP) \ - FUNC(activation_format, NHWC) SEP \ - FUNC(activation_format, NHCWB16) - -#define EXPAND_ACTIVATION_FUNCTION(FUNC, SEP) \ - FUNC(activation_function, LUT_NONE) SEP \ - FUNC(activation_function, LUT_U8_U8) SEP \ - FUNC(activation_function, LUT_S8_S8) SEP \ - FUNC(activation_function, LUT_S8_S16) SEP \ - FUNC(activation_function, LUT_S8_S32) SEP \ - FUNC(activation_function, LUT_S16_S16) SEP \ - FUNC(activation_function, LUT_S16_S32) SEP \ - FUNC(activation_function, LUT_TANH) SEP \ - FUNC(activation_function, LUT_SIGMOID) - -#define EXPAND_ACTIVATION_PRECISION(FUNC, SEP) \ - FUNC(activation_precision, B8) SEP \ - FUNC(activation_precision, B16) SEP \ - FUNC(activation_precision, B32) SEP \ - FUNC(activation_precision, B64) - -#define EXPAND_ACTIVATION_REVERSE(FUNC, SEP) \ - FUNC(activation_reverse, NONE) SEP \ - FUNC(activation_reverse, H) SEP \ - FUNC(activation_reverse, W) SEP \ - FUNC(activation_reverse, C) - -#define EXPAND_ACTIVATION_STORAGE(FUNC, SEP) \ - FUNC(activation_storage, TILE2X2) SEP \ - FUNC(activation_storage, TILE3X1) SEP \ - FUNC(activation_storage, CHAINED) SEP \ - FUNC(activation_storage, NONE) - -#define EXPAND_ACTIVATION_TRANSPOSE(FUNC, SEP) \ - FUNC(activation_transpose, HWC) SEP \ - FUNC(activation_transpose, WHC) SEP \ - FUNC(activation_transpose, HCW) SEP \ - FUNC(activation_transpose, WCH) SEP \ - FUNC(activation_transpose, CHW) SEP \ - FUNC(activation_transpose, CWH) - -#define EXPAND_ACTIVATION_TYPE(FUNC, SEP) \ - FUNC(activation_type, UNSIGNED) SEP \ - FUNC(activation_type, SIGNED) - -#define EXPAND_AXI_MEM_DOMAIN(FUNC, SEP) \ - FUNC(axi_mem_domain, NON_SHARABLE) SEP \ - FUNC(axi_mem_domain, INNER_SHARABLE) SEP \ - FUNC(axi_mem_domain, OUTER_SHARABLE) SEP \ - FUNC(axi_mem_domain, SYSTEM) - -#define EXPAND_AXI_MEM_ENCODING(FUNC, SEP) \ - FUNC(axi_mem_encoding, DEVICE_NON_BUFFERABLE) SEP \ - FUNC(axi_mem_encoding, DEVICE_BUFFERABLE) SEP \ - FUNC(axi_mem_encoding, NORMAL_NON_CACHEABLE_NON_BUFFERABLE) SEP \ - FUNC(axi_mem_encoding, NORMAL_NON_CACHEABLE_BUFFERABLE) SEP \ - FUNC(axi_mem_encoding, WRITE_THROUGH_NO_ALLOCATE) SEP \ - FUNC(axi_mem_encoding, WRITE_THROUGH_READ_ALLOCATE) SEP \ - FUNC(axi_mem_encoding, WRITE_THROUGH_WRITE_ALLOCATE) SEP \ - FUNC(axi_mem_encoding, WRITE_THROUGH_READ_AND_WRITE_ALLOCATE) SEP \ - FUNC(axi_mem_encoding, WRITE_BACK_NO_ALLOCATE) SEP \ - FUNC(axi_mem_encoding, WRITE_BACK_READ_ALLOCATE) SEP \ - FUNC(axi_mem_encoding, WRITE_BACK_WRITE_ALLOCATE) SEP \ - FUNC(axi_mem_encoding, WRITE_BACK_READ_AND_WRITE_ALLOCATE) - -#define EXPAND_AXI_PORT(FUNC, SEP) \ - FUNC(axi_port, SRAM) SEP \ - FUNC(axi_port, EXT) - -#define EXPAND_BRANCH_COND(FUNC, SEP) \ - FUNC(branch_cond, ALWAYS) SEP \ - FUNC(branch_cond, RF_TRUE) - -#define EXPAND_BROADCAST_MODE(FUNC, SEP) \ - FUNC(broadcast_mode, NONE) SEP \ - FUNC(broadcast_mode, H) SEP \ - FUNC(broadcast_mode, W) SEP \ - FUNC(broadcast_mode, HW) SEP \ - FUNC(broadcast_mode, C) SEP \ - FUNC(broadcast_mode, CH) SEP \ - FUNC(broadcast_mode, CW) SEP \ - FUNC(broadcast_mode, CWH) SEP \ - FUNC(broadcast_mode, SCALAR) - -#define EXPAND_CMD0_OPCODE(FUNC, SEP) \ - FUNC(cmd0_opcode, NPU_OP_STOP) SEP \ - FUNC(cmd0_opcode, NPU_OP_IRQ) SEP \ - FUNC(cmd0_opcode, NPU_OP_CONV) SEP \ - FUNC(cmd0_opcode, NPU_OP_DEPTHWISE) SEP \ - FUNC(cmd0_opcode, NPU_OP_POOL) SEP \ - FUNC(cmd0_opcode, NPU_OP_ELEMENTWISE) SEP \ - FUNC(cmd0_opcode, NPU_OP_RESIZE) SEP \ - FUNC(cmd0_opcode, NPU_OP_DMA_START) SEP \ - FUNC(cmd0_opcode, NPU_OP_DMA_WAIT) SEP \ - FUNC(cmd0_opcode, NPU_OP_KERNEL_WAIT) SEP \ - FUNC(cmd0_opcode, NPU_OP_PMU_MASK) SEP \ - FUNC(cmd0_opcode, NPU_SET_IFM_PAD_TOP) SEP \ - FUNC(cmd0_opcode, NPU_SET_IFM_PAD_LEFT) SEP \ - FUNC(cmd0_opcode, NPU_SET_IFM_PAD_RIGHT) SEP \ - FUNC(cmd0_opcode, NPU_SET_IFM_PAD_BOTTOM) SEP \ - FUNC(cmd0_opcode, NPU_SET_IFM_DEPTH_M1) SEP \ - FUNC(cmd0_opcode, NPU_SET_IFM_PRECISION) SEP \ - FUNC(cmd0_opcode, NPU_SET_IFM_UPSCALE) SEP \ - FUNC(cmd0_opcode, NPU_SET_IFM_BROADCAST) SEP \ - FUNC(cmd0_opcode, NPU_SET_IFM_ZERO_POINT) SEP \ - FUNC(cmd0_opcode, NPU_SET_IFM_WIDTH0_M1) SEP \ - FUNC(cmd0_opcode, NPU_SET_IFM_HEIGHT0_M1) SEP \ - FUNC(cmd0_opcode, NPU_SET_IFM_HEIGHT1_M1) SEP \ - FUNC(cmd0_opcode, NPU_SET_IFM_REGION) SEP \ - FUNC(cmd0_opcode, NPU_SET_OFM_WIDTH_M1) SEP \ - FUNC(cmd0_opcode, NPU_SET_OFM_HEIGHT_M1) SEP \ - FUNC(cmd0_opcode, NPU_SET_OFM_DEPTH_M1) SEP \ - FUNC(cmd0_opcode, NPU_SET_OFM_PRECISION) SEP \ - FUNC(cmd0_opcode, NPU_SET_OFM_BLK_WIDTH_M1) SEP \ - FUNC(cmd0_opcode, NPU_SET_OFM_BLK_HEIGHT_M1) SEP \ - FUNC(cmd0_opcode, NPU_SET_OFM_BLK_DEPTH_M1) SEP \ - FUNC(cmd0_opcode, NPU_SET_OFM_ZERO_POINT) SEP \ - FUNC(cmd0_opcode, NPU_SET_OFM_WIDTH0_M1) SEP \ - FUNC(cmd0_opcode, NPU_SET_OFM_HEIGHT0_M1) SEP \ - FUNC(cmd0_opcode, NPU_SET_OFM_HEIGHT1_M1) SEP \ - FUNC(cmd0_opcode, NPU_SET_OFM_REGION) SEP \ - FUNC(cmd0_opcode, NPU_SET_KERNEL_WIDTH_M1) SEP \ - FUNC(cmd0_opcode, NPU_SET_KERNEL_HEIGHT_M1) SEP \ - FUNC(cmd0_opcode, NPU_SET_KERNEL_STRIDE) SEP \ - FUNC(cmd0_opcode, NPU_SET_ACC_FORMAT) SEP \ - FUNC(cmd0_opcode, NPU_SET_ACTIVATION) SEP \ - FUNC(cmd0_opcode, NPU_SET_ACTIVATION_MIN) SEP \ - FUNC(cmd0_opcode, NPU_SET_ACTIVATION_MAX) SEP \ - FUNC(cmd0_opcode, NPU_SET_WEIGHT_REGION) SEP \ - FUNC(cmd0_opcode, NPU_SET_SCALE_REGION) SEP \ - FUNC(cmd0_opcode, NPU_SET_RESIZE_X_SCALE_N_M1) SEP \ - FUNC(cmd0_opcode, NPU_SET_RESIZE_Y_SCALE_N_M1) SEP \ - FUNC(cmd0_opcode, NPU_SET_RESIZE_X_OFFSET) SEP \ - FUNC(cmd0_opcode, NPU_SET_RESIZE_Y_OFFSET) SEP \ - FUNC(cmd0_opcode, NPU_SET_WEIGHT_FORMAT) SEP \ - FUNC(cmd0_opcode, NPU_SET_BLOCKDEP) SEP \ - FUNC(cmd0_opcode, NPU_SET_DMA0_SRC_REGION) SEP \ - FUNC(cmd0_opcode, NPU_SET_DMA0_DST_REGION) SEP \ - FUNC(cmd0_opcode, NPU_SET_DMA0_SIZE0) SEP \ - FUNC(cmd0_opcode, NPU_SET_DMA0_SIZE1) SEP \ - FUNC(cmd0_opcode, NPU_SET_DMA0_IDX_REGION) SEP \ - FUNC(cmd0_opcode, NPU_SET_IFM2_BROADCAST) SEP \ - FUNC(cmd0_opcode, NPU_SET_IFM2_PRECISION) SEP \ - FUNC(cmd0_opcode, NPU_SET_IFM2_ZERO_POINT) SEP \ - FUNC(cmd0_opcode, NPU_SET_IFM2_WIDTH0_M1) SEP \ - FUNC(cmd0_opcode, NPU_SET_IFM2_HEIGHT0_M1) SEP \ - FUNC(cmd0_opcode, NPU_SET_IFM2_HEIGHT1_M1) SEP \ - FUNC(cmd0_opcode, NPU_SET_IFM2_REGION) - -#define EXPAND_CMD1_OPCODE(FUNC, SEP) \ - FUNC(cmd1_opcode, NPU_SET_IFM_BASE0) SEP \ - FUNC(cmd1_opcode, NPU_SET_IFM_BASE1) SEP \ - FUNC(cmd1_opcode, NPU_SET_IFM_BASE2) SEP \ - FUNC(cmd1_opcode, NPU_SET_IFM_BASE3) SEP \ - FUNC(cmd1_opcode, NPU_SET_IFM_STRIDE_X) SEP \ - FUNC(cmd1_opcode, NPU_SET_IFM_STRIDE_Y) SEP \ - FUNC(cmd1_opcode, NPU_SET_IFM_STRIDE_C) SEP \ - FUNC(cmd1_opcode, NPU_SET_OFM_BASE0) SEP \ - FUNC(cmd1_opcode, NPU_SET_OFM_BASE1) SEP \ - FUNC(cmd1_opcode, NPU_SET_OFM_BASE2) SEP \ - FUNC(cmd1_opcode, NPU_SET_OFM_BASE3) SEP \ - FUNC(cmd1_opcode, NPU_SET_OFM_STRIDE_X) SEP \ - FUNC(cmd1_opcode, NPU_SET_OFM_STRIDE_Y) SEP \ - FUNC(cmd1_opcode, NPU_SET_OFM_STRIDE_C) SEP \ - FUNC(cmd1_opcode, NPU_SET_WEIGHT_BASE) SEP \ - FUNC(cmd1_opcode, NPU_SET_WEIGHT_LENGTH) SEP \ - FUNC(cmd1_opcode, NPU_SET_SCALE_BASE) SEP \ - FUNC(cmd1_opcode, NPU_SET_SCALE_LENGTH) SEP \ - FUNC(cmd1_opcode, NPU_SET_OFM_SCALE) SEP \ - FUNC(cmd1_opcode, NPU_SET_IFM_SCALE) SEP \ - FUNC(cmd1_opcode, NPU_SET_IFM2_SCALE) SEP \ - FUNC(cmd1_opcode, NPU_SET_OP_SCALAR) SEP \ - FUNC(cmd1_opcode, NPU_SET_DMA0_SRC) SEP \ - FUNC(cmd1_opcode, NPU_SET_DMA0_DST) SEP \ - FUNC(cmd1_opcode, NPU_SET_DMA0_LEN) SEP \ - FUNC(cmd1_opcode, NPU_SET_DMA0_SRC_STRIDE0) SEP \ - FUNC(cmd1_opcode, NPU_SET_DMA0_SRC_STRIDE1) SEP \ - FUNC(cmd1_opcode, NPU_SET_DMA0_DST_STRIDE0) SEP \ - FUNC(cmd1_opcode, NPU_SET_DMA0_DST_STRIDE1) SEP \ - FUNC(cmd1_opcode, NPU_SET_DMA0_IDX) SEP \ - FUNC(cmd1_opcode, NPU_SET_DMA0_IDX_MAX) SEP \ - FUNC(cmd1_opcode, NPU_SET_DMA0_IDX_SKIP1) SEP \ - FUNC(cmd1_opcode, NPU_SET_IFM2_BASE0) SEP \ - FUNC(cmd1_opcode, NPU_SET_IFM2_BASE1) SEP \ - FUNC(cmd1_opcode, NPU_SET_IFM2_BASE2) SEP \ - FUNC(cmd1_opcode, NPU_SET_IFM2_BASE3) SEP \ - FUNC(cmd1_opcode, NPU_SET_IFM2_STRIDE_X) SEP \ - FUNC(cmd1_opcode, NPU_SET_IFM2_STRIDE_Y) SEP \ - FUNC(cmd1_opcode, NPU_SET_IFM2_STRIDE_C) SEP \ - FUNC(cmd1_opcode, NPU_SET_WEIGHT1_BASE) SEP \ - FUNC(cmd1_opcode, NPU_SET_WEIGHT1_LENGTH) SEP \ - FUNC(cmd1_opcode, NPU_SET_WEIGHT2_BASE) SEP \ - FUNC(cmd1_opcode, NPU_SET_WEIGHT2_LENGTH) SEP \ - FUNC(cmd1_opcode, NPU_SET_WEIGHT3_BASE) SEP \ - FUNC(cmd1_opcode, NPU_SET_WEIGHT3_LENGTH) SEP \ - FUNC(cmd1_opcode, NPU_SET_RESIZE_X) SEP \ - FUNC(cmd1_opcode, NPU_SET_RESIZE_Y) SEP \ - FUNC(cmd1_opcode, NPU_OP_BRANCH) - -#define EXPAND_CMD_CTRL(FUNC, SEP) \ - FUNC(cmd_ctrl, CMD0_CTRL) SEP \ - FUNC(cmd_ctrl, CMD1_CTRL) - -#define EXPAND_CUSTOM_DMA(FUNC, SEP) \ - FUNC(custom_dma, NOT_IMPLEMENTED) SEP \ - FUNC(custom_dma, IMPLEMENTED) - -#define EXPAND_DMA_FAULT_SRC(FUNC, SEP) \ - FUNC(dma_fault_src, SRAM) SEP \ - FUNC(dma_fault_src, EXT) - -#define EXPAND_DMA_IDX_MODE(FUNC, SEP) \ - FUNC(dma_idx_mode, DISABLED) SEP \ - FUNC(dma_idx_mode, ENABLED) - -#define EXPAND_DMA_REGION_MODE(FUNC, SEP) \ - FUNC(dma_region_mode, EXTERNAL) SEP \ - FUNC(dma_region_mode, INTERNAL) - -#define EXPAND_DMA_STRIDE_MODE(FUNC, SEP) \ - FUNC(dma_stride_mode, D1) SEP \ - FUNC(dma_stride_mode, D2) SEP \ - FUNC(dma_stride_mode, D3) - -#define EXPAND_ELEMENTWISE_MODE(FUNC, SEP) \ - FUNC(elementwise_mode, MUL) SEP \ - FUNC(elementwise_mode, ADD) SEP \ - FUNC(elementwise_mode, SUB) SEP \ - FUNC(elementwise_mode, MIN) SEP \ - FUNC(elementwise_mode, MAX) SEP \ - FUNC(elementwise_mode, LRELU) SEP \ - FUNC(elementwise_mode, ABS) SEP \ - FUNC(elementwise_mode, CLZ) SEP \ - FUNC(elementwise_mode, SHR) SEP \ - FUNC(elementwise_mode, SHL) SEP \ - FUNC(elementwise_mode, LSR) SEP \ - FUNC(elementwise_mode, DIV) SEP \ - FUNC(elementwise_mode, CMP_EQ) SEP \ - FUNC(elementwise_mode, CMP_NE) SEP \ - FUNC(elementwise_mode, CMP_GE) SEP \ - FUNC(elementwise_mode, CMP_GT) SEP \ - FUNC(elementwise_mode, AND) SEP \ - FUNC(elementwise_mode, OR) SEP \ - FUNC(elementwise_mode, XOR) SEP \ - FUNC(elementwise_mode, NOT) SEP \ - FUNC(elementwise_mode, AND_NOT) - -#define EXPAND_IFM_UPSCALE_MODE(FUNC, SEP) \ - FUNC(ifm_upscale_mode, NONE) SEP \ - FUNC(ifm_upscale_mode, NEAREST) SEP \ - FUNC(ifm_upscale_mode, ZEROS) - -#define EXPAND_KERNEL_DECOMPOSITION(FUNC, SEP) \ - FUNC(kernel_decomposition, D8X8) SEP \ - FUNC(kernel_decomposition, D4X4) - -#define EXPAND_KERNEL_DILATION(FUNC, SEP) \ - FUNC(kernel_dilation, NONE) SEP \ - FUNC(kernel_dilation, X2) - -#define EXPAND_MAX_BEATS(FUNC, SEP) \ - FUNC(max_beats, B64) SEP \ - FUNC(max_beats, B128) SEP \ - FUNC(max_beats, B256) - -#define EXPAND_MICROBLOCK(FUNC, SEP) \ - FUNC(microblock, U1X1) SEP \ - FUNC(microblock, U1X2) SEP \ - FUNC(microblock, U1X4) SEP \ - FUNC(microblock, U2X2) SEP \ - FUNC(microblock, U2X4) SEP \ - FUNC(microblock, U4X4) - -#define EXPAND_OFM_SCALE_MODE(FUNC, SEP) \ - FUNC(ofm_scale_mode, PER_CHANNEL) SEP \ - FUNC(ofm_scale_mode, GLOBAL) - -#define EXPAND_PMU_AXI_CHANNEL(FUNC, SEP) \ - FUNC(pmu_axi_channel, RD_CMD) SEP \ - FUNC(pmu_axi_channel, RD_IFM) SEP \ - FUNC(pmu_axi_channel, RD_WEIGHTS) SEP \ - FUNC(pmu_axi_channel, RD_SCALE_BIAS) SEP \ - FUNC(pmu_axi_channel, RD_MEM2MEM) SEP \ - FUNC(pmu_axi_channel, RD_IFM_STREAM) SEP \ - FUNC(pmu_axi_channel, RD_MEM2MEM_IDX) SEP \ - FUNC(pmu_axi_channel, WR_OFM) SEP \ - FUNC(pmu_axi_channel, WR_MEM2MEM) - -#define EXPAND_PMU_EVENT(FUNC, SEP) \ - FUNC(pmu_event, NO_EVENT) SEP \ - FUNC(pmu_event, CYCLE) SEP \ - FUNC(pmu_event, NPU_IDLE) SEP \ - FUNC(pmu_event, CC_STALLED_ON_BLOCKDEP) SEP \ - FUNC(pmu_event, NPU_ACTIVE) SEP \ - FUNC(pmu_event, MAC_ACTIVE) SEP \ - FUNC(pmu_event, MAC_DPU_ACTIVE) SEP \ - FUNC(pmu_event, MAC_STALLED_BY_W_OR_ACC) SEP \ - FUNC(pmu_event, MAC_STALLED_BY_W) SEP \ - FUNC(pmu_event, MAC_STALLED_BY_ACC) SEP \ - FUNC(pmu_event, MAC_STALLED_BY_IB) SEP \ - FUNC(pmu_event, AO_ACTIVE) SEP \ - FUNC(pmu_event, AO_STALLED_BY_BS_OR_OB) SEP \ - FUNC(pmu_event, AO_STALLED_BY_BS) SEP \ - FUNC(pmu_event, AO_STALLED_BY_OB) SEP \ - FUNC(pmu_event, AO_STALLED_BY_AB_OR_CB) SEP \ - FUNC(pmu_event, AO_STALLED_BY_AB) SEP \ - FUNC(pmu_event, AO_STALLED_BY_CB) SEP \ - FUNC(pmu_event, WD_ACTIVE) SEP \ - FUNC(pmu_event, WD_STALLED) SEP \ - FUNC(pmu_event, WD_STALLED_BY_WD_BUF) SEP \ - FUNC(pmu_event, WD_STALLED_BY_WS_FC) SEP \ - FUNC(pmu_event, WD_STALLED_BY_WS_TC) SEP \ - FUNC(pmu_event, WD_TRANS_WBLK) SEP \ - FUNC(pmu_event, WD_TRANS_WS_FC) SEP \ - FUNC(pmu_event, WD_TRANS_WS_TC) SEP \ - FUNC(pmu_event, WD_STALLED_BY_WS_SC0) SEP \ - FUNC(pmu_event, WD_STALLED_BY_WS_SC1) SEP \ - FUNC(pmu_event, WD_STALLED_BY_WS_SC2) SEP \ - FUNC(pmu_event, WD_STALLED_BY_WS_SC3) SEP \ - FUNC(pmu_event, WD_PARSE_ACTIVE_SC0) SEP \ - FUNC(pmu_event, WD_PARSE_ACTIVE_SC1) SEP \ - FUNC(pmu_event, WD_PARSE_ACTIVE_SC2) SEP \ - FUNC(pmu_event, WD_PARSE_ACTIVE_SC3) SEP \ - FUNC(pmu_event, WD_PARSE_STALL_SC0) SEP \ - FUNC(pmu_event, WD_PARSE_STALL_SC1) SEP \ - FUNC(pmu_event, WD_PARSE_STALL_SC2) SEP \ - FUNC(pmu_event, WD_PARSE_STALL_SC3) SEP \ - FUNC(pmu_event, WD_PARSE_STALL_IN_SC0) SEP \ - FUNC(pmu_event, WD_PARSE_STALL_IN_SC1) SEP \ - FUNC(pmu_event, WD_PARSE_STALL_IN_SC2) SEP \ - FUNC(pmu_event, WD_PARSE_STALL_IN_SC3) SEP \ - FUNC(pmu_event, WD_PARSE_STALL_OUT_SC0) SEP \ - FUNC(pmu_event, WD_PARSE_STALL_OUT_SC1) SEP \ - FUNC(pmu_event, WD_PARSE_STALL_OUT_SC2) SEP \ - FUNC(pmu_event, WD_PARSE_STALL_OUT_SC3) SEP \ - FUNC(pmu_event, WD_TRANS_WS_SC0) SEP \ - FUNC(pmu_event, WD_TRANS_WS_SC1) SEP \ - FUNC(pmu_event, WD_TRANS_WS_SC2) SEP \ - FUNC(pmu_event, WD_TRANS_WS_SC3) SEP \ - FUNC(pmu_event, WD_TRANS_WB0) SEP \ - FUNC(pmu_event, WD_TRANS_WB1) SEP \ - FUNC(pmu_event, WD_TRANS_WB2) SEP \ - FUNC(pmu_event, WD_TRANS_WB3) SEP \ - FUNC(pmu_event, SRAM_RD_TRANS_ACCEPTED) SEP \ - FUNC(pmu_event, SRAM_RD_TRANS_COMPLETED) SEP \ - FUNC(pmu_event, SRAM_RD_DATA_BEAT_RECEIVED) SEP \ - FUNC(pmu_event, SRAM_RD_TRAN_REQ_STALLED) SEP \ - FUNC(pmu_event, SRAM_WR_TRANS_ACCEPTED) SEP \ - FUNC(pmu_event, SRAM_WR_TRANS_COMPLETED_M) SEP \ - FUNC(pmu_event, SRAM_WR_TRANS_COMPLETED_S) SEP \ - FUNC(pmu_event, SRAM_WR_DATA_BEAT_WRITTEN) SEP \ - FUNC(pmu_event, SRAM_WR_TRAN_REQ_STALLED) SEP \ - FUNC(pmu_event, SRAM_WR_DATA_BEAT_STALLED) SEP \ - FUNC(pmu_event, SRAM_ENABLED_CYCLES) SEP \ - FUNC(pmu_event, SRAM_RD_STALL_LIMIT) SEP \ - FUNC(pmu_event, SRAM_WR_STALL_LIMIT) SEP \ - FUNC(pmu_event, AXI_LATENCY_ANY) SEP \ - FUNC(pmu_event, AXI_LATENCY_32) SEP \ - FUNC(pmu_event, AXI_LATENCY_64) SEP \ - FUNC(pmu_event, AXI_LATENCY_128) SEP \ - FUNC(pmu_event, AXI_LATENCY_256) SEP \ - FUNC(pmu_event, AXI_LATENCY_512) SEP \ - FUNC(pmu_event, AXI_LATENCY_1024) SEP \ - FUNC(pmu_event, ECC_DMA) SEP \ - FUNC(pmu_event, ECC_MAC_IB) SEP \ - FUNC(pmu_event, ECC_MAC_AB) SEP \ - FUNC(pmu_event, ECC_AO_CB) SEP \ - FUNC(pmu_event, ECC_AO_OB) SEP \ - FUNC(pmu_event, ECC_AO_LUT) SEP \ - FUNC(pmu_event, EXT_RD_TRANS_ACCEPTED) SEP \ - FUNC(pmu_event, EXT_RD_TRANS_COMPLETED) SEP \ - FUNC(pmu_event, EXT_RD_DATA_BEAT_RECEIVED) SEP \ - FUNC(pmu_event, EXT_RD_TRAN_REQ_STALLED) SEP \ - FUNC(pmu_event, EXT_WR_TRANS_ACCEPTED) SEP \ - FUNC(pmu_event, EXT_WR_TRANS_COMPLETED_M) SEP \ - FUNC(pmu_event, EXT_WR_TRANS_COMPLETED_S) SEP \ - FUNC(pmu_event, EXT_WR_DATA_BEAT_WRITTEN) SEP \ - FUNC(pmu_event, EXT_WR_TRAN_REQ_STALLED) SEP \ - FUNC(pmu_event, EXT_WR_DATA_BEAT_STALLED) SEP \ - FUNC(pmu_event, EXT_ENABLED_CYCLES) SEP \ - FUNC(pmu_event, EXT_RD_STALL_LIMIT) SEP \ - FUNC(pmu_event, EXT_WR_STALL_LIMIT) SEP \ - FUNC(pmu_event, SRAM0_RD_TRANS_ACCEPTED) SEP \ - FUNC(pmu_event, SRAM0_RD_TRANS_COMPLETED) SEP \ - FUNC(pmu_event, SRAM0_RD_DATA_BEAT_RECEIVED) SEP \ - FUNC(pmu_event, SRAM0_RD_TRAN_REQ_STALLED) SEP \ - FUNC(pmu_event, SRAM0_WR_TRANS_ACCEPTED) SEP \ - FUNC(pmu_event, SRAM0_WR_TRANS_COMPLETED_M) SEP \ - FUNC(pmu_event, SRAM0_WR_TRANS_COMPLETED_S) SEP \ - FUNC(pmu_event, SRAM0_WR_DATA_BEAT_WRITTEN) SEP \ - FUNC(pmu_event, SRAM0_WR_TRAN_REQ_STALLED) SEP \ - FUNC(pmu_event, SRAM0_WR_DATA_BEAT_STALLED) SEP \ - FUNC(pmu_event, SRAM0_ENABLED_CYCLES) SEP \ - FUNC(pmu_event, SRAM0_RD_STALL_LIMIT) SEP \ - FUNC(pmu_event, SRAM0_WR_STALL_LIMIT) SEP \ - FUNC(pmu_event, SRAM1_RD_TRANS_ACCEPTED) SEP \ - FUNC(pmu_event, SRAM1_RD_TRANS_COMPLETED) SEP \ - FUNC(pmu_event, SRAM1_RD_DATA_BEAT_RECEIVED) SEP \ - FUNC(pmu_event, SRAM1_RD_TRAN_REQ_STALLED) SEP \ - FUNC(pmu_event, SRAM1_WR_TRANS_ACCEPTED) SEP \ - FUNC(pmu_event, SRAM1_WR_TRANS_COMPLETED_M) SEP \ - FUNC(pmu_event, SRAM1_WR_TRANS_COMPLETED_S) SEP \ - FUNC(pmu_event, SRAM1_WR_DATA_BEAT_WRITTEN) SEP \ - FUNC(pmu_event, SRAM1_WR_TRAN_REQ_STALLED) SEP \ - FUNC(pmu_event, SRAM1_WR_DATA_BEAT_STALLED) SEP \ - FUNC(pmu_event, SRAM1_ENABLED_CYCLES) SEP \ - FUNC(pmu_event, SRAM1_RD_STALL_LIMIT) SEP \ - FUNC(pmu_event, SRAM1_WR_STALL_LIMIT) SEP \ - FUNC(pmu_event, SRAM2_RD_TRANS_ACCEPTED) SEP \ - FUNC(pmu_event, SRAM2_RD_TRANS_COMPLETED) SEP \ - FUNC(pmu_event, SRAM2_RD_DATA_BEAT_RECEIVED) SEP \ - FUNC(pmu_event, SRAM2_RD_TRAN_REQ_STALLED) SEP \ - FUNC(pmu_event, SRAM2_WR_TRANS_ACCEPTED) SEP \ - FUNC(pmu_event, SRAM2_WR_TRANS_COMPLETED_M) SEP \ - FUNC(pmu_event, SRAM2_WR_TRANS_COMPLETED_S) SEP \ - FUNC(pmu_event, SRAM2_WR_DATA_BEAT_WRITTEN) SEP \ - FUNC(pmu_event, SRAM2_WR_TRAN_REQ_STALLED) SEP \ - FUNC(pmu_event, SRAM2_WR_DATA_BEAT_STALLED) SEP \ - FUNC(pmu_event, SRAM2_ENABLED_CYCLES) SEP \ - FUNC(pmu_event, SRAM2_RD_STALL_LIMIT) SEP \ - FUNC(pmu_event, SRAM2_WR_STALL_LIMIT) SEP \ - FUNC(pmu_event, SRAM3_RD_TRANS_ACCEPTED) SEP \ - FUNC(pmu_event, SRAM3_RD_TRANS_COMPLETED) SEP \ - FUNC(pmu_event, SRAM3_RD_DATA_BEAT_RECEIVED) SEP \ - FUNC(pmu_event, SRAM3_RD_TRAN_REQ_STALLED) SEP \ - FUNC(pmu_event, SRAM3_WR_TRANS_ACCEPTED) SEP \ - FUNC(pmu_event, SRAM3_WR_TRANS_COMPLETED_M) SEP \ - FUNC(pmu_event, SRAM3_WR_TRANS_COMPLETED_S) SEP \ - FUNC(pmu_event, SRAM3_WR_DATA_BEAT_WRITTEN) SEP \ - FUNC(pmu_event, SRAM3_WR_TRAN_REQ_STALLED) SEP \ - FUNC(pmu_event, SRAM3_WR_DATA_BEAT_STALLED) SEP \ - FUNC(pmu_event, SRAM3_ENABLED_CYCLES) SEP \ - FUNC(pmu_event, SRAM3_RD_STALL_LIMIT) SEP \ - FUNC(pmu_event, SRAM3_WR_STALL_LIMIT) SEP \ - FUNC(pmu_event, EXT0_RD_TRANS_ACCEPTED) SEP \ - FUNC(pmu_event, EXT0_RD_TRANS_COMPLETED) SEP \ - FUNC(pmu_event, EXT0_RD_DATA_BEAT_RECEIVED) SEP \ - FUNC(pmu_event, EXT0_RD_TRAN_REQ_STALLED) SEP \ - FUNC(pmu_event, EXT0_WR_TRANS_ACCEPTED) SEP \ - FUNC(pmu_event, EXT0_WR_TRANS_COMPLETED_M) SEP \ - FUNC(pmu_event, EXT0_WR_TRANS_COMPLETED_S) SEP \ - FUNC(pmu_event, EXT0_WR_DATA_BEAT_WRITTEN) SEP \ - FUNC(pmu_event, EXT0_WR_TRAN_REQ_STALLED) SEP \ - FUNC(pmu_event, EXT0_WR_DATA_BEAT_STALLED) SEP \ - FUNC(pmu_event, EXT0_ENABLED_CYCLES) SEP \ - FUNC(pmu_event, EXT0_RD_STALL_LIMIT) SEP \ - FUNC(pmu_event, EXT0_WR_STALL_LIMIT) SEP \ - FUNC(pmu_event, EXT1_RD_TRANS_ACCEPTED) SEP \ - FUNC(pmu_event, EXT1_RD_TRANS_COMPLETED) SEP \ - FUNC(pmu_event, EXT1_RD_DATA_BEAT_RECEIVED) SEP \ - FUNC(pmu_event, EXT1_RD_TRAN_REQ_STALLED) SEP \ - FUNC(pmu_event, EXT1_WR_TRANS_ACCEPTED) SEP \ - FUNC(pmu_event, EXT1_WR_TRANS_COMPLETED_M) SEP \ - FUNC(pmu_event, EXT1_WR_TRANS_COMPLETED_S) SEP \ - FUNC(pmu_event, EXT1_WR_DATA_BEAT_WRITTEN) SEP \ - FUNC(pmu_event, EXT1_WR_TRAN_REQ_STALLED) SEP \ - FUNC(pmu_event, EXT1_WR_DATA_BEAT_STALLED) SEP \ - FUNC(pmu_event, EXT1_ENABLED_CYCLES) SEP \ - FUNC(pmu_event, EXT1_RD_STALL_LIMIT) SEP \ - FUNC(pmu_event, EXT1_WR_STALL_LIMIT) - -#define EXPAND_PMU_PORT_DISABLE(FUNC, SEP) \ - FUNC(pmu_port_disable, ENABLE) SEP \ - FUNC(pmu_port_disable, DISABLE) - -#define EXPAND_POOLING_MODE(FUNC, SEP) \ - FUNC(pooling_mode, MAX) SEP \ - FUNC(pooling_mode, AVERAGE) SEP \ - FUNC(pooling_mode, REDUCE_SUM) SEP \ - FUNC(pooling_mode, SUM) SEP \ - FUNC(pooling_mode, NONE) SEP \ - FUNC(pooling_mode, MIN) SEP \ - FUNC(pooling_mode, ARGMAX_X) SEP \ - FUNC(pooling_mode, ARGMAX_Y) - -#define EXPAND_PRIVILEGE_LEVEL(FUNC, SEP) \ - FUNC(privilege_level, USER) SEP \ - FUNC(privilege_level, PRIVILEGED) - -#define EXPAND_RAM_ID(FUNC, SEP) \ - FUNC(ram_id, LUT) SEP \ - FUNC(ram_id, IB) SEP \ - FUNC(ram_id, AB) SEP \ - FUNC(ram_id, CB) SEP \ - FUNC(ram_id, OB) - -#define EXPAND_RESIZE_MODE(FUNC, SEP) \ - FUNC(resize_mode, BILINEAR) SEP \ - FUNC(resize_mode, REPLICATE) SEP \ - FUNC(resize_mode, NEAREST) - -#define EXPAND_ROUND_MODE_IFM(FUNC, SEP) \ - FUNC(round_mode_ifm, DOUBLE_SYMMETRIC) SEP \ - FUNC(round_mode_ifm, NATURAL) - -#define EXPAND_ROUND_MODE_OFM(FUNC, SEP) \ - FUNC(round_mode_ofm, DOUBLE_SYMMETRIC) SEP \ - FUNC(round_mode_ofm, NATURAL) SEP \ - FUNC(round_mode_ofm, DOUBLE_ASYMMETRIC) SEP \ - FUNC(round_mode_ofm, SYMMETRIC) SEP \ - FUNC(round_mode_ofm, TRUNCATE_TO_ZERO) SEP \ - FUNC(round_mode_ofm, TRUNCATE_TO_LOWER) - -#define EXPAND_SECURITY_LEVEL(FUNC, SEP) \ - FUNC(security_level, SECURE) SEP \ - FUNC(security_level, NON_SECURE) - -#define EXPAND_STATE(FUNC, SEP) \ - FUNC(state, STOPPED) SEP \ - FUNC(state, RUNNING) - -#define EXPAND_WD_ACTIVE_CORE(FUNC, SEP) \ - FUNC(wd_active_core, NONE) SEP \ - FUNC(wd_active_core, STANDARD) SEP \ - FUNC(wd_active_core, FAST) SEP \ - FUNC(wd_active_core, TENSOR) - -#define EXPAND_WEIGHT_FORMAT(FUNC, SEP) \ - FUNC(weight_format, SWD) SEP \ - FUNC(weight_format, FWD) - -#define EXPAND_WEIGHT_ORDER(FUNC, SEP) \ - FUNC(weight_order, DEPTH_FIRST) SEP \ - FUNC(weight_order, PART_KERNEL_FIRST) - -#define EXPAND_WEIGHT_SPARSITY(FUNC, SEP) \ - FUNC(weight_sparsity, NONE) SEP \ - FUNC(weight_sparsity, SPARSE_2_4) - -#ifdef __cplusplus -} -#endif -#endif diff --git a/ai_layer/engine/include/executorch/backends/arm/third-party/ethos-u-core-driver/src/ethosu_config_u55.h b/ai_layer/engine/include/executorch/backends/arm/third-party/ethos-u-core-driver/src/ethosu_config_u55.h deleted file mode 100644 index 9330bb1f..00000000 --- a/ai_layer/engine/include/executorch/backends/arm/third-party/ethos-u-core-driver/src/ethosu_config_u55.h +++ /dev/null @@ -1,124 +0,0 @@ -/* - * Copyright (c) 2019-2020,2022 Arm Limited. - * - * SPDX-License-Identifier: Apache-2.0 - * - * Licensed under the Apache License, Version 2.0 (the License); you may - * not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an AS IS BASIS, WITHOUT - * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef ETHOSU_CONFIG_H -#define ETHOSU_CONFIG_H - -/* Set default values if not manually overriden */ - -#ifndef NPU_QCONFIG -#define NPU_QCONFIG 2 -#endif - -#ifndef NPU_REGIONCFG_0 -#define NPU_REGIONCFG_0 3 -#endif - -#ifndef NPU_REGIONCFG_1 -#define NPU_REGIONCFG_1 0 -#endif - -#ifndef NPU_REGIONCFG_2 -#define NPU_REGIONCFG_2 1 -#endif - -#ifndef NPU_REGIONCFG_3 -#define NPU_REGIONCFG_3 1 -#endif - -#ifndef NPU_REGIONCFG_4 -#define NPU_REGIONCFG_4 1 -#endif - -#ifndef NPU_REGIONCFG_5 -#define NPU_REGIONCFG_5 1 -#endif - -#ifndef NPU_REGIONCFG_6 -#define NPU_REGIONCFG_6 1 -#endif - -#ifndef NPU_REGIONCFG_7 -#define NPU_REGIONCFG_7 1 -#endif - -#ifndef AXI_LIMIT0_MAX_BEATS_BYTES -#define AXI_LIMIT0_MAX_BEATS_BYTES 0x0 -#endif - -#ifndef AXI_LIMIT0_MEM_TYPE -#define AXI_LIMIT0_MEM_TYPE 0x0 -#endif - -#ifndef AXI_LIMIT0_MAX_OUTSTANDING_READS -#define AXI_LIMIT0_MAX_OUTSTANDING_READS 32 -#endif - -#ifndef AXI_LIMIT0_MAX_OUTSTANDING_WRITES -#define AXI_LIMIT0_MAX_OUTSTANDING_WRITES 16 -#endif - -#ifndef AXI_LIMIT1_MAX_BEATS_BYTES -#define AXI_LIMIT1_MAX_BEATS_BYTES 0x0 -#endif - -#ifndef AXI_LIMIT1_MEM_TYPE -#define AXI_LIMIT1_MEM_TYPE 0x0 -#endif - -#ifndef AXI_LIMIT1_MAX_OUTSTANDING_READS -#define AXI_LIMIT1_MAX_OUTSTANDING_READS 32 -#endif - -#ifndef AXI_LIMIT1_MAX_OUTSTANDING_WRITES -#define AXI_LIMIT1_MAX_OUTSTANDING_WRITES 16 -#endif - -#ifndef AXI_LIMIT2_MAX_BEATS_BYTES -#define AXI_LIMIT2_MAX_BEATS_BYTES 0x0 -#endif - -#ifndef AXI_LIMIT2_MEM_TYPE -#define AXI_LIMIT2_MEM_TYPE 0x0 -#endif - -#ifndef AXI_LIMIT2_MAX_OUTSTANDING_READS -#define AXI_LIMIT2_MAX_OUTSTANDING_READS 32 -#endif - -#ifndef AXI_LIMIT2_MAX_OUTSTANDING_WRITES -#define AXI_LIMIT2_MAX_OUTSTANDING_WRITES 16 -#endif - -#ifndef AXI_LIMIT3_MAX_BEATS_BYTES -#define AXI_LIMIT3_MAX_BEATS_BYTES 0x0 -#endif - -#ifndef AXI_LIMIT3_MEM_TYPE -#define AXI_LIMIT3_MEM_TYPE 0x0 -#endif - -#ifndef AXI_LIMIT3_MAX_OUTSTANDING_READS -#define AXI_LIMIT3_MAX_OUTSTANDING_READS 32 -#endif - -#ifndef AXI_LIMIT3_MAX_OUTSTANDING_WRITES -#define AXI_LIMIT3_MAX_OUTSTANDING_WRITES 16 -#endif - -#endif /* #ifndef ETHOSU_CONFIG_H */ diff --git a/ai_layer/engine/include/executorch/backends/arm/third-party/ethos-u-core-driver/src/ethosu_config_u65.h b/ai_layer/engine/include/executorch/backends/arm/third-party/ethos-u-core-driver/src/ethosu_config_u65.h deleted file mode 100644 index b115f43d..00000000 --- a/ai_layer/engine/include/executorch/backends/arm/third-party/ethos-u-core-driver/src/ethosu_config_u65.h +++ /dev/null @@ -1,124 +0,0 @@ -/* - * Copyright (c) 2019-2020,2022 Arm Limited. - * - * SPDX-License-Identifier: Apache-2.0 - * - * Licensed under the Apache License, Version 2.0 (the License); you may - * not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an AS IS BASIS, WITHOUT - * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef ETHOSU_CONFIG_H -#define ETHOSU_CONFIG_H - -/* Set default values if not manually overriden */ - -#ifndef NPU_QCONFIG -#define NPU_QCONFIG 2 -#endif - -#ifndef NPU_REGIONCFG_0 -#define NPU_REGIONCFG_0 3 -#endif - -#ifndef NPU_REGIONCFG_1 -#define NPU_REGIONCFG_1 2 -#endif - -#ifndef NPU_REGIONCFG_2 -#define NPU_REGIONCFG_2 1 -#endif - -#ifndef NPU_REGIONCFG_3 -#define NPU_REGIONCFG_3 1 -#endif - -#ifndef NPU_REGIONCFG_4 -#define NPU_REGIONCFG_4 1 -#endif - -#ifndef NPU_REGIONCFG_5 -#define NPU_REGIONCFG_5 1 -#endif - -#ifndef NPU_REGIONCFG_6 -#define NPU_REGIONCFG_6 1 -#endif - -#ifndef NPU_REGIONCFG_7 -#define NPU_REGIONCFG_7 1 -#endif - -#ifndef AXI_LIMIT0_MAX_BEATS_BYTES -#define AXI_LIMIT0_MAX_BEATS_BYTES 0x0 -#endif - -#ifndef AXI_LIMIT0_MEM_TYPE -#define AXI_LIMIT0_MEM_TYPE 0x0 -#endif - -#ifndef AXI_LIMIT0_MAX_OUTSTANDING_READS -#define AXI_LIMIT0_MAX_OUTSTANDING_READS 64 -#endif - -#ifndef AXI_LIMIT0_MAX_OUTSTANDING_WRITES -#define AXI_LIMIT0_MAX_OUTSTANDING_WRITES 32 -#endif - -#ifndef AXI_LIMIT1_MAX_BEATS_BYTES -#define AXI_LIMIT1_MAX_BEATS_BYTES 0x0 -#endif - -#ifndef AXI_LIMIT1_MEM_TYPE -#define AXI_LIMIT1_MEM_TYPE 0x0 -#endif - -#ifndef AXI_LIMIT1_MAX_OUTSTANDING_READS -#define AXI_LIMIT1_MAX_OUTSTANDING_READS 64 -#endif - -#ifndef AXI_LIMIT1_MAX_OUTSTANDING_WRITES -#define AXI_LIMIT1_MAX_OUTSTANDING_WRITES 32 -#endif - -#ifndef AXI_LIMIT2_MAX_BEATS_BYTES -#define AXI_LIMIT2_MAX_BEATS_BYTES 0x0 -#endif - -#ifndef AXI_LIMIT2_MEM_TYPE -#define AXI_LIMIT2_MEM_TYPE 0x0 -#endif - -#ifndef AXI_LIMIT2_MAX_OUTSTANDING_READS -#define AXI_LIMIT2_MAX_OUTSTANDING_READS 64 -#endif - -#ifndef AXI_LIMIT2_MAX_OUTSTANDING_WRITES -#define AXI_LIMIT2_MAX_OUTSTANDING_WRITES 32 -#endif - -#ifndef AXI_LIMIT3_MAX_BEATS_BYTES -#define AXI_LIMIT3_MAX_BEATS_BYTES 0x0 -#endif - -#ifndef AXI_LIMIT3_MEM_TYPE -#define AXI_LIMIT3_MEM_TYPE 0x0 -#endif - -#ifndef AXI_LIMIT3_MAX_OUTSTANDING_READS -#define AXI_LIMIT3_MAX_OUTSTANDING_READS 64 -#endif - -#ifndef AXI_LIMIT3_MAX_OUTSTANDING_WRITES -#define AXI_LIMIT3_MAX_OUTSTANDING_WRITES 32 -#endif - -#endif /* #ifndef ETHOSU_CONFIG_H */ diff --git a/ai_layer/engine/include/executorch/backends/arm/third-party/ethos-u-core-driver/src/ethosu_config_u85.h b/ai_layer/engine/include/executorch/backends/arm/third-party/ethos-u-core-driver/src/ethosu_config_u85.h deleted file mode 100644 index 3cc1f975..00000000 --- a/ai_layer/engine/include/executorch/backends/arm/third-party/ethos-u-core-driver/src/ethosu_config_u85.h +++ /dev/null @@ -1,112 +0,0 @@ -/* - * SPDX-FileCopyrightText: Copyright 2020, 2024 Arm Limited and/or its affiliates - * SPDX-License-Identifier: Apache-2.0 - * - * Licensed under the Apache License, Version 2.0 (the License); you may - * not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an AS IS BASIS, WITHOUT - * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef ETHOSU_CONFIG_U85_H -#define ETHOSU_CONFIG_U85_H - -/* Set default values if not manually overriden */ - -/* MAC power ramping up/down control - * NOTE: Actual number of cycles is 4*NPU_MAC_PWR_RAMP_CYCLES - */ -#ifndef NPU_MAC_PWR_RAMP_CYCLES -#define NPU_MAC_PWR_RAMP_CYCLES 0 /* Valid range 0-63, where 0 disables power ramping */ -#endif - -/* Default MEM_ATTR entries */ -#ifndef NPU_MEM_ATTR_0 -#define NPU_MEM_ATTR_0 0 /* SRAM AXI port, non_sharable, device_non_bufferable */ -#endif - -#ifndef NPU_MEM_ATTR_1 -#define NPU_MEM_ATTR_1 0 /* SRAM AXI port, non_sharable, device_non_bufferable */ -#endif - -#ifndef NPU_MEM_ATTR_2 -#define NPU_MEM_ATTR_2 (1 << 2) /* EXT AXI port, non_sharable, device_non_bufferable */ -#endif - -#ifndef NPU_MEM_ATTR_3 -#define NPU_MEM_ATTR_3 (1 << 2) /* EXT AXI port, non_sharable, device_non_bufferable */ -#endif - -/* Default MEM_ATTR index to use for command stream */ -#ifndef NPU_QCONFIG -#define NPU_QCONFIG 2 -#endif - -/* Default MEM_ATTR index to use for regions 0-7 */ -#ifndef NPU_REGIONCFG_0 -#define NPU_REGIONCFG_0 3 -#endif - -#ifndef NPU_REGIONCFG_1 -#define NPU_REGIONCFG_1 0 -#endif - -#ifndef NPU_REGIONCFG_2 -#define NPU_REGIONCFG_2 1 -#endif - -#ifndef NPU_REGIONCFG_3 -#define NPU_REGIONCFG_3 1 -#endif - -#ifndef NPU_REGIONCFG_4 -#define NPU_REGIONCFG_4 1 -#endif - -#ifndef NPU_REGIONCFG_5 -#define NPU_REGIONCFG_5 1 -#endif - -#ifndef NPU_REGIONCFG_6 -#define NPU_REGIONCFG_6 1 -#endif - -#ifndef NPU_REGIONCFG_7 -#define NPU_REGIONCFG_7 1 -#endif - -/* AXI SRAM/EXT limits - * Set defaults to max. Hardware can be configured to cap at lower values. - */ -#ifndef AXI_LIMIT_SRAM_MAX_OUTSTANDING_READ_M1 -#define AXI_LIMIT_SRAM_MAX_OUTSTANDING_READ_M1 12 -#endif - -#ifndef AXI_LIMIT_SRAM_MAX_OUTSTANDING_WRITE_M1 -#define AXI_LIMIT_SRAM_MAX_OUTSTANDING_WRITE_M1 16 -#endif - -#ifndef AXI_LIMIT_SRAM_MAX_BEATS -#define AXI_LIMIT_SRAM_MAX_BEATS 2 /* 0=64B, 1=128B, 2=256B */ -#endif - -#ifndef AXI_LIMIT_EXT_MAX_OUTSTANDING_READ_M1 -#define AXI_LIMIT_EXT_MAX_OUTSTANDING_READ_M1 64 /* Hardware max might be less */ -#endif - -#ifndef AXI_LIMIT_EXT_MAX_OUTSTANDING_WRITE_M1 -#define AXI_LIMIT_EXT_MAX_OUTSTANDING_WRITE_M1 32 -#endif - -#ifndef AXI_LIMIT_EXT_MAX_BEATS -#define AXI_LIMIT_EXT_MAX_BEATS 2 /* 0=64B, 1=128B, 2=256B */ -#endif - -#endif /* #ifndef ETHOSU_CONFIG_U85_H */ diff --git a/ai_layer/engine/include/executorch/backends/arm/third-party/ethos-u-core-driver/src/ethosu_device.h b/ai_layer/engine/include/executorch/backends/arm/third-party/ethos-u-core-driver/src/ethosu_device.h deleted file mode 100644 index 3567da4a..00000000 --- a/ai_layer/engine/include/executorch/backends/arm/third-party/ethos-u-core-driver/src/ethosu_device.h +++ /dev/null @@ -1,115 +0,0 @@ -/* - * SPDX-FileCopyrightText: Copyright 2019-2024 Arm Limited and/or its affiliates - * SPDX-License-Identifier: Apache-2.0 - * - * Licensed under the Apache License, Version 2.0 (the License); you may - * not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an AS IS BASIS, WITHOUT - * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef ETHOSU_DEVICE_H -#define ETHOSU_DEVICE_H - -/****************************************************************************** - * Includes - ******************************************************************************/ -#include "ethosu_types.h" - -#include -#include - -#ifdef __cplusplus -extern "C" { -#endif - -/****************************************************************************** - * Prototypes - ******************************************************************************/ - -/** - * Initialize the device. - */ -bool ethosu_dev_init(struct ethosu_device *dev, void *base_address, uint32_t secure_enable, uint32_t privilege_enable); - -/** - * Initialize AXI settings for device. - */ -enum ethosu_error_codes ethosu_dev_axi_init(struct ethosu_device *dev); - -/** - * Execute a given command stream on NPU. - * \param[in] cmd_stream_ptr Pointer to the command stream - * \param[in] cms_length Command stream length - * \param[in] base_addr Pointer to array of base addresses - * - 0: weight tensor - * - 1: scratch tensor - * - All input tensors - * - All output tensors - * \param[in] num_base_addr Number of base addresses. - */ -void ethosu_dev_run_command_stream(struct ethosu_device *dev, - const uint8_t *cmd_stream_ptr, - uint32_t cms_length, - const uint64_t *base_addr, - int num_base_addr); - -/** - * Print information on NPU error status - */ -void ethosu_dev_print_err_status(struct ethosu_device *dev); - -/** - * Interrupt handler on device layer - * \return true if NPU status is OK, otherwise false - */ -bool ethosu_dev_handle_interrupt(struct ethosu_device *dev); - -/** - * Get hardware information from NPU - * \param[out] hwinfo Pointer to the hardware info struct to be filled in. - */ -void ethosu_dev_get_hw_info(struct ethosu_device *dev, struct ethosu_hw_info *hwinfo); - -/** - * Verify that requested security state and privilege mode are active - * \return 32 bit status value - */ -bool ethosu_dev_verify_access_state(struct ethosu_device *dev); - -/** - * Performs a NPU soft reset and waits for the NPU to become ready - * \return \ref ethosu_error_codes - */ -enum ethosu_error_codes ethosu_dev_soft_reset(struct ethosu_device *dev); - -/** - * Enable/disable clock and power using clock/power q interface. - * \param[in] clock_q Clock q ENABLE/DISABLE \ref clock_q_request. - * \param[in] power_q Power q ENABLE/DISABLE \ref power_q_request. - * \return \ref ethosu_error_codes - */ -enum ethosu_error_codes ethosu_dev_set_clock_and_power(struct ethosu_device *dev, - enum ethosu_clock_q_request clock_q, - enum ethosu_power_q_request power_q); - -/** - * Verifies that optimizer parameters from model are compatible with the hardware - * \param[in] cfg Config data from optimizer. - * \param[in] id Id data from optimizer. - * \return true if parameters match with hardware, false otherwise. - */ -bool ethosu_dev_verify_optimizer_config(struct ethosu_device *dev, uint32_t cfg_in, uint32_t id_in); - -#ifdef __cplusplus -} -#endif - -#endif // ETHOSU_DEVICE_H diff --git a/ai_layer/engine/include/executorch/backends/arm/third-party/ethos-u-core-driver/src/ethosu_interface.h b/ai_layer/engine/include/executorch/backends/arm/third-party/ethos-u-core-driver/src/ethosu_interface.h deleted file mode 100644 index 2409cb4e..00000000 --- a/ai_layer/engine/include/executorch/backends/arm/third-party/ethos-u-core-driver/src/ethosu_interface.h +++ /dev/null @@ -1,32 +0,0 @@ -/* - * Copyright (c) 2020-2021 Arm Limited. All rights reserved. - * - * SPDX-License-Identifier: Apache-2.0 - * - * Licensed under the Apache License, Version 2.0 (the License); you may - * not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an AS IS BASIS, WITHOUT - * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -// clang-format off -#ifndef ETHOSU_INTERFACE_WRAPPER_ -#define ETHOSU_INTERFACE_WRAPPER_ - -#define xstr(a) str(a) -#define str(a) #a - -#define catm(a, b) catm_(a, b) -#define catm_(a, b) a##b - -#define ETHOSU_INTERFACE_FILE xstr(catm(ethos, ETHOSU_ARCH)_interface.h) - -#include ETHOSU_INTERFACE_FILE - -#endif // ETHOSU_INTERFACE_WRAPPER_ diff --git a/ai_layer/engine/include/executorch/backends/arm/third-party/ethos-u-core-driver/src/ethosu_log.h b/ai_layer/engine/include/executorch/backends/arm/third-party/ethos-u-core-driver/src/ethosu_log.h deleted file mode 100644 index 13f7726b..00000000 --- a/ai_layer/engine/include/executorch/backends/arm/third-party/ethos-u-core-driver/src/ethosu_log.h +++ /dev/null @@ -1,82 +0,0 @@ -/* - * SPDX-FileCopyrightText: Copyright 2021-2023 Arm Limited and/or its affiliates - * SPDX-License-Identifier: Apache-2.0 - * - * Licensed under the Apache License, Version 2.0 (the License); you may - * not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an AS IS BASIS, WITHOUT - * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef ETHOSU_LOG_H -#define ETHOSU_LOG_H - -/****************************************************************************** - * Includes - ******************************************************************************/ - -#include -#include - -/****************************************************************************** - * Defines - ******************************************************************************/ - -// Log severity levels -#define ETHOSU_LOG_ERR 0 -#define ETHOSU_LOG_WARN 1 -#define ETHOSU_LOG_INFO 2 -#define ETHOSU_LOG_DEBUG 3 - -// Define default log severity -#ifndef ETHOSU_LOG_SEVERITY -#define ETHOSU_LOG_SEVERITY ETHOSU_LOG_WARN -#endif - -// Logs enabled by default -#ifndef ETHOSU_LOG_ENABLE -#define ETHOSU_LOG_ENABLE 1 -#endif - -#if ETHOSU_LOG_ENABLE -#define LOG_COMMON(s, f, ...) (void)fprintf(s, f, ##__VA_ARGS__) -#else -#define LOG_COMMON(s, f, ...) -#endif - -// Log formatting -#define LOG(f, ...) LOG_COMMON(stdout, f, ##__VA__ARGS__) - -#if ETHOSU_LOG_SEVERITY >= ETHOSU_LOG_ERR -#define LOG_ERR(f, ...) \ - LOG_COMMON(stderr, "E: " f " (%s:%d)\n", ##__VA_ARGS__, strrchr("/" __FILE__, '/') + 1, __LINE__) -#else -#define LOG_ERR(f, ...) -#endif - -#if ETHOSU_LOG_SEVERITY >= ETHOSU_LOG_WARN -#define LOG_WARN(f, ...) LOG_COMMON(stdout, "W: " f "\n", ##__VA_ARGS__) -#else -#define LOG_WARN(f, ...) -#endif - -#if ETHOSU_LOG_SEVERITY >= ETHOSU_LOG_INFO -#define LOG_INFO(f, ...) LOG_COMMON(stdout, "I: " f "\n", ##__VA_ARGS__) -#else -#define LOG_INFO(f, ...) -#endif - -#if ETHOSU_LOG_SEVERITY >= ETHOSU_LOG_DEBUG -#define LOG_DEBUG(f, ...) LOG_COMMON(stdout, "D: %s(): " f "\n", __FUNCTION__, ##__VA_ARGS__) -#else -#define LOG_DEBUG(f, ...) -#endif - -#endif diff --git a/ai_layer/engine/include/executorch/backends/cortex_m/ops/cortex_m_ops_common.h b/ai_layer/engine/include/executorch/backends/cortex_m/ops/cortex_m_ops_common.h deleted file mode 100644 index 5ef2d9d4..00000000 --- a/ai_layer/engine/include/executorch/backends/cortex_m/ops/cortex_m_ops_common.h +++ /dev/null @@ -1,152 +0,0 @@ -/* - * Copyright (c) Meta Platforms, Inc. and affiliates. - * All rights reserved. - * - * This source code is licensed under the BSD-style license found in the - * LICENSE file in the root directory of this source tree. - */ - -#pragma once - -#include -#include - -#include -#include -#include -#include -#include - -using Tensor = torch::executor::Tensor; -using ScalarType = executorch::aten::ScalarType; -using Scalar = torch::executor::Scalar; -using Error = executorch::runtime::Error; - -// Basic tensor type / layout validation and dimension order checking -inline void validate_cmsis_nn_tensor_requirements( - const Tensor& input1, - const Tensor& input2, - Tensor& output, - ScalarType expected_dtype = ScalarType::Char, - bool require_channels_last = false) { - // Basic dtype validation - ET_CHECK_MSG( - input1.scalar_type() == expected_dtype, - "Input1 dtype must be %hhd", - expected_dtype); - ET_CHECK_MSG( - input2.scalar_type() == expected_dtype, - "Input2 dtype must be %hhd", - expected_dtype); - ET_CHECK_MSG( - output.scalar_type() == expected_dtype, - "Output dtype must be %hhd", - expected_dtype); - - // Dim order consistency - ET_CHECK_MSG( - executorch::runtime::tensors_have_same_dim_order(input1, input2, output), - "Tensors must have same dimension order"); - - // TBD: Validate memory alignment (CMSIS-NN requirement) -} - -inline void validate_single_quant_params( - const Scalar& zero_point, - const Scalar& multiplier, - const Scalar& shift, - const char* param_name) { - int64_t zp_val = zero_point.to(); - int64_t mult_val = multiplier.to(); - int64_t shift_val = shift.to(); - - ET_CHECK_MSG( - zp_val >= std::numeric_limits::min() && - zp_val <= std::numeric_limits::max(), - "%s zero point must be in int8 range [Value: %d]", - param_name, - zp_val); - - ET_CHECK_MSG( - mult_val >= std::numeric_limits::min() && - mult_val <= std::numeric_limits::max(), - "%s multiplier must be in int32 range [Value: %d]", - param_name, - mult_val); - - ET_CHECK_MSG( - shift_val >= -31 && shift_val <= 31, - "%s shift must be in range [-31, 31] [Value: %d]", - param_name, - shift_val); -} - -/** - * Validate quantization parameters for inputs and output. - * - * Checks that zero points fit in int8 range, multipliers fit in int32 range, - * and shifts are within a valid bit-shift range (0-31). - * - * Ensures parameters comply with Ahead-Of-Time (AOT) quantization requirements - * and CMSIS-NN kernel expectations. - * - * Raises errors via ET_KERNEL_CHECK if any check fails. - */ -inline void validate_quantization_params( - const Scalar& zero_point1, - const Scalar& multiplier1, - const Scalar& shift1, - const Scalar& zero_point2, - const Scalar& multiplier2, - const Scalar& shift2, - const Scalar& output_zero_point, - const Scalar& output_multiplier, - const Scalar& output_shift, - Tensor& output) { - validate_single_quant_params( - zero_point1, multiplier1, shift1, "Single quant Input1"); - validate_single_quant_params( - zero_point2, multiplier2, shift2, "Single quant Input2"); - validate_single_quant_params( - output_zero_point, - output_multiplier, - output_shift, - "Single quant Output"); -} - -inline Error resize_to_broadcast_target_size( - const Tensor& input1, - const Tensor& input2, - Tensor& output) { - static constexpr int kTensorDimensionLimit = 5; - Tensor::SizesType expected_output_size[kTensorDimensionLimit]; - size_t expected_output_dim = 0; - auto err = torch::executor::get_broadcast_target_size( - input1, - input2, - expected_output_size, - kTensorDimensionLimit, - &expected_output_dim); - - if (err != Error::Ok) - return err; - - return executorch::runtime::resize_tensor( - output, {expected_output_size, expected_output_dim}); -} - -/** - * Convert Scalar to CMSIS-NN int32 format - * For multipliers, zero_points, etc. from quantize_multiplier_aot - */ -inline int32_t extractScalarToInt32(const Scalar& scalar_value) { - return static_cast(scalar_value.to()); -} - -/** - * Convert Scalar to CMSIS-NN int format - * For shift values from quantize_multiplier_aot - */ -inline int extractScalarToInt(const Scalar& scalar_value) { - return static_cast(scalar_value.to()); -} diff --git a/ai_layer/engine/include/executorch/extension/android/jni/jni_helper.h b/ai_layer/engine/include/executorch/extension/android/jni/jni_helper.h deleted file mode 100644 index 898c1619..00000000 --- a/ai_layer/engine/include/executorch/extension/android/jni/jni_helper.h +++ /dev/null @@ -1,33 +0,0 @@ -/* - * Copyright (c) Meta Platforms, Inc. and affiliates. - * All rights reserved. - * - * This source code is licensed under the BSD-style license found in the - * LICENSE file in the root directory of this source tree. - */ - -#pragma once - -#include -#include - -namespace executorch::jni_helper { - -/** - * Throws a Java ExecutorchRuntimeException corresponding to the given error - * code and details. Uses the Java factory method - * ExecutorchRuntimeException.makeExecutorchException(int, String). - * - * @param errorCode The error code from the C++ Executorch runtime. - * @param details Additional details to include in the exception message. - */ -void throwExecutorchException(uint32_t errorCode, const std::string& details); - -// Define the JavaClass wrapper -struct JExecutorchRuntimeException - : public facebook::jni::JavaClass { - static constexpr auto kJavaDescriptor = - "Lorg/pytorch/executorch/ExecutorchRuntimeException;"; -}; - -} // namespace executorch::jni_helper diff --git a/ai_layer/engine/include/executorch/extension/android/jni/jni_layer_constants.h b/ai_layer/engine/include/executorch/extension/android/jni/jni_layer_constants.h deleted file mode 100644 index 0f98f7b4..00000000 --- a/ai_layer/engine/include/executorch/extension/android/jni/jni_layer_constants.h +++ /dev/null @@ -1,96 +0,0 @@ -/* - * Copyright (c) Meta Platforms, Inc. and affiliates. - * All rights reserved. - * - * This source code is licensed under the BSD-style license found in the - * LICENSE file in the root directory of this source tree. - */ - -#include - -#include - -namespace executorch::extension { - -constexpr static int kTensorDTypeUInt8 = 0; -constexpr static int kTensorDTypeInt8 = 1; -constexpr static int kTensorDTypeInt16 = 2; -constexpr static int kTensorDTypeInt32 = 3; -constexpr static int kTensorDTypeInt64 = 4; -constexpr static int kTensorDTypeHalf = 5; -constexpr static int kTensorDTypeFloat = 6; -constexpr static int kTensorDTypeDouble = 7; -// These types are not supported yet -// constexpr static int kTensorDTypeComplexHalf = 8; -// constexpr static int kTensorDTypeComplexFloat = 9; -// constexpr static int kTensorDTypeComplexDouble = 10; -constexpr static int kTensorDTypeBool = 11; -constexpr static int kTensorDTypeQint8 = 12; -constexpr static int kTensorDTypeQuint8 = 13; -constexpr static int kTensorDTypeQint32 = 14; -constexpr static int kTensorDTypeBFloat16 = 15; -constexpr static int kTensorDTypeQuint4x2 = 16; -constexpr static int kTensorDTypeQuint2x4 = 17; -constexpr static int kTensorDTypeBits1x8 = 18; -constexpr static int kTensorDTypeBits2x4 = 19; -constexpr static int kTensorDTypeBits4x2 = 20; -constexpr static int kTensorDTypeBits8 = 21; -constexpr static int kTensorDTypeBits16 = 22; - -using executorch::aten::ScalarType; - -const std::unordered_map scalar_type_to_java_dtype = { - {ScalarType::Byte, kTensorDTypeUInt8}, - {ScalarType::Char, kTensorDTypeInt8}, - {ScalarType::Short, kTensorDTypeInt16}, - {ScalarType::Int, kTensorDTypeInt32}, - {ScalarType::Long, kTensorDTypeInt64}, - {ScalarType::Half, kTensorDTypeHalf}, - {ScalarType::Float, kTensorDTypeFloat}, - {ScalarType::Double, kTensorDTypeDouble}, - // These types are not supported yet - // {ScalarType::ComplexHalf, kTensorDTypeComplexHalf}, - // {ScalarType::ComplexFloat, kTensorDTypeComplexFloat}, - // {ScalarType::ComplexDouble, kTensorDTypeComplexDouble}, - {ScalarType::Bool, kTensorDTypeBool}, - {ScalarType::QInt8, kTensorDTypeQint8}, - {ScalarType::QUInt8, kTensorDTypeQuint8}, - {ScalarType::QInt32, kTensorDTypeQint32}, - {ScalarType::BFloat16, kTensorDTypeBFloat16}, - {ScalarType::QUInt4x2, kTensorDTypeQuint4x2}, - {ScalarType::QUInt2x4, kTensorDTypeQuint2x4}, - {ScalarType::Bits1x8, kTensorDTypeBits1x8}, - {ScalarType::Bits2x4, kTensorDTypeBits2x4}, - {ScalarType::Bits4x2, kTensorDTypeBits4x2}, - {ScalarType::Bits8, kTensorDTypeBits8}, - {ScalarType::Bits16, kTensorDTypeBits16}, -}; - -const std::unordered_map java_dtype_to_scalar_type = { - {kTensorDTypeUInt8, ScalarType::Byte}, - {kTensorDTypeInt8, ScalarType::Char}, - {kTensorDTypeInt16, ScalarType::Short}, - {kTensorDTypeInt32, ScalarType::Int}, - {kTensorDTypeInt64, ScalarType::Long}, - {kTensorDTypeHalf, ScalarType::Half}, - {kTensorDTypeFloat, ScalarType::Float}, - {kTensorDTypeDouble, ScalarType::Double}, - // These types are not supported yet - // {kTensorDTypeComplexHalf, ScalarType::ComplexHalf}, - // {kTensorDTypeComplexFloat, ScalarType::ComplexFloat}, - // {kTensorDTypeComplexDouble, ScalarType::ComplexDouble}, - {kTensorDTypeBool, ScalarType::Bool}, - {kTensorDTypeQint8, ScalarType::QInt8}, - {kTensorDTypeQuint8, ScalarType::QUInt8}, - {kTensorDTypeQint32, ScalarType::QInt32}, - {kTensorDTypeBFloat16, ScalarType::BFloat16}, - {kTensorDTypeQuint4x2, ScalarType::QUInt4x2}, - {kTensorDTypeQuint2x4, ScalarType::QUInt2x4}, - {kTensorDTypeBits1x8, ScalarType::Bits1x8}, - {kTensorDTypeBits2x4, ScalarType::Bits2x4}, - {kTensorDTypeBits4x2, ScalarType::Bits4x2}, - {kTensorDTypeBits8, ScalarType::Bits8}, - {kTensorDTypeBits16, ScalarType::Bits16}, -}; - -} // namespace executorch::extension diff --git a/ai_layer/engine/include/executorch/extension/android/jni/log.h b/ai_layer/engine/include/executorch/extension/android/jni/log.h deleted file mode 100644 index 4389b1d6..00000000 --- a/ai_layer/engine/include/executorch/extension/android/jni/log.h +++ /dev/null @@ -1,43 +0,0 @@ -/* - * Copyright (c) Meta Platforms, Inc. and affiliates. - * All rights reserved. - * - * This source code is licensed under the BSD-style license found in the - * LICENSE file in the root directory of this source tree. - */ - -#include -#include -#include - -#include -#include -#include - -namespace executorch::extension { -struct log_entry { - et_timestamp_t timestamp; - et_pal_log_level_t level; - std::string filename; - std::string function; - size_t line; - std::string message; - - log_entry( - et_timestamp_t timestamp, - et_pal_log_level_t level, - const char* filename, - const char* function, - size_t line, - const char* message, - size_t length) - : timestamp(timestamp), - level(level), - filename(filename), - function(function), - line(line), - message(message, length) {} -}; - -void access_log_buffer(std::function&)> accessor); -} // namespace executorch::extension diff --git a/ai_layer/engine/include/executorch/extension/apple/ExecuTorch/Exported/ExecuTorch.h b/ai_layer/engine/include/executorch/extension/apple/ExecuTorch/Exported/ExecuTorch.h deleted file mode 100644 index 3a12a5dd..00000000 --- a/ai_layer/engine/include/executorch/extension/apple/ExecuTorch/Exported/ExecuTorch.h +++ /dev/null @@ -1,13 +0,0 @@ -/* - * Copyright (c) Meta Platforms, Inc. and affiliates. - * All rights reserved. - * - * This source code is licensed under the BSD-style license found in the - * LICENSE file in the root directory of this source tree. - */ - -#import "ExecuTorchError.h" -#import "ExecuTorchLog.h" -#import "ExecuTorchModule.h" -#import "ExecuTorchTensor.h" -#import "ExecuTorchValue.h" diff --git a/ai_layer/engine/include/executorch/extension/apple/ExecuTorch/Exported/ExecuTorchError.h b/ai_layer/engine/include/executorch/extension/apple/ExecuTorch/Exported/ExecuTorchError.h deleted file mode 100644 index 32b2f948..00000000 --- a/ai_layer/engine/include/executorch/extension/apple/ExecuTorch/Exported/ExecuTorchError.h +++ /dev/null @@ -1,86 +0,0 @@ -/* - * Copyright (c) Meta Platforms, Inc. and affiliates. - * All rights reserved. - * - * This source code is licensed under the BSD-style license found in the - * LICENSE file in the root directory of this source tree. - */ - -#import - -NS_ASSUME_NONNULL_BEGIN - -FOUNDATION_EXPORT NSErrorDomain const ExecuTorchErrorDomain NS_SWIFT_NAME(ErrorDomain); - -/** - * Enum to define the error codes. - * Values can be a subset, but must numerically match exactly those defined in - * runtime/core/error.h - */ -typedef NS_ERROR_ENUM(ExecuTorchErrorDomain, ExecuTorchErrorCode) { - // System errors. - ExecuTorchErrorCodeOk = 0, - ExecuTorchErrorCodeInternal = 1, - ExecuTorchErrorCodeInvalidState = 2, - ExecuTorchErrorCodeEndOfMethod = 3, - - // Logical errors. - ExecuTorchErrorCodeNotSupported = 16, - ExecuTorchErrorCodeNotImplemented = 17, - ExecuTorchErrorCodeInvalidArgument = 18, - ExecuTorchErrorCodeInvalidType = 19, - ExecuTorchErrorCodeOperatorMissing = 20, - - // Registration errors. - ExecuTorchErrorCodeRegistrationExceedingMaxKernels = 21, - ExecuTorchErrorCodeRegistrationAlreadyRegistered = 22, - - // Resource errors. - ExecuTorchErrorCodeNotFound = 32, - ExecuTorchErrorCodeMemoryAllocationFailed = 33, - ExecuTorchErrorCodeAccessFailed = 34, - ExecuTorchErrorCodeInvalidProgram = 35, - ExecuTorchErrorCodeInvalidExternalData = 36, - ExecuTorchErrorCodeOutOfResources = 37, - - // Delegate errors. - ExecuTorchErrorCodeDelegateInvalidCompatibility = 48, - ExecuTorchErrorCodeDelegateMemoryAllocationFailed = 49, - ExecuTorchErrorCodeDelegateInvalidHandle = 50, -} NS_SWIFT_NAME(ErrorCode); - -/** - * Returns a brief error description for the given error code. - * - * @param code An ExecuTorchErrorCode value representing the error code. - * @return An NSString containing the error description. - */ -FOUNDATION_EXPORT -NS_RETURNS_RETAINED -NSString *ExecuTorchErrorDescription(ExecuTorchErrorCode code) - NS_SWIFT_NAME(ErrorDescription(_:)); - -/** - * Create an NSError in the ExecuTorch domain for the given code. - * - * @param code The ExecuTorchErrorCode to wrap. - * @return An NSError with ExecuTorchErrorDomain, the specified code, and a localized description. - */ -FOUNDATION_EXPORT -NS_RETURNS_RETAINED -NSError *ExecuTorchErrorWithCode(ExecuTorchErrorCode code) - NS_SWIFT_NAME(Error(code:)); - -/** - * Create an NSError in the ExecuTorch domain for the given code. - * - * @param code The ExecuTorchErrorCode to wrap. - * @param description Additional error description. - * @return An NSError with ExecuTorchErrorDomain, the specified code, and a localized description. - */ - FOUNDATION_EXPORT - NS_RETURNS_RETAINED - NSError *ExecuTorchErrorWithCodeAndDescription(ExecuTorchErrorCode code, NSString * __nullable description) - NS_SWIFT_NAME(Error(code:description:)); - -NS_ASSUME_NONNULL_END diff --git a/ai_layer/engine/include/executorch/extension/apple/ExecuTorch/Exported/ExecuTorchLog.h b/ai_layer/engine/include/executorch/extension/apple/ExecuTorch/Exported/ExecuTorchLog.h deleted file mode 100644 index 17d9f339..00000000 --- a/ai_layer/engine/include/executorch/extension/apple/ExecuTorch/Exported/ExecuTorchLog.h +++ /dev/null @@ -1,77 +0,0 @@ -/* - * Copyright (c) Meta Platforms, Inc. and affiliates. - * All rights reserved. - * - * This source code is licensed under the BSD-style license found in the - * LICENSE file in the root directory of this source tree. - */ - -#import - -NS_ASSUME_NONNULL_BEGIN - -/** - * Defines log levels with specific character codes representing each level. - */ -typedef NS_ENUM(NSInteger, ExecuTorchLogLevel) { - ExecuTorchLogLevelDebug = 'D', - ExecuTorchLogLevelInfo = 'I', - ExecuTorchLogLevelError = 'E', - ExecuTorchLogLevelFatal = 'F', - ExecuTorchLogLevelUnknown = '?' -} NS_SWIFT_NAME(LogLevel); - -/** - * A protocol defining the requirements for a log sink to receive log messages. - */ -NS_SWIFT_NAME(LogSink) -@protocol ExecuTorchLogSink - -/** - * Logs a message with the specified additional info. - * - * @param level The log level of the message. - * @param timestamp The timestamp of the log message since ExecuTorch PAL start. - * @param filename The name of the file generating the log message. - * @param line The line number in the file where the log message was generated. - * @param message The log message text. - */ -- (void)logWithLevel:(ExecuTorchLogLevel)level - timestamp:(NSTimeInterval)timestamp - filename:(NSString *)filename - line:(NSUInteger)line - message:(NSString *)message - NS_SWIFT_NAME(log(level:timestamp:filename:line:message:)); - -@end - -/** - * A singleton class for managing log sinks and dispatching log messages. - */ -NS_SWIFT_NAME(Log) -__attribute__((objc_subclassing_restricted)) -@interface ExecuTorchLog : NSObject - -/// The shared singleton log instance. -@property(class, readonly) ExecuTorchLog *sharedLog; - -/** - * Adds a log sink to receive log messages. - * - * @param sink The log sink to add. - */ -- (void)addSink:(id)sink NS_SWIFT_NAME(add(sink:)); - -/** - * Removes a previously added log sink. - * - * @param sink The log sink to remove. - */ -- (void)removeSink:(id)sink NS_SWIFT_NAME(remove(sink:)); - -+ (instancetype)new NS_UNAVAILABLE; -- (instancetype)init NS_UNAVAILABLE; - -@end - -NS_ASSUME_NONNULL_END diff --git a/ai_layer/engine/include/executorch/extension/apple/ExecuTorch/Exported/ExecuTorchModule.h b/ai_layer/engine/include/executorch/extension/apple/ExecuTorch/Exported/ExecuTorchModule.h deleted file mode 100644 index 9b8400d7..00000000 --- a/ai_layer/engine/include/executorch/extension/apple/ExecuTorch/Exported/ExecuTorchModule.h +++ /dev/null @@ -1,537 +0,0 @@ -/* - * Copyright (c) Meta Platforms, Inc. and affiliates. - * All rights reserved. - * - * This source code is licensed under the BSD-style license found in the - * LICENSE file in the root directory of this source tree. - */ - -#import "ExecuTorchValue.h" - -NS_ASSUME_NONNULL_BEGIN - -/** - * Holds the static metadata for a single tensor: its shape, layout, - * element type, whether its memory was pre-planned by the runtime, - * and its debug name. - */ -NS_SWIFT_NAME(TensorMetadata) -__attribute__((objc_subclassing_restricted)) -@interface ExecuTorchTensorMetadata : NSObject - -/** The size of each dimension. */ -@property (nonatomic, readonly) NSArray *shape - NS_REFINED_FOR_SWIFT; - -/** The order in which dimensions are laid out. */ -@property (nonatomic, readonly) NSArray *dimensionOrder - NS_REFINED_FOR_SWIFT; - -/** The scalar type of each element in the tensor. */ -@property (nonatomic, readonly) ExecuTorchDataType dataType; - -/** YES if the runtime pre-allocated memory for this tensor. */ -@property (nonatomic, readonly) BOOL isMemoryPlanned; - -/** The (optional) user-visible name of this tensor (may be empty) */ -@property (nonatomic, readonly) NSString *name; - -+ (instancetype)new NS_UNAVAILABLE; -- (instancetype)init NS_UNAVAILABLE; - -@end - -/** - * Encapsulates all of the metadata for a loaded method: its name, - * how many inputs/outputs/attributes it has, per-argument tags, - * per-tensor metadata, buffer sizes, backends, and instruction count. - */ -NS_SWIFT_NAME(MethodMetadata) -__attribute__((objc_subclassing_restricted)) -@interface ExecuTorchMethodMetadata : NSObject - -/** The method’s name. */ -@property (nonatomic, readonly) NSString *name; - -/** An array of ExecuTorchValueTag raw values, one per declared input. */ -@property (nonatomic, readonly) NSArray *inputValueTags - NS_REFINED_FOR_SWIFT; - -/** An array of ExecuTorchValueTag raw values, one per declared output. */ -@property (nonatomic, readonly) NSArray *outputValueTags - NS_REFINED_FOR_SWIFT; - -/** - * Mapping from input-index to TensorMetadata. - * Only present for those indices whose tag == .tensor - */ -@property (nonatomic, readonly) NSDictionary *inputTensorMetadata - NS_REFINED_FOR_SWIFT; - -/** - * Mapping from output-index to TensorMetadata. - * Only present for those indices whose tag == .tensor - */ -@property (nonatomic, readonly) NSDictionary *outputTensorMetadata - NS_REFINED_FOR_SWIFT; - -/** A list of attribute TensorsMetadata. */ -@property (nonatomic, readonly) NSArray *attributeTensorMetadata; - -/** A list of memory-planned buffer sizes. */ -@property (nonatomic, readonly) NSArray *memoryPlannedBufferSizes - NS_REFINED_FOR_SWIFT; - -/** Names of all backends this method can run on. */ -@property (nonatomic, readonly) NSArray *backendNames; - -/** Total number of low-level instructions in this method’s body. */ -@property (nonatomic, readonly) NSInteger instructionCount; - -+ (instancetype)new NS_UNAVAILABLE; -- (instancetype)init NS_UNAVAILABLE; - -@end - -/** - * Enum to define loading behavior. - * Values can be a subset, but must numerically match exactly those defined in - * extension/module/module.h - */ -typedef NS_ENUM(NSInteger, ExecuTorchModuleLoadMode) { - ExecuTorchModuleLoadModeFile = 0, - ExecuTorchModuleLoadModeMmap, - ExecuTorchModuleLoadModeMmapUseMlock, - ExecuTorchModuleLoadModeMmapUseMlockIgnoreErrors, -} NS_SWIFT_NAME(ModuleLoadMode); - -/** - * Enum to define the verification level used when loading a module. - * Values can be a subset, but must numerically match exactly those defined in - * runtime/executor/program.h - */ -typedef NS_ENUM(uint8_t, ExecuTorchVerification) { - ExecuTorchVerificationMinimal, - ExecuTorchVerificationInternalConsistency, -} NS_SWIFT_NAME(ModuleVerification); - -/** - * Represents a module that encapsulates an ExecuTorch program. - * This class is a facade for loading programs and executing methods within them. - */ -NS_SWIFT_NAME(Module) -@interface ExecuTorchModule : NSObject - -/** - * Initializes a module with a file path, data path and a specified load mode. - * - * @param filePath A string representing the path to the ExecuTorch program file. - * @param dataFilePaths A list of strings representing paths to .ptd files with - * external tensors and external data. - * @param loadMode A value from ExecuTorchModuleLoadMode that determines the - * file loading behavior. - * @return An initialized ExecuTorchModule instance. - */ -- (instancetype)initWithFilePath:(NSString *)filePath - dataFilePaths:(NSArray *)dataFilePaths - loadMode:(ExecuTorchModuleLoadMode)loadMode - NS_DESIGNATED_INITIALIZER; - -/** - * Initializes a module with a file path, data path and a specified load mode. - * - * @param filePath A string representing the path to the ExecuTorch program file. - * @param dataFilePaths A list of strings representing paths to .ptd files with - * external tensors and external data. - * @return An initialized ExecuTorchModule instance. - */ -- (instancetype)initWithFilePath:(NSString *)filePath - dataFilePaths:(NSArray *)dataFilePaths; - -/** - * Initializes a module with a file path and a specified load mode. - * - * @param filePath A string representing the path to the ExecuTorch program file. - * @param loadMode A value from ExecuTorchModuleLoadMode that determines the file loading behavior. - * @return An initialized ExecuTorchModule instance. - */ -- (instancetype)initWithFilePath:(NSString *)filePath - loadMode:(ExecuTorchModuleLoadMode)loadMode; - -/** - * Initializes a module with a file path using the default load mode (File mode). - * - * @param filePath A string representing the path to the ExecuTorch program file. - * @return An initialized ExecuTorchModule instance. - */ -- (instancetype)initWithFilePath:(NSString *)filePath; - -/** - * Loads the module’s program using the specified verification level. - * - * @param verification The verification level to apply when loading the program. - * @param error A pointer to an NSError pointer that will be set if an error occurs. - * @return YES if the program was successfully loaded; otherwise, NO. - */ -- (BOOL)loadWithVerification:(ExecuTorchVerification)verification - error:(NSError **)error; - -/** - * Loads the module’s program using minimal verification. - * - * This is a convenience overload that defaults the verification level to Minimal. - * - * @param error A pointer to an NSError pointer that will be set if an error occurs. - * @return YES if the program was successfully loaded; otherwise, NO. - */ -- (BOOL)load:(NSError **)error; - -/** - * Checks if the module is loaded. - * - * @return YES if the module's program is loaded; otherwise, NO. - */ -- (BOOL)isLoaded; - -/** - * Loads a specific method from the program. - * - * @param methodName A string representing the name of the method to load. - * @param error A pointer to an NSError pointer that is set if an error occurs. - * @return YES if the method was successfully loaded; otherwise, NO. - */ -- (BOOL)loadMethod:(NSString *)methodName - error:(NSError **)error NS_SWIFT_NAME(load(_:)); - -/** - * Checks if a specific method is loaded. - * - * @param methodName A string representing the method name. - * @return YES if the method is loaded; otherwise, NO. - */ -- (BOOL)isMethodLoaded:(NSString *)methodName NS_SWIFT_NAME(isLoaded(_:)); - -/** - * Unloads a method and releases its native resources and planned buffers. - * - * @param methodName The method to unload. - * @return YES if the method was unloaded; NO if it was not loaded at all. - */ -- (BOOL)unloadMethod:(NSString *)methodName NS_SWIFT_NAME(unload(_:)); - -/** - * Retrieves the set of method names available in the loaded program. - * - * The method names are returned as an unordered set of strings. The program and methods - * are loaded as needed. - * - * @param error A pointer to an NSError pointer that is set if an error occurs. - * @return An unordered set of method names, or nil in case of an error. - */ -- (nullable NSSet *)methodNames:(NSError **)error - NS_RETURNS_RETAINED; - -/** - * Retrieves full metadata for a particular method in the loaded module. - * - * This includes the method’s name, input/output value tags, tensor shapes - * and layouts, buffer sizes, backend support list, and instruction count. - * - * @param methodName A string representing the method name. - * @param error A pointer to an NSError pointer that is set if an error occurs. - * @return An ExecuTorchMethodMetadata object on success, or nil if the method isn’t found or a load error occurred. - */ - - (nullable ExecuTorchMethodMetadata *)methodMetadata:(NSString *)methodName - error:(NSError **)error - NS_RETURNS_RETAINED; - -/** - * Executes a specific method with the provided input values. - * - * The method is loaded on demand if not already loaded. - * - * @param methodName A string representing the method name. - * @param values An NSArray of ExecuTorchValue objects representing the inputs. - * @param error A pointer to an NSError pointer that is set if an error occurs. - * @return An NSArray of ExecuTorchValue objects representing the outputs, or nil in case of an error. - */ -- (nullable NSArray *)executeMethod:(NSString *)methodName - withInputs:(NSArray *)values - error:(NSError **)error - NS_REFINED_FOR_SWIFT - NS_RETURNS_RETAINED; - -/** - * Executes a specific method with the provided single input value. - * - * The method is loaded on demand if not already loaded. - * - * @param methodName A string representing the method name. - * @param value An ExecuTorchValue object representing the input. - * @param error A pointer to an NSError pointer that is set if an error occurs. - * @return An NSArray of ExecuTorchValue objects representing the outputs, or nil in case of an error. - */ -- (nullable NSArray *)executeMethod:(NSString *)methodName - withInput:(ExecuTorchValue *)value - error:(NSError **)error - NS_SWIFT_UNAVAILABLE("") - NS_RETURNS_RETAINED; - -/** - * Executes a specific method with no input values. - * - * The method is loaded on demand if not already loaded. - * - * @param methodName A string representing the method name. - * @param error A pointer to an NSError pointer that is set if an error occurs. - * @return An NSArray of ExecuTorchValue objects representing the outputs, or nil in case of an error. - */ -- (nullable NSArray *)executeMethod:(NSString *)methodName - error:(NSError **)error - NS_SWIFT_NAME(execute(_:)) - NS_RETURNS_RETAINED; - -/** - * Executes a specific method with the provided input tensors. - * - * The method is loaded on demand if not already loaded. - * - * @param methodName A string representing the method name. - * @param tensors An NSArray of ExecuTorchTensor objects representing the inputs. - * @param error A pointer to an NSError pointer that is set if an error occurs. - * @return An NSArray of ExecuTorchValue objects representing the outputs, or nil in case of an error. - */ -- (nullable NSArray *)executeMethod:(NSString *)methodName - withTensors:(NSArray *)tensors - error:(NSError **)error - NS_SWIFT_UNAVAILABLE("") - NS_RETURNS_RETAINED; - -/** - * Executes a specific method with the provided single input tensor. - * - * The method is loaded on demand if not already loaded. - * - * @param methodName A string representing the method name. - * @param tensor An ExecuTorchTensor object representing the input. - * @param error A pointer to an NSError pointer that is set if an error occurs. - * @return An NSArray of ExecuTorchValue objects representing the outputs, or nil in case of an error. - */ -- (nullable NSArray *)executeMethod:(NSString *)methodName - withTensor:(ExecuTorchTensor *)tensor - error:(NSError **)error - NS_SWIFT_UNAVAILABLE("") - NS_RETURNS_RETAINED; - -/** - * Executes the "forward" method with the provided input values. - * - * This is a convenience method that calls the executeMethod with "forward" as the method name. - * - * @param values An NSArray of ExecuTorchValue objects representing the inputs. - * @param error A pointer to an NSError pointer that is set if an error occurs. - * @return An NSArray of ExecuTorchValue objects representing the outputs, or nil in case of an error. - */ -- (nullable NSArray *)forwardWithInputs:(NSArray *)values - error:(NSError **)error - NS_SWIFT_UNAVAILABLE("") - NS_RETURNS_RETAINED; - -/** - * Executes the "forward" method with the provided single input value. - * - * This is a convenience method that calls the executeMethod with "forward" as the method name. - * - * @param value An ExecuTorchValue object representing the input. - * @param error A pointer to an NSError pointer that is set if an error occurs. - * @return An NSArray of ExecuTorchValue objects representing the outputs, or nil in case of an error. - */ -- (nullable NSArray *)forwardWithInput:(ExecuTorchValue *)value - error:(NSError **)error - NS_SWIFT_UNAVAILABLE("") - NS_RETURNS_RETAINED; - -/** - * Executes the "forward" method with no inputs. - * - * This is a convenience method that calls the executeMethod with "forward" as the method name. - * - * @param error A pointer to an NSError pointer that is set if an error occurs. - * @return An NSArray of ExecuTorchValue objects representing the outputs, or nil in case of an error. - */ -- (nullable NSArray *)forward:(NSError **)error - NS_RETURNS_RETAINED; - -/** - * Executes the "forward" method with the provided input tensors. - * - * This is a convenience method that calls the executeMethod with "forward" as the method name. - * - * @param tensors An NSArray of ExecuTorchTensor objects representing the inputs. - * @param error A pointer to an NSError pointer that is set if an error occurs. - * @return An NSArray of ExecuTorchValue objects representing the outputs, or nil in case of an error. - */ -- (nullable NSArray *)forwardWithTensors:(NSArray *)tensors - error:(NSError **)error - NS_SWIFT_UNAVAILABLE("") - NS_RETURNS_RETAINED; - -/** - * Executes the "forward" method with the provided single input tensor. - * - * This is a convenience method that calls the executeMethod with "forward" as the method name. - * - * @param tensor An ExecuTorchTensor object representing the input. - * @param error A pointer to an NSError pointer that is set if an error occurs. - * @return An NSArray of ExecuTorchValue objects representing the outputs, or nil in case of an error. - */ -- (nullable NSArray *)forwardWithTensor:(ExecuTorchTensor *)tensor - error:(NSError **)error - NS_SWIFT_UNAVAILABLE("") - NS_RETURNS_RETAINED; - -/** - * Sets a single input value for the "forward" method at index 0. - * - * @param value The input value. - * @param error On failure, set to an NSError describing the issue. - * @return YES on success; NO otherwise. - */ -- (BOOL)setInput:(ExecuTorchValue *)value - error:(NSError **)error NS_SWIFT_UNAVAILABLE(""); - -/** - * Sets a single input value for the "forward" method at the specified index. - * - * @param value The input value. - * @param index Zero-based input index. - * @param error On failure, set to an NSError describing the issue. - * @return YES on success; NO otherwise. - */ -- (BOOL)setInput:(ExecuTorchValue *)value - atIndex:(NSInteger)index - error:(NSError **)error NS_SWIFT_UNAVAILABLE(""); - -/** - * Sets a single input value for the specified method at index 0. - * - * @param value The input value. - * @param methodName The method name. - * @param error On failure, set to an NSError describing the issue. - * @return YES on success; NO otherwise. - */ -- (BOOL)setInput:(ExecuTorchValue *)value - forMethod:(NSString *)methodName - error:(NSError **)error NS_SWIFT_UNAVAILABLE(""); - -/** - * Sets a single input value for the specified method at the given index. - * - * The module retains the provided value to keep its backing storage alive - * until the value is overwritten or the module is deallocated. - * - * @param value The input value. - * @param methodName The method name. - * @param index Zero-based input index. - * @param error On failure, set to an NSError describing the issue. - * @return YES on success; NO otherwise. - */ -- (BOOL)setInput:(ExecuTorchValue *)value - forMethod:(NSString *)methodName - atIndex:(NSInteger)index - error:(NSError **)error NS_REFINED_FOR_SWIFT; - -/** - * Sets all input values for the "forward" method. - * - * The number and types of values must match the method’s declared inputs. - * - * @param values The input values, one per declared input. - * @param error On failure, set to an NSError describing the issue. - * @return YES on success; NO otherwise. - */ -- (BOOL)setInputs:(NSArray *)values - error:(NSError **)error NS_SWIFT_UNAVAILABLE(""); - -/** - * Sets all input values for the specified method. - * - * The module retains the provided values to keep their backing storage alive - * until the values are overwritten or the module is deallocated. - * - * @param values The input values, one per declared input. - * @param methodName The method name. - * @param error On failure, set to an NSError describing the issue. - * @return YES on success; NO otherwise. - */ -- (BOOL)setInputs:(NSArray *)values - forMethod:(NSString *)methodName - error:(NSError **)error NS_REFINED_FOR_SWIFT; - -/** - * Sets the output buffer for the "forward" method at index 0. - * - * Only tensor outputs are supported. The provided value must wrap a tensor - * compatible with the method’s output slot. - * - * @param value The output buffer (must wrap a tensor). - * @param error On failure, set to an NSError describing the issue. - * @return YES on success; NO otherwise. - */ -- (BOOL)setOutput:(ExecuTorchValue *)value - error:(NSError **)error NS_SWIFT_UNAVAILABLE(""); - -/** - * Sets the output buffer for the "forward" method at the specified index. - * - * Only tensor outputs are supported. The provided value must wrap a tensor - * compatible with the method’s output slot. - * - * @param value The output buffer (must wrap a tensor). - * @param index Zero-based output index. - * @param error On failure, set to an NSError describing the issue. - * @return YES on success; NO otherwise. - */ -- (BOOL)setOutput:(ExecuTorchValue *)value - atIndex:(NSInteger)index - error:(NSError **)error NS_SWIFT_UNAVAILABLE(""); - -/** - * Sets the output buffer for the specified method at index 0. - * - * Only tensor outputs are supported. The provided value must wrap a tensor - * compatible with the method’s output slot. - * - * @param value The output buffer (must wrap a tensor). - * @param methodName The method name. - * @param error On failure, set to an NSError describing the issue. - * @return YES on success; NO otherwise. - */ -- (BOOL)setOutput:(ExecuTorchValue *)value - forMethod:(NSString *)methodName - error:(NSError **)error NS_SWIFT_UNAVAILABLE(""); - -/** - * Sets the output buffer for the specified method at the given index. - * - * The module retains the provided value to keep its backing storage alive - * until the value is overwritten or the module is deallocated. - * Only tensor outputs are supported. - * - * @param value The output buffer (must wrap a tensor). - * @param methodName The method name. - * @param index Zero-based output index. - * @param error On failure, set to an NSError describing the issue. - * @return YES on success; NO otherwise. - */ -- (BOOL)setOutput:(ExecuTorchValue *)value - forMethod:(NSString *)methodName - atIndex:(NSInteger)index - error:(NSError **)error NS_REFINED_FOR_SWIFT; - -+ (instancetype)new NS_UNAVAILABLE; -- (instancetype)init NS_UNAVAILABLE; - -@end - -NS_ASSUME_NONNULL_END diff --git a/ai_layer/engine/include/executorch/extension/apple/ExecuTorch/Exported/ExecuTorchTensor.h b/ai_layer/engine/include/executorch/extension/apple/ExecuTorch/Exported/ExecuTorchTensor.h deleted file mode 100644 index 53d23258..00000000 --- a/ai_layer/engine/include/executorch/extension/apple/ExecuTorch/Exported/ExecuTorchTensor.h +++ /dev/null @@ -1,1308 +0,0 @@ -/* - * Copyright (c) Meta Platforms, Inc. and affiliates. - * All rights reserved. - * - * This source code is licensed under the BSD-style license found in the - * LICENSE file in the root directory of this source tree. - */ - -#import - -NS_ASSUME_NONNULL_BEGIN - -/** - * Enum to define the data type of a Tensor. - * Values can be a subset, but must numerically match exactly those defined in - * runtime/core/portable_type/scalar_type.h - */ -typedef NS_ENUM(int8_t, ExecuTorchDataType) { - ExecuTorchDataTypeByte, - ExecuTorchDataTypeChar, - ExecuTorchDataTypeShort, - ExecuTorchDataTypeInt, - ExecuTorchDataTypeLong, - ExecuTorchDataTypeHalf, - ExecuTorchDataTypeFloat, - ExecuTorchDataTypeDouble, - ExecuTorchDataTypeComplexHalf, - ExecuTorchDataTypeComplexFloat, - ExecuTorchDataTypeComplexDouble, - ExecuTorchDataTypeBool, - ExecuTorchDataTypeQInt8, - ExecuTorchDataTypeQUInt8, - ExecuTorchDataTypeQInt32, - ExecuTorchDataTypeBFloat16, - ExecuTorchDataTypeQUInt4x2, - ExecuTorchDataTypeQUInt2x4, - ExecuTorchDataTypeBits1x8, - ExecuTorchDataTypeBits2x4, - ExecuTorchDataTypeBits4x2, - ExecuTorchDataTypeBits8, - ExecuTorchDataTypeBits16, - ExecuTorchDataTypeFloat8_e5m2, - ExecuTorchDataTypeFloat8_e4m3fn, - ExecuTorchDataTypeFloat8_e5m2fnuz, - ExecuTorchDataTypeFloat8_e4m3fnuz, - ExecuTorchDataTypeUInt16, - ExecuTorchDataTypeUInt32, - ExecuTorchDataTypeUInt64, - ExecuTorchDataTypeUndefined, - ExecuTorchDataTypeNumOptions, -} NS_SWIFT_NAME(DataType); - -/** - * Enum to define the shape dynamism of a Tensor. - * Values can be a subset, but must numerically match exactly those defined in - * runtime/core/tensor_shape_dynamism.h - */ -typedef NS_ENUM(uint8_t, ExecuTorchShapeDynamism) { - ExecuTorchShapeDynamismStatic, - ExecuTorchShapeDynamismDynamicBound, - ExecuTorchShapeDynamismDynamicUnbound, -} NS_SWIFT_NAME(ShapeDynamism); - -/** - * Returns the size in bytes of the specified data type. - * - * @param dataType An ExecuTorchDataType value representing the tensor's element type. - * @return An NSInteger indicating the size in bytes. - */ -FOUNDATION_EXPORT -NSInteger ExecuTorchSizeOfDataType(ExecuTorchDataType dataType) - NS_SWIFT_NAME(size(ofDataType:)); - -/** - * Computes the total number of elements in a tensor based on its shape. - * - * @param shape An NSArray of NSNumber objects, where each element represents a dimension size. - * @return An NSInteger equal to the product of the sizes of all dimensions. - */ -FOUNDATION_EXPORT -NSInteger ExecuTorchElementCountOfShape(NSArray *shape) - NS_REFINED_FOR_SWIFT; - -/** - * A tensor class for ExecuTorch operations. - * - * This class encapsulates a native TensorPtr instance and provides a variety of - * initializers and utility methods to work with tensor data. - */ - NS_SWIFT_NAME(AnyTensor) -__attribute__((objc_subclassing_restricted)) -@interface ExecuTorchTensor : NSObject - -/** - * Pointer to the underlying native TensorPtr instance. - * - * @return A raw pointer to the native TensorPtr held by this Tensor class. - */ -@property(nonatomic, readonly) void *nativeInstance NS_SWIFT_UNAVAILABLE(""); - -/** - * The data type of the tensor. - * - * @return An ExecuTorchDataType value representing the tensor's element type. - */ -@property(nonatomic, readonly) ExecuTorchDataType dataType; - -/** - * The shape of the tensor. - * - * @return An NSArray of NSNumber objects representing the size of each dimension. - */ -@property(nonatomic, readonly) NSArray *shape NS_REFINED_FOR_SWIFT; - -/** - * The order of dimensions in the tensor. - * - * @return An NSArray of NSNumber objects representing the tensor’s dimension order. - */ -@property(nonatomic, readonly) NSArray *dimensionOrder NS_REFINED_FOR_SWIFT; - -/** - * The strides of the tensor. - * - * @return An NSArray of NSNumber objects representing the step sizes for each dimension. - */ -@property(nonatomic, readonly) NSArray *strides NS_REFINED_FOR_SWIFT; - -/** - * The dynamism of the tensor's shape. - * - * @return An ExecuTorchShapeDynamism value indicating whether the tensor shape is static or dynamic. - */ -@property(nonatomic, readonly) ExecuTorchShapeDynamism shapeDynamism; - -/** - * The total number of elements in the tensor. - * - * @return An NSInteger representing the total element count. - */ -@property(nonatomic, readonly) NSInteger count NS_REFINED_FOR_SWIFT; - -/** - * Initializes a tensor with a native TensorPtr instance. - * - * @param nativeInstance A pointer to a native TensorPtr instance. - * @return An initialized ExecuTorchTensor instance. - */ -- (instancetype)initWithNativeInstance:(void *)nativeInstance - NS_DESIGNATED_INITIALIZER - NS_SWIFT_UNAVAILABLE(""); - -/** - * Creates a new tensor that shares the underlying data storage with the - * given tensor. This new tensor is a view and does not own the data. - * - * @param otherTensor The tensor instance to create a view of. - * @return A new ExecuTorchTensor instance that shares data with otherTensor. - */ -- (instancetype)initWithTensor:(ExecuTorchTensor *)otherTensor - NS_SWIFT_NAME(init(_:)); - -/** - * Creates a deep copy of the tensor. - * The new tensor will have its own copy of the data. - * - * @return A new ExecuTorchTensor instance that is a duplicate of the current tensor. - */ -- (instancetype)copy; - -/** - * Executes a block with a pointer to the tensor's immutable byte data. - * - * @param handler A block that receives: - * - a pointer to the data, - * - the total number of elements, - * - and the data type. - */ -- (void)bytesWithHandler:(NS_NOESCAPE void (^)(const void *pointer, NSInteger count, ExecuTorchDataType dataType))handler - NS_SWIFT_NAME(bytes(_:)); - -/** - * Executes a block with a pointer to the tensor's mutable byte data. - * - * @param handler A block that receives: - * - a mutable pointer to the data, - * - the total number of elements, - * - and the data type. - */ -- (void)mutableBytesWithHandler:(NS_NOESCAPE void (^)(void *pointer, NSInteger count, ExecuTorchDataType dataType))handler - NS_SWIFT_NAME(mutableBytes(_:)); - -/** - * Resizes the tensor to a new shape. - * - * @param shape An NSArray of NSNumber objects representing the desired new shape. - * @param error A pointer to an NSError pointer that is set if an error occurs. - * @return YES if the tensor was successfully resized; otherwise, NO. - */ -- (BOOL)resizeToShape:(NSArray *)shape - error:(NSError **)error - NS_REFINED_FOR_SWIFT; - -/** - * Determines whether the current tensor is equal to another tensor. - * - * @param other Another ExecuTorchTensor instance to compare against. - * @return YES if the tensors have the same data type, shape, dimension order, - * strides, and underlying data; otherwise, NO. - */ -- (BOOL)isEqualToTensor:(nullable ExecuTorchTensor *)other - NS_REFINED_FOR_SWIFT; - -+ (instancetype)new NS_UNAVAILABLE; -- (instancetype)init NS_UNAVAILABLE; - -@end - -#pragma mark - BytesNoCopy Category - -@interface ExecuTorchTensor (BytesNoCopy) - -/** - * Initializes a tensor without copying the provided data. - * - * @param pointer A pointer to the data buffer. - * @param shape An NSArray of NSNumber objects representing the tensor's shape. - * @param strides An NSArray of NSNumber objects representing the tensor's strides. - * @param dimensionOrder An NSArray of NSNumber objects indicating the order of dimensions. - * @param dataType An ExecuTorchDataType value specifying the element type. - * @param shapeDynamism An ExecuTorchShapeDynamism value indicating whether the shape is static or dynamic. - * @return An initialized ExecuTorchTensor instance using the provided data buffer. - */ -- (instancetype)initWithBytesNoCopy:(void *)pointer - shape:(NSArray *)shape - strides:(NSArray *)strides - dimensionOrder:(NSArray *)dimensionOrder - dataType:(ExecuTorchDataType)dataType - shapeDynamism:(ExecuTorchShapeDynamism)shapeDynamism - NS_REFINED_FOR_SWIFT; - -/** - * Initializes a tensor without copying data using dynamic bound shape (default strides and dimension order). - * - * @param pointer A pointer to the data buffer. - * @param shape An NSArray of NSNumber objects representing the tensor's shape. - * @param strides An NSArray of NSNumber objects representing the tensor's strides. - * @param dimensionOrder An NSArray of NSNumber objects indicating the order of dimensions. - * @param dataType An ExecuTorchDataType value specifying the element type. - * @return An initialized ExecuTorchTensor instance. - */ -- (instancetype)initWithBytesNoCopy:(void *)pointer - shape:(NSArray *)shape - strides:(NSArray *)strides - dimensionOrder:(NSArray *)dimensionOrder - dataType:(ExecuTorchDataType)dataType - NS_SWIFT_UNAVAILABLE(""); - -/** - * Initializes a tensor without copying data, with an explicit shape dynamism. - * - * @param pointer A pointer to the data buffer. - * @param shape An NSArray of NSNumber objects representing the tensor's shape. - * @param dataType An ExecuTorchDataType value specifying the element type. - * @param shapeDynamism An ExecuTorchShapeDynamism value indicating the shape dynamism. - * @return An initialized ExecuTorchTensor instance. - */ -- (instancetype)initWithBytesNoCopy:(void *)pointer - shape:(NSArray *)shape - dataType:(ExecuTorchDataType)dataType - shapeDynamism:(ExecuTorchShapeDynamism)shapeDynamism - NS_SWIFT_UNAVAILABLE(""); - -/** - * Initializes a tensor without copying data, specifying only the shape and data type. - * - * @param pointer A pointer to the data buffer. - * @param shape An NSArray of NSNumber objects representing the tensor's shape. - * @param dataType An ExecuTorchDataType value specifying the element type. - * @return An initialized ExecuTorchTensor instance. - */ -- (instancetype)initWithBytesNoCopy:(void *)pointer - shape:(NSArray *)shape - dataType:(ExecuTorchDataType)dataType - NS_SWIFT_UNAVAILABLE(""); - -@end - -#pragma mark - Bytes Category - -@interface ExecuTorchTensor (Bytes) - -/** - * Initializes a tensor by copying bytes from the provided pointer. - * - * @param pointer A pointer to the source data buffer. - * @param shape An NSArray of NSNumber objects representing the tensor's shape. - * @param strides An NSArray of NSNumber objects representing the tensor's strides. - * @param dimensionOrder An NSArray of NSNumber objects indicating the order of dimensions. - * @param dataType An ExecuTorchDataType value specifying the element type. - * @param shapeDynamism An ExecuTorchShapeDynamism value indicating the shape dynamism. - * @return An initialized ExecuTorchTensor instance with its own copy of the data. - */ -- (instancetype)initWithBytes:(const void *)pointer - shape:(NSArray *)shape - strides:(NSArray *)strides - dimensionOrder:(NSArray *)dimensionOrder - dataType:(ExecuTorchDataType)dataType - shapeDynamism:(ExecuTorchShapeDynamism)shapeDynamism - NS_REFINED_FOR_SWIFT; - -/** - * Initializes a tensor by copying bytes from the provided pointer with dynamic bound shape. - * - * @param pointer A pointer to the source data buffer. - * @param shape An NSArray of NSNumber objects representing the tensor's shape. - * @param strides An NSArray of NSNumber objects representing the tensor's strides. - * @param dimensionOrder An NSArray of NSNumber objects indicating the order of dimensions. - * @param dataType An ExecuTorchDataType value specifying the element type. - * @return An initialized ExecuTorchTensor instance with its own copy of the data. - */ -- (instancetype)initWithBytes:(const void *)pointer - shape:(NSArray *)shape - strides:(NSArray *)strides - dimensionOrder:(NSArray *)dimensionOrder - dataType:(ExecuTorchDataType)dataType - NS_SWIFT_UNAVAILABLE(""); - -/** - * Initializes a tensor by copying bytes from the provided pointer, specifying shape, data type, and explicit shape dynamism. - * - * @param pointer A pointer to the source data buffer. - * @param shape An NSArray of NSNumber objects representing the tensor's shape. - * @param dataType An ExecuTorchDataType value specifying the element type. - * @param shapeDynamism An ExecuTorchShapeDynamism value indicating the shape dynamism. - * @return An initialized ExecuTorchTensor instance with its own copy of the data. - */ -- (instancetype)initWithBytes:(const void *)pointer - shape:(NSArray *)shape - dataType:(ExecuTorchDataType)dataType - shapeDynamism:(ExecuTorchShapeDynamism)shapeDynamism - NS_SWIFT_UNAVAILABLE(""); - -/** - * Initializes a tensor by copying bytes from the provided pointer, specifying only the shape and data type. - * - * @param pointer A pointer to the source data buffer. - * @param shape An NSArray of NSNumber objects representing the tensor's shape. - * @param dataType An ExecuTorchDataType value specifying the element type. - * @return An initialized ExecuTorchTensor instance with its own copy of the data. - */ -- (instancetype)initWithBytes:(const void *)pointer - shape:(NSArray *)shape - dataType:(ExecuTorchDataType)dataType - NS_SWIFT_UNAVAILABLE(""); - -@end - -#pragma mark - Data Category - -@interface ExecuTorchTensor (Data) - -/** - * Initializes a tensor using an NSData object. The tensor will hold a - * strong reference to the NSData object to manage the lifetime of the - * underlying data buffer, which is not copied. - * - * @param data An NSData object containing the tensor data. - * @param shape An NSArray of NSNumber objects representing the tensor's shape. - * @param strides An NSArray of NSNumber objects representing the tensor's strides. - * @param dimensionOrder An NSArray of NSNumber objects indicating the order of dimensions. - * @param dataType An ExecuTorchDataType value specifying the element type. - * @param shapeDynamism An ExecuTorchShapeDynamism value indicating the shape dynamism. - * @return An initialized ExecuTorchTensor instance using the provided data. - */ -- (instancetype)initWithData:(NSData *)data - shape:(NSArray *)shape - strides:(NSArray *)strides - dimensionOrder:(NSArray *)dimensionOrder - dataType:(ExecuTorchDataType)dataType - shapeDynamism:(ExecuTorchShapeDynamism)shapeDynamism - NS_REFINED_FOR_SWIFT; - -/** - * Initializes a tensor using an NSData object as the underlying data buffer with dynamic bound shape. - * - * @param data An NSData object containing the tensor data. - * @param shape An NSArray of NSNumber objects representing the tensor's shape. - * @param strides An NSArray of NSNumber objects representing the tensor's strides. - * @param dimensionOrder An NSArray of NSNumber objects indicating the order of dimensions. - * @param dataType An ExecuTorchDataType value specifying the element type. - * @return An initialized ExecuTorchTensor instance using the provided data. - */ -- (instancetype)initWithData:(NSData *)data - shape:(NSArray *)shape - strides:(NSArray *)strides - dimensionOrder:(NSArray *)dimensionOrder - dataType:(ExecuTorchDataType)dataType - NS_SWIFT_UNAVAILABLE(""); - -/** - * Initializes a tensor using an NSData object as the underlying data buffer, specifying shape, data type, and explicit shape dynamism. - * - * @param data An NSData object containing the tensor data. - * @param shape An NSArray of NSNumber objects representing the tensor's shape. - * @param dataType An ExecuTorchDataType value specifying the element type. - * @param shapeDynamism An ExecuTorchShapeDynamism value indicating the shape dynamism. - * @return An initialized ExecuTorchTensor instance using the provided data. - */ -- (instancetype)initWithData:(NSData *)data - shape:(NSArray *)shape - dataType:(ExecuTorchDataType)dataType - shapeDynamism:(ExecuTorchShapeDynamism)shapeDynamism - NS_SWIFT_UNAVAILABLE(""); - -/** - * Initializes a tensor using an NSData object as the underlying data buffer, specifying only the shape and data type. - * - * @param data An NSData object containing the tensor data. - * @param shape An NSArray of NSNumber objects representing the tensor's shape. - * @param dataType An ExecuTorchDataType value specifying the element type. - * @return An initialized ExecuTorchTensor instance using the provided data. - */ -- (instancetype)initWithData:(NSData *)data - shape:(NSArray *)shape - dataType:(ExecuTorchDataType)dataType - NS_SWIFT_UNAVAILABLE(""); - -@end - -#pragma mark - Scalars Category - -@interface ExecuTorchTensor (Scalars) - -/** - * Initializes a tensor with an array of scalar values and full tensor properties. - * - * @param scalars An NSArray of NSNumber objects representing the scalar values. - * @param shape An NSArray of NSNumber objects representing the desired tensor shape. - * @param strides An NSArray of NSNumber objects representing the tensor strides. - * @param dimensionOrder An NSArray of NSNumber objects indicating the order of dimensions. - * @param dataType An ExecuTorchDataType value specifying the element type. - * @param shapeDynamism An ExecuTorchShapeDynamism value indicating the shape dynamism. - * @return An initialized ExecuTorchTensor instance containing the provided scalar values. - */ -- (instancetype)initWithScalars:(NSArray *)scalars - shape:(NSArray *)shape - strides:(NSArray *)strides - dimensionOrder:(NSArray *)dimensionOrder - dataType:(ExecuTorchDataType)dataType - shapeDynamism:(ExecuTorchShapeDynamism)shapeDynamism - NS_SWIFT_UNAVAILABLE(""); - -/** - * Initializes a tensor with an array of scalar values, specifying shape, strides, dimension order, and data type, - * using a default dynamic bound shape for shape dynamism. - * - * @param scalars An NSArray of NSNumber objects representing the scalar values. - * @param shape An NSArray of NSNumber objects representing the desired tensor shape. - * @param strides An NSArray of NSNumber objects representing the tensor strides. - * @param dimensionOrder An NSArray of NSNumber objects indicating the order of dimensions. - * @param dataType An ExecuTorchDataType value specifying the element type. - * @return An initialized ExecuTorchTensor instance containing the scalar values. - */ -- (instancetype)initWithScalars:(NSArray *)scalars - shape:(NSArray *)shape - strides:(NSArray *)strides - dimensionOrder:(NSArray *)dimensionOrder - dataType:(ExecuTorchDataType)dataType - NS_SWIFT_UNAVAILABLE(""); - -/** - * Initializes a tensor with an array of scalar values, specifying the desired shape, data type, and explicit shape dynamism. - * - * @param scalars An NSArray of NSNumber objects representing the scalar values. - * @param shape An NSArray of NSNumber objects representing the desired tensor shape. - * @param dataType An ExecuTorchDataType value specifying the element type. - * @param shapeDynamism An ExecuTorchShapeDynamism value indicating the shape dynamism. - * @return An initialized ExecuTorchTensor instance. - */ -- (instancetype)initWithScalars:(NSArray *)scalars - shape:(NSArray *)shape - dataType:(ExecuTorchDataType)dataType - shapeDynamism:(ExecuTorchShapeDynamism)shapeDynamism - NS_SWIFT_UNAVAILABLE(""); - -/** - * Initializes a tensor with an array of scalar values and a specified shape, - * using a default dynamic bound shape for shape dynamism. - * - * @param scalars An NSArray of NSNumber objects representing the scalar values. - * @param shape An NSArray of NSNumber objects representing the desired tensor shape. - * @param dataType An ExecuTorchDataType value specifying the element type. - * @return An initialized ExecuTorchTensor instance. - */ -- (instancetype)initWithScalars:(NSArray *)scalars - shape:(NSArray *)shape - dataType:(ExecuTorchDataType)dataType - NS_SWIFT_UNAVAILABLE(""); - -/** - * Initializes a tensor with an array of scalar values, specifying the tensor data type and explicit shape dynamism. - * The shape is deduced from the count of the scalar array. - * - * @param scalars An NSArray of NSNumber objects representing the scalar values. - * @param dataType An ExecuTorchDataType value specifying the element type. - * @param shapeDynamism An ExecuTorchShapeDynamism value indicating the shape dynamism. - * @return An initialized ExecuTorchTensor instance with the shape deduced from the scalar count. - */ -- (instancetype)initWithScalars:(NSArray *)scalars - dataType:(ExecuTorchDataType)dataType - shapeDynamism:(ExecuTorchShapeDynamism)shapeDynamism - NS_SWIFT_UNAVAILABLE(""); - -/** - * Initializes a tensor with an array of scalar values, specifying the tensor data type. - * The shape is deduced from the count of the scalar array. - * - * @param scalars An NSArray of NSNumber objects representing the scalar values. - * @param dataType An ExecuTorchDataType value specifying the element type. - * @return An initialized ExecuTorchTensor instance with the shape deduced from the scalar count. - */ -- (instancetype)initWithScalars:(NSArray *)scalars - dataType:(ExecuTorchDataType)dataType - NS_SWIFT_UNAVAILABLE(""); - -/** - * Initializes a tensor with an array of scalar values, a specified shape and explicit shape dynamism. - * The data type is automatically deduced from the first element of the array. - * - * @param scalars An NSArray of NSNumber objects representing the scalar values. - * @param shape An NSArray of NSNumber objects representing the desired tensor shape. - * @param shapeDynamism An ExecuTorchShapeDynamism value indicating the shape dynamism. - * @return An initialized ExecuTorchTensor instance. - */ -- (instancetype)initWithScalars:(NSArray *)scalars - shape:(NSArray *)shape - shapeDynamism:(ExecuTorchShapeDynamism)shapeDynamism - NS_SWIFT_UNAVAILABLE(""); - -/** - * Initializes a tensor with an array of scalar values and a specified shape. - * The data type is automatically deduced from the first element of the array. - * - * @param scalars An NSArray of NSNumber objects representing the scalar values. - * @param shape An NSArray of NSNumber objects representing the desired tensor shape. - * @return An initialized ExecuTorchTensor instance. - */ -- (instancetype)initWithScalars:(NSArray *)scalars - shape:(NSArray *)shape - NS_SWIFT_UNAVAILABLE(""); - -/** - * Initializes a tensor with an array of scalar values, automatically deducing the tensor shape and data type. - * - * @param scalars An NSArray of NSNumber objects representing the scalar values. - * @return An initialized ExecuTorchTensor instance with shape and data type deduced. - */ -- (instancetype)initWithScalars:(NSArray *)scalars - NS_SWIFT_UNAVAILABLE(""); - -@end - -@interface ExecuTorchTensor (Scalar) - -/** - * Initializes a tensor with a single scalar value and a specified data type. - * - * @param scalar An NSNumber representing the scalar value. - * @param dataType An ExecuTorchDataType value specifying the element type. - * @return An initialized ExecuTorchTensor instance representing the scalar. - */ -- (instancetype)initWithScalar:(NSNumber *)scalar - dataType:(ExecuTorchDataType)dataType - NS_REFINED_FOR_SWIFT; - -/** - * Initializes a tensor with a single scalar value, automatically deducing its data type. - * - * @param scalar An NSNumber representing the scalar value. - * @return An initialized ExecuTorchTensor instance representing the scalar. - */ -- (instancetype)initWithScalar:(NSNumber *)scalar - NS_SWIFT_UNAVAILABLE(""); - -/** - * Initializes a tensor with a byte scalar value. - * - * @param scalar A uint8_t value. - * @return An initialized ExecuTorchTensor instance. - */ -- (instancetype)initWithByte:(uint8_t)scalar - NS_SWIFT_UNAVAILABLE(""); - -/** - * Initializes a tensor with a char scalar value. - * - * @param scalar An int8_t value. - * @return An initialized ExecuTorchTensor instance. - */ -- (instancetype)initWithChar:(int8_t)scalar - NS_SWIFT_UNAVAILABLE(""); - -/** - * Initializes a tensor with a short scalar value. - * - * @param scalar An int16_t value. - * @return An initialized ExecuTorchTensor instance. - */ -- (instancetype)initWithShort:(int16_t)scalar - NS_SWIFT_UNAVAILABLE(""); - -/** - * Initializes a tensor with an int scalar value. - * - * @param scalar An int32_t value. - * @return An initialized ExecuTorchTensor instance. - */ -- (instancetype)initWithInt:(int32_t)scalar - NS_SWIFT_UNAVAILABLE(""); - -/** - * Initializes a tensor with a long scalar value. - * - * @param scalar An int64_t value. - * @return An initialized ExecuTorchTensor instance. - */ -- (instancetype)initWithLong:(int64_t)scalar - NS_SWIFT_UNAVAILABLE(""); - -/** - * Initializes a tensor with a float scalar value. - * - * @param scalar A float value. - * @return An initialized ExecuTorchTensor instance. - */ -- (instancetype)initWithFloat:(float)scalar - NS_SWIFT_UNAVAILABLE(""); - -/** - * Initializes a tensor with a double scalar value. - * - * @param scalar A double value. - * @return An initialized ExecuTorchTensor instance. - */ -- (instancetype)initWithDouble:(double)scalar - NS_SWIFT_UNAVAILABLE(""); - -/** - * Initializes a tensor with a boolean scalar value. - * - * @param scalar A BOOL value. - * @return An initialized ExecuTorchTensor instance. - */ -- (instancetype)initWithBool:(BOOL)scalar - NS_SWIFT_UNAVAILABLE(""); - -/** - * Initializes a tensor with a uint16 scalar value. - * - * @param scalar A uint16_t value. - * @return An initialized ExecuTorchTensor instance. - */ -- (instancetype)initWithUInt16:(uint16_t)scalar - NS_SWIFT_NAME(init(_:)); - -/** - * Initializes a tensor with a uint32 scalar value. - * - * @param scalar A uint32_t value. - * @return An initialized ExecuTorchTensor instance. - */ -- (instancetype)initWithUInt32:(uint32_t)scalar - NS_SWIFT_NAME(init(_:)); - -/** - * Initializes a tensor with a uint64 scalar value. - * - * @param scalar A uint64_t value. - * @return An initialized ExecuTorchTensor instance. - */ -- (instancetype)initWithUInt64:(uint64_t)scalar - NS_SWIFT_NAME(init(_:)); - -/** - * Initializes a tensor with an NSInteger scalar value. - * - * @param scalar An NSInteger value. - * @return An initialized ExecuTorchTensor instance. - */ -- (instancetype)initWithInteger:(NSInteger)scalar - NS_SWIFT_NAME(init(_:)); - -/** - * Initializes a tensor with an NSUInteger scalar value. - * - * @param scalar An NSUInteger value. - * @return An initialized ExecuTorchTensor instance. - */ -- (instancetype)initWithUnsignedInteger:(NSUInteger)scalar - NS_SWIFT_NAME(init(_:)); - -@end - -#pragma mark - Empty Category - -@interface ExecuTorchTensor (Empty) - -/** - * Creates an empty tensor with the specified shape, strides, data type, and shape dynamism. - * - * @param shape An NSArray of NSNumber objects representing the desired shape. - * @param strides An NSArray of NSNumber objects representing the desired strides. - * @param dataType An ExecuTorchDataType value specifying the element type. - * @param shapeDynamism An ExecuTorchShapeDynamism value specifying whether the shape is static or dynamic. - * @return A new, empty ExecuTorchTensor instance. - */ -+ (instancetype)emptyTensorWithShape:(NSArray *)shape - strides:(NSArray *)strides - dataType:(ExecuTorchDataType)dataType - shapeDynamism:(ExecuTorchShapeDynamism)shapeDynamism - NS_REFINED_FOR_SWIFT - NS_RETURNS_RETAINED; - -/** - * Creates an empty tensor with the specified shape, data type, and shape dynamism. - * - * @param shape An NSArray of NSNumber objects representing the desired shape. - * @param dataType An ExecuTorchDataType value specifying the element type. - * @param shapeDynamism An ExecuTorchShapeDynamism value specifying whether the shape is static or dynamic. - * @return A new, empty ExecuTorchTensor instance. - */ -+ (instancetype)emptyTensorWithShape:(NSArray *)shape - dataType:(ExecuTorchDataType)dataType - shapeDynamism:(ExecuTorchShapeDynamism)shapeDynamism - NS_SWIFT_UNAVAILABLE("") - NS_RETURNS_RETAINED; - -/** - * Creates an empty tensor with the specified shape and data type, using dynamic bound shape. - * - * @param shape An NSArray of NSNumber objects representing the desired shape. - * @param dataType An ExecuTorchDataType value specifying the element type. - * @return A new, empty ExecuTorchTensor instance. - */ -+ (instancetype)emptyTensorWithShape:(NSArray *)shape - dataType:(ExecuTorchDataType)dataType - NS_SWIFT_UNAVAILABLE("") - NS_RETURNS_RETAINED; - -/** - * Creates an empty tensor similar to the given tensor, with the specified data type and shape dynamism. - * - * @param tensor An existing ExecuTorchTensor instance whose shape and strides are used. - * @param dataType An ExecuTorchDataType value specifying the desired element type. - * @param shapeDynamism An ExecuTorchShapeDynamism value specifying whether the shape is static or dynamic. - * @return A new, empty ExecuTorchTensor instance with the same shape as the provided tensor. - */ -+ (instancetype)emptyTensorLikeTensor:(ExecuTorchTensor *)tensor - dataType:(ExecuTorchDataType)dataType - shapeDynamism:(ExecuTorchShapeDynamism)shapeDynamism - NS_REFINED_FOR_SWIFT - NS_RETURNS_RETAINED; - -/** - * Creates an empty tensor similar to the given tensor, with the specified data type. - * - * @param tensor An existing ExecuTorchTensor instance whose shape and strides are used. - * @param dataType An ExecuTorchDataType value specifying the desired element type. - * @return A new, empty ExecuTorchTensor instance with the same shape as the provided tensor. - */ -+ (instancetype)emptyTensorLikeTensor:(ExecuTorchTensor *)tensor - dataType:(ExecuTorchDataType)dataType - NS_SWIFT_UNAVAILABLE("") - NS_RETURNS_RETAINED; - -/** - * Creates an empty tensor similar to the given tensor. - * - * @param tensor An existing ExecuTorchTensor instance. - * @return A new, empty ExecuTorchTensor instance with the same properties as the provided tensor. - */ -+ (instancetype)emptyTensorLikeTensor:(ExecuTorchTensor *)tensor - NS_SWIFT_UNAVAILABLE("") - NS_RETURNS_RETAINED; - -@end - -#pragma mark - Full Category - -@interface ExecuTorchTensor (Full) - -/** - * Creates a tensor filled with the specified scalar value, with full specification of shape, strides, data type, and shape dynamism. - * - * @param shape An NSArray of NSNumber objects representing the desired shape. - * @param scalar An NSNumber representing the value to fill the tensor. - * @param strides An NSArray of NSNumber objects representing the desired strides. - * @param dataType An ExecuTorchDataType value specifying the element type. - * @param shapeDynamism An ExecuTorchShapeDynamism value specifying whether the shape is static or dynamic. - * @return A new ExecuTorchTensor instance filled with the scalar value. - */ -+ (instancetype)fullTensorWithShape:(NSArray *)shape - scalar:(NSNumber *)scalar - strides:(NSArray *)strides - dataType:(ExecuTorchDataType)dataType - shapeDynamism:(ExecuTorchShapeDynamism)shapeDynamism - NS_REFINED_FOR_SWIFT - NS_RETURNS_RETAINED; - -/** - * Creates a tensor filled with the specified scalar value, with the given shape, data type, and shape dynamism. - * - * @param shape An NSArray of NSNumber objects representing the desired shape. - * @param scalar An NSNumber representing the value to fill the tensor. - * @param dataType An ExecuTorchDataType value specifying the element type. - * @param shapeDynamism An ExecuTorchShapeDynamism value specifying whether the shape is static or dynamic. - * @return A new ExecuTorchTensor instance filled with the scalar value. - */ -+ (instancetype)fullTensorWithShape:(NSArray *)shape - scalar:(NSNumber *)scalar - dataType:(ExecuTorchDataType)dataType - shapeDynamism:(ExecuTorchShapeDynamism)shapeDynamism - NS_SWIFT_UNAVAILABLE("") - NS_RETURNS_RETAINED; - -/** - * Creates a tensor filled with the specified scalar value, with the given shape and data type, - * using dynamic bound shape for strides and dimension order. - * - * @param shape An NSArray of NSNumber objects representing the desired shape. - * @param scalar An NSNumber representing the value to fill the tensor. - * @param dataType An ExecuTorchDataType value specifying the element type. - * @return A new ExecuTorchTensor instance filled with the scalar value. - */ -+ (instancetype)fullTensorWithShape:(NSArray *)shape - scalar:(NSNumber *)scalar - dataType:(ExecuTorchDataType)dataType - NS_SWIFT_UNAVAILABLE("") - NS_RETURNS_RETAINED; - -/** - * Creates a tensor filled with the specified scalar value, similar to an existing tensor, with the given data type and shape dynamism. - * - * @param tensr An existing ExecuTorchTensor instance whose shape and strides are used. - * @param scalar An NSNumber representing the value to fill the tensor. - * @param dataType An ExecuTorchDataType value specifying the desired element type. - * @param shapeDynamism An ExecuTorchShapeDynamism value specifying whether the shape is static or dynamic. - * @return A new ExecuTorchTensor instance filled with the scalar value. - */ -+ (instancetype)fullTensorLikeTensor:(ExecuTorchTensor *)tensr - scalar:(NSNumber *)scalar - dataType:(ExecuTorchDataType)dataType - shapeDynamism:(ExecuTorchShapeDynamism)shapeDynamism - NS_REFINED_FOR_SWIFT - NS_RETURNS_RETAINED; - -/** - * Creates a tensor filled with the specified scalar value, similar to an existing tensor, with the given data type. - * - * @param tensr An existing ExecuTorchTensor instance whose shape and strides are used. - * @param scalar An NSNumber representing the value to fill the tensor. - * @param dataType An ExecuTorchDataType value specifying the desired element type. - * @return A new ExecuTorchTensor instance filled with the scalar value. - */ -+ (instancetype)fullTensorLikeTensor:(ExecuTorchTensor *)tensr - scalar:(NSNumber *)scalar - dataType:(ExecuTorchDataType)dataType - NS_SWIFT_UNAVAILABLE("") - NS_RETURNS_RETAINED; - -/** - * Creates a tensor filled with the specified scalar value, similar to an existing tensor. - * - * @param tensr An existing ExecuTorchTensor instance. - * @param scalar An NSNumber representing the value to fill the tensor. - * @return A new ExecuTorchTensor instance filled with the scalar value. - */ -+ (instancetype)fullTensorLikeTensor:(ExecuTorchTensor *)tensr - scalar:(NSNumber *)scalar - NS_SWIFT_UNAVAILABLE("") - NS_RETURNS_RETAINED; - -@end - -#pragma mark - Ones Category - -@interface ExecuTorchTensor (Ones) - -/** - * Creates a tensor filled with ones, with the specified shape, data type, and shape dynamism. - * - * @param shape An NSArray of NSNumber objects representing the desired shape. - * @param dataType An ExecuTorchDataType value specifying the element type. - * @param shapeDynamism An ExecuTorchShapeDynamism value specifying whether the shape is static or dynamic. - * @return A new ExecuTorchTensor instance filled with ones. - */ -+ (instancetype)onesTensorWithShape:(NSArray *)shape - dataType:(ExecuTorchDataType)dataType - shapeDynamism:(ExecuTorchShapeDynamism)shapeDynamism - NS_REFINED_FOR_SWIFT - NS_RETURNS_RETAINED; - -/** - * Creates a tensor filled with ones, with the specified shape and data type. - * - * @param shape An NSArray of NSNumber objects representing the desired shape. - * @param dataType An ExecuTorchDataType value specifying the element type. - * @return A new ExecuTorchTensor instance filled with ones. - */ -+ (instancetype)onesTensorWithShape:(NSArray *)shape - dataType:(ExecuTorchDataType)dataType - NS_SWIFT_UNAVAILABLE("") - NS_RETURNS_RETAINED; - -/** - * Creates a tensor filled with ones similar to an existing tensor, with the specified data type and shape dynamism. - * - * @param tensor An existing ExecuTorchTensor instance whose shape and strides are used. - * @param dataType An ExecuTorchDataType value specifying the desired element type. - * @param shapeDynamism An ExecuTorchShapeDynamism value specifying whether the shape is static or dynamic. - * @return A new ExecuTorchTensor instance filled with ones. - */ -+ (instancetype)onesTensorLikeTensor:(ExecuTorchTensor *)tensor - dataType:(ExecuTorchDataType)dataType - shapeDynamism:(ExecuTorchShapeDynamism)shapeDynamism - NS_REFINED_FOR_SWIFT - NS_RETURNS_RETAINED; - -/** - * Creates a tensor filled with ones similar to an existing tensor, with the specified data type. - * - * @param tensor An existing ExecuTorchTensor instance whose shape and strides are used. - * @param dataType An ExecuTorchDataType value specifying the desired element type. - * @return A new ExecuTorchTensor instance filled with ones. - */ -+ (instancetype)onesTensorLikeTensor:(ExecuTorchTensor *)tensor - dataType:(ExecuTorchDataType)dataType - NS_SWIFT_UNAVAILABLE("") - NS_RETURNS_RETAINED; - -/** - * Creates a tensor filled with ones similar to an existing tensor. - * - * @param tensor An existing ExecuTorchTensor instance. - * @return A new ExecuTorchTensor instance filled with ones. - */ -+ (instancetype)onesTensorLikeTensor:(ExecuTorchTensor *)tensor - NS_SWIFT_UNAVAILABLE("") - NS_RETURNS_RETAINED; - -@end - -#pragma mark - Zeros Category - -@interface ExecuTorchTensor (Zeros) - -/** - * Creates a tensor filled with zeros, with the specified shape, data type, and shape dynamism. - * - * @param shape An NSArray of NSNumber objects representing the desired shape. - * @param dataType An ExecuTorchDataType value specifying the element type. - * @param shapeDynamism An ExecuTorchShapeDynamism value specifying whether the shape is static or dynamic. - * @return A new ExecuTorchTensor instance filled with zeros. - */ -+ (instancetype)zerosTensorWithShape:(NSArray *)shape - dataType:(ExecuTorchDataType)dataType - shapeDynamism:(ExecuTorchShapeDynamism)shapeDynamism - NS_REFINED_FOR_SWIFT - NS_RETURNS_RETAINED; - -/** - * Creates a tensor filled with zeros, with the specified shape and data type. - * - * @param shape An NSArray of NSNumber objects representing the desired shape. - * @param dataType An ExecuTorchDataType value specifying the element type. - * @return A new ExecuTorchTensor instance filled with zeros. - */ -+ (instancetype)zerosTensorWithShape:(NSArray *)shape - dataType:(ExecuTorchDataType)dataType - NS_SWIFT_UNAVAILABLE("") - NS_RETURNS_RETAINED; - -/** - * Creates a tensor filled with zeros similar to an existing tensor, with the specified data type and shape dynamism. - * - * @param tensor An existing ExecuTorchTensor instance whose shape and strides are used. - * @param dataType An ExecuTorchDataType value specifying the desired element type. - * @param shapeDynamism An ExecuTorchShapeDynamism value specifying whether the shape is static or dynamic. - * @return A new ExecuTorchTensor instance filled with zeros. - */ -+ (instancetype)zerosTensorLikeTensor:(ExecuTorchTensor *)tensor - dataType:(ExecuTorchDataType)dataType - shapeDynamism:(ExecuTorchShapeDynamism)shapeDynamism - NS_REFINED_FOR_SWIFT - NS_RETURNS_RETAINED; - -/** - * Creates a tensor filled with zeros similar to an existing tensor, with the specified data type. - * - * @param tensor An existing ExecuTorchTensor instance whose shape and strides are used. - * @param dataType An ExecuTorchDataType value specifying the desired element type. - * @return A new ExecuTorchTensor instance filled with zeros. - */ -+ (instancetype)zerosTensorLikeTensor:(ExecuTorchTensor *)tensor - dataType:(ExecuTorchDataType)dataType - NS_SWIFT_UNAVAILABLE("") - NS_RETURNS_RETAINED; - -/** - * Creates a tensor filled with zeros similar to an existing tensor. - * - * @param tensor An existing ExecuTorchTensor instance. - * @return A new ExecuTorchTensor instance filled with zeros. - */ -+ (instancetype)zerosTensorLikeTensor:(ExecuTorchTensor *)tensor - NS_SWIFT_UNAVAILABLE("") - NS_RETURNS_RETAINED; - -@end - -#pragma mark - Random Category - -@interface ExecuTorchTensor (Random) - -/** - * Creates a tensor with random values, with full specification of shape, strides, data type, and shape dynamism. - * - * @param shape An NSArray of NSNumber objects representing the desired shape. - * @param strides An NSArray of NSNumber objects representing the desired strides. - * @param dataType An ExecuTorchDataType value specifying the element type. - * @param shapeDynamism An ExecuTorchShapeDynamism value specifying whether the shape is static or dynamic. - * @return A new ExecuTorchTensor instance filled with random values. - */ -+ (instancetype)randomTensorWithShape:(NSArray *)shape - strides:(NSArray *)strides - dataType:(ExecuTorchDataType)dataType - shapeDynamism:(ExecuTorchShapeDynamism)shapeDynamism - NS_REFINED_FOR_SWIFT - NS_RETURNS_RETAINED; - -/** - * Creates a tensor with random values, with the specified shape and data type. - * - * @param shape An NSArray of NSNumber objects representing the desired shape. - * @param dataType An ExecuTorchDataType value specifying the element type. - * @param shapeDynamism An ExecuTorchShapeDynamism value specifying whether the shape is static or dynamic. - * @return A new ExecuTorchTensor instance filled with random values. - */ -+ (instancetype)randomTensorWithShape:(NSArray *)shape - dataType:(ExecuTorchDataType)dataType - shapeDynamism:(ExecuTorchShapeDynamism)shapeDynamism - NS_SWIFT_UNAVAILABLE("") - NS_RETURNS_RETAINED; - -/** - * Creates a tensor with random values, with the specified shape (using dynamic bound shape) and data type. - * - * @param shape An NSArray of NSNumber objects representing the desired shape. - * @param dataType An ExecuTorchDataType value specifying the element type. - * @return A new ExecuTorchTensor instance filled with random values. - */ -+ (instancetype)randomTensorWithShape:(NSArray *)shape - dataType:(ExecuTorchDataType)dataType - NS_SWIFT_UNAVAILABLE("") - NS_RETURNS_RETAINED; - -/** - * Creates a tensor with random values similar to an existing tensor, with the specified data type and shape dynamism. - * - * @param tensor An existing ExecuTorchTensor instance whose shape and strides are used. - * @param dataType An ExecuTorchDataType value specifying the desired element type. - * @param shapeDynamism An ExecuTorchShapeDynamism value specifying whether the shape is static or dynamic. - * @return A new ExecuTorchTensor instance filled with random values. - */ -+ (instancetype)randomTensorLikeTensor:(ExecuTorchTensor *)tensor - dataType:(ExecuTorchDataType)dataType - shapeDynamism:(ExecuTorchShapeDynamism)shapeDynamism - NS_REFINED_FOR_SWIFT - NS_RETURNS_RETAINED; - -/** - * Creates a tensor with random values similar to an existing tensor, with the specified data type. - * - * @param tensor An existing ExecuTorchTensor instance whose shape and strides are used. - * @param dataType An ExecuTorchDataType value specifying the desired element type. - * @return A new ExecuTorchTensor instance filled with random values. - */ -+ (instancetype)randomTensorLikeTensor:(ExecuTorchTensor *)tensor - dataType:(ExecuTorchDataType)dataType - NS_SWIFT_UNAVAILABLE("") - NS_RETURNS_RETAINED; - -/** - * Creates a tensor with random values similar to an existing tensor. - * - * @param tensor An existing ExecuTorchTensor instance. - * @return A new ExecuTorchTensor instance filled with random values. - */ -+ (instancetype)randomTensorLikeTensor:(ExecuTorchTensor *)tensor - NS_SWIFT_UNAVAILABLE("") - NS_RETURNS_RETAINED; - -@end - -#pragma mark - RandomNormal Category - -@interface ExecuTorchTensor (RandomNormal) - -/** - * Creates a tensor with random values drawn from a normal distribution, - * with full specification of shape, strides, data type, and shape dynamism. - * - * @param shape An NSArray of NSNumber objects representing the desired shape. - * @param strides An NSArray of NSNumber objects representing the desired strides. - * @param dataType An ExecuTorchDataType value specifying the element type. - * @param shapeDynamism An ExecuTorchShapeDynamism value specifying whether the shape is static or dynamic. - * @return A new ExecuTorchTensor instance filled with values from a normal distribution. - */ -+ (instancetype)randomNormalTensorWithShape:(NSArray *)shape - strides:(NSArray *)strides - dataType:(ExecuTorchDataType)dataType - shapeDynamism:(ExecuTorchShapeDynamism)shapeDynamism - NS_REFINED_FOR_SWIFT - NS_RETURNS_RETAINED; - -/** - * Creates a tensor with random values drawn from a normal distribution, - * with the specified shape and data type. - * - * @param shape An NSArray of NSNumber objects representing the desired shape. - * @param dataType An ExecuTorchDataType value specifying the element type. - * @param shapeDynamism An ExecuTorchShapeDynamism value specifying whether the shape is static or dynamic. - * @return A new ExecuTorchTensor instance filled with values from a normal distribution. - */ -+ (instancetype)randomNormalTensorWithShape:(NSArray *)shape - dataType:(ExecuTorchDataType)dataType - shapeDynamism:(ExecuTorchShapeDynamism)shapeDynamism - NS_SWIFT_UNAVAILABLE("") - NS_RETURNS_RETAINED; - -/** - * Creates a tensor with random values drawn from a normal distribution, - * with the specified shape (using dynamic bound shape) and data type. - * - * @param shape An NSArray of NSNumber objects representing the desired shape. - * @param dataType An ExecuTorchDataType value specifying the element type. - * @return A new ExecuTorchTensor instance filled with values from a normal distribution. - */ -+ (instancetype)randomNormalTensorWithShape:(NSArray *)shape - dataType:(ExecuTorchDataType)dataType - NS_SWIFT_UNAVAILABLE("") - NS_RETURNS_RETAINED; - -/** - * Creates a tensor with random normal values similar to an existing tensor, - * with the specified data type and shape dynamism. - * - * @param tensor An existing ExecuTorchTensor instance whose shape and strides are used. - * @param dataType An ExecuTorchDataType value specifying the desired element type. - * @param shapeDynamism An ExecuTorchShapeDynamism value specifying whether the shape is static or dynamic. - * @return A new ExecuTorchTensor instance filled with values from a normal distribution. - */ -+ (instancetype)randomNormalTensorLikeTensor:(ExecuTorchTensor *)tensor - dataType:(ExecuTorchDataType)dataType - shapeDynamism:(ExecuTorchShapeDynamism)shapeDynamism - NS_REFINED_FOR_SWIFT - NS_RETURNS_RETAINED; - -/** - * Creates a tensor with random normal values similar to an existing tensor, - * with the specified data type. - * - * @param tensor An existing ExecuTorchTensor instance whose shape and strides are used. - * @param dataType An ExecuTorchDataType value specifying the desired element type. - * @return A new ExecuTorchTensor instance filled with values from a normal distribution. - */ -+ (instancetype)randomNormalTensorLikeTensor:(ExecuTorchTensor *)tensor - dataType:(ExecuTorchDataType)dataType - NS_SWIFT_UNAVAILABLE("") - NS_RETURNS_RETAINED; - -/** - * Creates a tensor with random normal values similar to an existing tensor. - * - * @param tensor An existing ExecuTorchTensor instance. - * @return A new ExecuTorchTensor instance filled with values from a normal distribution. - */ -+ (instancetype)randomNormalTensorLikeTensor:(ExecuTorchTensor *)tensor - NS_SWIFT_UNAVAILABLE("") - NS_RETURNS_RETAINED; - -@end - -#pragma mark - RandomInteger Category - -@interface ExecuTorchTensor (RandomInteger) - -/** - * Creates a tensor with random integer values in the specified range, - * with full specification of shape, strides, data type, and shape dynamism. - * - * @param low An NSInteger specifying the inclusive lower bound of random values. - * @param high An NSInteger specifying the exclusive upper bound of random values. - * @param shape An NSArray of NSNumber objects representing the desired shape. - * @param strides An NSArray of NSNumber objects representing the desired strides. - * @param dataType An ExecuTorchDataType value specifying the element type. - * @param shapeDynamism An ExecuTorchShapeDynamism value specifying whether the shape is static or dynamic. - * @return A new ExecuTorchTensor instance filled with random integer values. - */ -+ (instancetype)randomIntegerTensorWithLow:(NSInteger)low - high:(NSInteger)high - shape:(NSArray *)shape - strides:(NSArray *)strides - dataType:(ExecuTorchDataType)dataType - shapeDynamism:(ExecuTorchShapeDynamism)shapeDynamism - NS_REFINED_FOR_SWIFT - NS_RETURNS_RETAINED; - -/** - * Creates a tensor with random integer values in the specified range, - * with the given shape and data type. - * - * @param low An NSInteger specifying the inclusive lower bound of random values. - * @param high An NSInteger specifying the exclusive upper bound of random values. - * @param shape An NSArray of NSNumber objects representing the desired shape. - * @param dataType An ExecuTorchDataType value specifying the element type. - * @param shapeDynamism An ExecuTorchShapeDynamism value specifying whether the shape is static or dynamic. - * @return A new ExecuTorchTensor instance filled with random integer values. - */ -+ (instancetype)randomIntegerTensorWithLow:(NSInteger)low - high:(NSInteger)high - shape:(NSArray *)shape - dataType:(ExecuTorchDataType)dataType - shapeDynamism:(ExecuTorchShapeDynamism)shapeDynamism - NS_SWIFT_UNAVAILABLE("") - NS_RETURNS_RETAINED; - -/** - * Creates a tensor with random integer values in the specified range, - * with the given shape (using dynamic bound shape) and data type. - * - * @param low An NSInteger specifying the inclusive lower bound of random values. - * @param high An NSInteger specifying the exclusive upper bound of random values. - * @param shape An NSArray of NSNumber objects representing the desired shape. - * @param dataType An ExecuTorchDataType value specifying the element type. - * @return A new ExecuTorchTensor instance filled with random integer values. - */ -+ (instancetype)randomIntegerTensorWithLow:(NSInteger)low - high:(NSInteger)high - shape:(NSArray *)shape - dataType:(ExecuTorchDataType)dataType - NS_SWIFT_UNAVAILABLE("") - NS_RETURNS_RETAINED; - -/** - * Creates a tensor with random integer values in the specified range, similar to an existing tensor, - * with the given data type and shape dynamism. - * - * @param tensor An existing ExecuTorchTensor instance whose shape and strides are used. - * @param low An NSInteger specifying the inclusive lower bound of random values. - * @param high An NSInteger specifying the exclusive upper bound of random values. - * @param dataType An ExecuTorchDataType value specifying the element type. - * @param shapeDynamism An ExecuTorchShapeDynamism value specifying whether the shape is static or dynamic. - * @return A new ExecuTorchTensor instance filled with random integer values. - */ -+ (instancetype)randomIntegerTensorLikeTensor:(ExecuTorchTensor *)tensor - low:(NSInteger)low - high:(NSInteger)high - dataType:(ExecuTorchDataType)dataType - shapeDynamism:(ExecuTorchShapeDynamism)shapeDynamism - NS_REFINED_FOR_SWIFT - NS_RETURNS_RETAINED; - -/** - * Creates a tensor with random integer values in the specified range, similar to an existing tensor, - * with the given data type. - * - * @param tensor An existing ExecuTorchTensor instance whose shape and strides are used. - * @param low An NSInteger specifying the inclusive lower bound of random values. - * @param high An NSInteger specifying the exclusive upper bound of random values. - * @param dataType An ExecuTorchDataType value specifying the element type. - * @return A new ExecuTorchTensor instance filled with random integer values. - */ -+ (instancetype)randomIntegerTensorLikeTensor:(ExecuTorchTensor *)tensor - low:(NSInteger)low - high:(NSInteger)high - dataType:(ExecuTorchDataType)dataType - NS_SWIFT_UNAVAILABLE("") - NS_RETURNS_RETAINED; - -/** - * Creates a tensor with random integer values in the specified range, similar to an existing tensor. - * - * @param tensor An existing ExecuTorchTensor instance. - * @param low An NSInteger specifying the inclusive lower bound of random values. - * @param high An NSInteger specifying the exclusive upper bound of random values. - * @return A new ExecuTorchTensor instance filled with random integer values. - */ -+ (instancetype)randomIntegerTensorLikeTensor:(ExecuTorchTensor *)tensor - low:(NSInteger)low - high:(NSInteger)high - NS_SWIFT_UNAVAILABLE("") - NS_RETURNS_RETAINED; - -@end - -NS_ASSUME_NONNULL_END diff --git a/ai_layer/engine/include/executorch/extension/apple/ExecuTorch/Exported/ExecuTorchValue.h b/ai_layer/engine/include/executorch/extension/apple/ExecuTorch/Exported/ExecuTorchValue.h deleted file mode 100644 index 5f1f588a..00000000 --- a/ai_layer/engine/include/executorch/extension/apple/ExecuTorch/Exported/ExecuTorchValue.h +++ /dev/null @@ -1,256 +0,0 @@ -/* - * Copyright (c) Meta Platforms, Inc. and affiliates. - * All rights reserved. - * - * This source code is licensed under the BSD-style license found in the - * LICENSE file in the root directory of this source tree. - */ - -#import "ExecuTorchTensor.h" - -NS_ASSUME_NONNULL_BEGIN - -/** - * Enum to define the dynamic type of a Value. - * Values can be a subset, but must numerically match exactly those defined in - * runtime/core/tag.h - */ -typedef NS_ENUM(uint32_t, ExecuTorchValueTag) { - ExecuTorchValueTagNone, - ExecuTorchValueTagTensor, - ExecuTorchValueTagString, - ExecuTorchValueTagDouble, - ExecuTorchValueTagInteger, - ExecuTorchValueTagBoolean, -} NS_SWIFT_NAME(ValueTag); - -typedef NSNumber *ExecuTorchScalarValue - NS_SWIFT_BRIDGED_TYPEDEF NS_SWIFT_NAME(ScalarValue); -typedef NSString *ExecuTorchStringValue - NS_SWIFT_BRIDGED_TYPEDEF NS_SWIFT_NAME(StringValue); -typedef BOOL ExecuTorchBooleanValue NS_SWIFT_NAME(BoolValue); -typedef NSInteger ExecuTorchIntegerValue - NS_SWIFT_BRIDGED_TYPEDEF NS_SWIFT_NAME(IntegerValue); -typedef double ExecuTorchDoubleValue - NS_SWIFT_BRIDGED_TYPEDEF NS_SWIFT_NAME(DoubleValue); -typedef float ExecuTorchFloatValue - NS_SWIFT_BRIDGED_TYPEDEF NS_SWIFT_NAME(FloatValue); - -/** - * A dynamic value type used by ExecuTorch. - * - * ExecuTorchValue encapsulates a value that may be of various types such as - * a tensor or a scalar. The value’s type is indicated by its tag. - */ -NS_SWIFT_NAME(Value) -__attribute__((objc_subclassing_restricted)) -@interface ExecuTorchValue : NSObject - -/** - * The tag that indicates the dynamic type of the value. - * - * @return An ExecuTorchValueTag value. - */ -@property(nonatomic, readonly) ExecuTorchValueTag tag; - -/** - * The tensor value if the tag is ExecuTorchValueTagTensor. - * - * @return A Tensor instance or nil. - */ -@property(nullable, nonatomic, readonly) ExecuTorchTensor *tensorValue NS_REFINED_FOR_SWIFT; - -/** - * The string value if the tag is ExecuTorchValueTagString. - * - * @return An NSString instance or nil. - */ -@property(nullable, nonatomic, readonly) ExecuTorchStringValue stringValue NS_SWIFT_NAME(string); - -/** - * The scalar value if the tag is boolean, integer or double. - * - * @return A scalar value or nil. - */ -@property(nullable, nonatomic, readonly) ExecuTorchScalarValue scalarValue NS_SWIFT_NAME(scalar); - -/** - * The boolean value if the tag is ExecuTorchValueTagBoolean. - * - * @return A BOOL representing the boolean value. - */ -@property(nonatomic, readonly) ExecuTorchBooleanValue boolValue NS_SWIFT_NAME(boolean); - -/** - * The integer value if the tag is ExecuTorchValueTagInteger. - * - * @return An NSInteger representing the integer value. - */ -@property(nonatomic, readonly) ExecuTorchIntegerValue intValue NS_SWIFT_NAME(integer); - -/** - * The double value if the tag is ExecuTorchValueTagDouble. - * - * @return A double representing the double value. - */ -@property(nonatomic, readonly) ExecuTorchDoubleValue doubleValue NS_SWIFT_NAME(double); - -/** - * The float value if the tag is ExecuTorchValueTagDouble. - * - * @return An float representing the float value. - */ -@property(nonatomic, readonly) ExecuTorchFloatValue floatValue NS_SWIFT_NAME(float); - -/** - * Returns YES if the value is of type None. - * - * @return A BOOL indicating whether the value is None. - */ -@property(nonatomic, readonly) BOOL isNone; - -/** - * Returns YES if the value is a Tensor. - * - * @return A BOOL indicating whether the value is a Tensor. - */ -@property(nonatomic, readonly) BOOL isTensor; - -/** - * Returns YES if the value is a string. - * - * @return A BOOL indicating whether the value is a string. - */ -@property(nonatomic, readonly) BOOL isString; - -/** - * Returns YES if the value is a scalar (boolean, integer or double). - * - * @return A BOOL indicating whether the value is a scalar. - */ -@property(nonatomic, readonly) BOOL isScalar; - -/** - * Returns YES if the value is a boolean. - * - * @return A BOOL indicating whether the value is a boolean. - */ -@property(nonatomic, readonly) BOOL isBoolean; - -/** - * Returns YES if the value is an integer. - * - * @return A BOOL indicating whether the value is an integer. - */ -@property(nonatomic, readonly) BOOL isInteger; - -/** - * Returns YES if the value is a double. - * - * @return A BOOL indicating whether the value is a double. - */ -@property(nonatomic, readonly) BOOL isDouble; - -/** - * Returns YES if the value's tag is Double. - * - * Note: Since float values are stored with a Double tag, this property will - * also be YES for values created from floats. - * - * @return A BOOL indicating whether the value is a float. - */ -@property(nonatomic, readonly) BOOL isFloat; - -/** - * Creates an instance encapsulating a Tensor. - * - * @param value An ExecuTorchTensor instance. - * @return A new ExecuTorchValue instance with a tag of ExecuTorchValueTagTensor. - */ -+ (instancetype)valueWithTensor:(ExecuTorchTensor *)value - NS_SWIFT_NAME(init(_:)) - NS_RETURNS_RETAINED; - -/** - * Creates an instance encapsulating a string. - * - * @param value A string. - * @return A new ExecuTorchValue instance with a tag of ExecuTorchValueTagString. - */ -+ (instancetype)valueWithString:(ExecuTorchStringValue)value - NS_SWIFT_NAME(init(_:)) - NS_RETURNS_RETAINED; - -/** - * Creates an instance encapsulating a boolean. - * - * @param value A boolean. - * @return A new ExecuTorchValue instance with a tag of ExecuTorchValueTagBoolean. - */ -+ (instancetype)valueWithBoolean:(ExecuTorchBooleanValue)value - NS_SWIFT_NAME(init(_:)) - NS_RETURNS_RETAINED; - -/** - * Creates an instance encapsulating an integer. - * - * @param value An integer. - * @return A new ExecuTorchValue instance with a tag of ExecuTorchValueTagInteger. - */ -+ (instancetype)valueWithInteger:(ExecuTorchIntegerValue)value - NS_SWIFT_NAME(init(_:)) - NS_RETURNS_RETAINED; - -/** - * Creates an instance encapsulating a double value. - * - * @param value A double value. - * @return A new ExecuTorchValue instance with a tag of ExecuTorchValueTagDouble. - */ -+ (instancetype)valueWithDouble:(ExecuTorchDoubleValue)value - NS_SWIFT_NAME(init(_:)) - NS_RETURNS_RETAINED; - -/** - * Creates an instance encapsulating a float value. - * - * Note: The underlying value will be stored with a tag of - * ExecuTorchValueTagDouble, as there is no distinct float tag. - * - * @param value A float value. - * @return A new ExecuTorchValue instance with a tag of ExecuTorchValueTagDouble. - */ - + (instancetype)valueWithFloat:(ExecuTorchFloatValue)value - NS_SWIFT_NAME(init(_:)) - NS_RETURNS_RETAINED; - -/** - * Creates an instance encapsulating a scalar value. - * - * The value's tag will be set according to the type encoding of the ExecuTorchScalarValue. - * - * @param value An ExecuTorchScalarValue. - * @return A new ExecuTorchValue instance with the appropriate tag. - */ -+ (instancetype)valueWithScalar:(ExecuTorchScalarValue)value - NS_SWIFT_NAME(init(_:)) - NS_RETURNS_RETAINED; - -/** - * Returns a copy of the value. - * - * @return A new ExecuTorchValue instance that is a duplicate of the current value. - */ - - (instancetype)copy; - -/** - * Determines whether the current Value is equal to another Value. - * - * @param other Another ExecuTorchValue instance to compare against. - * @return YES if the values have the same tag and equal underlying values; otherwise, NO. - */ -- (BOOL)isEqualToValue:(nullable ExecuTorchValue *)other; - -@end - -NS_ASSUME_NONNULL_END diff --git a/ai_layer/engine/include/executorch/extension/apple/ExecuTorch/Internal/ExecuTorchUtils.h b/ai_layer/engine/include/executorch/extension/apple/ExecuTorch/Internal/ExecuTorchUtils.h deleted file mode 100644 index d47d577a..00000000 --- a/ai_layer/engine/include/executorch/extension/apple/ExecuTorch/Internal/ExecuTorchUtils.h +++ /dev/null @@ -1,124 +0,0 @@ -/* - * Copyright (c) Meta Platforms, Inc. and affiliates. - * All rights reserved. - * - * This source code is licensed under the BSD-style license found in the - * LICENSE file in the root directory of this source tree. - */ - -#import - -#ifdef __cplusplus - -#import -#import - -namespace executorch::extension::utils { -using namespace aten; -using namespace runtime; - -/** - * Deduces the scalar type for a given NSNumber based on its type encoding. - * - * @param number The NSNumber instance whose scalar type is to be deduced. - * @return The corresponding ScalarType. - */ -ScalarType deduceType(NSNumber *number); - -/** - * Converts the value held in the NSNumber to the specified C++ type T. - * - * @tparam T The target C++ numeric type. - * @param number The NSNumber instance to extract the value from. - * @return The value converted to type T. - */ -template -T toType(NSNumber *number) { - ET_CHECK_MSG(!(isFloatingType(deduceType(number)) && - isIntegralType(CppTypeToScalarType::value, true)), - "Cannot convert floating point to integral type"); - T value; - if constexpr (std::is_same_v) { - value = number.unsignedCharValue; - } else if constexpr (std::is_same_v) { - value = number.charValue; - } else if constexpr (std::is_same_v) { - value = number.shortValue; - } else if constexpr (std::is_same_v) { - value = number.intValue; - } else if constexpr (std::is_same_v) { - value = number.longLongValue; - } else if constexpr (std::is_same_v) { - value = number.floatValue; - } else if constexpr (std::is_same_v) { - value = number.doubleValue; - } else if constexpr (std::is_same_v) { - value = number.boolValue; - } else if constexpr (std::is_same_v) { - value = number.unsignedShortValue; - } else if constexpr (std::is_same_v) { - value = number.unsignedIntValue; - } else if constexpr (std::is_same_v) { - value = number.unsignedLongLongValue; - } else if constexpr (std::is_same_v) { - value = number.integerValue; - } else if constexpr (std::is_same_v) { - value = number.unsignedIntegerValue; - } else if constexpr (std::is_same_v || - std::is_same_v) { - value = T(number.floatValue); - } else { - static_assert(sizeof(T) == 0, "Unsupported type"); - } - ET_DCHECK_MSG(std::numeric_limits::lowest() <= value && value <= std::numeric_limits::max(), - "Value out of range"); - return value; -} - -/** - * Converts an NSArray of NSNumber objects to a std::vector of type T. - * - * @tparam T The target C++ numeric type. - * @param array The NSArray containing NSNumber objects. - * @return A std::vector with the values extracted as type T. - */ -template -std::vector toVector(NSArray *array) { - std::vector vector; - vector.reserve(array.count); - for (NSNumber *number in array) { - vector.push_back(toType(number)); - } - return vector; -} - -// Trait for types that can be wrapped into an NSNumber. -template -constexpr bool isNSNumberWrapable = - std::is_arithmetic_v || - std::is_same_v || - std::is_same_v || - std::is_same_v; - -/** - * Converts a generic container of numeric values to an NSArray of NSNumber objects. - * - * @tparam Container The container type holding numeric values. - * @param container The container whose items are to be converted. - * @return An NSArray populated with NSNumber objects representing the container's items. - */ -template -NS_RETURNS_RETAINED -NSArray *toNSArray(const Container &container) { - static_assert(isNSNumberWrapable, "Invalid container value type"); - const NSUInteger count = std::distance(std::begin(container), std::end(container)); - NSMutableArray *array = [[NSMutableArray alloc] initWithCapacity:count]; - for (const auto &item : container) { - [array addObject:@(item)]; - } - return array; -} - -} // namespace executorch::extension::utils - -#endif // __cplusplus diff --git a/ai_layer/engine/include/executorch/extension/aten_util/aten_bridge.h b/ai_layer/engine/include/executorch/extension/aten_util/aten_bridge.h deleted file mode 100644 index 62b07eee..00000000 --- a/ai_layer/engine/include/executorch/extension/aten_util/aten_bridge.h +++ /dev/null @@ -1,86 +0,0 @@ -/* - * Copyright (c) Meta Platforms, Inc. and affiliates. - * All rights reserved. - * - * This source code is licensed under the BSD-style license found in the - * LICENSE file in the root directory of this source tree. - */ - -#pragma once - -#include -#include - -#include // @manual=//caffe2/aten:ATen-cpu -#include // @manual=//caffe2/aten:ATen-core -#include // @manual=//caffe2/aten:ATen-core -#include // @manual=//caffe2/c10:c10 - -#include -#include - -namespace executorch { -namespace extension { - -torch::executor::ScalarType torch_to_executorch_scalar_type( - caffe2::TypeMeta type); - -c10::ScalarType executorch_to_torch_scalar_type( - torch::executor::ScalarType type); - -/* - * @param[in] aten_tensor Input at::Tensor - * @param[in,out] mutable_et ETensor whose underlying memory now will alias to - * aten_tensor - */ -void alias_etensor_to_attensor(at::Tensor& at, torch::executor::Tensor& et); - -/* - * @param[in] et ETensor whose underlying memory now will alias to returned - * output tensor - * @param[ret] aten_tensor output at::Tensor - * Notes: - * It is owned by the caller of alias_attensor_to_etensor. - * Lifetime of tensor meta must be >= to that of the returned tensor since - * this function uses at::from_blob API that constructs non-owning tensor - * along with non-owning metadata, e.g. sizes. - * If such lifetime guarantees cannot be provided, returned tensor should be - * cloned. - */ -at::Tensor alias_attensor_to_etensor(const torch::executor::Tensor& et); - -TensorPtr alias_tensor_ptr_to_attensor(at::Tensor& t); - -} // namespace extension -} // namespace executorch - -namespace torch { -namespace executor { -namespace util { -// TODO(T197294990): Remove these deprecated aliases once all users have moved -// to the new `::executorch` namespaces. -using ::executorch::extension::alias_attensor_to_etensor; -using ::executorch::extension::alias_etensor_to_attensor; -inline torch::executor::ScalarType torchToExecuTorchScalarType( - caffe2::TypeMeta type) { - return ::executorch::extension::torch_to_executorch_scalar_type(type); -} -inline c10::ScalarType execuTorchtoTorchScalarType( - torch::executor::ScalarType type) { - return ::executorch::extension::executorch_to_torch_scalar_type(type); -} -} // namespace util -} // namespace executor -} // namespace torch - -// Some users refer to these as `torch::util::`. -namespace torch { -namespace util { -// TODO(T197294990): Remove these deprecated aliases once all users have moved -// to the new `::executorch` namespaces. -using ::torch::executor::util::alias_attensor_to_etensor; -using ::torch::executor::util::alias_etensor_to_attensor; -using ::torch::executor::util::execuTorchtoTorchScalarType; -using ::torch::executor::util::torchToExecuTorchScalarType; -} // namespace util -} // namespace torch diff --git a/ai_layer/engine/include/executorch/extension/aten_util/make_aten_functor_from_et_functor.h b/ai_layer/engine/include/executorch/extension/aten_util/make_aten_functor_from_et_functor.h deleted file mode 100644 index 104531f0..00000000 --- a/ai_layer/engine/include/executorch/extension/aten_util/make_aten_functor_from_et_functor.h +++ /dev/null @@ -1,308 +0,0 @@ -/* - * Copyright (c) Meta Platforms, Inc. and affiliates. - * All rights reserved. - * - * This source code is licensed under the BSD-style license found in the - * LICENSE file in the root directory of this source tree. - */ - -//===----------------------------------------------------------------------===// -/// \file runtime/kernel/make_aten_functor_from_et_functor.h -/// Defines a template that can be used to create a ATen version of an unboxed -/// ExecuTorch kernel. -//===----------------------------------------------------------------------===// - -#pragma once -#include -#include -#if __cplusplus < 201703L -#error "This header requires C++17" -#endif -#include -#include -#include -#include - -// X11 headers via volk define Complex, so we need to undef it -#if defined(__linux__) -#undef Complex -#endif - -#include - -namespace executorch { -namespace extension { -namespace internal { - -// Map types from ETen to ATen. -// This is used to convert ETen arguments into ATen. -template -struct type_map final { - using type = T; -}; - -// Const. -template -struct type_map final { - using type = const typename type_map::type; -}; - -// Ref. -template -struct type_map final { - using type = typename type_map::type&; -}; - -// Const ref. -template -struct type_map final { - using type = const typename type_map::type&; -}; - -// Tensor. -template <> -struct type_map final { - using type = at::Tensor; -}; - -// Optional. -template -struct type_map> final { - using type = std::optional::type>; -}; - -template -struct type_map&> final { - using type = std::optional::type>&; -}; - -// ArrayRef. -template -struct type_map> final { - using type = at::ArrayRef::type>; -}; - -template -struct remove_const_ref final { - using type = std::remove_const_t>; -}; - -// Convert ATen->ETen: input args. -// Convert ETen->ATen: output args. -// Default argument conversions between ATen and ETen (scalars). -template -struct type_convert final { - public: - F val; - explicit type_convert(F value) : val(value) {} - T call() { - return static_cast(val); - } -}; - -// Tensors: ATen to ETen. -template -struct type_convert< - ATensor, - ETensor, - std::enable_if_t< - std::is_same_v::type, at::Tensor> && - std::is_same_v< - typename remove_const_ref::type, - torch::executor::Tensor>>> - final { - explicit type_convert(ATensor value) - : value_(value.contiguous()), - converted_(from_blob( - value_.mutable_data_ptr(), - {value_.sizes().begin(), value_.sizes().end()}, - ::torch::executor::ScalarType(value_.scalar_type()))) {} - - ETensor call() { - return *converted_; - } - - private: - typename remove_const_ref::type value_; - TensorPtr converted_; -}; - -// Tensors: ETen to ATen. -template -struct type_convert< - ETensor, - ATensor, - std::enable_if_t< - std::is_same_v::type, at::Tensor> && - std::is_same_v< - typename remove_const_ref::type, - ::torch::executor::Tensor>>> - final { - explicit type_convert(ETensor value) - : value_(value), - converted_(at::from_blob( - value_.mutable_data_ptr(), - std::vector{value_.sizes().begin(), value_.sizes().end()}, - c10::ScalarType(value_.scalar_type()))) {} - - ATensor call() { - return converted_; - } - - private: - ETensor value_; - at::Tensor converted_; -}; - -// Optionals: ATen to ETen. -template -struct type_convert< - AOptional, - EOptional, - std::enable_if_t< - std::is_same_v< - typename remove_const_ref::type, - std::optional< - typename remove_const_ref::type::value_type>> && - std::is_same_v< - typename remove_const_ref::type, - torch::executor::optional< - typename remove_const_ref::type::value_type>>>> - final { - public: - typename remove_const_ref::type val; - std::unique_ptr::type::value_type, - typename remove_const_ref::type::value_type>> - convert_struct; - explicit type_convert(AOptional value) : val(value) {} - typename remove_const_ref::type call() { - if (val.has_value()) { - convert_struct = std::make_unique::type::value_type, - typename remove_const_ref::type::value_type>>( - type_convert< - typename remove_const_ref::type::value_type, - typename remove_const_ref::type::value_type>( - val.value())); - return typename remove_const_ref::type(convert_struct->call()); - } else { - return typename remove_const_ref::type(); - } - } -}; - -// ArrayRefs: ATen to ETen. -template -struct type_convert, torch::executor::ArrayRef> final { - public: - c10::ArrayRef val; - std::vector converted; - std::vector> converters; - explicit type_convert(c10::ArrayRef value) : val(value) { - for (int i = 0; i < val.size(); i++) { - converters.push_back(type_convert(val[i])); - } - } - torch::executor::ArrayRef call() { - for (int i = 0; i < val.size(); i++) { - converted.push_back(converters[i].call()); - } - return torch::executor::ArrayRef(converted.data(), converted.size()); - } -}; - -// ArrayRefs: ETen to ATen. -template -struct type_convert, c10::ArrayRef> final { - public: - torch::executor::ArrayRef val; - std::vector converted; - std::vector> converters; - explicit type_convert(torch::executor::ArrayRef value) : val(value) { - for (int i = 0; i < val.size(); i++) { - converters.push_back(type_convert(val[i])); - } - } - c10::ArrayRef call() { - for (int i = 0; i < val.size(); i++) { - converted.push_back(converters[i].call()); - } - return c10::ArrayRef(converted); - } -}; - -template -struct wrapper_impl; - -template -struct wrapper_impl { - static_assert( - !(std::is_same::value && N == -1), - "Can't wrap a kernel with 'Tensor &' return type without specifying an index to the out tensor"); - using ReturnType = typename type_map::type; - using TupleConvertsType = - std::tuple::type, Args>...>; - using TupleArgsType = std::tuple::type...>; - static constexpr size_t num_args = sizeof...(Args); - static_assert( - (N < num_args && - std::is_same_v< - executorch::extension::kernel_util_internal::element_t< - N, - executorch::extension::kernel_util_internal::typelist>, - R>) || - N == -1, - "The index of the out tensor can't be greater or equal to num_args and " - "the Nth argument type has to be the same as the return type."); - - static ReturnType wrap(typename type_map::type... args) { - // The wrapped function that takes ATen argument types, convert them into - // ExecuTorch equivalent, call `f` then return the result converted back to - // ATen. - TupleArgsType args_tuple = std::forward_as_tuple(args...); - TupleConvertsType converts = std::forward_as_tuple( - type_convert::type, Args>(args)...); - R result = - call_functor_with_args(converts, std::make_index_sequence()); - typename std::remove_reference::type converted_result = - type_convert(result).call(); - if constexpr (N == -1) { - return converted_result; - } else { - static_assert( - std::is_same_v< - typename std::remove_reference::type, - at::Tensor>, - "Only support at::Tensor-like return"); - ReturnType out = std::get(args_tuple); - at::native::resize_output(out, converted_result.sizes()); - out.copy_(converted_result); - return out; - } - } - - private: - template - static R call_functor_with_args( - TupleConvertsType& converts, - std::index_sequence) { - return f(std::get(converts).call()...); - } -}; - -} // namespace internal -} // namespace extension -} // namespace executorch - -// Wrapper macro for out variant function. N is the index of the out tensor. -// We need N to know how to preserve the semantics of modifying out tensor and -// return the reference without allocating a new memory buffer for out tensor. -#define _WRAP_2(func, N) \ - ::executorch::extension::internal:: \ - wrapper_impl::wrap -#define _WRAP_1(func) \ - ::executorch::extension::internal::wrapper_impl::wrap - -#define _GET_MACRO(_1, _2, NAME, ...) NAME -#define WRAP_TO_ATEN(...) _GET_MACRO(__VA_ARGS__, _WRAP_2, _WRAP_1)(__VA_ARGS__) diff --git a/ai_layer/engine/include/executorch/extension/benchmark/apple/Benchmark/TestUtils/DynamicTestCase.h b/ai_layer/engine/include/executorch/extension/benchmark/apple/Benchmark/TestUtils/DynamicTestCase.h deleted file mode 100644 index 4cf7b525..00000000 --- a/ai_layer/engine/include/executorch/extension/benchmark/apple/Benchmark/TestUtils/DynamicTestCase.h +++ /dev/null @@ -1,24 +0,0 @@ -/* - * Copyright (c) Meta Platforms, Inc. and affiliates. - * All rights reserved. - * - * This source code is licensed under the BSD-style license found in the - * LICENSE file in the root directory of this source tree. - */ - -#import - -/** - * DynamicTestCase is a subclass of XCTestCase that allows dynamic creation of - * test methods. Subclasses should override the `+dynamicTests` method to - * provide a dictionary of test names and corresponding test blocks. - */ -@interface DynamicTestCase : XCTestCase - -/** - * Returns a dictionary mapping test names to test blocks. - * Subclasses should override this method to provide dynamic tests. - */ -+ (NSDictionary *)dynamicTests; - -@end diff --git a/ai_layer/engine/include/executorch/extension/benchmark/apple/Benchmark/TestUtils/ResourceTestCase.h b/ai_layer/engine/include/executorch/extension/benchmark/apple/Benchmark/TestUtils/ResourceTestCase.h deleted file mode 100644 index 3bab25d0..00000000 --- a/ai_layer/engine/include/executorch/extension/benchmark/apple/Benchmark/TestUtils/ResourceTestCase.h +++ /dev/null @@ -1,50 +0,0 @@ -/* - * Copyright (c) Meta Platforms, Inc. and affiliates. - * All rights reserved. - * - * This source code is licensed under the BSD-style license found in the - * LICENSE file in the root directory of this source tree. - */ - -#import "DynamicTestCase.h" - -/** - * ResourceTestCase is a subclass of DynamicTestCase that generates tests based - * on resources. Subclasses should override the bundle, directories, predicates, - * and dynamicTestsForResources methods. - */ -@interface ResourceTestCase : DynamicTestCase - -/** - * Returns an array of NSBundle objects to search for resources. - * By default, returns the main bundle and the bundle for the class. - */ -+ (NSArray *)bundles; - -/** - * Returns an array of directory paths (relative to the bundles' resource paths) - * to search. Subclasses should override to specify directories containing - * resources. - */ -+ (NSArray *)directories; - -/** - * Returns a dictionary mapping resource keys to predicates. - * Each predicate is a block that takes a filename and returns a BOOL indicating - * a match. Subclasses should override to specify predicates for matching - * resources. - */ -+ (NSDictionary *)predicates; - -/** - * Returns a dictionary mapping test names to test blocks, given a dictionary of - * resources. Subclasses should override to provide tests for combinations of - * resources. - * - * @param resources A dictionary mapping resource keys to resource file paths. - * @return A dictionary mapping test names to test blocks. - */ -+ (NSDictionary *)dynamicTestsForResources: - (NSDictionary *)resources; - -@end diff --git a/ai_layer/engine/include/executorch/extension/data_loader/buffer_data_loader.h b/ai_layer/engine/include/executorch/extension/data_loader/buffer_data_loader.h deleted file mode 100644 index ee25d865..00000000 --- a/ai_layer/engine/include/executorch/extension/data_loader/buffer_data_loader.h +++ /dev/null @@ -1,86 +0,0 @@ -/* - * Copyright (c) Meta Platforms, Inc. and affiliates. - * All rights reserved. - * - * This source code is licensed under the BSD-style license found in the - * LICENSE file in the root directory of this source tree. - */ - -#pragma once - -#include -#include -#include -#include -#include - -namespace executorch { -namespace extension { - -/** - * A DataLoader that wraps a pre-allocated buffer. The FreeableBuffers - * that it returns do not actually free any data. - * - * This can be used to wrap data that is directly embedded into the firmware - * image, or to wrap data that was allocated elsewhere. - */ -class BufferDataLoader final : public executorch::runtime::DataLoader { - public: - BufferDataLoader(const void* data, size_t size) - : data_(reinterpret_cast(data)), size_(size) {} - - ET_NODISCARD - executorch::runtime::Result load( - size_t offset, - size_t size, - ET_UNUSED const DataLoader::SegmentInfo& segment_info) const override { - ET_CHECK_OR_RETURN_ERROR( - offset + size <= size_, - InvalidArgument, - "offset %zu + size %zu > size_ %zu", - offset, - size, - size_); - return executorch::runtime::FreeableBuffer( - data_ + offset, size, /*free_fn=*/nullptr); - } - - ET_NODISCARD executorch::runtime::Result size() const override { - return size_; - } - - ET_NODISCARD executorch::runtime::Error load_into( - size_t offset, - size_t size, - ET_UNUSED const SegmentInfo& segment_info, - void* buffer) const override { - ET_CHECK_OR_RETURN_ERROR( - buffer != nullptr, - InvalidArgument, - "Destination buffer cannot be null"); - - auto result = load(offset, size, segment_info); - if (!result.ok()) { - return result.error(); - } - std::memcpy(buffer, result->data(), size); - return executorch::runtime::Error::Ok; - } - - private: - const uint8_t* const data_; // uint8 is easier to index into. - const size_t size_; -}; - -} // namespace extension -} // namespace executorch - -namespace torch { -namespace executor { -namespace util { -// TODO(T197294990): Remove these deprecated aliases once all users have moved -// to the new `::executorch` namespaces. -using ::executorch::extension::BufferDataLoader; -} // namespace util -} // namespace executor -} // namespace torch diff --git a/ai_layer/engine/include/executorch/extension/data_loader/file_data_loader.h b/ai_layer/engine/include/executorch/extension/data_loader/file_data_loader.h deleted file mode 100644 index 596c005b..00000000 --- a/ai_layer/engine/include/executorch/extension/data_loader/file_data_loader.h +++ /dev/null @@ -1,114 +0,0 @@ -/* - * Copyright (c) Meta Platforms, Inc. and affiliates. - * All rights reserved. - * - * This source code is licensed under the BSD-style license found in the - * LICENSE file in the root directory of this source tree. - */ - -#pragma once - -#include - -#include -#include -#include - -namespace executorch { -namespace extension { - -/** - * A DataLoader that loads segments from a file, allocating the memory - * with `malloc()`. - * - * Note that this will keep the file open for the duration of its lifetime, to - * avoid the overhead of opening it again for every load() call. - */ -class FileDataLoader final : public executorch::runtime::DataLoader { - public: - /** - * Creates a new FileDataLoader that wraps the named file. - * - * @param[in] file_name Path to the file to read from. - * @param[in] alignment Alignment in bytes of pointers returned by this - * instance. Must be a power of two. - * - * @returns A new FileDataLoader on success. - * @retval Error::InvalidArgument `alignment` is not a power of two. - * @retval Error::AccessFailed `file_name` could not be opened, or its size - * could not be found. - * @retval Error::MemoryAllocationFailed Internal memory allocation failure. - */ - static executorch::runtime::Result from( - const char* file_name, - size_t alignment = alignof(std::max_align_t)); - - /// DEPRECATED: Use the lowercase `from()` instead. - ET_DEPRECATED static executorch::runtime::Result From( - const char* file_name, - size_t alignment = alignof(std::max_align_t)) { - return from(file_name, alignment); - } - - // Movable to be compatible with Result. - FileDataLoader(FileDataLoader&& rhs) noexcept - : file_name_(rhs.file_name_), - file_size_(rhs.file_size_), - alignment_(rhs.alignment_), - fd_(rhs.fd_) { - const_cast(rhs.file_name_) = nullptr; - const_cast(rhs.file_size_) = 0; - const_cast(rhs.alignment_) = {}; - const_cast(rhs.fd_) = -1; - } - - ~FileDataLoader() override; - - ET_NODISCARD - executorch::runtime::Result load( - size_t offset, - size_t size, - const DataLoader::SegmentInfo& segment_info) const override; - - ET_NODISCARD executorch::runtime::Result size() const override; - - ET_NODISCARD executorch::runtime::Error load_into( - size_t offset, - size_t size, - ET_UNUSED const SegmentInfo& segment_info, - void* buffer) const override; - - private: - FileDataLoader( - int fd, - size_t file_size, - size_t alignment, - const char* file_name) - : file_name_(file_name), - file_size_(file_size), - alignment_{alignment}, - fd_(fd) {} - - // Not safely copyable. - FileDataLoader(const FileDataLoader&) = delete; - FileDataLoader& operator=(const FileDataLoader&) = delete; - FileDataLoader& operator=(FileDataLoader&&) = delete; - - const char* const file_name_; // Owned by the instance. - const size_t file_size_; - const std::align_val_t alignment_; - const int fd_; // Owned by the instance. -}; - -} // namespace extension -} // namespace executorch - -namespace torch { -namespace executor { -namespace util { -// TODO(T197294990): Remove these deprecated aliases once all users have moved -// to the new `::executorch` namespaces. -using ::executorch::extension::FileDataLoader; -} // namespace util -} // namespace executor -} // namespace torch diff --git a/ai_layer/engine/include/executorch/extension/data_loader/file_descriptor_data_loader.h b/ai_layer/engine/include/executorch/extension/data_loader/file_descriptor_data_loader.h deleted file mode 100644 index eff64835..00000000 --- a/ai_layer/engine/include/executorch/extension/data_loader/file_descriptor_data_loader.h +++ /dev/null @@ -1,112 +0,0 @@ -/* - * Copyright (c) Meta Platforms, Inc. and affiliates. - * All rights reserved. - * - * This source code is licensed under the BSD-style license found in the - * LICENSE file in the root directory of this source tree. - */ - -#pragma once - -#include - -#include -#include -#include - -namespace executorch { -namespace extension { - -/** - * A DataLoader that loads segments from a file descriptor, allocating the - * memory with `malloc()`. This data loader is used when ET is running in a - * process that does not have access to the filesystem, and the caller is able - * to open the file and pass the file descriptor. - * - * Note that this will keep the file open for the duration of its lifetime, to - * avoid the overhead of opening it again for every load() call. - */ -class FileDescriptorDataLoader final : public executorch::runtime::DataLoader { - public: - /** - * Creates a new FileDescriptorDataLoader that wraps the named file - * descriptor, and the ownership of the file descriptor is passed. - * - * @param[in] file_descriptor_uri File descriptor with the prefix "fd:///", - * followed by the file descriptor number. - * @param[in] alignment Alignment in bytes of pointers returned by this - * instance. Must be a power of two. - * - * @returns A new FileDescriptorDataLoader on success. - * @retval Error::InvalidArgument `alignment` is not a power of two. - * @retval Error::AccessFailed `file_descriptor_uri` is incorrectly formatted, - * or its size could not be found. - * @retval Error::MemoryAllocationFailed Internal memory allocation failure. - */ - static executorch::runtime::Result - fromFileDescriptorUri( - const char* file_descriptor_uri, - size_t alignment = alignof(std::max_align_t)); - - // Movable to be compatible with Result. - FileDescriptorDataLoader(FileDescriptorDataLoader&& rhs) noexcept - : file_descriptor_uri_(rhs.file_descriptor_uri_), - file_size_(rhs.file_size_), - alignment_(rhs.alignment_), - fd_(rhs.fd_) { - const_cast(rhs.file_descriptor_uri_) = nullptr; - const_cast(rhs.file_size_) = 0; - const_cast(rhs.alignment_) = {}; - const_cast(rhs.fd_) = -1; - } - - ~FileDescriptorDataLoader() override; - - ET_NODISCARD - executorch::runtime::Result load( - size_t offset, - size_t size, - const DataLoader::SegmentInfo& segment_info) const override; - - ET_NODISCARD executorch::runtime::Result size() const override; - - ET_NODISCARD executorch::runtime::Error load_into( - size_t offset, - size_t size, - ET_UNUSED const SegmentInfo& segment_info, - void* buffer) const override; - - private: - FileDescriptorDataLoader( - int fd, - size_t file_size, - size_t alignment, - const char* file_descriptor_uri) - : file_descriptor_uri_(file_descriptor_uri), - file_size_(file_size), - alignment_{alignment}, - fd_(fd) {} - - // Not safely copyable. - FileDescriptorDataLoader(const FileDescriptorDataLoader&) = delete; - FileDescriptorDataLoader& operator=(const FileDescriptorDataLoader&) = delete; - FileDescriptorDataLoader& operator=(FileDescriptorDataLoader&&) = delete; - - const char* const file_descriptor_uri_; // Owned by the instance. - const size_t file_size_; - const std::align_val_t alignment_; - const int fd_; // Owned by the instance. -}; - -} // namespace extension -} // namespace executorch - -namespace torch { -namespace executor { -namespace util { -// TODO(T197294990): Remove these deprecated aliases once all users have moved -// to the new `::executorch` namespaces. -using ::executorch::extension::FileDescriptorDataLoader; -} // namespace util -} // namespace executor -} // namespace torch diff --git a/ai_layer/engine/include/executorch/extension/data_loader/mman.h b/ai_layer/engine/include/executorch/extension/data_loader/mman.h deleted file mode 100644 index 24606898..00000000 --- a/ai_layer/engine/include/executorch/extension/data_loader/mman.h +++ /dev/null @@ -1,43 +0,0 @@ -/* - * Copyright (c) Meta Platforms, Inc. and affiliates. - * All rights reserved. - * - * This source code is licensed under the BSD-style license found in the - * LICENSE file in the root directory of this source tree. - */ - -// This file ensures that mman.h compatible functions are defined in the global -// namespace for windows and posix environments. - -#pragma once - -#include - -#ifndef _WIN32 - -#include -#include - -ET_INLINE size_t get_os_page_size() { - return sysconf(_SC_PAGESIZE); -} - -#else - -#define NOMINMAX -#include -#undef NOMINMAX -#include - -#include - -ET_INLINE long get_os_page_size() { - SYSTEM_INFO si; - GetSystemInfo(&si); - long pagesize = si.dwAllocationGranularity > si.dwPageSize - ? si.dwAllocationGranularity - : si.dwPageSize; - return pagesize; -} - -#endif diff --git a/ai_layer/engine/include/executorch/extension/data_loader/mman_windows.h b/ai_layer/engine/include/executorch/extension/data_loader/mman_windows.h deleted file mode 100644 index 563db5d8..00000000 --- a/ai_layer/engine/include/executorch/extension/data_loader/mman_windows.h +++ /dev/null @@ -1,68 +0,0 @@ -/* - * Copyright (c) Google Inc. and affiliates. - * All rights reserved. - * - * This source code is licensed under the MIT license. - */ - -/* - * Adapted from: https://code.google.com/archive/p/mman-win32/ - * - * mman-win32 - * mman library for Windows - * - * A light implementation of the mmap functions for MinGW. - * - * The mmap-win32 library implements a wrapper for mmap functions around the - * memory mapping Windows API. - */ - -#pragma once - -#ifndef _WIN32_WINNT // Allow use of features specific to Windows XP or later. -#define _WIN32_WINNT \ - 0x0501 // Change this to the appropriate value to target other versions of - // Windows. -#endif - -/* All the headers include this file. */ -#ifndef _MSC_VER -#include <_mingw.h> -#endif - -#include - -#ifdef __cplusplus -extern "C" { -#endif - -#define PROT_NONE 0 -#define PROT_READ 1 -#define PROT_WRITE 2 -#define PROT_EXEC 4 - -#define MAP_FILE 0 -#define MAP_SHARED 1 -#define MAP_PRIVATE 2 -#define MAP_TYPE 0xf -#define MAP_FIXED 0x10 -#define MAP_ANONYMOUS 0x20 -#define MAP_ANON MAP_ANONYMOUS - -#define MAP_FAILED ((void*)-1) - -/* Flags for msync. */ -#define MS_ASYNC 1 -#define MS_SYNC 2 -#define MS_INVALIDATE 4 - -void* mmap(void* addr, size_t len, int prot, int flags, int fildes, off_t off); -int munmap(void* addr, size_t len); -int mprotect(void* addr, size_t len, int prot); -int msync(void* addr, size_t len, int flags); -int mlock(const void* addr, size_t len); -int munlock(const void* addr, size_t len); - -#ifdef __cplusplus -}; -#endif diff --git a/ai_layer/engine/include/executorch/extension/data_loader/mmap_data_loader.h b/ai_layer/engine/include/executorch/extension/data_loader/mmap_data_loader.h deleted file mode 100644 index c0496a39..00000000 --- a/ai_layer/engine/include/executorch/extension/data_loader/mmap_data_loader.h +++ /dev/null @@ -1,145 +0,0 @@ -/* - * Copyright (c) Meta Platforms, Inc. and affiliates. - * All rights reserved. - * - * This source code is licensed under the BSD-style license found in the - * LICENSE file in the root directory of this source tree. - */ - -#pragma once - -#include -#include -#include - -namespace executorch { -namespace extension { - -/** - * A DataLoader that loads segments from a file, allocating the memory - * with `malloc()`. - * - * Note that this will keep the file open for the duration of its lifetime, to - * avoid the overhead of opening it again for every load() call. - */ -class MmapDataLoader final : public executorch::runtime::DataLoader { - public: - /** - * Describes how and whether to lock loaded pages with `mlock()`. - * - * Using `mlock()` typically loads all of the pages immediately, and will - * typically ensure that they are not swapped out. The actual behavior - * will depend on the host system. - */ - enum class MlockConfig { - /// Do not call `mlock()` on loaded pages. - NoMlock, - /// Call `mlock()` on loaded pages, failing if it fails. - UseMlock, - /// Call `mlock()` on loaded pages, ignoring errors if it fails. - UseMlockIgnoreErrors, - }; - - /** - * Creates a new MmapDataLoader that wraps the named file. Fails if - * the file can't be opened for reading or if its size can't be found. - * - * @param[in] file_name The path to the file to load from. The file will be - * kept open until the MmapDataLoader is destroyed, to avoid the - * overhead of opening it again for every load() call. - * @param[in] mlock_config How and whether to lock loaded pages with - * `mlock()`. - */ - static executorch::runtime::Result from( - const char* file_name, - MlockConfig mlock_config = MlockConfig::UseMlock); - - /// DEPRECATED: Use the lowercase `from()` instead. - ET_DEPRECATED static executorch::runtime::Result From( - const char* file_name, - MlockConfig mlock_config = MlockConfig::UseMlock) { - return from(file_name, mlock_config); - } - - /// DEPRECATED: Use the version of `from()` that takes an MlockConfig. - ET_DEPRECATED - static executorch::runtime::Result From( - const char* file_name, - bool use_mlock) { - MlockConfig mlock_config = - use_mlock ? MlockConfig::UseMlock : MlockConfig::NoMlock; - return from(file_name, mlock_config); - } - - // Movable to be compatible with Result. - MmapDataLoader(MmapDataLoader&& rhs) noexcept - : file_name_(rhs.file_name_), - file_size_(rhs.file_size_), - page_size_(rhs.page_size_), - fd_(rhs.fd_), - mlock_config_(rhs.mlock_config_) { - const_cast(rhs.file_name_) = nullptr; - const_cast(rhs.file_size_) = 0; - const_cast(rhs.page_size_) = 0; - const_cast(rhs.fd_) = -1; - const_cast(rhs.mlock_config_) = MlockConfig::NoMlock; - } - - ~MmapDataLoader() override; - - ET_NODISCARD - executorch::runtime::Result load( - size_t offset, - size_t size, - const DataLoader::SegmentInfo& segment_info) const override; - - ET_NODISCARD executorch::runtime::Result size() const override; - - ET_NODISCARD - executorch::runtime::Error load_into( - size_t offset, - size_t size, - ET_UNUSED const SegmentInfo& segment_info, - void* buffer) const override; - - private: - MmapDataLoader( - int fd, - size_t file_size, - const char* file_name, - size_t page_size, - MlockConfig mlock_config) - : file_name_(file_name), - file_size_(file_size), - page_size_(page_size), - fd_(fd), - mlock_config_(mlock_config) {} - - // Not safely copyable. - MmapDataLoader(const MmapDataLoader&) = delete; - MmapDataLoader& operator=(const MmapDataLoader&) = delete; - MmapDataLoader& operator=(MmapDataLoader&&) = delete; - - ET_NODISCARD executorch::runtime::Error validate_input( - size_t offset, - size_t size) const; - - const char* const file_name_; // String data is owned by the instance. - const size_t file_size_; - const size_t page_size_; - const int fd_; // Owned by the instance. - const MlockConfig mlock_config_; -}; - -} // namespace extension -} // namespace executorch - -namespace torch { -namespace executor { -namespace util { -// TODO(T197294990): Remove these deprecated aliases once all users have moved -// to the new `::executorch` namespaces. -using ::executorch::extension::MmapDataLoader; -} // namespace util -} // namespace executor -} // namespace torch diff --git a/ai_layer/engine/include/executorch/extension/data_loader/shared_ptr_data_loader.h b/ai_layer/engine/include/executorch/extension/data_loader/shared_ptr_data_loader.h deleted file mode 100644 index 551ab4d4..00000000 --- a/ai_layer/engine/include/executorch/extension/data_loader/shared_ptr_data_loader.h +++ /dev/null @@ -1,67 +0,0 @@ -/* - * Copyright (c) Meta Platforms, Inc. and affiliates. - * All rights reserved. - * - * This source code is licensed under the BSD-style license found in the - * LICENSE file in the root directory of this source tree. - */ - -#pragma once - -#include -#include -#include -#include -#include - -namespace executorch { -namespace extension { - -/** - * A DataLoader that wraps a pre-allocated buffer and shares ownership to it. - * The FreeableBuffers that it returns do not actually free any data. - * - * This can be used to wrap data that was allocated elsewhere. - */ -class SharedPtrDataLoader final : public executorch::runtime::DataLoader { - public: - SharedPtrDataLoader(std::shared_ptr data, size_t size) - : data_(data), size_(size) {} - - ET_NODISCARD - executorch::runtime::Result load( - size_t offset, - size_t size, - ET_UNUSED const DataLoader::SegmentInfo& segment_info) const override { - ET_CHECK_OR_RETURN_ERROR( - offset + size <= size_, - InvalidArgument, - "offset %zu + size %zu > size_ %zu", - offset, - size, - size_); - return executorch::runtime::FreeableBuffer( - static_cast(data_.get()) + offset, size, /*free_fn=*/nullptr); - } - - ET_NODISCARD executorch::runtime::Result size() const override { - return size_; - } - - private: - const std::shared_ptr data_; - const size_t size_; -}; - -} // namespace extension -} // namespace executorch - -namespace torch { -namespace executor { -namespace util { -// TODO(T197294990): Remove these deprecated aliases once all users have moved -// to the new `::executorch` namespaces. -using ::executorch::extension::SharedPtrDataLoader; -} // namespace util -} // namespace executor -} // namespace torch diff --git a/ai_layer/engine/include/executorch/extension/evalue_util/print_evalue.h b/ai_layer/engine/include/executorch/extension/evalue_util/print_evalue.h deleted file mode 100644 index e7e8ea15..00000000 --- a/ai_layer/engine/include/executorch/extension/evalue_util/print_evalue.h +++ /dev/null @@ -1,83 +0,0 @@ -/* - * Copyright (c) Meta Platforms, Inc. and affiliates. - * All rights reserved. - * - * This source code is licensed under the BSD-style license found in the - * LICENSE file in the root directory of this source tree. - */ - -#pragma once - -#include - -#include - -namespace executorch { -namespace runtime { -/** - * Prints an Evalue to a stream. - */ -std::ostream& operator<<(std::ostream& os, const EValue& value); -// Note that this must be declared in the same namespace as EValue. -} // namespace runtime -} // namespace executorch - -namespace executorch { -namespace extension { - -/** - * Sets the number of "edge items" when printing EValue lists to a stream. - * - * The edge item count is used to elide inner elements from large lists, and - * like core PyTorch defaults to 3. - * - * For example, - * ``` - * os << torch::executor::util::evalue_edge_items(3) << evalue_int_list << "\n"; - * os << torch::executor::util::evalue_edge_items(1) << evalue_int_list << "\n"; - * ``` - * will print the same list with three edge items, then with only one edge item: - * ``` - * [0, 1, 2, ..., 6, 7, 8] - * [0, ..., 8] - * ``` - * This setting is sticky, and will affect all subsequent evalues printed to the - * affected stream until the value is changed again. - * - * @param[in] os The stream to modify. - * @param[in] edge_items The number of "edge items" to print at the beginning - * and end of a list before eliding inner elements. If zero or negative, - * uses the default number of edge items. - */ -class evalue_edge_items final { - // See https://stackoverflow.com/a/29337924 for other examples of stream - // manipulators like this. - public: - explicit evalue_edge_items(long edge_items) - : edge_items_(edge_items < 0 ? 0 : edge_items) {} - - friend std::ostream& operator<<( - std::ostream& os, - const evalue_edge_items& e) { - set_edge_items(os, e.edge_items_); - return os; - } - - private: - static void set_edge_items(std::ostream& os, long edge_items); - - const long edge_items_; -}; - -} // namespace extension -} // namespace executorch - -namespace torch { -namespace executor { -namespace util { -// TODO(T197294990): Remove these deprecated aliases once all users have moved -// to the new `::executorch` namespaces. -using ::executorch::extension::evalue_edge_items; -} // namespace util -} // namespace executor -} // namespace torch diff --git a/ai_layer/engine/include/executorch/extension/flat_tensor/flat_tensor_data_map.h b/ai_layer/engine/include/executorch/extension/flat_tensor/flat_tensor_data_map.h deleted file mode 100644 index 751e312f..00000000 --- a/ai_layer/engine/include/executorch/extension/flat_tensor/flat_tensor_data_map.h +++ /dev/null @@ -1,131 +0,0 @@ -/* - * Copyright (c) Meta Platforms, Inc. and affiliates. - * All rights reserved. - * - * This source code is licensed under the BSD-style license found in the - * LICENSE file in the root directory of this source tree. - */ - -#pragma once - -#include - -#include - -#include -#include -#include -#include -#include - -#include - -// Forward declare flatbuffer types. This is a public header and must not -// include the generated flatbuffer header. -namespace flat_tensor_flatbuffer { -struct FlatTensor; -} // namespace flat_tensor_flatbuffer - -namespace executorch { -namespace extension { - -/** - * A NamedDataMap implementation for FlatTensor-serialized data. - */ -class FlatTensorDataMap final - : public executorch::ET_RUNTIME_NAMESPACE::NamedDataMap { - public: - /** - * Creates a new DataMap that wraps FlatTensor data. - * - * @param[in] loader The DataLoader that wraps the FlatTensor file. - * Note: the loader must outlive the FlatTensorDataMap instance. - */ - static executorch::runtime::Result load( - executorch::runtime::DataLoader* loader); - - /** - * Retrieve the tensor_layout for the specified key. - * - * @param[in] key The name of the tensor to get metadata on. - * - * @return Error::NotFound if the key is not present. - */ - ET_NODISCARD - executorch::runtime::Result< - const executorch::ET_RUNTIME_NAMESPACE::TensorLayout> - get_tensor_layout(executorch::aten::string_view key) const override; - - /** - * Retrieve read-only data for the specified key. - * - * @param[in] key The name of the tensor to get data on. - * - * @return error if the key is not present or data cannot be loaded. - */ - ET_NODISCARD - executorch::runtime::Result get_data( - executorch::aten::string_view key) const override; - - /** - * Loads the data of the specified tensor into the provided buffer. - * - * @param[in] key The name of the tensor to get the data of. - * @param[in] buffer The buffer to load data into. Must point to at least - * `size` bytes of memory. - * @param[in] size The number of bytes to load. - * - * @returns an Error indicating if the load was successful. - */ - ET_NODISCARD executorch::runtime::Error load_data_into( - executorch::aten::string_view key, - void* buffer, - size_t size) const override; - - /** - * @returns The number of keys in the map. - */ - ET_NODISCARD executorch::runtime::Result get_num_keys() - const override; - - /** - * @returns The key at the specified index, error if index out of bounds. - */ - ET_NODISCARD executorch::runtime::Result get_key( - uint32_t index) const override; - - FlatTensorDataMap(FlatTensorDataMap&&) noexcept = default; - - ~FlatTensorDataMap() override = default; - - private: - FlatTensorDataMap( - const FlatTensorHeader& header, - executorch::runtime::FreeableBuffer&& flat_tensor_data, - const flat_tensor_flatbuffer::FlatTensor* flat_tensor, - executorch::runtime::DataLoader* loader) - : header_(header), - flat_tensor_data_(std::move(flat_tensor_data)), - flat_tensor_(flat_tensor), - loader_(loader) {} - - // Not copyable or assignable. - FlatTensorDataMap(const FlatTensorDataMap& rhs) = delete; - FlatTensorDataMap& operator=(FlatTensorDataMap&& rhs) noexcept = delete; - FlatTensorDataMap& operator=(const FlatTensorDataMap& rhs) = delete; - - // FlatTensor header, containing segment_base_offset and segment_data_size. - const FlatTensorHeader header_; - - // Serialized flat_tensor flatbuffer data. - executorch::runtime::FreeableBuffer flat_tensor_data_; - - // Flatbuffer representation of the flat_tensor. - const flat_tensor_flatbuffer::FlatTensor* flat_tensor_; - - // Data loader, used to load segment data. - executorch::runtime::DataLoader* loader_; -}; - -} // namespace extension -} // namespace executorch diff --git a/ai_layer/engine/include/executorch/extension/flat_tensor/serialize/flat_tensor_header.h b/ai_layer/engine/include/executorch/extension/flat_tensor/serialize/flat_tensor_header.h deleted file mode 100644 index e722cd74..00000000 --- a/ai_layer/engine/include/executorch/extension/flat_tensor/serialize/flat_tensor_header.h +++ /dev/null @@ -1,90 +0,0 @@ -/* - * Copyright (c) Meta Platforms, Inc. and affiliates. - * All rights reserved. - * - * This source code is licensed under the BSD-style license found in the - * LICENSE file in the root directory of this source tree. - */ - -#pragma once - -#include - -namespace executorch { -namespace extension { - -/** - * A FlatTensor header found at the beginning of a flat_tensor-serialized blob. - */ -struct FlatTensorHeader { - /** - * To find the header, callers should provide at least this many bytes of the - * head of the serialized FlatTensor data. - */ - static constexpr size_t kNumHeadBytes = 64; - - /** - * The offset into the serialized FlatTensor data where the FlatTensor - * header should begin. - */ - static constexpr size_t kHeaderOffset = 8; - - /** - * The magic bytes that identify the header. This should be in sync with - * the magic in executorch/extension/flat_tensor/serialize/serialize.py - * - * This is the canonical definition of the expected value. If the header - * layout ever changes in a compatibility-breaking way, increment the digits - * in the magic. But, doing so will prevent older binaries from recognizing - * the presence of the header. The compatibility-preserving way to make - * changes is to increase the header's length field and add new fields at the - * end. - */ - static constexpr size_t kMagicSize = 4; - // @lint-ignore CLANGTIDY facebook-hte-CArray - static constexpr char kMagic[kMagicSize] = {'F', 'H', '0', '1'}; - - /// The expected length of the header, in bytes. - static constexpr uint32_t kHeaderExpectedLength = - // Header magic - 4 - // Header length - + 4 - // Flatbuffer offset - + 8 - // Flatbuffer data size - + 8 - // Segment base offset - + 8 - // Data size - + 8; - - /** - * Look for and parse a FlatTensorHeader in the provided data. - * - * @param[in] data The contents of the beginning of the serialized binary - * FlatTensor data, starting at offset 0 (i.e., the head of the file). - * @param[in] size Length of `data` in bytes. Must be >= kNumHeadBytes or this - * call will fail. - * - * @returns a FlatTensorHeader if the header was found and is valid. Returns - * an error if size was too short, if the header was not found, or if the - * header appeared to be corrupt. - */ - static runtime::Result Parse(const void* data, size_t size); - - /// Offset of the FlatTensor flatbuffer in the serialized binary. - uint64_t flatbuffer_offset; - - /// Size of the flatbuffer in bytes. - uint64_t flatbuffer_size; - - /// The offset in bytes of the first segment. - uint64_t segment_base_offset; - - /// Size of all the segment data, in bytes. - uint64_t segment_data_size; -}; - -} // namespace extension -} // namespace executorch diff --git a/ai_layer/engine/include/executorch/extension/flat_tensor/serialize/serialize.h b/ai_layer/engine/include/executorch/extension/flat_tensor/serialize/serialize.h deleted file mode 100644 index 759fc8d4..00000000 --- a/ai_layer/engine/include/executorch/extension/flat_tensor/serialize/serialize.h +++ /dev/null @@ -1,53 +0,0 @@ -/* - * Copyright (c) Meta Platforms, Inc. and affiliates. - * All rights reserved. - * - * This source code is licensed under the BSD-style license found in the - * LICENSE file in the root directory of this source tree. - */ - -#pragma once - -#include - -#include -#include - -namespace executorch { -namespace extension { -namespace flat_tensor { - -/** - * Schema version of the .ptd format. Should be kept in sync with serialize.py - */ -constexpr uint32_t kSchemaVersion = 0; - -/** - * Creates a .ptd from the given tensor map. - * - * @param path The file path to save the .ptd to. - * @param tensor_map The map of tensor names to tensors to save. - * @param tensor_alignment The bytes tensor data should be aligned to. - * @return An error if the data could not be saved. Error::Ok for success. - */ -ET_EXPERIMENTAL runtime::Error save_ptd( - const std::string& path, - const std::map& tensor_map, - const size_t tensor_alignment); - -/** - * Creates a .ptd from the given tensor map. - * - * @param out The stream to write the .ptd data to. - * @param tensor_map The map of tensor names to tensors to save. - * @param tensor_alignment The bytes tensor data should be aligned to. - * @return An error if the data could not be saved. Error::Ok for success. - */ -ET_EXPERIMENTAL runtime::Error save_ptd( - std::ostream& out, - const std::map& tensor_map, - const size_t tensor_alignment); - -} // namespace flat_tensor -} // namespace extension -} // namespace executorch diff --git a/ai_layer/engine/include/executorch/extension/kernel_util/make_boxed_from_unboxed_functor.h b/ai_layer/engine/include/executorch/extension/kernel_util/make_boxed_from_unboxed_functor.h deleted file mode 100644 index 1710f876..00000000 --- a/ai_layer/engine/include/executorch/extension/kernel_util/make_boxed_from_unboxed_functor.h +++ /dev/null @@ -1,263 +0,0 @@ -/* - * Copyright (c) Meta Platforms, Inc. and affiliates. - * All rights reserved. - * - * This source code is licensed under the BSD-style license found in the - * LICENSE file in the root directory of this source tree. - */ - -//===----------------------------------------------------------------------===// -/// \file extension/kernel_util/make_boxed_from_unboxed_functor.h -/// Defines a template that can be used to create a boxed version of an unboxed -/// functor. -/// Example usage: -/// ``` -/// Tensor& -/// my_op(KernelRuntimeContext& ctx, const Tensor& self, const Tensor& other, -/// Tensor& out) -/// { -/// // ... -/// return out; -/// } -/// -/// Kernel my_kernel = Kernel::make_boxed_kernel("my_ns::my_op", -/// EXECUTORCH_FN(my_op)); -/// static auto res = register_kernels({my_kernel}); -/// ``` -/// Or simply: -/// ``` -/// EXECUTORCH_LIBRARY(my_ns, "my_op", my_op); -/// ``` -/// -/// The trick here is to convert each EValue to inferred argument type. This -/// uses a lot of C++17 features. -//===----------------------------------------------------------------------===// - -#pragma once -#if __cplusplus < 201703L -#error "This header requires C++17" -#endif - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -namespace executorch { -namespace runtime { -class KernelRuntimeContext; // Forward declaration -} // namespace runtime -} // namespace executorch - -namespace executorch { -namespace extension { - -// This extension has a lot of generic internal names like "size"; use a unique -// internal namespace to avoid conflicts with other extensions. -namespace kernel_util_internal { - -// Template trait to check if a type is a non-const tensor -template -struct is_nonconst_tensor : std::false_type {}; - -template <> -struct is_nonconst_tensor : std::true_type {}; - -// Template trait to check if a type is a non-const tensor -// Count non-const tensors in a typelist -template -struct count_nonconst_tensors; - -template <> -struct count_nonconst_tensors> { - static constexpr size_t value = 0; -}; - -template -struct count_nonconst_tensors> { - static constexpr size_t value = 0; -}; - -template <> -struct count_nonconst_tensors> { - static constexpr size_t value = 1; -}; - -template -struct count_nonconst_tensors> { - private: - static constexpr size_t tail_tensor_count = - count_nonconst_tensors>::value; - static constexpr size_t tail_args_count = sizeof...(Tail); - static constexpr bool is_head_a_tensor = is_nonconst_tensor::value; - static constexpr bool all_tail_args_are_tensor = - tail_tensor_count == tail_args_count; - - public: - static constexpr size_t value = (is_head_a_tensor && all_tail_args_are_tensor) - ? tail_tensor_count + 1 - : tail_tensor_count; -}; - -template -struct decay_if_not_tensor final { - using type = std::decay_t; -}; -template <> -struct decay_if_not_tensor final { - using type = executorch::aten::Tensor&; -}; -template <> -struct decay_if_not_tensor final { - using type = const executorch::aten::Tensor&; -}; - -template -struct evalue_to_arg final { - static T call(executorch::runtime::EValue& v) { - return std::move(v).to(); - } -}; - -template <> -struct evalue_to_arg final { - static executorch::aten::Tensor& call(executorch::runtime::EValue& v) { - return v.toTensor(); - } -}; - -template <> -struct evalue_to_arg final { - static const executorch::aten::Tensor& call(executorch::runtime::EValue& v) { - return v.toTensor(); - } -}; - -template -struct evalue_to_arg> final { - static std::optional call(executorch::runtime::EValue& v) { - return v.toOptional(); - } -}; - -template -struct evalue_to_arg>> final { - static executorch::aten::ArrayRef> call( - executorch::runtime::EValue& v) { - return v.toListOptionalTensor(); - } -}; - -template < - class Functor, - size_t nonconst_tensors_to_log, - size_t... evalue_arg_indices, - typename... ArgTypes> -void call_functor_with_args_from_stack( - executorch::runtime::KernelRuntimeContext& ctx, - executorch::runtime::Span stack, - std::index_sequence, - typelist*) { - executorch::runtime::internal::EventTracerProfileOpScope - event_tracer_op_scope(ctx.internal_event_tracer(), Functor::func_name_); - EXECUTORCH_SCOPE_PROF(Functor::func_name_); - (*Functor::func_ptr())( - ctx, - evalue_to_arg::type>::call( - *stack[evalue_arg_indices])...); - constexpr size_t num_inputs = - std::index_sequence::size(); - for (size_t i = num_inputs - nonconst_tensors_to_log; i < num_inputs; ++i) { - executorch::runtime::internal::event_tracer_log_evalue( - ctx.internal_event_tracer(), *stack[i]); - } -} - -} // namespace kernel_util_internal - -/** - * WrapUnboxedIntoFunctor: Given a function pointer, wrap it into a functor that - * takes EValues as input and returns void. The wrapped functor will unbox all - * inputs and forward them to unboxed kernel. - */ -template -struct WrapUnboxedIntoFunctor { - static_assert( - kernel_util_internal::is_compile_time_function_pointer::value, - "Can't handle function other than EXECUTORCH_FN"); - using TrueType = typename FuncType::FuncType; - using ReturnType = typename kernel_util_internal::infer_function_traits_t< - TrueType>::return_type; - using ArgsType = typename kernel_util_internal::infer_function_traits_t< - TrueType>::parameter_types; - // check if the first argument is KernelRuntimeContext, if so, remove it - static constexpr bool first_arg_is_context = std::is_same< - ::executorch::runtime::KernelRuntimeContext, - std::remove_reference_t< - kernel_util_internal::head_with_default_t>>::value; - using ContextRemovedArgsType = std::conditional_t< - first_arg_is_context, - kernel_util_internal::drop_if_nonempty_t, - ArgsType>; - - static void call( - ::executorch::runtime::KernelRuntimeContext& ctx, - executorch::runtime::Span stack) { - constexpr size_t num_inputs = - kernel_util_internal::size::value; - constexpr size_t num_nonconst_tensors = - kernel_util_internal::count_nonconst_tensors< - ContextRemovedArgsType>::value; - static_assert(num_nonconst_tensors == 1, "Invalid number of inputs"); - return kernel_util_internal:: - call_functor_with_args_from_stack( - ctx, - stack, - std::make_index_sequence(), - static_cast(nullptr)); - } -}; - -template -static executorch::runtime::Kernel make_boxed_kernel( - const char* name, - FuncType) { - return executorch::runtime::Kernel( - name, WrapUnboxedIntoFunctor::call); -} - -} // namespace extension -} // namespace executorch - -// Inspired from C10_CONCATENATE -#define ET_CONCATENATE_IMPL(s1, s2) s1##s2 -#define ET_CONCATENATE(s1, s2) ET_CONCATENATE_IMPL(s1, s2) -#define ET_UID __LINE__ - -#define EXECUTORCH_LIBRARY(ns, op_name, func) \ - _EXECUTORCH_LIBRARY_IMPL(ns, op_name, func, ET_UID) - -#define _EXECUTORCH_LIBRARY_IMPL(ns, op_name, func, uid) \ - static constexpr const char ET_CONCATENATE(name_of_op_, uid)[] = \ - #ns "::" op_name; \ - static auto ET_CONCATENATE(res_##ns##_, uid) = \ - ::executorch::runtime::register_kernel( \ - ::executorch::extension::make_boxed_kernel( \ - #ns "::" op_name, \ - EXECUTORCH_FN(func, ET_CONCATENATE(name_of_op_, uid)))) - -namespace torch { -namespace executor { -// TODO(T197294990): Remove these deprecated aliases once all users have moved -// to the new `::executorch` namespaces. -using ::executorch::extension::make_boxed_kernel; -using ::executorch::extension::WrapUnboxedIntoFunctor; -} // namespace executor -} // namespace torch diff --git a/ai_layer/engine/include/executorch/extension/kernel_util/meta_programming.h b/ai_layer/engine/include/executorch/extension/kernel_util/meta_programming.h deleted file mode 100644 index e3b3649d..00000000 --- a/ai_layer/engine/include/executorch/extension/kernel_util/meta_programming.h +++ /dev/null @@ -1,122 +0,0 @@ -/* - * Copyright (c) Meta Platforms, Inc. and affiliates. - * All rights reserved. - * - * This source code is licensed under the BSD-style license found in the - * LICENSE file in the root directory of this source tree. - */ - -#pragma once -#if __cplusplus < 201703L -#error "This header requires C++17" -#endif - -#include -#include -#include -#include -#include - -namespace executorch { -namespace extension { -// This extension has a lot of generic internal names like "size"; use a unique -// internal namespace to avoid conflicts with other extensions. -namespace kernel_util_internal { - -// Check if a given type is a function -template -struct is_function_type : std::false_type {}; -template -struct is_function_type : std::true_type {}; -template -using is_function_type_t = typename is_function_type::type; - -// A compile-time wrapper around a function pointer -template -struct CompileTimeFunctionPointer final { - static_assert( - is_function_type::value, - "EXECUTORCH_FN can only wrap function types."); - using FuncType = FuncType_; - static constexpr const char* func_name_ = func_name; - - static constexpr FuncType* func_ptr() { - return func_ptr_; - } -}; - -// Check if a given type is a compile-time function pointer -template -struct is_compile_time_function_pointer : std::false_type {}; -template -struct is_compile_time_function_pointer< - CompileTimeFunctionPointer> - : std::true_type {}; - -#define EXECUTORCH_FN_TYPE(func, name) \ - ::executorch::extension::kernel_util_internal::CompileTimeFunctionPointer< \ - std::remove_pointer_t>, \ - func, \ - name> -#define EXECUTORCH_FN(func, name) EXECUTORCH_FN_TYPE(func, name)() - -/** - * strip_class: helper to remove the class type from pointers to `operator()`. - */ -template -struct strip_class {}; -template -struct strip_class { - using type = Result(Args...); -}; -template -struct strip_class { - using type = Result(Args...); -}; -template -using strip_class_t = typename strip_class::type; - -/** - * Access information about result type or arguments from a function type. - * Example: - * using A = function_traits::return_type // A == int - * using A = function_traits::parameter_types::tuple_type - * // A == tuple - */ -template -struct function_traits { - static_assert( - !std::is_same::value, - "In function_traits, Func must be a plain function type."); -}; -template -struct function_traits { - using func_type = Result(Args...); - using return_type = Result; - using parameter_types = typelist; - static constexpr auto number_of_parameters = sizeof...(Args); -}; - -/** - * infer_function_traits: creates a `function_traits` type for a simple - * function (pointer) or functor (lambda/struct). Currently does not support - * class methods. - */ -template -struct infer_function_traits { - using type = function_traits>; -}; -template -struct infer_function_traits { - using type = function_traits; -}; -template -struct infer_function_traits { - using type = function_traits; -}; -template -using infer_function_traits_t = typename infer_function_traits::type; - -} // namespace kernel_util_internal -} // namespace extension -} // namespace executorch diff --git a/ai_layer/engine/include/executorch/extension/kernel_util/type_list.h b/ai_layer/engine/include/executorch/extension/kernel_util/type_list.h deleted file mode 100644 index 300cbfcb..00000000 --- a/ai_layer/engine/include/executorch/extension/kernel_util/type_list.h +++ /dev/null @@ -1,148 +0,0 @@ -/* - * Copyright (c) Meta Platforms, Inc. and affiliates. - * All rights reserved. - * - * This source code is licensed under the BSD-style license found in the - * LICENSE file in the root directory of this source tree. - */ - -/// -/// \file runtime/kernel/type_list.h -/// Forked from pytorch/c10/util/TypeList.h -/// \brief Utilities for working with type lists. -#pragma once -#if __cplusplus < 201703L -#error "This header requires C++17" -#endif - -#include -#include -#include -#include - -namespace executorch { -namespace extension { -// This extension has a lot of generic internal names like "size"; use a unique -// internal namespace to avoid conflicts with other extensions. -namespace kernel_util_internal { - -/** - * Type holding a list of types for compile time type computations - * constexpr size_t num = size>::value; - * static_assert(num == 2, ""); - */ -template -struct false_t : std::false_type {}; - -template -struct typelist final { - public: - typelist() = delete; // not for instantiation -}; -template -struct size final { - static_assert( - false_t::value, - "In typelist::size, T must be typelist<...>."); -}; -template -struct size> final { - static constexpr size_t value = sizeof...(Types); -}; - -/** - * is_instantiation_of is true_type iff I is a template instantiation of T - * (e.g. vector is an instantiation of vector) Example: - * is_instantiation_of_t> // true - * is_instantiation_of_t> // true - * is_instantiation_of_t> // false - */ -template